https://oklahomaagritourism.com/js/app.js?1

321ict mode should be common
322// enough that all such attempts are guarded in a try block.
323"use strict";
324
325var arr = [];
326
327var document = window.document;
328
329var getProto = Object.getPrototypeOf;
330
331var slice = arr.slice;
332
333var concat = arr.concat;
334
335var push = arr.push;
336
337var indexOf = arr.indexOf;
338
339var class2type = {};
340
341var toString = class2type.toString;
342
343var hasOwn = class2type.hasOwnProperty;
344
345var fnToString = hasOwn.toString;
346
347var ObjectFunctionString = fnToString.call( Object );
348
349var support = {};
350
351
352
353	function DOMEval( code, doc ) {
354		doc = doc || document;
355
356		var script = doc.createElement( "script" );
357
358		script.text = code;
359		doc.head.appendChild( script ).parentNode.removeChild( script );
360	}
361/* global Symbol */
362// Defining this global in .eslintrc.json would create a danger of using the global
363// unguarded in another place, it seems safer to define global only for this module
364
365
366
367var
368	version = "3.2.1",
369
370	// Define a local copy of jQuery
371	jQuery = function( selector, context ) {
372
373		// The jQuery object is actually just the init constructor 'enhanced'
374		// Need init if jQuery is called (just allow error to be thrown if not included)
375		return new jQuery.fn.init( selector, context );
376	},
377
378	// Support: Android <=4.0 only
379	// Make sure we trim BOM and NBSP
380	rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
381
382	// Matches dashed string for camelizing
383	rmsPrefix = /^-ms-/,
384	rdashAlpha = /-([a-z])/g,
385
386	// Used by jQuery.camelCase as callback to replace()
387	fcamelCase = function( all, letter ) {
388		return letter.toUpperCase();
389	};
390
391jQuery.fn = jQuery.prototype = {
392
393	// The current version of jQuery being used
394	jquery: version,
395
396	constructor: jQuery,
397
398	// The default length of a jQuery object is 0
399	length: 0,
400
401	toArray: function() {
402		return slice.call( this );
403	},
404
405	// Get the Nth element in the matched element set OR
406	// Get the whole matched element set as a clean array
407	get: function( num ) {
408
409		// Return all the elements in a clean array
410		if ( num == null ) {
411			return slice.call( this );
412		}
413
414		// Return just the one element from the set
415		return num < 0 ? this[ num + this.length ] : this[ num ];
416	},
417
418	// Take an array of elements and push it onto the stack
419	// (returning the new matched element set)
420	pushStack: function( elems ) {
421
422		// Build a new jQuery matched element set
423		var ret = jQuery.merge( this.constructor(), elems );
424
425		// Add the old object onto the stack (as a reference)
426		ret.prevObject = this;
427
428		// Return the newly-formed element set
429		return ret;
430	},
431
432	// Execute a callback for every element in the matched set.
433	each: function( callback ) {
434		return jQuery.each( this, callback );
435	},
436
437	map: function( callback ) {
438		return this.pushStack( jQuery.map( this, function( elem, i ) {
439			return callback.call( elem, i, elem );
440		} ) );
441	},
442
443	slice: function() {
444		return this.pushStack( slice.apply( this, arguments ) );
445	},
446
447	first: function() {
448		return this.eq( 0 );
449	},
450
451	last: function() {
452		return this.eq( -1 );
453	},
454
455	eq: function( i ) {
456		var len = this.length,
457			j = +i + ( i < 0 ? len : 0 );
458		return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );
459	},
460
461	end: function() {
462		return this.prevObject || this.constructor();
463	},
464
465	// For internal use only.
466	// Behaves like an Array's method, not like a jQuery method.
467	push: push,
468	sort: arr.sort,
469	splice: arr.splice
470};
471
472jQuery.extend = jQuery.fn.extend = function() {
473	var options, name, src, copy, copyIsArray, clone,
474		target = arguments[ 0 ] || {},
475		i = 1,
476		length = arguments.length,
477		deep = false;
478
479	// Handle a deep copy situation
480	if ( typeof target === "boolean" ) {
481		deep = target;
482
483		// Skip the boolean and the target
484		target = arguments[ i ] || {};
485		i++;
486	}
487
488	// Handle case when target is a string or something (possible in deep copy)
489	if ( typeof target !== "object" && !jQuery.isFunction( target ) ) {
490		target = {};
491	}
492
493	// Extend jQuery itself if only one argument is passed
494	if ( i === length ) {
495		target = this;
496		i--;
497	}
498
499	for ( ; i < length; i++ ) {
500
501		// Only deal with non-null/undefined values
502		if ( ( options = arguments[ i ] ) != null ) {
503
504			// Extend the base object
505			for ( name in options ) {
506				src = target[ name ];
507				copy = options[ name ];
508
509				// Prevent never-ending loop
510				if ( target === copy ) {
511					continue;
512				}
513
514				// Recurse if we're merging plain objects or arrays
515				if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
516					( copyIsArray = Array.isArray( copy ) ) ) ) {
517
518					if ( copyIsArray ) {
519						copyIsArray = false;
520						clone = src && Array.isArray( src ) ? src : [];
521
522					} else {
523						clone = src && jQuery.isPlainObject( src ) ? src : {};
524					}
525
526					// Never move original objects, clone them
527					target[ name ] = jQuery.extend( deep, clone, copy );
528
529				// Don't bring in undefined values
530				} else if ( copy !== undefined ) {
531					target[ name ] = copy;
532				}
533			}
534		}
535	}
536
537	// Return the modified object
538	return target;
539};
540
541jQuery.extend( {
542
543	// Unique for each copy of jQuery on the page
544	expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
545
546	// Assume jQuery is ready without the ready module
547	isReady: true,
548
549	error: function( msg ) {
550		throw new Error( msg );
551	},
552
553	noop: function() {},
554
555	isFunction: function( obj ) {
556		return jQuery.type( obj ) === "function";
557	},
558
559	isWindow: function( obj ) {
560		return obj != null && obj === obj.window;
561	},
562
563	isNumeric: function( obj ) {
564
565		// As of jQuery 3.0, isNumeric is limited to
566		// strings and numbers (primitives or objects)
567		// that can be coerced to finite numbers (gh-2662)
568		var type = jQuery.type( obj );
569		return ( type === "number" || type === "string" ) &&
570
571			// parseFloat NaNs numeric-cast false positives ("")
572			// ...but misinterprets leading-number strings, particularly hex literals ("0x...")
573			// subtraction forces infinities to NaN
574			!isNaN( obj - parseFloat( obj ) );
575	},
576
577	isPlainObject: function( obj ) {
578		var proto, Ctor;
579
580		// Detect obvious negatives
581		// Use toString instead of jQuery.type to catch host objects
582		if ( !obj || toString.call( obj ) !== "[object Object]" ) {
583			return false;
584		}
585
586		proto = getProto( obj );
587
588		// Objects with no prototype (e.g., `Object.create( null )`) are plain
589		if ( !proto ) {
590			return true;
591		}
592
593		// Objects with prototype are plain iff they were constructed by a global Object function
594		Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor;
595		return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString;
596	},
597
598	isEmptyObject: function( obj ) {
599
600		/* eslint-disable no-unused-vars */
601		// See https://github.com/eslint/eslint/issues/6125
602		var name;
603
604		for ( name in obj ) {
605			return false;
606		}
607		return true;
608	},
609
610	type: function( obj ) {
611		if ( obj == null ) {
612			return obj + "";
613		}
614
615		// Support: Android <=2.3 only (functionish RegExp)
616		return typeof obj === "object" || typeof obj === "function" ?
617			class2type[ toString.call( obj ) ] || "object" :
618			typeof obj;
619	},
620
621	// Evaluates a script in a global context
622	globalEval: function( code ) {
623		DOMEval( code );
624	},
625
626	// Convert dashed to camelCase; used by the css and data modules
627	// Support: IE <=9 - 11, Edge 12 - 13
628	// Microsoft forgot to hump their vendor prefix (#9572)
629	camelCase: function( string ) {
630		return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
631	},
632
633	each: function( obj, callback ) {
634		var length, i = 0;
635
636		if ( isArrayLike( obj ) ) {
637			length = obj.length;
638			for ( ; i < length; i++ ) {
639				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
640					break;
641				}
642			}
643		} else {
644			for ( i in obj ) {
645				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
646					break;
647				}
648			}
649		}
650
651		return obj;
652	},
653
654	// Support: Android <=4.0 only
655	trim: function( text ) {
656		return text == null ?
657			"" :
658			( text + "" ).replace( rtrim, "" );
659	},
660
661	// results is for internal usage only
662	makeArray: function( arr, results ) {
663		var ret = results || [];
664
665		if ( arr != null ) {
666			if ( isArrayLike( Object( arr ) ) ) {
667				jQuery.merge( ret,
668					typeof arr === "string" ?
669					[ arr ] : arr
670				);
671			} else {
672				push.call( ret, arr );
673			}
674		}
675
676		return ret;
677	},
678
679	inArray: function( elem, arr, i ) {
680		return arr == null ? -1 : indexOf.call( arr, elem, i );
681	},
682
683	// Support: Android <=4.0 only, PhantomJS 1 only
684	// push.apply(_, arraylike) throws on ancient WebKit
685	merge: function( first, second ) {
686		var len = +second.length,
687			j = 0,
688			i = first.length;
689
690		for ( ; j < len; j++ ) {
691			first[ i++ ] = second[ j ];
692		}
693
694		first.length = i;
695
696		return first;
697	},
698
699	grep: function( elems, callback, invert ) {
700		var callbackInverse,
701			matches = [],
702			i = 0,
703			length = elems.length,
704			callbackExpect = !invert;
705
706		// Go through the array, only saving the items
707		// that pass the validator function
708		for ( ; i < length; i++ ) {
709			callbackInverse = !callback( elems[ i ], i );
710			if ( callbackInverse !== callbackExpect ) {
711				matches.push( elems[ i ] );
712			}
713		}
714
715		return matches;
716	},
717
718	// arg is for internal usage only
719	map: function( elems, callback, arg ) {
720		var length, value,
721			i = 0,
722			ret = [];
723
724		// Go through the array, translating each of the items to their new values
725		if ( isArrayLike( elems ) ) {
726			length = elems.length;
727			for ( ; i < length; i++ ) {
728				value = callback( elems[ i ], i, arg );
729
730				if ( value != null ) {
731					ret.push( value );
732				}
733			}
734
735		// Go through every key on the object,
736		} else {
737			for ( i in elems ) {
738				value = callback( elems[ i ], i, arg );
739
740				if ( value != null ) {
741					ret.push( value );
742				}
743			}
744		}
745
746		// Flatten any nested arrays
747		return concat.apply( [], ret );
748	},
749
750	// A global GUID counter for objects
751	guid: 1,
752
753	// Bind a function to a context, optionally partially applying any
754	// arguments.
755	proxy: function( fn, context ) {
756		var tmp, args, proxy;
757
758		if ( typeof context === "string" ) {
759			tmp = fn[ context ];
760			context = fn;
761			fn = tmp;
762		}
763
764		// Quick check to determine if target is callable, in the spec
765		// this throws a TypeError, but we will just return undefined.
766		if ( !jQuery.isFunction( fn ) ) {
767			return undefined;
768		}
769
770		// Simulated bind
771		args = slice.call( arguments, 2 );
772		proxy = function() {
773			return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
774		};
775
776		// Set the guid of unique handler to the same of original handler, so it can be removed
777		proxy.guid = fn.guid = fn.guid || jQuery.guid++;
778
779		return proxy;
780	},
781
782	now: Date.now,
783
784	// jQuery.support is not used in Core but other projects attach their
785	// properties to it so it needs to exist.
786	support: support
787} );
788
789if ( typeof Symbol === "function" ) {
790	jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];
791}
792
793// Populate the class2type map
794jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
795function( i, name ) {
796	class2type[ "[object " + name + "]" ] = name.toLowerCase();
797} );
798
799function isArrayLike( obj ) {
800
801	// Support: real iOS 8.2 only (not reproducible in simulator)
802	// `in` check used to prevent JIT error (gh-2145)
803	// hasOwn isn't used here due to false negatives
804	// regarding Nodelist length in IE
805	var length = !!obj && "length" in obj && obj.length,
806		type = jQuery.type( obj );
807
808	if ( type === "function" || jQuery.

808isWindow( obj ) ) {
809		return false;
810	}
811
812	return type === "array" || length === 0 ||
813		typeof length === "number" && length > 0 && ( length - 1 ) in obj;
814}
815var Sizzle =
816/*!
817 * Sizzle CSS Selector Engine v2.3.3
818 * https://sizzlejs.com/
819 *
820 * Copyright jQuery Foundation and other contributors
821 * Released under the MIT license
822 * http://jquery.org/license
823 *
824 * Date: 2016-08-08
825 */
826(function( window ) {
827
828var i,
829	support,
830	Expr,
831	getText,
832	isXML,
833	tokenize,
834	compile,
835	select,
836	outermostContext,
837	sortInput,
838	hasDuplicate,
839
840	// Local document vars
841	setDocument,
842	document,
843	docElem,
844	documentIsHTML,
845	rbuggyQSA,
846	rbuggyMatches,
847	matches,
848	contains,
849
850	// Instance-specific data
851	expando = "sizzle" + 1 * new Date(),
852	preferredDoc = window.document,
853	dirruns = 0,
854	done = 0,
855	classCache = createCache(),
856	tokenCache = createCache(),
857	compilerCache = createCache(),
858	sortOrder = function( a, b ) {
859		if ( a === b ) {
860			hasDuplicate = true;
861		}
862		return 0;
863	},
864
865	// Instance methods
866	hasOwn = ({}).hasOwnProperty,
867	arr = [],
868	pop = arr.pop,
869	push_native = arr.push,
870	push = arr.push,
871	slice = arr.slice,
872	// Use a stripped-down indexOf as it's faster than native
873	// https://jsperf.com/thor-indexof-vs-for/5
874	indexOf = function( list, elem ) {
875		var i = 0,
876			len = list.length;
877		for ( ; i < len; i++ ) {
878			if ( list[i] === elem ) {
879				return i;
880			}
881		}
882		return -1;
883	},
884
885	booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",
886
887	// Regular expressions
888
889	// http://www.w3.org/TR/css3-selectors/#whitespace
890	whitespace = "[\\x20\\t\\r\\n\\f]",
891
892	// http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
893	identifier = "(?:\\\\.|[\\w-]|[^\0-\\xa0])+",
894
895	// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
896	attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +
897		// Operator (capture 2)
898		"*([*^$|!~]?=)" + whitespace +
899		// "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"
900		"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace +
901		"*\\]",
902
903	pseudos = ":(" + identifier + ")(?:\\((" +
904		// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
905		// 1. quoted (capture 3; capture 4 or capture 5)
906		"('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
907		// 2. simple (capture 6)
908		"((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
909		// 3. anything else (capture 2)
910		".*" +
911		")\\)|)",
912
913	// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
914	rwhitespace = new RegExp( whitespace + "+", "g" ),
915	rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ),
916
917	rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
918	rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ),
919
920	rattributeQuotes = new RegExp( "=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g" ),
921
922	rpseudo = new RegExp( pseudos ),
923	ridentifier = new RegExp( "^" + identifier + "$" ),
924
925	matchExpr = {
926		"ID": new RegExp( "^#(" + identifier + ")" ),
927		"CLASS": new RegExp( "^\\.(" + identifier + ")" ),
928		"TAG": new RegExp( "^(" + identifier + "|[*])" ),
929		"ATTR": new RegExp( "^" + attributes ),
930		"PSEUDO": new RegExp( "^" + pseudos ),
931		"CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace +
932			"*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace +
933			"*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
934		"bool": new RegExp( "^(?:" + booleans + ")$", "i" ),
935		// For use in libraries implementing .is()
936		// We use this for POS matching in `select`
937		"needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" +
938			whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
939	},
940
941	rinputs = /^(?:input|select|textarea|button)$/i,
942	rheader = /^h\d$/i,
943
944	rnative = /^[^{]+\{\s*\[native \w/,
945
946	// Easily-parseable/retrievable ID or TAG or CLASS selectors
947	rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
948
949	rsibling = /[+~]/,
950
951	// CSS escapes
952	// http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
953	runescape = new RegExp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ),
954	funescape = function( _, escaped, escapedWhitespace ) {
955		var high = "0x" + escaped - 0x10000;
956		// NaN means non-codepoint
957		// Support: Firefox<24
958		// Workaround erroneous numeric interpretation of +"0x"
959		return high !== high || escapedWhitespace ?
960			escaped :
961			high < 0 ?
962				// BMP codepoint
963				String.fromCharCode( high + 0x10000 ) :
964				// Supplemental Plane codepoint (surrogate pair)
965				String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
966	},
967
968	// CSS string/identifier serialization
969	// https://drafts.csswg.org/cssom/#common-serializing-idioms
970	rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,
971	fcssescape = function( ch, asCodePoint ) {
972		if ( asCodePoint ) {
973
974			// U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
975			if ( ch === "\0" ) {
976				return "\uFFFD";
977			}
978
979			// Control characters and (dependent upon position) numbers get escaped as code points
980			return ch.slice( 0, -1 ) + "\\" + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " ";
981		}
982
983		// Other potentially-special ASCII characters get backslash-escaped
984		return "\\" + ch;
985	},
986
987	// Used for iframes
988	// See setDocument()
989	// Removing the function wrapper causes a "Permission Denied"
990	// error in IE
991	unloadHandler = function() {
992		setDocument();
993	},
994
995	disabledAncestor = addCombinator(
996		function( elem ) {
997			return elem.disabled === true && ("form" in elem || "label" in elem);
998		},
999		{ dir: "parentNode", next: "legend" }
1000	);
1001
1002// Optimize for push.apply( _, NodeList )
1003try {
1004	push.apply(
1005		(arr = slice.call( preferredDoc.childNodes )),
1006		preferredDoc.childNodes
1007	);
1008	// Support: Android<4.0
1009	// Detect silently failing push.apply
1010	arr[ preferredDoc.childNodes.length ].nodeType;
1011} catch ( e ) {
1012	push = { apply: arr.length ?
1013
1014		// Leverage slice if possible
1015		function( target, els ) {
1016			push_native.apply( target, slice.call(els) );
1017		} :
1018
1019		// Support: IE<9
1020		// Otherwise append directly
1021		function( target, els ) {
1022			var j = target.length,
1023				i = 0;
1024			// Can't trust NodeList.length
1025			while ( (target[j++] = els[i++]) ) {}
1026			target.length = j - 1;
1027		}
1028	};
1029}
1030
1031function Sizzle( selector, context, results, seed ) {
1032	var m, i, elem, nid, match, groups, newSelector,
1033		newContext = context && context.ownerDocument,
1034
1035		// nodeType defaults to 9, since context defaults to document
1036		nodeType = context ? context.nodeType : 9;
1037
1038	results = results || [];
1039
1040	// Return early from calls with invalid selector or context
1041	if ( typeof selector !== "string" || !selector ||
1042		nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {
1043
1044		return results;
1045	}
1046
1047	// Try to shortcut find operations (as opposed to filters) in HTML documents
1048	if ( !seed ) {
1049
1050		if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {
1051			setDocument( context );
1052		}
1053		context = context || document;
1054
1055		if ( documentIsHTML ) {
1056
1057			// If the selector is sufficiently simple, try using a "get*By*" DOM method
1058			// (excepting DocumentFragment context, where the methods don't exist)
1059			if ( nodeType !== 11 && (match = rquickExpr.exec( selector )) ) {
1060
1061				// ID selector
1062				if ( (m = match[1]) ) {
1063
1064					// Document context
1065					if ( nodeType === 9 ) {
1066						if ( (elem = context.getElementById( m )) ) {
1067
1068							// Support: IE, Opera, Webkit
1069							// TODO: identify versions
1070							// getElementById can match elements by name instead of ID
1071							if ( elem.id === m ) {
1072								results.push( elem );
1073								return results;
1074							}
1075						} else {
1076							return results;
1077						}
1078
1079					// Element context
1080					} else {
1081
1082						// Support: IE, Opera, Webkit
1083						// TODO: identify versions
1084						// getElementById can match elements by name instead of ID
1085						if ( newContext && (elem = newContext.getElementById( m )) &&
1086							contains( context, elem ) &&
1087							elem.id === m ) {
1088
1089							results.push( elem );
1090							return results;
1091						}
1092					}
1093
1094				// Type selector
1095				} else if ( match[2] ) {
1096					push.apply( results, context.getElementsByTagName( selector ) );
1097					return results;
1098
1099				// Class selector
1100				} else if ( (m = match[3]) && support.getElementsByClassName &&
1101					context.getElementsByClassName ) {
1102
1103					push.apply( results, context.getElementsByClassName( m ) );
1104					return results;
1105				}
1106			}
1107
1108			// Take advantage of querySelectorAll
1109			if ( support.qsa &&
1110				!compilerCache[ selector + " " ] &&
1111				(!rbuggyQSA || !rbuggyQSA.test( selector )) ) {
1112
1113				if ( nodeType !== 1 ) {
1114					newContext = context;
1115					newSelector = selector;
1116
1117				// qSA looks outside Element context, which is not what we want
1118				// Thanks to Andrew Dupont for this workaround technique
1119				// Support: IE <=8
1120				// Exclude object elements
1121				} else if ( context.nodeName.toLowerCase() !== "object" ) {
1122
1123					// Capture the context ID, setting it first if necessary
1124					if ( (nid = context.getAttribute( "id" )) ) {
1125						nid = nid.replace( rcssescape, fcssescape );
1126					} else {
1127						context.setAttribute( "id", (nid = expando) );
1128					}
1129
1130					// Prefix every selector in the list
1131					groups = tokenize( selector );
1132					i = groups.length;
1133					while ( i-- ) {
1134						groups[i] = "#" + nid + " " + toSelector( groups[i] );
1135					}
1136					newSelector = groups.join( "," );
1137
1138					// Expand context for sibling selectors
1139					newContext = rsibling.test( selector ) && testContext( context.parentNode ) ||
1140						context;
1141				}
1142
1143				if ( newSelector ) {
1144					try {
1145						push.apply( results,
1146							newContext.querySelectorAll( newSelector )
1147						);
1148						return results;
1149					} catch ( qsaError ) {
1150					} finally {
1151						if ( nid === expando ) {
1152							context.removeAttribute( "id" );
1153						}
1154					}
1155				}
1156			}
1157		}
1158	}
1159
1160	// All others
1161	return select( selector.replace( rtrim, "$1" ), context, results, seed );
1162}
1163
1164/**
1165 * Create key-value caches of limited size
1166 * @returns {function(string, object)} Returns the Object data after storing it on itself with
1167 *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
1168 *	deleting the oldest entry
1169 */
1170function createCache() {
1171	var keys = [];
1172
1173	function cache( key, value ) {
1174		// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
1175		if ( keys.push( key + " " ) > Expr.cacheLength ) {
1176			// Only keep the most recent entries
1177			delete cache[ keys.shift() ];
1178		}
1179		return (cache[ key + " " ] = value);
1180	}
1181	return cache;
1182}
1183
1184/**
1185 * Mark a function for special use by Sizzle
1186 * @param {Function} fn The function to mark
1187 */
1188function markFunction( fn ) {
1189	fn[ expando ] = true;
1190	return fn;
1191}
1192
1193/**
1194 * Support testing using an element
1195 * @param {Function} fn Passed the created element and returns a boolean result
1196 */
1197function assert( fn ) {
1198	var el = document.createElement("fieldset");
1199
1200	try {
1201		return !!fn( el );
1202	} catch (e) {
1203		return false;
1204	} finally {
1205		// Remove from its parent by default
1206		if ( el.parentNode ) {
1207			el.parentNode.removeChild( el );
1208		}
1209		// release memory in IE
1210		el = null;
1211	}
1212}
1213
1214/**
1215 * Adds the same handler for all of the specified attrs
1216 * @param {String} attrs Pipe-separated list of attributes
1217 * @param {Function} handler The method that will be applied
1218 */
1219function addHandle( attrs, handler ) {
1220	var arr = attrs.split("|"),
1221		i = arr.length;
1222
1223	while ( i-- ) {
1224		Expr.attrHandle[ arr[i] ] = handler;
1225	}
1226}
1227
1228/**
1229 * Checks document order of two siblings
1230 * @param {Element} a
1231 * @param {Element} b
1232 * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
1233 */
1234function siblingCheck( a, b ) {
1235	var cur = b && a,
1236		diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
1237			a.sourceIndex - b.sourceIndex;
1238
1239	// Use IE sourceIndex if available on both nodes
1240	if ( diff ) {
1241		return diff;
1242	}
1243
1244	// Check if b follows a
1245	if ( cur ) {
1246		while ( (cur = cur.nextSibling) ) {
1247			if ( cur === b ) {
1248				return -1;
1249			}
1250		}
1251	}
1252
1253	return a ? 1 : -1;
1254}
1255
1256/**
1257 * Returns a function to use in pseudos for input types
1258 * @param {String} type
1259 */
1260function createInputPseudo( type ) {
1261	return function( elem ) {
1262		var name = elem.nodeName.toLowerCase();
1263		return name === "input" && elem.type === type;
1264	};
1265}
1266
1267/**
1268 * Returns a function to use in pseudos for buttons
1269 * @param {String} type
1270 */
1271function createButtonPseudo( type ) {
1272	return function( elem ) {
1273		var name = elem.nodeName.toLowerCase();
1274		return (name === "input" || name === "button") && elem.type === type;
1275	};
1276}
1277
1278/**
1279 * Returns a function to use in pseudos for :enabled/:disabled
1280 * @param {Boolean} disabled true for :disabled; false for :enabled
1281 */
1282function createDisabledPseudo( disabled ) {
1283
1284	// Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable
1285	return function( elem ) {
1286
1287		// Only certain elements can match :enabled or :disabled
1288		// https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled
1289		// https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled
1290		if ( "form" in elem ) {
1291
1292			// Check for inherited disabledness on relevant non-disabled elements:
1293			// * listed form-associated elements in a disabled fieldset
1294			//   https://html.spec.whatwg.org/multipage/forms.html#category-listed
1295			//   https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled
1296			// * option elements in a disabled optgroup
1297			//   https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled
1298			// All such elements have a "form" property.
1299			if ( elem.parentNode && elem.disabled === false ) {
1300
1301				// Option elements defer to a parent optgroup if present
1302				if ( "label" in elem ) {
1303					if ( "label" in elem.parentNode ) {
1304						return elem.parentNode.disabled === disabled;
1305					} else {
1306						return elem.disabled === disabled;
1307					}
1308				}
1309
1310				// Support: IE 6 - 11
1311				// Use the isDisabled shortcut property to check for disabled fieldset ancestors
1312				return elem.isDisabled === disabled ||
1313
1314					// Where there is no isDisabled, check manually
1315					/* jshint -W018 */
1316					elem.isDisabled !== !disabled &&
1317						disabledAncestor( elem ) === disabled;
1318			}
1319
1320			return elem.disabled === disabled;
1321
1322		// Try to winnow out elements that can't be disabled before trusting the disabled property.
1323		// Some victims get caught in our net (label, legend, menu, track), but it shouldn't
1324		// even exist on them, let alone have a boolean value.
1325		} else if ( "label" in elem ) {
1326			return elem.disabled === disabled;
1327		}
1328
1329		// Remaining elements are neither :enabled nor :disabled
1330		return false;
1331	};
1332}
1333
1334/**
1335 * Returns a function to use in pseudos for positionals
1336 * @param {Function} fn
1337 */
1338function createPositionalPseudo( fn ) {
1339	return markFunction(function( argument ) {
1340		argument = +argument;
1341		return markFunction(function( seed, matches ) {
1342			var j,
1343				matchIndexes = fn( [], seed.length, argument ),
1344				i = matchIndexes.length;
1345
1346			// Match elements found at the specified indexes
1347			while ( i-- ) {
1348				if ( seed[ (j = matchIndexes[i]) ] ) {
1349					seed[j] = !(matches[j] = seed[j]);
1350				}
1351			}
1352		});
1353	});
1354}
1355
1356/**
1357 * Checks a node for validity as a Sizzle context
1358 * @param {Element|Object=} context
1359 * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
1360 */
1361function testContext( context ) {
1362	return context && typeof context.getElementsByTagName !== "undefined" && context;
1363}
1364
1365// Expose support vars for convenience
1366support = Sizzle.support = {};
1367
1368/**
1369 * Detects XML nodes
1370 * @param {Element|Object} elem An element or a document
1371 * @returns {Boolean} True iff elem is a non-HTML XML node
1372 */
1373isXML = Sizzle.isXML = function( elem ) {
1374	// documentElement is verified for cases where it doesn't yet exist
1375	// (such as loading iframes in IE - #4833)
1376	var documentElement = elem && (elem.ownerDocument || elem).documentElement;
1377	return documentElement ? documentElement.nodeName !== "HTML" : false;
1378};
1379
1380/**
1381 * Sets document-related variables once based on the current document
1382 * @param {Element|Object} [doc] An element or document object to use to set the document
1383 * @returns {Object} Returns the current document
1384 */
1385setDocument = Sizzle.setDocument = function( node ) {
1386	var hasCompare, subWindow,
1387		doc = node ? node.ownerDocument || node : preferredDoc;
1388
1389	// Return early if doc is invalid or already selected
1390	if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {
1391		return document;
1392	}
1393
1394	// Update global variables
1395	document = doc;
1396	docElem = document.documentElement;
1397	documentIsHTML = !isXML( document );
1398
1399	// Support: IE 9-11, Edge
1400	// Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936)
1401	if ( preferredDoc !== document &&
1402		(subWindow = document.defaultView) && subWindow.top !== subWindow ) {
1403
1404		// Support: IE 11, Edge
1405		if ( subWindow.addEventListener ) {
1406			subWindow.addEventListener( "unload", unloadHandler, false );
1407
1408		// Support: IE 9 - 10 only
1409		} else if ( subWindow.attachEvent ) {
1410			subWindow.attachEvent( "onunload", unloadHandler );
1411		}
1412	}
1413
1414	/* Attributes
1415	---------------------------------------------------------------------- */
1416
1417	// Support: IE<8
1418	// Verify that getAttribute really returns attributes and not properties
1419	// (excepting IE8 booleans)
1420	support.attributes = assert(function( el ) {
1421		el.className = "i";
1422		return !el.getAttribute("className");
1423	});
1424
1425	/* getElement(s)By*
1426	---------------------------------------------------------------------- */
1427
1428	// Check if getElementsByTagName("*") returns only elements
1429	support.getElementsByTagName = assert(function( el ) {
1430		el.appendChild( document.createComment("") );
1431		return !el.getElementsByTagName("*").length;
1432	});
1433
1434	// Support: IE<9
1435	support.getElementsByClassName = rnative.test( document.getElementsByClassName );
1436
1437	// Support: IE<10
1438	// Check if getElementById returns elements by name
1439	// The broken getElementById methods don't pick up programmatically-set names,
1440	// so use a roundabout getElementsByName test
1441	support.getById = assert(function( el ) {
1442		docElem.appendChild( el ).id = expando;
1443		return !document.getElementsByName || !document.getElementsByName( expando ).length;
1444	});
1445
1446	// ID filter and find
1447	if ( support.getById ) {
1448		Expr.filter["ID"] = function( id ) {
1449			var attrId = id.replace( runescape, funescape );
1450			return function( elem ) {
1451				return elem.getAttribute("id") === attrId;
1452			};
1453		};
1454		Expr.find["ID"] = function( id, context ) {
1455			if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
1456				var elem = context.getElementById( id );
1457				return elem ? [ elem ] : [];
1458			}
1459		};
1460	} else {
1461		Expr.filter["ID"] =  function( id ) {
1462			var attrId = id.replace( runescape, funescape );
1463			return function( elem ) {
1464				var node = typeof elem.getAttributeNode !== "undefined" &&
1465					elem.getAttributeNode("id");
1466				return node && node.value === attrId;
1467			};
1468		};
1469
1470		// Support: IE 6 - 7 only
1471		// getElementById is not reliable as a find shortcut
1472		Expr.find["ID"] = function( id, context ) {
1473			if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
1474				var node, i, elems,
1475					elem = context.getElementById( id );
1476
1477				if ( elem ) {
1478
1479					// Verify the id attribute
1480					node = elem.getAttributeNode("id");
1481					if ( node && node.value === id ) {
1482						return [ elem ];
1483					}
1484
1485					// Fall back on getElementsByName
1486					elems = context.getElementsByName( id );
1487					i = 0;
1488					while ( (elem = elems[i++]) ) {
1489						node = elem.getAttributeNode("id");
1490						if ( node && node.value === id ) {
1491							return [ elem ];
1492						}
1493					}
1494				}
1495
1496				return [];
1497			}
1498		};
1499	}
1500
1501	// Tag
1502	Expr.find["TAG"] = support.getElementsByTagName ?
1503		function( tag, context ) {
1504			if ( typeof context.getElementsByTagName !== "undefined" ) {
1505				return context.getElementsByTagName( tag );
1506
1507			// DocumentFragment nodes don't have gEBTN
1508			} else if ( support.qsa ) {
1509				return context.querySelectorAll( tag );
1510			}
1511		} :
1512
1513		function( tag, context ) {
1514			var elem,
1515				tmp = [],
1516				i = 0,
1517				// By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
1518				results = context.getElementsByTagName( tag );
1519
1520			// Filter out possible comments
1521			if ( tag === "*" ) {
1522				while ( (elem = results[i++]) ) {
1523					if ( elem.nodeType === 1 ) {
1524						tmp.push( elem );
1525					}
1526				}
1527
1528				return tmp;
1529			}
1530			return results;
1531		};
1532
1533	// Class
1534	Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) {
1535		if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) {
1536			return context.getElementsByClassName( className );
1537		}
1538	};
1539
1540	/* QSA/matchesSelector
1541	---------------------------------------------------------------------- */
1542
1543	// QSA and matchesSelector support
1544
1545	// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
1546	rbuggyMatches = [];
1547
1548	// qSa(:focus) reports false when true (Chrome 21)
1549	// We allow this because of a bug in IE8/9 that throws an error
1550	// whenever `document.activeElement` is accessed on an iframe
1551	// So, we allow :focus to pass through QSA all the time to avoid the IE error
1552	// See https://bugs.jquery.com/ticket/13378
1553	rbuggyQSA = [];
1554
1555	if ( (support.qsa = rnative.test( document.querySelectorAll )) ) {
1556		// Build QSA regex
1557		// Regex strategy adopted from Diego Perini
1558		assert(function( el ) {
1559			// Select is set to empty string on purpose
1560			// This is to test IE's treatment of not explicitly
1561			// setting a boolean content attribute,
1562			// since its presence should be enough
1563			// https://bugs.jquery.com/ticket/12359
1564			docElem.appendChild( el ).innerHTML = "<a id='" + expando + "'></a>" +
1565				"<select id='" + expando + "-\r\\' msallowcapture=''>" +
1566				"<option selected=''></option></select>";
1567
1568			// Support: IE8, Opera 11-12.16
1569			// Nothing should be selected when empty strings follow ^= or $= or *=
1570			// The test attribute must be unknown in Opera but "safe" for WinRT
1571			// https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
1572			if ( el.querySelectorAll("[msallowcapture^='']").length ) {
1573				rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
1574			}
1575
1576			// Support: IE8
1577			// Boolean attributes and "value" are not treated correctly
1578			if ( !el.querySelectorAll("[selected]").length ) {
1579				rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
1580			}
1581
1582			// Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+
1583			if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) {
1584				rbuggyQSA.push("~=");
1585			}
1586
1587			// Webkit/Opera - :checked should return selected option elements
1588			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
1589			// IE8 throws error here and will not see later tests
1590			if ( !el.querySelectorAll(":checked").length ) {
1591				rbuggyQSA.push(":checked");
1592			}
1593
1594			// Support: Safari 8+, iOS 8+
1595			// https://bugs.webkit.org/show_bug.cgi?id=136851
1596			// In-page `selector#id sibling-combinator selector` fails
1597			if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) {
1598				rbuggyQSA.push(".#.+[+~]");
1599			}
1600		});
1601
1602		assert(function( el ) {
1603			el.innerHTML = "<a href='' disabled='disabled'></a>" +
1604				"<select disabled='disabled'><option/></select>";
1605
1606			// Support: Windows 8 Native Apps
1607			// The type and name attributes are restricted during .innerHTML assignment
1608			var input = document.createElement("input");
1609			input.setAttribute( "type", "hidden" );
1610			el.appendChild( input ).setAttribute( "name", "D" );
1611
1612			// Support: IE8
1613			// Enforce case-sensitivity of name attribute
1614			if ( el.querySelectorAll("[name=d]").length ) {
1615				rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );
1616			}
1617
1618			// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
1619			// IE8 throws error here and will not see later tests
1620			if ( el.querySelectorAll(":enabled").length !== 2 ) {
1621				rbuggyQSA.push( ":enabled", ":disabled" );
1622			}
1623
1624			// Support: IE9-11+
1625			// IE's :disabled selector does not pick up the children of disabled fieldsets
1626			docElem.appendChild( el ).disabled = true;
1627			if ( el.querySelectorAll(":disabled").length !== 2 ) {
1628				rbuggyQSA.push( ":enabled", ":disabled" );
1629			}
1630
1631			// Opera 10-11 does not throw on post-comma invalid pseudos
1632			el.querySelectorAll("*,:x");
1633			rbuggyQSA.push(",.*:");
1634		});
1635	}
1636
1637	if ( (support.matchesSelector = rnative.test( (matches = docElem.matches ||
1638		docElem.webkitMatchesSelector ||
1639		docElem.mozMatchesSelector ||
1640		docElem.oMatchesSelector ||
1641		docElem.msMatchesSelector) )) ) {
1642
1643		assert(function( el ) {
1644			// Check to see if it's possible to do matchesSelector
1645			// on a disconnected node (IE 9)
1646			support.disconnectedMatch = matches.call( el, "*" );
1647
1648			// This should fail with an exception
1649			// Gecko does not error, returns false instead
1650			matches.call( el, "[s!='']:x" );
1651			rbuggyMatches.push( "!=", pseudos );
1652		});
1653	}
1654
1655	rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") );
1656	rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") );
1657
1658	/* Contains
1659	---------------------------------------------------------------------- */
1660	hasCompare = rnative.test( docElem.compareDocumentPosition );
1661
1662	// Element contains another
1663	// Purposefully self-exclusive
1664	// As in, an element does not contain itself
1665	contains = hasCompare || rnative.test( docElem.contains ) ?
1666		function( a, b ) {
1667			var adown = a.nodeType === 9 ? a.documentElement : a,
1668				bup = b && b.parentNode;
1669			return a === bup || !!( bup && bup.nodeType === 1 && (
1670				adown.contains ?
1671					adown.contains( bup ) :
1672					a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
1673			));
1674		} :
1675		function( a, b ) {
1676			if ( b ) {
1677				while ( (b = b.parentNode) ) {
1678					if ( b === a ) {
1679						return true;
1680					}
1681				}
1682			}
1683			return false;
1684		};
1685
1686	/* Sorting
1687	---------------------------------------------------------------------- */
1688
1689	// Document order sorting
1690	sortOrder = hasCompare ?
1691	function( a, b ) {
1692
1693		// Flag for duplicate removal
1694		if ( a === b ) {
1695			hasDuplicate = true;
1696			return 0;
1697		}
1698
1699		// Sort on method existence if only one input has compareDocumentPosition
1700		var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
1701		if ( compare ) {
1702			return compare;
1703		}
1704
1705		// Calculate position if both inputs belong to the same document
1706		compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?
1707			a.compareDocumentPosition( b ) :
1708
1709			// Otherwise we know they are disconnected
1710			1;
1711
1712		// Disconnected nodes
1713		if ( compare & 1 ||
1714			(!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {
1715
1716			// Choose the first element that is related to our preferred document
1717			if ( a === document || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) {
1718				return -1;
1719			}
1720			if ( b === document || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) {
1721				return 1;
1722			}
1723
1724			// Maintain original order
1725			return sortInput ?
1726				( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
1727				0;
1728		}
1729
1730		return compare & 4 ? -1 : 1;
1731	} :
1732	function( a, b ) {
1733		// Exit early if the nodes are identical
1734		if ( a === b ) {
1735			hasDuplicate = true;
1736			return 0;
1737		}
1738
1739		var cur,
1740			i = 0,
1741			aup = a.parentNode,
1742			bup = b.parentNode,
1743			ap = [ a ],
1744			bp = [ b ];
1745
1746		// Parentless nodes are either documents or disconnected
1747		if ( !aup || !bup ) {
1748			return a === document ? -1 :
1749				b === document ? 1 :
1750				aup ? -1 :
1751				bup ? 1 :
1752				sortInput ?
1753				( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
1754				0;
1755
1756		// If the nodes are siblings, we can do a quick check
1757		} else if ( aup === bup ) {
1758			return siblingCheck( a, b );
1759		}
1760
1761		// Otherwise we need full lists of their ancestors for comparison
1762		cur = a;
1763		while ( (cur = cur.parentNode) ) {
1764			ap.unshift( cur );
1765		}
1766		cur = b;
1767		while ( (cur = cur.parentNode) ) {
1768			bp.unshift( cur );
1769		}
1770
1771		// Walk down the tree looking for a discrepancy
1772		while ( ap[i] === bp[i] ) {
1773			i++;
1774		}
1775
1776		return i ?
1777			// Do a sibling check if the nodes have a common ancestor
1778			siblingCheck( ap[i], bp[i] ) :
1779
1780			// Otherwise nodes in our document sort first
1781			ap[i] === preferredDoc ? -1 :
1782			bp[i] === preferredDoc ? 1 :
1783			0;
1784	};
1785
1786	return document;
1787};
1788
1789Sizzle.matches = function( expr, elements ) {
1790	return Sizzle( expr, null, null, elements );
1791};
1792
1793Sizzle.matchesSelector = function( elem, expr ) {
1794	// Set document vars if needed
1795	if ( ( elem.ownerDocument || elem ) !== document ) {
1796		setDocument( elem );
1797	}
1798
1799	// Make sure that attribute selectors are quoted
1800	expr = expr.replace( rattributeQuotes, "='$1']" );
1801
1802	if ( support.matchesSelector && documentIsHTML &&
1803		!compilerCache[ expr + " " ] &&
1804		( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
1805		( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {
1806
1807		try {
1808			var ret = matches.call( elem, expr );
1809
1810			// IE 9's matchesSelector returns false on disconnected nodes
1811			if ( ret || support.disconnectedMatch ||
1812					// As well, disconnected nodes are said to be in a document
1813					// fragment in IE 9
1814					elem.document && elem.document.nodeType !== 11 ) {
1815				return ret;
1816			}
1817		} catch (e) {}
1818	}
1819
1820	return Sizzle( expr, document, null, [ elem ] ).length > 0;
1821};
1822
1823Sizzle.contains = function( context, elem ) {
1824	// Set document vars if needed
1825	if ( ( context.ownerDocument || context ) !== document ) {
1826		setDocument( context );
1827	}
1828	return contains( context, elem );
1829};
1830
1831Sizzle.attr = function( elem, name ) {
1832	// Set document vars if needed
1833	if ( ( elem.ownerDocument || elem ) !== document ) {
1834		setDocument( elem );
1835	}
1836
1837	var fn = Expr.attrHandle[ name.toLowerCase() ],
1838		// Don't get fooled by Object.prototype properties (jQuery #13807)
1839		val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
1840			fn( elem, name, !documentIsHTML ) :
1841			undefined;
1842
1843	return val !== undefined ?
1844		val :
1845		support.attributes || !documentIsHTML ?
1846			elem.getAttribute( name ) :
1847			(val = elem.getAttributeNode(name)) && val.specified ?
1848				val.value :
1849				null;
1850};
1851
1852Sizzle.escape = function( sel ) {
1853	return (sel + "").replace( rcssescape, fcssescape );
1854};
1855
1856Sizzle.error = function( msg ) {
1857	throw new Error( "Syntax error, unrecognized expression: " + msg );
1858};
1859
1860/**
1861 * Document sorting and removing duplicates
1862 * @param {ArrayLike} results
1863 */
1864Sizzle.uniqueSort = function( results ) {
1865	var elem,
1866		duplicates = [],
1867		j = 0,
1868		i = 0;
1869
1870	// Unless we *know* we can detect duplicates, assume their presence
1871	hasDuplicate = !support.detectDuplicates;
1872	sortInput = !support.sortStable && results.slice( 0 );
1873	results.sort( sortOrder );
1874
1875	if ( hasDuplicate ) {
1876		while ( (elem = results[i++]) ) {
1877			if ( elem === results[ i ] ) {
1878				j = duplicates.push( i );
1879			}
1880		}
1881		while ( j-- ) {
1882			results.splice( duplicates[ j ], 1 );
1883		}
1884	}
1885
1886	// Clear input after sorting to release objects
1887	// See https://github.com/jquery/sizzle/pull/225
1888	sortInput = null;
1889
1890	return results;
1891};
1892
1893/**
1894 * Utility function for retrieving the text value of an array of DOM nodes
1895 * @param {Array|Element} elem
1896 */
1897getText = Sizzle.getText = function( elem ) {
1898	var node,
1899		ret = "",
1900		i = 0,
1901		nodeType = elem.nodeType;
1902
1903	if ( !nodeType ) {
1904		// If no nodeType, this is expected to be an array
1905		while ( (node = elem[i++]) ) {

1906			// Do not traverse comment nodes
1907			ret += getText( node );
1908		}
1909	} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
1910		// Use textContent for elements
1911		// innerText usage removed for consistency of new lines (jQuery #11153)
1912		if ( typeof elem.textContent === "string" ) {
1913			return elem.textContent;
1914		} else {
1915			// Traverse its children
1916			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
1917				ret += getText( elem );
1918			}
1919		}
1920	} else if ( nodeType === 3 || nodeType === 4 ) {
1921		return elem.nodeValue;
1922	}
1923	// Do not include comment or processing instruction nodes
1924
1925	return ret;
1926};
1927
1928Expr = Sizzle.selectors = {
1929
1930	// Can be adjusted by the user
1931	cacheLength: 50,
1932
1933	createPseudo: markFunction,
1934
1935	match: matchExpr,
1936
1937	attrHandle: {},
1938
1939	find: {},
1940
1941	relative: {
1942		">": { dir: "parentNode", first: true },
1943		" ": { dir: "parentNode" },
1944		"+": { dir: "previousSibling", first: true },
1945		"~": { dir: "previousSibling" }
1946	},
1947
1948	preFilter: {
1949		"ATTR": function( match ) {
1950			match[1] = match[1].replace( runescape, funescape );
1951
1952			// Move the given value to match[3] whether quoted or unquoted
1953			match[3] = ( match[3] || match[4] || match[5] || "" ).replace( runescape, funescape );
1954
1955			if ( match[2] === "~=" ) {
1956				match[3] = " " + match[3] + " ";
1957			}
1958
1959			return match.slice( 0, 4 );
1960		},
1961
1962		"CHILD": function( match ) {
1963			/* matches from matchExpr["CHILD"]
1964				1 type (only|nth|...)
1965				2 what (child|of-type)
1966				3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
1967				4 xn-component of xn+y argument ([+-]?\d*n|)
1968				5 sign of xn-component
1969				6 x of xn-component
1970				7 sign of y-component
1971				8 y of y-component
1972			*/
1973			match[1] = match[1].toLowerCase();
1974
1975			if ( match[1].slice( 0, 3 ) === "nth" ) {
1976				// nth-* requires argument
1977				if ( !match[3] ) {
1978					Sizzle.error( match[0] );
1979				}
1980
1981				// numeric x and y parameters for Expr.filter.CHILD
1982				// remember that false/true cast respectively to 0/1
1983				match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) );
1984				match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" );
1985
1986			// other types prohibit arguments
1987			} else if ( match[3] ) {
1988				Sizzle.error( match[0] );
1989			}
1990
1991			return match;
1992		},
1993
1994		"PSEUDO": function( match ) {
1995			var excess,
1996				unquoted = !match[6] && match[2];
1997
1998			if ( matchExpr["CHILD"].test( match[0] ) ) {
1999				return null;
2000			}
2001
2002			// Accept quoted arguments as-is
2003			if ( match[3] ) {
2004				match[2] = match[4] || match[5] || "";
2005
2006			// Strip excess characters from unquoted arguments
2007			} else if ( unquoted && rpseudo.test( unquoted ) &&
2008				// Get excess from tokenize (recursively)
2009				(excess = tokenize( unquoted, true )) &&
2010				// advance to the next closing parenthesis
2011				(excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) {
2012
2013				// excess is a negative index
2014				match[0] = match[0].slice( 0, excess );
2015				match[2] = unquoted.slice( 0, excess );
2016			}
2017
2018			// Return only captures needed by the pseudo filter method (type and argument)
2019			return match.slice( 0, 3 );
2020		}
2021	},
2022
2023	filter: {
2024
2025		"TAG": function( nodeNameSelector ) {
2026			var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
2027			return nodeNameSelector === "*" ?
2028				function() { return true; } :
2029				function( elem ) {
2030					return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
2031				};
2032		},
2033
2034		"CLASS": function( className ) {
2035			var pattern = classCache[ className + " " ];
2036
2037			return pattern ||
2038				(pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) &&
2039				classCache( className, function( elem ) {
2040					return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "" );
2041				});
2042		},
2043
2044		"ATTR": function( name, operator, check ) {
2045			return function( elem ) {
2046				var result = Sizzle.attr( elem, name );
2047
2048				if ( result == null ) {
2049					return operator === "!=";
2050				}
2051				if ( !operator ) {
2052					return true;
2053				}
2054
2055				result += "";
2056
2057				return operator === "=" ? result === check :
2058					operator === "!=" ? result !== check :
2059					operator === "^=" ? check && result.indexOf( check ) === 0 :
2060					operator === "*=" ? check && result.indexOf( check ) > -1 :
2061					operator === "$=" ? check && result.slice( -check.length ) === check :
2062					operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 :
2063					operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
2064					false;
2065			};
2066		},
2067
2068		"CHILD": function( type, what, argument, first, last ) {
2069			var simple = type.slice( 0, 3 ) !== "nth",
2070				forward = type.slice( -4 ) !== "last",
2071				ofType = what === "of-type";
2072
2073			return first === 1 && last === 0 ?
2074
2075				// Shortcut for :nth-*(n)
2076				function( elem ) {
2077					return !!elem.parentNode;
2078				} :
2079
2080				function( elem, context, xml ) {
2081					var cache, uniqueCache, outerCache, node, nodeIndex, start,
2082						dir = simple !== forward ? "nextSibling" : "previousSibling",
2083						parent = elem.parentNode,
2084						name = ofType && elem.nodeName.toLowerCase(),
2085						useCache = !xml && !ofType,
2086						diff = false;
2087
2088					if ( parent ) {
2089
2090						// :(first|last|only)-(child|of-type)
2091						if ( simple ) {
2092							while ( dir ) {
2093								node = elem;
2094								while ( (node = node[ dir ]) ) {
2095									if ( ofType ?
2096										node.nodeName.toLowerCase() === name :
2097										node.nodeType === 1 ) {
2098
2099										return false;
2100									}
2101								}
2102								// Reverse direction for :only-* (if we haven't yet done so)
2103								start = dir = type === "only" && !start && "nextSibling";
2104							}
2105							return true;
2106						}
2107
2108						start = [ forward ? parent.firstChild : parent.lastChild ];
2109
2110						// non-xml :nth-child(...) stores cache data on `parent`
2111						if ( forward && useCache ) {
2112
2113							// Seek `elem` from a previously-cached index
2114
2115							// ...in a gzip-friendly way
2116							node = parent;
2117							outerCache = node[ expando ] || (node[ expando ] = {});
2118
2119							// Support: IE <9 only
2120							// Defend against cloned attroperties (jQuery gh-1709)
2121							uniqueCache = outerCache[ node.uniqueID ] ||
2122								(outerCache[ node.uniqueID ] = {});
2123
2124							cache = uniqueCache[ type ] || [];
2125							nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
2126							diff = nodeIndex && cache[ 2 ];
2127							node = nodeIndex && parent.childNodes[ nodeIndex ];
2128
2129							while ( (node = ++nodeIndex && node && node[ dir ] ||
2130
2131								// Fallback to seeking `elem` from the start
2132								(diff = nodeIndex = 0) || start.pop()) ) {
2133
2134								// When found, cache indexes on `parent` and break
2135								if ( node.nodeType === 1 && ++diff && node === elem ) {
2136									uniqueCache[ type ] = [ dirruns, nodeIndex, diff ];
2137									break;
2138								}
2139							}
2140
2141						} else {
2142							// Use previously-cached element index if available
2143							if ( useCache ) {
2144								// ...in a gzip-friendly way
2145								node = elem;
2146								outerCache = node[ expando ] || (node[ expando ] = {});
2147
2148								// Support: IE <9 only
2149								// Defend against cloned attroperties (jQuery gh-1709)
2150								uniqueCache = outerCache[ node.uniqueID ] ||
2151									(outerCache[ node.uniqueID ] = {});
2152
2153								cache = uniqueCache[ type ] || [];
2154								nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
2155								diff = nodeIndex;
2156							}
2157
2158							// xml :nth-child(...)
2159							// or :nth-last-child(...) or :nth(-last)?-of-type(...)
2160							if ( diff === false ) {
2161								// Use the same loop as above to seek `elem` from the start
2162								while ( (node = ++nodeIndex && node && node[ dir ] ||
2163									(diff = nodeIndex = 0) || start.pop()) ) {
2164
2165									if ( ( ofType ?
2166										node.nodeName.toLowerCase() === name :
2167										node.nodeType === 1 ) &&
2168										++diff ) {
2169
2170										// Cache the index of each encountered element
2171										if ( useCache ) {
2172											outerCache = node[ expando ] || (node[ expando ] = {});
2173
2174											// Support: IE <9 only
2175											// Defend against cloned attroperties (jQuery gh-1709)
2176											uniqueCache = outerCache[ node.uniqueID ] ||
2177												(outerCache[ node.uniqueID ] = {});
2178
2179											uniqueCache[ type ] = [ dirruns, diff ];
2180										}
2181
2182										if ( node === elem ) {
2183											break;
2184										}
2185									}
2186								}
2187							}
2188						}
2189
2190						// Incorporate the offset, then check against cycle size
2191						diff -= last;
2192						return diff === first || ( diff % first === 0 && diff / first >= 0 );
2193					}
2194				};
2195		},
2196
2197		"PSEUDO": function( pseudo, argument ) {
2198			// pseudo-class names are case-insensitive
2199			// http://www.w3.org/TR/selectors/#pseudo-classes
2200			// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
2201			// Remember that setFilters inherits from pseudos
2202			var args,
2203				fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
2204					Sizzle.error( "unsupported pseudo: " + pseudo );
2205
2206			// The user may use createPseudo to indicate that
2207			// arguments are needed to create the filter function
2208			// just as Sizzle does
2209			if ( fn[ expando ] ) {
2210				return fn( argument );
2211			}
2212
2213			// But maintain support for old signatures
2214			if ( fn.length > 1 ) {
2215				args = [ pseudo, pseudo, "", argument ];
2216				return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
2217					markFunction(function( seed, matches ) {
2218						var idx,
2219							matched = fn( seed, argument ),
2220							i = matched.length;
2221						while ( i-- ) {
2222							idx = indexOf( seed, matched[i] );
2223							seed[ idx ] = !( matches[ idx ] = matched[i] );
2224						}
2225					}) :
2226					function( elem ) {
2227						return fn( elem, 0, args );
2228					};
2229			}
2230
2231			return fn;
2232		}
2233	},
2234
2235	pseudos: {
2236		// Potentially complex pseudos
2237		"not": markFunction(function( selector ) {
2238			// Trim the selector passed to compile
2239			// to avoid treating leading and trailing
2240			// spaces as combinators
2241			var input = [],
2242				results = [],
2243				matcher = compile( selector.replace( rtrim, "$1" ) );
2244
2245			return matcher[ expando ] ?
2246				markFunction(function( seed, matches, context, xml ) {
2247					var elem,
2248						unmatched = matcher( seed, null, xml, [] ),
2249						i = seed.length;
2250
2251					// Match elements unmatched by `matcher`
2252					while ( i-- ) {
2253						if ( (elem = unmatched[i]) ) {
2254							seed[i] = !(matches[i] = elem);
2255						}
2256					}
2257				}) :
2258				function( elem, context, xml ) {
2259					input[0] = elem;
2260					matcher( input, null, xml, results );
2261					// Don't keep the element (issue #299)
2262					input[0] = null;
2263					return !results.pop();
2264				};
2265		}),
2266
2267		"has": markFunction(function( selector ) {
2268			return function( elem ) {
2269				return Sizzle( selector, elem ).length > 0;
2270			};
2271		}),
2272
2273		"contains": markFunction(function( text ) {
2274			text = text.replace( runescape, funescape );
2275			return function( elem ) {
2276				return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1;
2277			};
2278		}),
2279
2280		// "Whether an element is represented by a :lang() selector
2281		// is based solely on the element's language value
2282		// being equal to the identifier C,
2283		// or beginning with the identifier C immediately followed by "-".
2284		// The matching of C against the element's language value is performed case-insensitively.
2285		// The identifier C does not have to be a valid language name."
2286		// http://www.w3.org/TR/selectors/#lang-pseudo
2287		"lang": markFunction( function( lang ) {
2288			// lang value must be a valid identifier
2289			if ( !ridentifier.test(lang || "") ) {
2290				Sizzle.error( "unsupported lang: " + lang );
2291			}
2292			lang = lang.replace( runescape, funescape ).toLowerCase();
2293			return function( elem ) {
2294				var elemLang;
2295				do {
2296					if ( (elemLang = documentIsHTML ?
2297						elem.lang :
2298						elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) {
2299
2300						elemLang = elemLang.toLowerCase();
2301						return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
2302					}
2303				} while ( (elem = elem.parentNode) && elem.nodeType === 1 );
2304				return false;

2305			};
2306		}),
2307
2308		// Miscellaneous
2309		"target": function( elem ) {
2310			var hash = window.location && window.location.hash;
2311			return hash && hash.slice( 1 ) === elem.id;
2312		},
2313
2314		"root": function( elem ) {
2315			return elem === docElem;
2316		},
2317
2318		"focus": function( elem ) {
2319			return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
2320		},
2321
2322		// Boolean properties
2323		"enabled": createDisabledPseudo( false ),
2324		"disabled": createDisabledPseudo( true ),
2325
2326		"checked": function( elem ) {
2327			// In CSS3, :checked should return both checked and selected elements
2328			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
2329			var nodeName = elem.nodeName.toLowerCase();
2330			return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);
2331		},
2332
2333		"selected": function( elem ) {
2334			// Accessing this property makes selected-by-default
2335			// options in Safari work properly
2336			if ( elem.parentNode ) {
2337				elem.parentNode.selectedIndex;
2338			}
2339
2340			return elem.selected === true;
2341		},
2342
2343		// Contents
2344		"empty": function( elem ) {
2345			// http://www.w3.org/TR/selectors/#empty-pseudo
2346			// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
2347			//   but not by others (comment: 8; processing instruction: 7; etc.)
2348			// nodeType < 6 works because attributes (2) do not appear as children
2349			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
2350				if ( elem.nodeType < 6 ) {
2351					return false;
2352				}
2353			}
2354			return true;
2355		},
2356
2357		"parent": function( elem ) {
2358			return !Expr.pseudos["empty"]( elem );
2359		},
2360
2361		// Element/input types
2362		"header": function( elem ) {
2363			return rheader.test( elem.nodeName );
2364		},
2365
2366		"input": function( elem ) {
2367			return rinputs.test( elem.nodeName );
2368		},
2369
2370		"button": function( elem ) {
2371			var name = elem.nodeName.toLowerCase();
2372			return name === "input" && elem.type === "button" || name === "button";
2373		},
2374
2375		"text": function( elem ) {
2376			var attr;
2377			return elem.nodeName.toLowerCase() === "input" &&
2378				elem.type === "text" &&
2379
2380				// Support: IE<8
2381				// New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
2382				( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text" );
2383		},
2384
2385		// Position-in-collection
2386		"first": createPositionalPseudo(function() {
2387			return [ 0 ];
2388		}),
2389
2390		"last": createPositionalPseudo(function( matchIndexes, length ) {
2391			return [ length - 1 ];
2392		}),
2393
2394		"eq": createPositionalPseudo(function( matchIndexes, length, argument ) {
2395			return [ argument < 0 ? argument + length : argument ];
2396		}),
2397
2398		"even": createPositionalPseudo(function( matchIndexes, length ) {
2399			var i = 0;
2400			for ( ; i < length; i += 2 ) {
2401				matchIndexes.push( i );
2402			}
2403			return matchIndexes;
2404		}),
2405
2406		"odd": createPositionalPseudo(function( matchIndexes, length ) {
2407			var i = 1;
2408			for ( ; i < length; i += 2 ) {
2409				matchIndexes.push( i );
2410			}
2411			return matchIndexes;
2412		}),
2413
2414		"lt": createPositionalPseudo(function( matchIndexes, length, argument ) {
2415			var i = argument < 0 ? argument + length : argument;
2416			for ( ; --i >= 0; ) {
2417				matchIndexes.push( i );
2418			}
2419			return matchIndexes;
2420		}),
2421
2422		"gt": createPositionalPseudo(function( matchIndexes, length, argument ) {
2423			var i = argument < 0 ? argument + length : argument;
2424			for ( ; ++i < length; ) {
2425				matchIndexes.push( i );
2426			}
2427			return matchIndexes;
2428		})
2429	}
2430};
2431
2432Expr.pseudos["nth"] = Expr.pseudos["eq"];
2433
2434// Add button/input type pseudos
2435for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
2436	Expr.pseudos[ i ] = createInputPseudo( i );
2437}
2438for ( i in { submit: true, reset: true } ) {
2439	Expr.pseudos[ i ] = createButtonPseudo( i );
2440}
2441
2442// Easy API for creating new setFilters
2443function setFilters() {}
2444setFilters.prototype = Expr.filters = Expr.pseudos;
2445Expr.setFilters = new setFilters();
2446
2447tokenize = Sizzle.tokenize = function( selector, parseOnly ) {
2448	var matched, match, tokens, type,
2449		soFar, groups, preFilters,
2450		cached = tokenCache[ selector + " " ];
2451
2452	if ( cached ) {
2453		return parseOnly ? 0 : cached.slice( 0 );
2454	}
2455
2456	soFar = selector;
2457	groups = [];
2458	preFilters = Expr.preFilter;
2459
2460	while ( soFar ) {
2461
2462		// Comma and first run
2463		if ( !matched || (match = rcomma.exec( soFar )) ) {
2464			if ( match ) {
2465				// Don't consume trailing commas as valid
2466				soFar = soFar.slice( match[0].length ) || soFar;
2467			}
2468			groups.push( (tokens = []) );
2469		}
2470
2471		matched = false;
2472
2473		// Combinators
2474		if ( (match = rcombinators.exec( soFar )) ) {
2475			matched = match.shift();
2476			tokens.push({
2477				value: matched,
2478				// Cast descendant combinators to space
2479				type: match[0].replace( rtrim, " " )
2480			});
2481			soFar = soFar.slice( matched.length );
2482		}
2483
2484		// Filters
2485		for ( type in Expr.filter ) {
2486			if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||
2487				(match = preFilters[ type ]( match ))) ) {
2488				matched = match.shift();
2489				tokens.push({
2490					value: matched,
2491					type: type,
2492					matches: match
2493				});
2494				soFar = soFar.slice( matched.length );
2495			}
2496		}
2497
2498		if ( !matched ) {
2499			break;
2500		}
2501	}
2502
2503	// Return the length of the invalid excess
2504	// if we're just parsing
2505	// Otherwise, throw an error or return tokens
2506	return parseOnly ?
2507		soFar.length :
2508		soFar ?
2509			Sizzle.error( selector ) :
2510			// Cache the tokens
2511			tokenCache( selector, groups ).slice( 0 );
2512};
2513
2514function toSelector( tokens ) {
2515	var i = 0,
2516		len = tokens.length,
2517		selector = "";
2518	for ( ; i < len; i++ ) {
2519		selector += tokens[i].value;
2520	}
2521	return selector;
2522}
2523
2524function addCombinator( matcher, combinator, base ) {
2525	var dir = combinator.dir,
2526		skip = combinator.next,
2527		key = skip || dir,
2528		checkNonElements = base && key === "parentNode",
2529		doneName = done++;
2530
2531	return combinator.first ?
2532		// Check against closest ancestor/preceding element
2533		function( elem, context, xml ) {
2534			while ( (elem = elem[ dir ]) ) {
2535				if ( elem.nodeType === 1 || checkNonElements ) {
2536					return matcher( elem, context, xml );
2537				}
2538			}
2539			return false;
2540		} :
2541
2542		// Check against all ancestor/preceding elements
2543		function( elem, context, xml ) {
2544			var oldCache, uniqueCache, outerCache,
2545				newCache = [ dirruns, doneName ];
2546
2547			// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching
2548			if ( xml ) {
2549				while ( (elem = elem[ dir ]) ) {
2550					if ( elem.nodeType === 1 || checkNonElements ) {
2551						if ( matcher( elem, context, xml ) ) {
2552							return true;
2553						}
2554					}
2555				}
2556			} else {
2557				while ( (elem = elem[ dir ]) ) {
2558					if ( elem.nodeType === 1 || checkNonElements ) {
2559						outerCache = elem[ expando ] || (elem[ expando ] = {});
2560
2561						// Support: IE <9 only
2562						// Defend against cloned attroperties (jQuery gh-1709)
2563						uniqueCache = outerCache[ elem.uniqueID ] || (outerCache[ elem.uniqueID ] = {});
2564
2565						if ( skip && skip === elem.nodeName.toLowerCase() ) {
2566							elem = elem[ dir ] || elem;
2567						} else if ( (oldCache = uniqueCache[ key ]) &&
2568							oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {
2569
2570							// Assign to newCache so results back-propagate to previous elements
2571							return (newCache[ 2 ] = oldCache[ 2 ]);
2572						} else {
2573							// Reuse newcache so results back-propagate to previous elements
2574							uniqueCache[ key ] = newCache;
2575
2576							// A match means we're done; a fail means we have to keep checking
2577							if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) {
2578								return true;
2579							}
2580						}
2581					}
2582				}
2583			}
2584			return false;
2585		};
2586}
2587
2588function elementMatcher( matchers ) {
2589	return matchers.length > 1 ?
2590		function( elem, context, xml ) {
2591			var i = matchers.length;
2592			while ( i-- ) {
2593				if ( !matchers[i]( elem, context, xml ) ) {
2594					return false;
2595				}
2596			}
2597			return true;
2598		} :
2599		matchers[0];
2600}
2601
2602function multipleContexts( selector, contexts, results ) {
2603	var i = 0,
2604		len = contexts.length;
2605	for ( ; i < len; i++ ) {
2606		Sizzle( selector, contexts[i], results );
2607	}
2608	return results;
2609}
2610
2611function condense( unmatched, map, filter, context, xml ) {
2612	var elem,
2613		newUnmatched = [],
2614		i = 0,
2615		len = unmatched.length,
2616		mapped = map != null;
2617
2618	for ( ; i < len; i++ ) {
2619		if ( (elem = unmatched[i]) ) {
2620			if ( !filter || filter( elem, context, xml ) ) {
2621				newUnmatched.push( elem );
2622				if ( mapped ) {
2623					map.push( i );
2624				}
2625			}
2626		}
2627	}
2628
2629	return newUnmatched;
2630}
2631
2632function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
2633	if ( postFilter && !postFilter[ expando ] ) {
2634		postFilter = setMatcher( postFilter );
2635	}
2636	if ( postFinder && !postFinder[ expando ] ) {
2637		postFinder = setMatcher( postFinder, postSelector );
2638	}
2639	return markFunction(function( seed, results, context, xml ) {
2640		var temp, i, elem,
2641			preMap = [],
2642			postMap = [],
2643			preexisting = results.length,
2644
2645			// Get initial elements from seed or context
2646			elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ),
2647
2648			// Prefilter to get matcher input, preserving a map for seed-results synchronization
2649			matcherIn = preFilter && ( seed || !selector ) ?
2650				condense( elems, preMap, preFilter, context, xml ) :
2651				elems,
2652
2653			matcherOut = matcher ?
2654				// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
2655				postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
2656
2657					// ...intermediate processing is necessary
2658					[] :
2659
2660					// ...otherwise use results directly
2661					results :
2662				matcherIn;
2663
2664		// Find primary matches
2665		if ( matcher ) {
2666			matcher( matcherIn, matcherOut, context, xml );
2667		}
2668
2669		// Apply postFilter
2670		if ( postFilter ) {
2671			temp = condense( matcherOut, postMap );
2672			postFilter( temp, [], context, xml );
2673
2674			// Un-match failing elements by moving them back to matcherIn
2675			i = temp.length;
2676			while ( i-- ) {
2677				if ( (elem = temp[i]) ) {
2678					matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);
2679				}
2680			}
2681		}
2682
2683		if ( seed ) {
2684			if ( postFinder || preFilter ) {
2685				if ( postFinder ) {
2686					// Get the final matcherOut by condensing this intermediate into postFinder contexts
2687					temp = [];
2688					i = matcherOut.length;
2689					while ( i-- ) {
2690						if ( (elem = matcherOut[i]) ) {
2691							// Restore matcherIn since elem is not yet a final match
2692							temp.push( (matcherIn[i] = elem) );
2693						}
2694					}
2695					postFinder( null, (matcherOut = []), temp, xml );
2696				}
2697
2698				// Move matched elements from seed to results to keep them synchronized
2699				i = matcherOut.length;
2700				while ( i-- ) {
2701					if ( (elem = matcherOut[i]) &&
2702						(temp = postFinder ? indexOf( seed, elem ) : preMap[i]) > -1 ) {
2703
2704						seed[temp] = !(results[temp] = elem);
2705					}
2706				}
2707			}
2708
2709		// Add elements to results, through postFinder if defined
2710		} else {
2711			matcherOut = condense(
2712				matcherOut === results ?
2713					matcherOut.splice( preexisting, matcherOut.length ) :
2714					matcherOut
2715			);
2716			if ( postFinder ) {
2717				postFinder( null, results, matcherOut, xml );
2718			} else {
2719				push.apply( results, matcherOut );
2720			}
2721		}
2722	});
2723}
2724
2725function matcherFromTokens( tokens ) {
2726	var checkContext, matcher, j,
2727		len = tokens.length,
2728		leadingRelative = Expr.relative[ tokens[0].type ],
2729		implicitRelative = leadingRelative || Expr.relative[" "],
2730		i = leadingRelative ? 1 : 0,
2731
2732		// The foundational matcher ensures that elements are reachable from top-level context(s)
2733		matchContext = addCombinator( function( elem ) {
2734			return elem === checkContext;
2735		}, implicitRelative, true ),
2736		matchAnyContext = addCombinator( function( elem ) {
2737			return indexOf( checkContext, elem ) > -1;
2738		}, implicitRelative, true ),
2739		matchers = [ function( elem, context, xml ) {
2740			var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
2741				(checkContext = context).nodeType ?
2742					matchContext( elem, context, xml ) :
2743					matchAnyContext( elem, context, xml ) );
2744			// Avoid hanging onto element (issue #299)
2745			checkContext = null;
2746			return ret;
2747		} ];
2748
2749	for ( ; i < len; i++ ) {
2750		if ( (matcher = Expr.relative[ tokens[i].type ]) ) {
2751			matchers = [ addCombinator(elementMatcher( matchers ), matcher) ];
2752		} else {
2753			matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );
2754
2755			// Return special upon seeing a positional matcher
2756			if ( matcher[ expando ] ) {
2757				// Find the next relative operator (if any) for proper handling
2758				j = ++i;
2759				for ( ; j < len; j++ ) {
2760					if ( Expr.relative[ tokens[j].type ] ) {
2761						break;
2762					}
2763				}
2764				return setMatcher(
2765					i > 1 && elementMatcher( matchers ),
2766					i > 1 && toSelector(
2767						// If the preceding token was a descendant combinator, insert an implicit any-element `*`
2768						tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" })
2769					).replace( rtrim, "$1" ),
2770					matcher,
2771					i < j && matcherFromTokens( tokens.slice( i, j ) ),
2772					j < len && matcherFromTokens( (tokens = tokens.slice( j )) ),
2773					j < len && toSelector( tokens )
2774				);
2775			}
2776			matchers.push( matcher );
2777		}
2778	}
2779
2780	return elementMatcher( matchers );
2781}
2782
2783function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
2784	var bySet = setMatchers.length > 0,
2785		byElement = elementMatchers.length > 0,
2786		superMatcher = function( seed, context, xml, results, outermost ) {
2787			var elem, j, matcher,
2788				matchedCount = 0,
2789				i = "0",
2790				unmatched = seed && [],
2791				setMatched = [],
2792				contextBackup = outermostContext,
2793				// We must always have either seed elements or outermost context
2794				elems = seed || byElement && Expr.find["TAG"]( "*", outermost ),
2795				// Use integer dirruns iff this is the outermost matcher
2796				dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1),
2797				len = elems.length;
2798
2799			if ( outermost ) {
2800				outermostContext = context === document || context || outermost;
2801			}
2802
2803			// Add elements passing elementMatchers directly to results
2804			// Support: IE<9, Safari
2805			// Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
2806			for ( ; i !== len && (elem = elems[i]) != null; i++ ) {
2807				if ( byElement && elem ) {
2808					j = 0;
2809					if ( !context && elem.ownerDocument !== document ) {
2810						setDocument( elem );
2811						xml = !documentIsHTML;
2812					}
2813					while ( (matcher = elementMatchers[j++]) ) {
2814						if ( matcher( elem, context || document, xml) ) {
2815							results.push( elem );
2816							break;
2817						}
2818					}
2819					if ( outermost ) {
2820						dirruns = dirrunsUnique;
2821					}
2822				}
2823
2824				// Track unmatched elements for set filters
2825				if ( bySet ) {
2826					// They will have gone through all possible matchers
2827					if ( (elem = !matcher && elem) ) {
2828						matchedCount--;
2829					}
2830
2831					// Lengthen the array for every element, matched or not
2832					if ( seed ) {
2833						unmatched.push( elem );
2834					}
2835				}
2836			}
2837
2838			// `i` is now the count of elements visited above, and adding it to `matchedCount`
2839			// makes the latter nonnegative.
2840			matchedCount += i;
2841
2842			// Apply set filters to unmatched elements
2843			// NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`
2844			// equals `i`), unless we didn't visit _any_ elements in the above loop because we have
2845			// no element matchers and no seed.
2846			// Incrementing an initially-string "0" `i` allows `i` to remain a string only in that
2847			// case, which will result in a "00" `matchedCount` that differs from `i` but is also
2848			// numerically zero.
2849			if ( bySet && i !== matchedCount ) {
2850				j = 0;
2851				while ( (matcher = setMatchers[j++]) ) {
2852					matcher( unmatched, setMatched, context, xml );
2853				}
2854
2855				if ( seed ) {
2856					// Reintegrate element matches to eliminate the need for sorting
2857					if ( matchedCount > 0 ) {
2858						while ( i-- ) {
2859							if ( !(unmatched[i] || setMatched[i]) ) {
2860								setMatched[i] = pop.call( results );
2861							}
2862						}
2863					}
2864
2865					// Discard index placeholder values to get only actual matches
2866					setMatched = condense( setMatched );
2867				}
2868
2869				// Add matches to results
2870				push.apply( results, setMatched );
2871
2872				// Seedless set matches succeeding multiple successful matchers stipulate sorting
2873				if ( outermost && !seed && setMatched.length > 0 &&
2874					( matchedCount + setMatchers.length ) > 1 ) {
2875
2876					Sizzle.uniqueSort( results );
2877				}
2878			}
2879
2880			// Override manipulation of globals by nested matchers
2881			if ( outermost ) {
2882				dirruns = dirrunsUnique;
2883				outermostContext = contextBackup;
2884			}
2885
2886			return unmatched;
2887		};
2888
2889	return bySet ?
2890		markFunction( superMatcher ) :
2891		superMatcher;
2892}
2893
2894compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {
2895	var i,
2896		setMatchers = [],
2897		elementMatchers = [],
2898		cached = compilerCache[ selector + " " ];
2899
2900	if ( !cached ) {
2901		// Generate a function of recursive functions that can be used to check each element
2902		if ( !match ) {
2903			match = tokenize( selector );
2904		}
2905		i = match.length;
2906		while ( i-- ) {
2907			cached = matcherFromTokens( match[i] );
2908			if ( cached[ expando ] ) {
2909				setMatchers.push( cached );
2910			} else {
2911				elementMatchers.push( cached );
2912			}
2913		}
2914
2915		// Cache the compiled function
2916		cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );
2917
2918		// Save selector and tokenization
2919		cached.selector = selector;
2920	}
2921	return cached;
2922};
2923
2924/**
2925 * A low-level selection function that works with Sizzle's compiled
2926 *  selector functions
2927 * @param {String|Function} selector A selector or a pre-compiled
2928 *  selector function built with Sizzle.compile
2929 * @param {Element} context
2930 * @param {Array} [results]
2931 * @param {Array} [seed] A set of elements to match against
2932 */
2933select = Sizzle.select = function( selector, context, results, seed ) {
2934	var i, tokens, token, type, find,
2935		compiled = typeof selector === "function" && selector,
2936		match = !seed && tokenize( (selector = compiled.selector || selector) );
2937
2938	results = results || [];
2939
2940	// Try to minimize operations if there is only one selector in the list and no seed
2941	// (the latter of which guarantees us context)
2942	if ( match.length === 1 ) {
2943
2944		// Reduce context if the leading compound selector is an ID
2945		tokens = match[0] = match[0].slice( 0 );
2946		if ( tokens.length > 2 && (token = tokens[0]).type === "ID" &&
2947				context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[1].type ] ) {
2948
2949			context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0];
2950			if ( !context ) {
2951				return results;
2952
2953			// Precompiled matchers will still verify ancestry, so step up a level
2954			} else if ( compiled ) {
2955				context = context.parentNode;
2956			}
2957
2958			selector = selector.slice( tokens.shift().value.length );
2959		}
2960
2961		// Fetch a seed set for right-to-left matching
2962		i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length;
2963		while ( i-- ) {
2964			token = tokens[i];
2965
2966			// Abort if we hit a combinator
2967			if ( Expr.relative[ (type = token.type) ] ) {
2968				break;
2969			}
2970			if ( (find = Expr.find[ type ]) ) {
2971				// Search, expanding context for leading sibling combinators
2972				if ( (seed = find(
2973					token.matches[0].replace( runescape, funescape ),
2974					rsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context
2975				)) ) {
2976
2977					// If seed is empty or no tokens remain, we can return early
2978					tokens.splice( i, 1 );
2979					selector = seed.length && toSelector( tokens );
2980					if ( !selector ) {
2981						push.apply( results, seed );
2982						return results;
2983					}
2984
2985					break;
2986				}
2987			}
2988		}
2989	}
2990
2991	// Compile and execute a filtering function if one is not provided
2992	// Provide `match` to avoid retokenization if we modified the selector above
2993	( compiled || compile( selector, match ) )(
2994		seed,
2995		context,
2996		!documentIsHTML,
2997		results,
2998		!context || rsibling.test( selector ) && testContext( context.parentNode ) || context
2999	);
3000	return results;
3001};
3002
3003// One-time assignments
3004
3005// Sort stability
3006support.sortStable = expando.split("").sort( sortOrder ).join("") === expando;
3007
3008// Support: Chrome 14-35+
3009// Always assume duplicates if they aren't passed to the comparison function
3010support.detectDuplicates = !!hasDuplicate;
3011
3012// Initialize against the default document
3013setDocument();
3014
3015// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
3016// Detached nodes confoundingly follow *each other*
3017support.sortDetached = assert(function( el ) {
3018	// Should return 1, but returns 4 (following)
3019	return el.compareDocumentPosition( document.createElement("fieldset") ) & 1;
3020});
3021
3022// Support: IE<8
3023// Prevent attribute/property "interpolation"
3024// https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
3025if ( !assert(function( el ) {
3026	el.innerHTML = "<a href='#'></a>";
3027	return el.firstChild.getAttribute("href") === "#" ;
3028}) ) {
3029	addHandle( "type|href|height|width", function( elem, name, isXML ) {
3030		if ( !isXML ) {
3031			return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 );
3032		}
3033	});
3034}
3035
3036// Support: IE<9
3037// Use defaultValue in place of getAttribute("value")
3038if ( !support.attributes || !assert(function( el ) {
3039	el.innerHTML = "<input/>";
3040	el.firstChild.setAttribute( "value", "" );
3041	return el.firstChild.getAttribute( "value" ) === "";
3042}) ) {
3043	addHandle( "value", function( elem, name, isXML ) {
3044		if ( !isXML && elem.nodeName.toLowerCase() === "input" ) {
3045			return elem.defaultValue;
3046		}
3047	});
3048}
3049
3050// Support: IE<9
3051// Use getAttributeNode to fetch booleans when getAttribute lies
3052if ( !assert(function( el ) {
3053	return el.getAttribute("disabled") == null;
3054}) ) {
3055	addHandle( booleans, function( elem, name, isXML ) {
3056		var val;
3057		if ( !isXML ) {
3058			return elem[ name ] === true ? name.toLowerCase() :
3059					(val = elem.getAttributeNode( name )) && val.specified ?
3060					val.value :
3061				null;
3062		}
3063	});
3064}
3065
3066return Sizzle;
3067
3068})( window );
3069
3070
3071
3072jQuery.find = Sizzle;
3073jQuery.expr = Sizzle.selectors;
3074
3075// Deprecated
3076jQuery.expr[ ":" ] = jQuery.expr.pseudos;
3077jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;
3078jQuery.text = Sizzle.getText;
3079jQuery.isXMLDoc = Sizzle.isXML;
3080jQuery.contains = Sizzle.contains;
3081jQuery.escapeSelector = Sizzle.escape;
3082
3083
3084
3085
3086var dir = function( elem, dir, until ) {
3087	var matched = [],
3088		truncate = until !== undefined;
3089
3090	while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) {
3091		if ( elem.nodeType === 1 ) {
3092			if ( truncate && jQuery( elem ).is( until ) ) {
3093				break;
3094			}
3095			matched.push( elem );
3096		}
3097	}
3098	return matched;
3099};
3100
3101
3102var siblings = function( n, elem ) {
3103	var matched = [];
3104
3105	for ( ; n; n = n.nextSibling ) {
3106		if ( n.nodeType === 1 && n !== elem ) {
3107			matched.push( n );
3108		}
3109	}
3110
3111	return matched;
3112};
3113
3114
3115var rneedsContext = jQuery.expr.match.needsContext;
3116
3117
3118
3119function nodeName( elem, name ) {
3120
3121  return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
3122
3123};
3124var rsingleTag = ( /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i );
3125
3126
3127