https://shinhoglobal.com/js/custom/lyt-cn-careers.js?MMHzV4aty1

111	// you try to trace through "use strict" call chains. (#13335)
112	//"use strict";
113	var deletedIds = [];
114
115	var document = window.document;
116
117	var slice = deletedIds.slice;
118
119	var concat = deletedIds.concat;
120
121	var push = deletedIds.push;
122
123	var indexOf = deletedIds.indexOf;
124
125	var class2type = {};
126
127	var toString = class2type.toString;
128
129	var hasOwn = class2type.hasOwnProperty;
130
131	var support = {};
132
133	var version = "1.12.4",
134
135
136	// Define a local copy of jQuery
137	jQuery = function (selector, context) {
138
139		// The jQuery object is actually just the init constructor 'enhanced'
140		// Need init if jQuery is called (just allow error to be thrown if not included)
141		return new jQuery.fn.init(selector, context);
142	},
143
144
145	// Support: Android<4.1, IE<9
146	// Make sure we trim BOM and NBSP
147	rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
148
149
150	// Matches dashed string for camelizing
151	rmsPrefix = /^-ms-/,
152	    rdashAlpha = /-([\da-z])/gi,
153
154
155	// Used by jQuery.camelCase as callback to replace()
156	fcamelCase = function (all, letter) {
157		return letter.toUpperCase();
158	};
159
160	jQuery.fn = jQuery.prototype = {
161
162		// The current version of jQuery being used
163		jquery: version,
164
165		constructor: jQuery,
166
167		// Start with an empty selector
168		selector: "",
169
170		// The default length of a jQuery object is 0
171		length: 0,
172
173		toArray: function () {
174			return slice.call(this);
175		},
176
177		// Get the Nth element in the matched element set OR
178		// Get the whole matched element set as a clean array
179		get: function (num) {
180			return num != null ?
181
182			// Return just the one element from the set
183			num < 0 ? this[num + this.length] : this[num] :
184
185			// Return all the elements in a clean array
186			slice.call(this);
187		},
188
189		// Take an array of elements and push it onto the stack
190		// (returning the new matched element set)
191		pushStack: function (elems) {
192
193			// Build a new jQuery matched element set
194			var ret = jQuery.merge(this.constructor(), elems);
195
196			// Add the old object onto the stack (as a reference)
197			ret.prevObject = this;
198			ret.context = this.context;
199
200			// Return the newly-formed element set
201			return ret;
202		},
203
204		// Execute a callback for every element in the matched set.
205		each: function (callback) {
206			return jQuery.each(this, callback);
207		},
208
209		map: function (callback) {
210			return this.pushStack(jQuery.map(this, function (elem, i) {
211				return callback.call(elem, i, elem);
212			}));
213		},
214
215		slice: function () {
216			return this.pushStack(slice.apply(this, arguments));
217		},
218
219		first: function () {
220			return this.eq(0);
221		},
222
223		last: function () {
224			return this.eq(-1);
225		},
226
227		eq: function (i) {
228			var len = this.length,
229			    j = +i + (i < 0 ? len : 0);
230			return this.pushStack(j >= 0 && j < len ? [this[j]] : []);
231		},
232
233		end: function () {
234			return this.prevObject || this.constructor();
235		},
236
237		// For internal use only.
238		// Behaves like an Array's method, not like a jQuery method.
239		push: push,
240		sort: deletedIds.sort,
241		splice: deletedIds.splice
242	};
243
244	jQuery.extend = jQuery.fn.extend = function () {
245		var src,
246		    copyIsArray,
247		    copy,
248		    name,
249		    options,
250		    clone,
251		    target = arguments[0] || {},
252		    i = 1,
253		    length = arguments.length,
254		    deep = false;
255
256		// Handle a deep copy situation
257		if (typeof target === "boolean") {
258			deep = target;
259
260			// skip the boolean and the target
261			target = arguments[i] || {};
262			i++;
263		}
264
265		// Handle case when target is a string or something (possible in deep copy)
266		if (typeof target !== "object" && !jQuery.isFunction(target)) {
267			target = {};
268		}
269
270		// extend jQuery itself if only one argument is passed
271		if (i === length) {
272			target = this;
273			i--;
274		}
275
276		for (; i < length; i++) {
277
278			// Only deal with non-null/undefined values
279			if ((options = arguments[i]) != null) {
280
281				// Extend the base object
282				for (name in options) {
283					src = target[name];
284					copy = options[name];
285
286					// Prevent never-ending loop
287					if (target === copy) {
288						continue;
289					}
290
291					// Recurse if we're merging plain objects or arrays
292					if (deep && copy && (jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)))) {
293
294						if (copyIsArray) {
295							copyIsArray = false;

296							clone = src && jQuery.isArray(src) ? src : [];
297						} else {
298							clone = src && jQuery.isPlainObject(src) ? src : {};
299						}
300
301						// Never move original objects, clone them
302						target[name] = jQuery.extend(deep, clone, copy);
303
304						// Don't bring in undefined values
305					} else if (copy !== undefined) {
306						target[name] = copy;
307					}
308				}
309			}
310		}
311
312		// Return the modified object
313		return target;
314	};
315
316	jQuery.extend({
317
318		// Unique for each copy of jQuery on the page
319		expando: "jQuery" + (version + Math.random()).replace(/\D/g, ""),
320
321		// Assume jQuery is ready without the ready module
322		isReady: true,
323
324		error: function (msg) {
325			throw new Error(msg);
326		},
327
328		noop: function () {},
329
330		// See test/unit/core.js for details concerning isFunction.
331		// Since version 1.3, DOM methods and functions like alert
332		// aren't supported. They return false on IE (#2968).
333		isFunction: function (obj) {
334			return jQuery.type(obj) === "function";
335		},
336
337		isArray: Array.isArray || function (obj) {
338			return jQuery.type(obj) === "array";
339		},
340
341		isWindow: function (obj) {
342			/* jshint eqeqeq: false */
343			return obj != null && obj == obj.window;
344		},
345
346		isNumeric: function (obj) {
347
348			// parseFloat NaNs numeric-cast false positives (null|true|false|"")
349			// ...but misinterprets leading-number strings, particularly hex literals ("0x...")
350			// subtraction forces infinities to NaN
351			// adding 1 corrects loss of precision from parseFloat (#15100)
352			var realStringObj = obj && obj.toString();
353			return !jQuery.isArray(obj) && realStringObj - parseFloat(realStringObj) + 1 >= 0;
354		},
355
356		isEmptyObject: function (obj) {
357			var name;
358			for (name in obj) {
359				return false;
360			}
361			return true;
362		},
363
364		isPlainObject: function (obj) {
365			var key;
366
367			// Must be an Object.
368			// Because of IE, we also have to check the presence of the constructor property.
369			// Make sure that DOM nodes and window objects don't pass through, as well
370			if (!obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow(obj)) {
371				return false;
372			}
373
374			try {
375
376				// Not own constructor property must be Object
377				if (obj.constructor && !hasOwn.call(obj, "constructor") && !hasOwn.call(obj.constructor.prototype, "isPrototypeOf")) {
378					return false;
379				}
380			} catch (e) {
381
382				// IE8,9 Will throw exceptions on certain host objects #9897
383				return false;
384			}
385
386			// Support: IE<9
387			// Handle iteration over inherited properties before own properties.
388			if (!support.ownFirst) {
389				for (key in obj) {
390					return hasOwn.call(obj, key);
391				}
392			}
393
394			// Own properties are enumerated firstly, so to speed up,
395			// if last one is own, then all properties are own.
396			for (key in obj) {}
397
398			return key === undefined || hasOwn.call(obj, key);
399		},
400
401		type: function (obj) {
402			if (obj == null) {
403				return obj + "";
404			}
405			return typeof obj === "object" || typeof obj === "function" ? class2type[toString.call(obj)] || "object" : typeof obj;
406		},
407
408		// Workarounds based on findings by Jim Driscoll
409		// http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
410		globalEval: function (data) {
411			if (data && jQuery.trim(data)) {
412
413				// We use execScript on Internet Explorer
414				// We use an anonymous function so that context is window
415				// rather than jQuery in Firefox
416				(window.execScript || function (data) {
417					window["eval"].call(window, data); // jscs:ignore requireDotNotation
418				})(data);
419			}
420		},
421
422		// Convert dashed to camelCase; used by the css and data modules
423		// Microsoft forgot to hump their vendor prefix (#9572)
424		camelCase: function (string) {
425			return string.replace(rmsPrefix, "ms-").replace(rdashAlpha, fcamelCase);
426		},
427
428		nodeName: function (elem, name) {
429			return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
430		},
431
432		each: function (obj, callback) {
433			var length,
434			    i = 0;
435
436			if (isArrayLike(obj)) {
437				length = obj.length;
438				for (; i < length; i++) {
439					if (callback.call(obj[i], i, obj[i]) === false) {
440						break;
441					}
442				}
443			} else {
444				for (i in obj) {
445					if (callback.call(obj[i], i, obj[i]) === false) {
446						break;
447					}
448				}
449			}
450
451			return obj;
452		},
453
454		// Support: Android<4.1, IE<9
455		trim: function (text) {
456			return text == null ? "" : (text + "").replace(rtrim, "");
457		},
458
459		// results is for internal usage only
460		makeArray: function (arr, results) {
461			var ret = results || [];
462
463			if (arr != null) {
464				if (isArrayLike(Object(arr))) {
465					jQuery.merge(ret, typeof arr === "string" ? [arr] : arr);
466				} else {
467					push.call(ret, arr);
468				}
469			}
470
471			return ret;
472		},
473
474		inArray: function (elem, arr, i) {
475			var len;
476
477			if (arr) {
478				if (indexOf) {
479					return indexOf.call(arr, elem, i);
480				}
481
482				len = arr.length;
483				i = i ? i < 0 ? Math.max(0, len + i) : i : 0;
484
485				for (; i < len; i++) {
486
487					// Skip accessing in sparse arrays
488					if (i in arr && arr[i] === elem) {
489						return i;
490					}
491				}
492			}
493
494			return -1;
495		},
496
497		merge: function (first, second) {
498			var len = +second.length,
499			    j = 0,
500			    i = first.length;
501
502			while (j < len) {
503				first[i++] = second[j++];
504			}
505
506			// Support: IE<9
507			// Workaround casting of .length to NaN on otherwise arraylike objects (e.g., NodeLists)
508			if (len !== len) {
509				while (second[j] !== undefined) {
510					first[i++] = second[j++];
511				}
512			}
513
514			first.length = i;
515
516			return first;
517		},
518
519		grep: function (elems, callback, invert) {
520			var callbackInverse,
521			    matches = [],
522			    i = 0,
523			    length = elems.length,
524			    callbackExpect = !invert;
525
526			// Go through the array, only saving the items
527			// that pass the validator function
528			for (; i < length; i++) {
529				callbackInverse = !callback(elems[i], i);
530				if (callbackInverse !== callbackExpect) {
531					matches.push(elems[i]);
532				}
533			}
534
535			return matches;
536		},
537
538		// arg is for internal usage only
539		map: function (elems, callback, arg) {
540			var length,
541			    value,
542			    i = 0,
543			    ret = [];
544
545			// Go through the array, translating each of the items to their new values
546			if (isArrayLike(elems)) {
547				length = elems.length;
548				for (; i < length; i++) {
549					value = callback(elems[i], i, arg);
550
551					if (value != null) {
552						ret.push(value);
553					}
554				}
555
556				// Go through every key on the object,
557			} else {
558				for (i in elems) {
559					value = callback(elems[i], i, arg);
560
561					if (value != null) {
562						ret.push(value);
563					}
564				}
565			}
566
567			// Flatten any nested arrays
568			return concat.apply([], ret);
569		},
570
571		// A global GUID counter for objects
572		guid: 1,
573
574		// Bind a function to a context, optionally partially applying any
575		// arguments.
576		proxy: function (fn, context) {
577			var args, proxy, tmp;
578
579			if (typeof context === "string") {
580				tmp = fn[context];
581				context = fn;
582				fn = tmp;
583			}
584
585			// Quick check to determine if target is callable, in the spec
586			// this throws a TypeError, but we will just return undefined.
587			if (!jQuery.isFunction(fn)) {
588				return undefined;
589			}
590
591			// Simulated bind
592			args = slice.call(arguments, 2);
593			proxy = function () {
594				return fn.apply(context || this, args.concat(slice.call(arguments)));
595			};
596
597			// Set the guid of unique handler to the same of original handler, so it can be removed
598			proxy.guid = fn.guid = fn.guid || jQuery.guid++;
599
600			return proxy;
601		},
602
603		now: function () {
604			return +new Date();
605		},
606
607		// jQuery.support is not used in Core but other projects attach their
608		// properties to it so it needs to exist.
609		support: support
610	});
611
612	// JSHint would error on this code due to the Symbol not being defined in ES5.
613	// Defining this global in .jshintrc would create a danger of using the global
614	// unguarded in another place, it seems safer to just disable JSHint for these
615	// three lines.
616	/* jshint ignore: start */
617	if (typeof Symbol === "function") {
618		jQuery.fn[Symbol.iterator] = deletedIds[Symbol.iterator];
619	}
620	/* jshint ignore: end */
621
622	// Populate the class2type map
623	jQuery.each("Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "), function (i, name) {
624		class2type["[object " + name + "]"] = name.toLowerCase();
625	});
626
627	function isArrayLike(obj) {
628
629		// Support: iOS 8.2 (not reproducible in simulator)
630		// `in` check used to prevent JIT error (gh-2145)
631		// hasOwn isn't used here due to false negatives
632		// regarding Nodelist length in IE
633		var length = !!obj && "length" in obj && obj.length,
634		    type = jQuery.type(obj);
635
636		if (type === "function" || jQuery.isWindow(obj)) {
637			return false;

638		}
639
640		return type === "array" || length === 0 || typeof length === "number" && length > 0 && length - 1 in obj;
641	}
642	var Sizzle =
643	/*!
644  * Sizzle CSS Selector Engine v2.2.1
645  * http://sizzlejs.com/
646  *
647  * Copyright jQuery Foundation and other contributors
648  * Released under the MIT license
649  * http://jquery.org/license
650  *
651  * Date: 2015-10-17
652  */
653	function (window) {
654
655		var i,
656		    support,
657		    Expr,
658		    getText,
659		    isXML,
660		    tokenize,
661		    compile,
662		    select,
663		    outermostContext,
664		    sortInput,
665		    hasDuplicate,
666
667
668		// Local document vars
669		setDocument,
670		    document,
671		    docElem,
672		    documentIsHTML,
673		    rbuggyQSA,
674		    rbuggyMatches,
675		    matches,
676		    contains,
677
678
679		// Instance-specific data
680		expando = "sizzle" + 1 * new Date(),
681		    preferredDoc = window.document,
682		    dirruns = 0,
683		    done = 0,
684		    classCache = createCache(),
685		    tokenCache = createCache(),
686		    compilerCache = createCache(),
687		    sortOrder = function (a, b) {
688			if (a === b) {
689				hasDuplicate = true;
690			}
691			return 0;
692		},
693
694
695		// General-purpose constants
696		MAX_NEGATIVE = 1 << 31,
697
698
699		// Instance methods
700		hasOwn = {}.hasOwnProperty,
701		    arr = [],
702		    pop = arr.pop,
703		    push_native = arr.push,
704		    push = arr.push,
705		    slice = arr.slice,
706
707		// Use a stripped-down indexOf as it's faster than native
708		// http://jsperf.com/thor-indexof-vs-for/5
709		indexOf = function (list, elem) {
710			var i = 0,
711			    len = list.length;
712			for (; i < len; i++) {
713				if (list[i] === elem) {
714					return i;
715				}
716			}
717			return -1;
718		},
719		    booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",
720
721
722		// Regular expressions
723
724		// http://www.w3.org/TR/css3-selectors/#whitespace
725		whitespace = "[\\x20\\t\\r\\n\\f]",
726
727
728		// http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
729		identifier = "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+",
730
731
732		// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
733		attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +
734		// Operator (capture 2)
735		"*([*^$|!~]?=)" + whitespace +
736		// "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"
737		"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace + "*\\]",
738		    pseudos = ":(" + identifier + ")(?:\\((" +
739		// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
740		// 1. quoted (capture 3; capture 4 or capture 5)
741		"('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
742		// 2. simple (capture 6)
743		"((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
744		// 3. anything else (capture 2)
745		".*" + ")\\)|)",
746
747
748		// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
749		rwhitespace = new RegExp(whitespace + "+", "g"),
750		    rtrim = new RegExp("^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g"),
751		    rcomma = new RegExp("^" + whitespace + "*," + whitespace + "*"),
752		    rcombinators = new RegExp("^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*"),
753		    rattributeQuotes = new RegExp("=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g"),
754		    rpseudo = new RegExp(pseudos),
755		    ridentifier = new RegExp("^" + identifier + "$"),
756		    matchExpr = {
757			"ID": new RegExp("^#(" + identifier + ")"),
758			"CLASS": new RegExp("^\\.(" + identifier + ")"),
759			"TAG": new RegExp("^(" + identifier + "|[*])"),
760			"ATTR": new RegExp("^" + attributes),
761			"PSEUDO": new RegExp("^" + pseudos),
762			"CHILD": new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i"),
763			"bool": new RegExp("^(?:" + booleans + ")$", "i"),
764			// For use in libraries implementing .is()
765			// We use this for POS matching in `select`
766			"needsContext": new RegExp("^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i")
767		},
768		    rinputs = /^(?:input|select|textarea|button)$/i,
769		    rheader = /^h\d$/i,
770		    rnative = /^[^{]+\{\s*\[native \w/,
771
772
773		// Easily-parseable/retrievable ID or TAG or CLASS selectors
774		rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
775		    rsibling = /[+~]/,
776		    rescape = /'|\\/g,
777
778
779		// CSS escapes http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
780		runescape = new RegExp("\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig"),
781		    funescape = function (_, escaped, escapedWhitespace) {
782			var high = "0x" + escaped - 0x10000;
783			// NaN means non-codepoint

939							newContext = rsibling.test(selector) && testContext(context.parentNode) || context;
940						}
941
942						if (newSelector) {
943							try {
944								push.apply(results, newContext.querySelectorAll(newSelector));
945								return results;
946							} catch (qsaError) {} finally {
947								if (nid === expando) {
948									context.removeAttribute("id");
949								}
950							}
951						}
952					}
953				}
954			}
955
956			// All others
957			return select(selector.replace(rtrim, "$1"), context, results, seed);
958		}
959
960		/**
961   * Create key-value caches of limited size
962   * @returns {function(string, object)} Returns the Object data after storing it on itself with
963   *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
964   *	deleting the oldest entry
965   */
966		function createCache() {
967			var keys = [];
968
969			function cache(key, value) {
970				// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
971				if (keys.push(key + " ") > Expr.cacheLength) {
972					// Only keep the most recent entries
973					delete cache[keys.shift()];
974				}
975				return cache[key + " "] = value;
976			}
977			return cache;
978		}
979
980		/**
981   * Mark a function for special use by Sizzle
982   * @param {Function} fn The function to mark
983   */
984		function markFunction(fn) {
985			fn[expando] = true;
986			return fn;
987		}
988
989		/**
990   * Support testing using an element
991   * @param {Function} fn Passed the created div and expects a boolean result
992   */
993		function assert(fn) {
994			var div = document.createElement("div");
995
996			try {
997				return !!fn(div);
998			} catch (e) {
999				return false;
1000			} finally {
1001				// Remove from its parent by default
1002				if (div.parentNode) {
1003					div.parentNode.removeChild(div);
1004				}
1005				// release memory in IE
1006				div = null;
1007			}
1008		}
1009
1010		/**
1011   * Adds the same handler for all of the specified attrs
1012   * @param {String} attrs Pipe-separated list of attributes
1013   * @param {Function} handler The method that will be applied
1014   */
1015		function addHandle(attrs, handler) {
1016			var arr = attrs.split("|"),
1017			    i = arr.length;
1018
1019			while (i--) {
1020				Expr.attrHandle[arr[i]] = handler;
1021			}
1022		}
1023
1024		/**
1025   * Checks document order of two siblings
1026   * @param {Element} a
1027   * @param {Element} b
1028   * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
1029   */
1030		function siblingCheck(a, b) {
1031			var cur = b && a,
1032			    diff = cur && a.nodeType === 1 && b.nodeType === 1 && (~b.sourceIndex || MAX_NEGATIVE) - (~a.sourceIndex || MAX_NEGATIVE);
1033
1034			// Use IE sourceIndex if available on both nodes
1035			if (diff) {
1036				return diff;
1037			}
1038
1039			// Check if b follows a
1040			if (cur) {
1041				while (cur = cur.nextSibling) {
1042					if (cur === b) {
1043						return -1;
1044					}
1045				}
1046			}
1047
1048			return a ? 1 : -1;
1049		}
1050
1051		/**
1052   * Returns a function to use in pseudos for input types
1053   * @param {String} type
1054   */
1055		function createInputPseudo(type) {
1056			return function (elem) {
1057				var name = elem.nodeName.toLowerCase();
1058				return name === "input" && elem.type === type;
1059			};
1060		}
1061
1062		/**
1063   * Returns a function to use in pseudos for buttons
1064   * @param {String} type
1065   */
1066		function createButtonPseudo(type) {
1067			return function (elem) {
1068				var name = elem.nodeName.toLowerCase();
1069				return (name === "input" || name === "button") && elem.type === type;
1070			};
1071		}
1072
1073		/**
1074   * Returns a function to use in pseudos for positionals
1075   * @param {Function} fn
1076   */
1077		function createPositionalPseudo(fn) {
1078			return markFunction(function (argument) {
1079				argument = +argument;
1080				return markFunction(function (seed, matches) {
1081					var j,
1082					    matchIndexes = fn([], seed.length, argument),
1083					    i = matchIndexes.length;
1084
1085					// Match elements found at the specified indexes
1086					while (i--) {
1087						if (seed[j = matchIndexes[i]]) {
1088							seed[j] = !(matches[j] = seed[j]);
1089						}
1090					}
1091				});
1092			});
1093		}
1094
1095		/**
1096   * Checks a node for validity as a Sizzle context
1097   * @param {Element|Object=} context
1098   * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
1099   */
1100		function testContext(context) {
1101			return context && typeof context.getElementsByTagName !== "undefined" && context;
1102		}
1103
1104		// Expose support vars for convenience
1105		support = Sizzle.support = {};
1106
1107		/**
1108   * Detects XML nodes
1109   * @param {Element|Object} elem An element or a document
1110   * @returns {Boolean} True iff elem is a non-HTML XML node
1111   */
1112		isXML = Sizzle.isXML = function (elem) {
1113			// documentElement is verified for cases where it doesn't yet exist
1114			// (such as loading iframes in IE - #4833)
1115			var documentElement = elem && (elem.ownerDocument || elem).documentElement;
1116			return documentElement ? documentElement.nodeName !== "HTML" : false;
1117		};
1118
1119		/**
1120   * Sets document-related variables once based on the current document
1121   * @param {Element|Object} [doc] An element or document object to use to set the document
1122   * @returns {Object} Returns the current document
1123   */
1124		setDocument = Sizzle.setDocument = function (node) {
1125			var hasCompare,
1126			    parent,
1127			    doc = node ? node.ownerDocument || node : preferredDoc;
1128
1129			// Return early if doc is invalid or already selected
1130			if (doc === document || doc.nodeType !== 9 || !doc.documentElement) {
1131				return document;
1132			}
1133
1134			// Update global variables
1135			document = doc;
1136			docElem = document.documentElement;
1137			documentIsHTML = !isXML(document);
1138
1139			// Support: IE 9-11, Edge
1140			// Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936)
1141			if ((parent = document.defaultView) && parent.top !== parent) {
1142				// Support: IE 11
1143				if (parent.addEventListener) {
1144					parent.addEventListener("unload", unloadHandler, false);
1145
1146					// Support: IE 9 - 10 only
1147				} else if (parent.attachEvent) {
1148					parent.attachEvent("onunload", unloadHandler);
1149				}
1150			}
1151
1152			/* Attributes
1153   ---------------------------------------------------------------------- */
1154
1155			// Support: IE<8
1156			// Verify that getAttribute really returns attributes and not properties
1157			// (excepting IE8 booleans)
1158			support.attributes = assert(function (div) {
1159				div.className = "i";
1160				return !div.getAttribute("className");
1161			});
1162
1163			/* getElement(s)By*
1164   ---------------------------------------------------------------------- */
1165
1166			// Check if getElementsByTagName("*") returns only elements
1167			support.getElementsByTagName = assert(function (div) {
1168				div.appendChild(document.createComment(""));
1169				return !div.getElementsByTagName("*").length;
1170			});
1171
1172			// Support: IE<9
1173			support.getElementsByClassName = rnative.test(document.getElementsByClassName);
1174
1175			// Support: IE<10
1176			// Check if getElementById returns elements by name
1177			// The broken getElementById methods don't pick up programatically-set names,
1178			// so use a roundabout getElementsByName test
1179			support.getById = assert(function (div) {
1180				docElem.appendChild(div).id = expando;
1181				return !document.getElementsByName || !document.getElementsByName(expando).length;
1182			});
1183
1184			// ID find and filter
1185			if (support.getById) {
1186				Expr.find["ID"] = function (id, context) {
1187					if (typeof context.getElementById !== "undefined" && documentIsHTML) {
1188						var m = context.getElementById(id);
1189						return m ? [m] : [];
1190					}
1191				};
1192				Expr.filter["ID"] = function (id) {
1193					var attrId = id.replace(runescape, funescape);
1194					return function (elem) {
1195						return elem.getAttribute("id") === attrId;
1196					};
1197				};
1198			} else {
1199				// Support: IE6/7
1200				// getElementById is not reliable as a find shortcut
1201				delete Expr.find["ID"];
1202
1203				Expr.filter["ID"] = function (id) {
1204					var attrId = id.replace(runescape, funescape);
1205					return function (elem) {
1206						var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
1207						return node && node.value === attrId;
1208					};
1209				};
1210			}
1211
1212			// Tag
1213			Expr.find["TAG"] = support.getElementsByTagName ? function (tag, context) {
1214				if (typeof context.getElementsByTagName !== "undefined") {
1215					return context.getElementsByTagName(tag);
1216
1217					// DocumentFragment nodes don't have gEBTN
1218				} else if (support.qsa) {
1219					return context.querySelectorAll(tag);
1220				}
1221			} : function (tag, context) {
1222				var elem,
1223				    tmp = [],
1224				    i = 0,
1225
1226				// By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
1227				results = context.getElementsByTagName(tag);
1228
1229				// Filter out possible comments
1230				if (tag === "*") {
1231					while (elem = results[i++]) {
1232						if (elem.nodeType === 1) {
1233							tmp.push(elem);
1234						}
1235					}
1236
1237					return tmp;
1238				}
1239				return results;
1240			};
1241
1242			// Class
1243			Expr.find["CLASS"] = support.getElementsByClassName && function (className, context) {
1244				if (typeof context.getElementsByClassName !== "undefined" && documentIsHTML) {
1245					return context.getElementsByClassName(className);
1246				}
1247			};
1248
1249			/* QSA/matchesSelector
1250   ---------------------------------------------------------------------- */
1251
1252			// QSA and matchesSelector support
1253
1254			// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
1255			rbuggyMatches = [];
1256
1257			// qSa(:focus) reports false when true (Chrome 21)
1258			// We allow this because of a bug in IE8/9 that throws an error
1259			// whenever `document.activeElement` is accessed on an iframe
1260			// So, we allow :focus to pass through QSA all the time to avoid the IE error
1261			// See http://bugs.jquery.com/ticket/13378
1262			rbuggyQSA = [];
1263
1264			if (support.qsa = rnative.test(document.querySelectorAll)) {
1265				// Build QSA regex
1266				// Regex strategy adopted from Diego Perini
1267				assert(function (div) {
1268					// Select is set to empty string on purpose
1269					// This is to test IE's treatment of not explicitly
1270					// setting a boolean content attribute,
1271					// since its presence should be enough
1272					// http://bugs.jquery.com/ticket/12359
1273					docElem.appendChild(div).innerHTML = "<a id='" + expando + "'></a>" + "<select id='" + expando + "-\r\\' msallowcapture=''>" + "<option selected=''></option></select>";
1274
1275					// Support: IE8, Opera 11-12.16
1276					// Nothing should be selected when empty strings follow ^= or $= or *=
1277					// The test attribute must be unknown in Opera but "safe" for WinRT
1278					// http://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
1279					if (div.querySelectorAll("[msallowcapture^='']").length) {
1280						rbuggyQSA.push("[*^$]=" + whitespace + "*(?:''|\"\")");
1281					}
1282
1283					// Support: IE8
1284					// Boolean attributes and "value" are not treated correctly
1285					if (!div.querySelectorAll("[selected]").length) {
1286						rbuggyQSA.push("\\[" + whitespace + "*(?:value|" + booleans + ")");
1287					}
1288
1289					// Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+
1290					if (!div.querySelectorAll("[id~=" + expando + "-]").length) {
1291						rbuggyQSA.push("~=");
1292					}
1293
1294					// Webkit/Opera - :checked should return selected option elements
1295					// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
1296					// IE8 throws error here and will not see later tests
1297					if (!div.querySelectorAll(":checked").length) {
1298						rbuggyQSA.push(":checked");
1299					}
1300
1301					// Support: Safari 8+, iOS 8+
1302					// https://bugs.webkit.org/show_bug.cgi?id=136851
1303					// In-page `selector#id sibing-combinator selector` fails
1304					if (!div.querySelectorAll("a#" + expando + "+*").length) {
1305						rbuggyQSA.push(".#.+[+~]");
1306					}
1307				});
1308
1309				assert(function (div) {
1310					// Support: Windows 8 Native Apps
1311					// The type and name attributes are restricted during .innerHTML assignment
1312					var input = document.createElement("input");
1313					input.setAttribute("type", "hidden");
1314					div.appendChild(input).setAttribute("name", "D");
1315
1316					// Support: IE8
1317					// Enforce case-sensitivity of name attribute
1318					if (div.querySelectorAll("[name=d]").length) {
1319						rbuggyQSA.push("name" + whitespace + "*[*^$|!~]?=");
1320					}
1321
1322					// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
1323					// IE8 throws error here and will not see later tests
1324					if (!div.querySelectorAll(":enabled").length) {
1325						rbuggyQSA.push(":enabled", ":disabled");
1326					}
1327
1328					// Opera 10-11 does not throw on post-comma invalid pseudos
1329					div.querySelectorAll("*,:x");
1330					rbuggyQSA.push(",.*:");
1331				});
1332			}
1333
1334			if (support.matchesSelector = rnative.test(matches = docElem.matches || docElem.webkitMatchesSelector || docElem.mozMatchesSelector || docElem.oMatchesSelector || docElem.msMatchesSelector)) {
1335
1336				assert(function (div) {
1337					// Check to see if it's possible to do matchesSelector
1338					// on a disconnected node (IE 9)
1339					support.disconnectedMatch = matches.call(div, "div");
1340
1341					// This should fail with an exception
1342					// Gecko does not error, returns false instead
1343					matches.call(div, "[s!='']:x");
1344					rbuggyMatches.push("!=", pseudos);
1345				});
1346			}
1347
1348			rbuggyQSA = rbuggyQSA.length && new RegExp(rbuggyQSA.join("|"));
1349			rbuggyMatches = rbuggyMatches.length && new RegExp(rbuggyMatches.join("|"));
1350
1351			/* Contains
1352   ---------------------------------------------------------------------- */
1353			hasCompare = rnative.test(docElem.compareDocumentPosition);
1354
1355			// Element contains another
1356			// Purposefully self-exclusive
1357			// As in, an element does not contain itself
1358			contains = hasCompare || rnative.test(docElem.contains) ? function (a, b) {
1359				var adown = a.nodeType === 9 ? a.documentElement : a,
1360				    bup = b && b.parentNode;
1361				return a === bup || !!(bup && bup.nodeType === 1 && (adown.contains ? adown.contains(bup) : a.compareDocumentPosition && a.compareDocumentPosition(bup) & 16));
1362			} : function (a, b) {
1363				if (b) {
1364					while (b = b.parentNode) {
1365						if (b === a) {
1366							return true;
1367						}
1368					}
1369				}
1370				return false;
1371			};
1372
1373			/* Sorting
1374   ---------------------------------------------------------------------- */
1375
1376			// Document order sorting
1377			sortOrder = hasCompare ? function (a, b) {
1378
1379				// Flag for duplicate removal
1380				if (a === b) {
1381					hasDuplicate = true;
1382					return 0;
1383				}
1384
1385				// Sort on method existence if only one input has compareDocumentPosition
1386				var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
1387				if (compare) {
1388					return compare;
1389				}
1390
1391				// Calculate position if both inputs belong to the same document
1392				compare = (a.ownerDocument || a) === (b.ownerDocument || b) ? a.compareDocumentPosition(b) :
1393
1394				// Otherwise we know they are disconnected
1395				1;
1396
1397				// Disconnected nodes
1398				if (compare & 1 || !support.sortDetached && b.compareDocumentPosition(a) === compare) {
1399
1400					// Choose the first element that is related to our preferred document
1401					if (a === document || a.ownerDocument === preferredDoc && contains(preferredDoc, a)) {
1402						return -1;
1403					}
1404					if (b === document || b.ownerDocument === preferredDoc && contains(preferredDoc, b)) {
1405						return 1;
1406					}
1407
1408					// Maintain original order
1409					return sortInput ? indexOf(sortInput, a) - indexOf(sortInput, b) : 0;
1410				}
1411
1412				return compare & 4 ? -1 : 1;
1413			} : function (a, b) {
1414				// Exit early if the nodes are identical
1415				if (a === b) {
1416					hasDuplicate = true;
1417					return 0;
1418				}
1419
1420				var cur,
1421				    i = 0,
1422				    aup = a.parentNode,
1423				    bup = b.parentNode,
1424				    ap = [a],
1425				    bp = [b];
1426
1427				// Parentless nodes are either documents or disconnected
1428				if (!aup || !bup) {
1429					return a === document ? -1 : b === document ? 1 : aup ? -1 : bup ? 1 : sortInput ? indexOf(sortInput, a) - indexOf(sortInput, b) : 0;
1430
1431					// If the nodes are siblings, we can do a quick check
1432				} else if (aup === bup) {
1433					return siblingCheck(a, b);
1434				}
1435
1436				// Otherwise we need full lists of their ancestors for comparison
1437				cur = a;
1438				while (cur = cur.parentNode) {
1439					ap.unshift(cur);
1440				}
1441				cur = b;
1442				while (cur = cur.parentNode) {
1443					bp.unshift(cur);
1444				}
1445
1446				// Walk down the tree looking for a discrepancy
1447				while (ap[i] === bp[i]) {
1448					i++;
1449				}
1450
1451				return i ?
1452				// Do a sibling check if the nodes have a common ancestor
1453				siblingCheck(ap[i], bp[i]) :
1454
1455				// Otherwise nodes in our document sort first
1456				ap[i] === preferredDoc ? -1 : bp[i] === preferredDoc ? 1 : 0;
1457			};
1458
1459			return document;
1460		};
1461
1462		Sizzle.matches = function (expr, elements) {
1463			return Sizzle(expr, null, null, elements);
1464		};
1465
1466		Sizzle.matchesSelector = function (elem, expr) {
1467			// Set document vars if needed
1468			if ((elem.ownerDocument || elem) !== document) {
1469				setDocument(elem);
1470			}
1471
1472			// Make sure that attribute selectors are quoted
1473			expr = expr.replace(rattributeQuotes, "='$1']");
1474
1475			if (support.matchesSelector && documentIsHTML && !compilerCache[expr + " "] && (!rbuggyMatches || !rbuggyMatches.test(expr)) && (!rbuggyQSA || !rbuggyQSA.test(expr))) {
1476
1477				try {
1478					var ret = matches.call(elem, expr);
1479
1480					// IE 9's matchesSelector returns false on disconnected nodes
1481					if (ret || support.disconnectedMatch ||
1482					// As well, disconnected nodes are said to be in a document
1483					// fragment in IE 9
1484					elem.document && elem.document.nodeType !== 11) {
1485						return ret;
1486					}
1487				} catch (e) {}
1488			}
1489
1490			return Sizzle(expr, document, null, [elem]).length > 0;
1491		};
1492
1493		Sizzle.contains = function (context, elem) {
1494			// Set document vars if needed
1495			if ((context.ownerDocument || context) !== document) {
1496				setDocument(context);
1497			}
1498			return contains(context, elem);
1499		};
1500
1501		Sizzle.attr = function (elem, name) {
1502			// Set document vars if needed
1503			if ((elem.ownerDocument || elem) !== document) {
1504				setDocument(elem);
1505			}
1506
1507			var fn = Expr.attrHandle[name.toLowerCase()],
1508
1509			// Don't get fooled by Object.prototype properties (jQuery #13807)
1510			val = fn && hasOwn.call(Expr.attrHandle, name.toLowerCase()) ? fn(elem, name, !documentIsHTML) : undefined;
1511
1512			return val !== undefined ? val : support.attributes || !documentIsHTML ? elem.getAttribute(name) : (val = elem.getAttributeNode(name)) && val.specified ? val.value : null;
1513		};
1514
1515		Sizzle.error = function (msg) {
1516			throw new Error("Syntax error, unrecognized expression: " + msg);
1517		};
1518
1519		/**
1520   * Document sorting and removing duplicates
1521   * @param {ArrayLike} results
1522   */
1523		Sizzle.uniqueSort = function (results) {
1524			var elem,
1525			    duplicates = [],
1526			    j = 0,
1527			    i = 0;
1528
1529			// Unless we *know* we can detect duplicates, assume their presence
1530			hasDuplicate = !support.detectDuplicates;
1531			sortInput = !support.sortStable && results.slice(0);
1532			results.sort(sortOrder);
1533

1534			if (hasDuplicate) {
1535				while (elem = results[i++]) {
1536					if (elem === results[i]) {
1537						j = duplicates.push(i);
1538					}
1539				}
1540				while (j--) {
1541					results.splice(duplicates[j], 1);
1542				}
1543			}
1544
1545			// Clear input after sorting to release objects
1546			// See https://github.com/jquery/sizzle/pull/225
1547			sortInput = null;
1548
1549			return results;
1550		};
1551
1552		/**
1553   * Utility function for retrieving the text value of an array of DOM nodes
1554   * @param {Array|Element} elem
1555   */
1556		getText = Sizzle.getText = function (elem) {
1557			var node,
1558			    ret = "",
1559			    i = 0,
1560			    nodeType = elem.nodeType;
1561
1562			if (!nodeType) {
1563				// If no nodeType, this is expected to be an array
1564				while (node = elem[i++]) {
1565					// Do not traverse comment nodes
1566					ret += getText(node);
1567				}
1568			} else if (nodeType === 1 || nodeType === 9 || nodeType === 11) {
1569				// Use textContent for elements
1570				// innerText usage removed for consistency of new lines (jQuery #11153)
1571				if (typeof elem.textContent === "string") {
1572					return elem.textContent;
1573				} else {
1574					// Traverse its children
1575					for (elem = elem.firstChild; elem; elem = elem.nextSibling) {
1576						ret += getText(elem);
1577					}
1578				}
1579			} else if (nodeType === 3 || nodeType === 4) {
1580				return elem.nodeValue;
1581			}
1582			// Do not include comment or processing instruction nodes
1583
1584			return ret;
1585		};
1586
1587		Expr = Sizzle.selectors = {
1588
1589			// Can be adjusted by the user
1590			cacheLength: 50,
1591
1592			createPseudo: markFunction,
1593
1594			match: matchExpr,
1595
1596			attrHandle: {},
1597
1598			find: {},
1599
1600			relative: {
1601				">": { dir: "parentNode", first: true },
1602				" ": { dir: "parentNode" },
1603				"+": { dir: "previousSibling", first: true },
1604				"~": { dir: "previousSibling" }
1605			},
1606
1607			preFilter: {
1608				"ATTR": function (match) {
1609					match[1] = match[1].replace(runescape, funescape);
1610
1611					// Move the given value to match[3] whether quoted or unquoted
1612					match[3] = (match[3] || match[4] || match[5] || "").replace(runescape, funescape);
1613
1614					if (match[2] === "~=") {
1615						match[3] = " " + match[3] + " ";
1616					}
1617
1618					return match.slice(0, 4);
1619				},
1620
1621				"CHILD": function (match) {
1622					/* matches from matchExpr["CHILD"]
1623     	1 type (only|nth|...)
1624     	2 what (child|of-type)
1625     	3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
1626     	4 xn-component of xn+y argument ([+-]?\d*n|)
1627     	5 sign of xn-component
1628     	6 x of xn-component
1629     	7 sign of y-component
1630     	8 y of y-component
1631     */
1632					match[1] = match[1].toLowerCase();
1633
1634					if (match[1].slice(0, 3) === "nth") {
1635						// nth-* requires argument
1636						if (!match[3]) {
1637							Sizzle.error(match[0]);
1638						}
1639
1640						// numeric x and y parameters for Expr.filter.CHILD
1641						// remember that false/true cast respectively to 0/1
1642						match[4] = +(match[4] ? match[5] + (match[6] || 1) : 2 * (match[3] === "even" || match[3] === "odd"));
1643						match[5] = +(match[7] + match[8] || match[3] === "odd");
1644
1645						// other types prohibit arguments
1646					} else if (match[3]) {
1647						Sizzle.error(match[0]);
1648					}
1649
1650					return match;
1651				},
1652
1653				"PSEUDO": function (match) {
1654					var excess,
1655					    unquoted = !match[6] && match[2];
1656
1657					if (matchExpr["CHILD"].test(match[0])) {
1658						return null;
1659					}
1660
1661					// Accept quoted arguments as-is
1662					if (match[3]) {
1663						match[2] = match[4] || match[5] || "";
1664
1665						// Strip excess characters from unquoted arguments
1666					} else if (unquoted && rpseudo.test(unquoted) && (
1667					// Get excess from tokenize (recursively)
1668					excess = tokenize(unquoted, true)) && (
1669					// advance to the next closing parenthesis
1670					excess = unquoted.indexOf(")", unquoted.length - excess) - unquoted.length)) {
1671
1672						// excess is a negative index
1673						match[0] = match[0].slice(0, excess);
1674						match[2] = unquoted.slice(0, excess);
1675					}
1676
1677					// Return only captures needed by the pseudo filter method (type and argument)
1678					return match.slice(0, 3);
1679				}
1680			},
1681
1682			filter: {
1683
1684				"TAG": function (nodeNameSelector) {
1685					var nodeName = nodeNameSelector.replace(runescape, funescape).toLowerCase();
1686					return nodeNameSelector === "*" ? function () {
1687						return true;
1688					} : function (elem) {
1689						return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
1690					};
1691				},
1692
1693				"CLASS": function (className) {
1694					var pattern = classCache[className + " "];
1695
1696					return pattern || (pattern = new RegExp("(^|" + whitespace + ")" + className + "(" + whitespace + "|$)")) && classCache(className, function (elem) {
1697						return pattern.test(typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "");
1698					});
1699				},
1700
1701				"ATTR": function (name, operator, check) {
1702					return function (elem) {
1703						var result = Sizzle.attr(elem, name);
1704
1705						if (result == null) {
1706							return operator === "!=";
1707						}
1708						if (!operator) {
1709							return true;
1710						}
1711
1712						result += "";
1713
1714						return operator === "=" ? result === check : operator === "!=" ? result !== check : operator === "^=" ? check && result.indexOf(check) === 0 : operator === "*=" ? check && result.indexOf(check) > -1 : operator === "$=" ? check && result.slice(-check.length) === check : operator === "~=" ? (" " + result.replace(rwhitespace, " ") + " ").indexOf(check) > -1 : operator === "|=" ? result === check || result.slice(0, check.length + 1) === check + "-" : false;
1715					};
1716				},
1717
1718				"CHILD": function (type, what, argument, first, last) {
1719					var simple = type.slice(0, 3) !== "nth",
1720					    forward = type.slice(-4) !== "last",
1721					    ofType = what === "of-type";
1722
1723					return first === 1 && last === 0 ?
1724
1725					// Shortcut for :nth-*(n)
1726					function (elem) {
1727						return !!elem.parentNode;
1728					} : function (elem, context, xml) {
1729						var cache,
1730						    uniqueCache,
1731						    outerCache,
1732						    node,
1733						    nodeIndex,
1734						    start,
1735						    dir = simple !== forward ? "nextSibling" : "previousSibling",
1736						    parent = elem.parentNode,
1737						    name = ofType && elem.nodeName.toLowerCase(),
1738						    useCache = !xml && !ofType,
1739						    diff = false;
1740
1741						if (parent) {
1742
1743							// :(first|last|only)-(child|of-type)
1744							if (simple) {
1745								while (dir) {
1746									node = elem;
1747									while (node = node[dir]) {
1748										if (ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1) {
1749
1750											return false;
1751										}
1752									}
1753									// Reverse direction for :only-* (if we haven't yet done so)
1754									start = dir = type === "only" && !start && "nextSibling";
1755								}
1756								return true;
1757							}
1758
1759							start = [forward ? parent.firstChild : parent.lastChild];
1760
1761							// non-xml :nth-child(...) stores cache data on `parent`
1762							if (forward && useCache) {
1763
1764								// Seek `elem` from a previously-cached index
1765
1766								// ...in a gzip-friendly way
1767								node = parent;
1768								outerCache = node[expando] || (node[expando] = {});
1769
1770								// Support: IE <9 only
1771								// Defend against cloned attroperties (jQuery gh-1709)
1772								uniqueCache = outerCache[node.uniqueID] || (outerCache[node.uniqueID] = {});
1773
1774								cache = uniqueCache[type] || [];
1775								nodeIndex = cache[0] === dirruns && cache[1];
1776								diff = nodeIndex && cache[2];
1777								node = nodeIndex && parent.childNodes[nodeIndex];
1778
1779								while (node = ++nodeIndex && node && node[dir] || (
1780
1781								// Fallback to seeking `elem` from the start
1782								diff = nodeIndex = 0) || start.pop()) {
1783
1784									// When found, cache indexes on `parent` and break
1785									if (node.nodeType === 1 && ++diff && node === elem) {
1786										uniqueCache[type] = [dirruns, nodeIndex, diff];
1787										break;
1788									}
1789								}
1790							} else {
1791								// Use previously-cached element index if available
1792								if (useCache) {
1793									// ...in a gzip-friendly way
1794									node = elem;
1795									outerCache = node[expando] || (node[expando] = {});
1796
1797									// Support: IE <9 only
1798									// Defend against cloned attroperties (jQuery gh-1709)
1799									uniqueCache = outerCache[node.uniqueID] || (outerCache[node.uniqueID] = {});
1800
1801									cache = uniqueCache[type] || [];
1802									nodeIndex = cache[0] === dirruns && cache[1];
1803									diff = nodeIndex;
1804								}
1805
1806								// xml :nth-child(...)
1807								// or :nth-last-child(...) or :nth(-last)?-of-type(...)
1808								if (diff === false) {
1809									// Use the same loop as above to seek `elem` from the start
1810									while (node = ++nodeIndex && node && node[dir] || (diff = nodeIndex = 0) || start.pop()) {
1811
1812										if ((ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1) && ++diff) {
1813
1814											// Cache the index of each encountered element
1815											if (useCache) {
1816												outerCache = node[expando] || (node[expando] = {});
1817
1818												// Support: IE <9 only
1819												// Defend against cloned attroperties (jQuery gh-1709)
1820												uniqueCache = outerCache[node.uniqueID] || (outerCache[node.uniqueID] = {});
1821
1822												uniqueCache[type] = [dirruns, diff];
1823											}
1824
1825											if (node === elem) {
1826												break;
1827											}
1828										}
1829									}
1830								}
1831							}
1832
1833							// Incorporate the offset, then check against cycle size
1834							diff -= last;
1835							return diff === first || diff % first === 0 && diff / first >= 0;
1836						}
1837					};
1838				},
1839
1840				"PSEUDO": function (pseudo, argument) {
1841					// pseudo-class names are case-insensitive
1842					// http://www.w3.org/TR/selectors/#pseudo-classes
1843					// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
1844					// Remember that setFilters inherits from pseudos
1845					var args,
1846					    fn = Expr.pseudos[pseudo] || Expr.setFilters[pseudo.toLowerCase()] || Sizzle.error("unsupported pseudo: " + pseudo);
1847
1848					// The user may use createPseudo to indicate that
1849					// arguments are needed to create the filter function
1850					// just as Sizzle does
1851					if (fn[expando]) {
1852						return fn(argument);
1853					}
1854
1855					// But maintain support for old signatures
1856					if (fn.length > 1) {
1857						args = [pseudo, pseudo, "", argument];
1858						return Expr.setFilters.hasOwnProperty(pseudo.toLowerCase()) ? markFunction(function (seed, matches) {
1859							var idx,
1860							    matched = fn(seed, argument),
1861							    i = matched.length;
1862							while (i--) {
1863								idx = indexOf(seed, matched[i]);
1864								seed[idx] = !(matches[idx] = matched[i]);
1865							}
1866						}) : function (elem) {
1867							return fn(elem, 0, args);
1868						};
1869					}
1870
1871					return fn;
1872				}
1873			},
1874
1875			pseudos: {
1876				// Potentially complex pseudos
1877				"not": markFunction(function (selector) {
1878					// Trim the selector passed to compile
1879					// to avoid treating leading and trailing
1880					// spaces as combinators
1881					var input = [],
1882					    results = [],
1883					    matcher = compile(selector.replace(rtrim, "$1"));
1884
1885					return matcher[expando] ? markFunction(function (seed, matches, context, xml) {
1886						var elem,
1887						    unmatched = matcher(seed, null, xml, []),
1888						    i = seed.length;
1889
1890						// Match elements unmatched by `matcher`
1891						while (i--) {
1892							if (elem = unmatched[i]) {
1893								seed[i] = !(matches[i] = elem);
1894							}
1895						}
1896					}) : function (elem, context, xml) {
1897						input[0] = elem;
1898						matcher(input, null, xml, results);
1899						// Don't keep the element (issue #299)
1900						input[0] = null;
1901						return !results.pop();
1902					};
1903				}),
1904
1905				"has": markFunction(function (selector) {
1906					return function (elem) {
1907						return Sizzle(selector, elem).length > 0;
1908					};
1909				}),
1910
1911				"contains": markFunction(function (text) {
1912					text = text.replace(runescape, funescape);
1913					return function (elem) {
1914						return (elem.textContent || elem.innerText || getText(elem)).indexOf(text) > -1;
1915					};
1916				}),
1917
1918				// "Whether an element is represented by a :lang() selector
1919				// is based solely on the element's language value
1920				// being equal to the identifier C,
1921				// or beginning with the identifier C immediately followed by "-".
1922				// The matching of C against the element's language value is performed case-insensitively.
1923				// The identifier C does not have to be a valid language name."
1924				// http://www.w3.org/TR/selectors/#lang-pseudo
1925				"lang": markFunction(function (lang) {
1926					// lang value must be a valid identifier
1927					if (!ridentifier.test(lang || "")) {
1928						Sizzle.error("unsupported lang: " + lang);
1929					}
1930					lang = lang.replace(runescape, funescape).toLowerCase();
1931					return function (elem) {
1932						var elemLang;
1933						do {
1934							if (elemLang = documentIsHTML ? elem.lang : elem.getAttribute("xml:lang") || elem.getAttribute("lang")) {
1935
1936								elemLang = elemLang.toLowerCase();
1937								return elemLang === lang || elemLang.indexOf(lang + "-") === 0;
1938							}
1939						} while ((elem = elem.parentNode) && elem.nodeType === 1);
1940						return false;

1941					};
1942				}),
1943
1944				// Miscellaneous
1945				"target": function (elem) {
1946					var hash = window.location && window.location.hash;
1947					return hash && hash.slice(1) === elem.id;
1948				},
1949
1950				"root": function (elem) {
1951					return elem === docElem;
1952				},
1953
1954				"focus": function (elem) {
1955					return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
1956				},
1957
1958				// Boolean properties
1959				"enabled": function (elem) {
1960					return elem.disabled === false;
1961				},
1962
1963				"disabled": function (elem) {
1964					return elem.disabled === true;
1965				},
1966
1967				"checked": function (elem) {
1968					// In CSS3, :checked should return both checked and selected elements
1969					// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
1970					var nodeName = elem.nodeName.toLowerCase();
1971					return nodeName === "input" && !!elem.checked || nodeName === "option" && !!elem.selected;
1972				},
1973
1974				"selected": function (elem) {
1975					// Accessing this property makes selected-by-default
1976					// options in Safari work properly
1977					if (elem.parentNode) {
1978						elem.parentNode.selectedIndex;
1979					}
1980
1981					return elem.selected === true;
1982				},
1983
1984				// Contents
1985				"empty": function (elem) {
1986					// http://www.w3.org/TR/selectors/#empty-pseudo
1987					// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
1988					//   but not by others (comment: 8; processing instruction: 7; etc.)
1989					// nodeType < 6 works because attributes (2) do not appear as children
1990					for (elem = elem.firstChild; elem; elem = elem.nextSibling) {
1991						if (elem.nodeType < 6) {
1992							return false;
1993						}
1994					}
1995					return true;
1996				},
1997
1998				"parent": function (elem) {
1999					return !Expr.pseudos["empty"](elem);
2000				},
2001
2002				// Element/input types
2003				"header": function (elem) {
2004					return rheader.test(elem.nodeName);
2005				},
2006
2007				"input": function (elem) {
2008					return rinputs.test(elem.nodeName);
2009				},
2010
2011				"button": function (elem) {
2012					var name = elem.nodeName.toLowerCase();
2013					return name === "input" && elem.type === "button" || name === "button";
2014				},
2015
2016				"text": function (elem) {
2017					var attr;
2018					return elem.nodeName.toLowerCase() === "input" && elem.type === "text" && (
2019
2020					// Support: IE<8
2021					// New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
2022					(attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text");
2023				},
2024
2025				// Position-in-collection
2026				"first": createPositionalPseudo(function () {
2027					return [0];
2028				}),
2029
2030				"last": createPositionalPseudo(function (matchIndexes, length) {
2031					return [length - 1];
2032				}),
2033
2034				"eq": createPositionalPseudo(function (matchIndexes, length, argument) {
2035					return [argument < 0 ? argument + length : argument];
2036				}),
2037
2038				"even": createPositionalPseudo(function (matchIndexes, length) {
2039					var i = 0;
2040					for (; i < length; i += 2) {
2041						matchIndexes.push(i);
2042					}
2043					return matchIndexes;
2044				}),
2045
2046				"odd": createPositionalPseudo(function (matchIndexes, length) {
2047					var i = 1;
2048					for (; i < length; i += 2) {
2049						matchIndexes.push(i);
2050					}
2051					return matchIndexes;
2052				}),
2053
2054				"lt": createPositionalPseudo(function (matchIndexes, length, argument) {
2055					var i = argument < 0 ? argument + length : argument;
2056					for (; --i >= 0;) {
2057						matchIndexes.push(i);
2058					}
2059					return matchIndexes;
2060				}),
2061
2062				"gt": createPositionalPseudo(function (matchIndexes, length, argument) {
2063					var i = argument < 0 ? argument + length : argument;
2064					for (; ++i < length;) {
2065						matchIndexes.push(i);
2066					}
2067					return matchIndexes;
2068				})
2069			}
2070		};
2071
2072		Expr.pseudos["nth"] = Expr.pseudos["eq"];
2073
2074		// Add button/input type pseudos
2075		for (i in { radio: true, checkbox: true, file: true, password: true, image: true }) {
2076			Expr.pseudos[i] = createInputPseudo(i);
2077		}
2078		for (i in { submit: true, reset: true }) {
2079			Expr.pseudos[i] = createButtonPseudo(i);
2080		}
2081
2082		// Easy API for creating new setFilters
2083		function setFilters() {}
2084		setFilters.prototype = Expr.filters = Expr.pseudos;
2085		Expr.setFilters = new setFilters();
2086
2087		tokenize = Sizzle.tokenize = function (selector, parseOnly) {
2088			var matched,
2089			    match,
2090			    tokens,
2091			    type,
2092			    soFar,
2093			    groups,
2094			    preFilters,

2095			    cached = tokenCache[selector + " "];
2096
2097			if (cached) {
2098				return parseOnly ? 0 : cached.slice(0);
2099			}
2100
2101			soFar = selector;
2102			groups = [];
2103			preFilters = Expr.preFilter;
2104
2105			while (soFar) {
2106
2107				// Comma and first run
2108				if (!matched || (match = rcomma.exec(soFar))) {
2109					if (match) {
2110						// Don't consume trailing commas as valid
2111						soFar = soFar.slice(match[0].length) || soFar;
2112					}
2113					groups.push(tokens = []);
2114				}
2115
2116				matched = false;
2117
2118				// Combinators
2119				if (match = rcombinators.exec(soFar)) {
2120					matched = match.shift();
2121					tokens.push({
2122						value: matched,
2123						// Cast descendant combinators to space
2124						type: match[0].replace(rtrim, " ")
2125					});
2126					soFar = soFar.slice(matched.length);
2127				}
2128
2129				// Filters
2130				for (type in Expr.filter) {
2131					if ((match = matchExpr[type].exec(soFar)) && (!preFilters[type] || (match = preFilters[type](match)))) {
2132						matched = match.shift();
2133						tokens.push({
2134							value: matched,
2135							type: type,
2136							matches: match
2137						});
2138						soFar = soFar.slice(matched.length);
2139					}
2140				}
2141
2142				if (!matched) {
2143					break;
2144				}
2145			}
2146
2147			// Return the length of the invalid excess
2148			// if we're just parsing
2149			// Otherwise, throw an error or return tokens
2150			return parseOnly ? soFar.length : soFar ? Sizzle.error(selector) :
2151			// Cache the tokens
2152			tokenCache(selector, groups).slice(0);
2153		};
2154
2155		function toSelector(tokens) {
2156			var i = 0,
2157			    len = tokens.length,
2158			    selector = "";
2159			for (; i < len; i++) {
2160				selector += tokens[i].value;
2161			}
2162			return selector;
2163		}
2164
2165		function addCombinator(matcher, combinator, base) {
2166			var dir = combinator.dir,
2167			    checkNonElements = base && dir === "parentNode",
2168			    doneName = done++;
2169
2170			return combinator.first ?
2171			// Check against closest ancestor/preceding element
2172			function (elem, context, xml) {
2173				while (elem = elem[dir]) {
2174					if (elem.nodeType === 1 || checkNonElements) {
2175						return matcher(elem, context, xml);
2176					}
2177				}
2178			} :
2179
2180			// Check against all ancestor/preceding elements
2181			function (elem, context, xml) {
2182				var oldCache,
2183				    uniqueCache,
2184				    outerCache,
2185				    newCache = [dirruns, doneName];
2186
2187				// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching
2188				if (xml) {
2189					while (elem = elem[dir]) {
2190						if (elem.nodeType === 1 || checkNonElements) {
2191							if (matcher(elem, context, xml)) {
2192								return true;
2193							}
2194						}
2195					}
2196				} else {
2197					while (elem = elem[dir]) {
2198						if (elem.nodeType === 1 || checkNonElements) {
2199							outerCache = elem[expando] || (elem[expando] = {});
2200
2201							// Support: IE <9 only
2202							// Defend against cloned attroperties (jQuery gh-1709)
2203							uniqueCache = outerCache[elem.uniqueID] || (outerCache[elem.uniqueID] = {});
2204
2205							if ((oldCache = uniqueCache[dir]) && oldCache[0] === dirruns && oldCache[1] === doneName) {
2206
2207								// Assign to newCache so results back-propagate to previous elements
2208								return newCache[2] = oldCache[2];
2209							} else {
2210								// Reuse newcache so results back-propagate to previous elements
2211								uniqueCache[dir] = newCache;
2212
2213								// A match means we're done; a fail means we have to keep checking
2214								if (newCache[2] = matcher(elem, context, xml)) {
2215									return true;
2216								}
2217							}
2218						}
2219					}
2220				}
2221			};
2222		}
2223
2224		function elementMatcher(matchers) {
2225			return matchers.length > 1 ? function (elem, context, xml) {
2226				var i = matchers.length;
2227				while (i--) {
2228					if (!matchers[i](elem, context, xml)) {
2229						return false;
2230					}
2231				}
2232				return true;
2233			} : matchers[0];
2234		}
2235
2236		function multipleContexts(selector, contexts, results) {
2237			var i = 0,
2238			    len = contexts.length;
2239			for (; i < len; i++) {
2240				Sizzle(selector, contexts[i], results);
2241			}
2242			return results;
2243		}
2244
2245		function condense(unmatched, map, filter, context, xml) {
2246			var elem,
2247			    newUnmatched = [],
2248			    i = 0,
2249			    len = unmatched.length,
2250			    mapped = map != null;
2251
2252			for (; i < len; i++) {
2253				if (elem = unmatched[i]) {
2254					if (!filter || filter(elem, context, xml)) {
2255						newUnmatched.push(elem);
2256						if (mapped) {
2257							map.push(i);
2258						}
2259					}
2260				}
2261			}
2262
2263			return newUnmatched;
2264		}
2265
2266		function setMatcher(preFilter, selector, matcher, postFilter, postFinder, postSelector) {
2267			if (postFilter && !postFilter[expando]) {
2268				postFilter = setMatcher(postFilter);
2269			}
2270			if (postFinder && !postFinder[expando]) {
2271				postFinder = setMatcher(postFinder, postSelector);
2272			}
2273			return markFunction(function (seed, results, context, xml) {
2274				var temp,
2275				    i,
2276				    elem,
2277				    preMap = [],
2278				    postMap = [],
2279				    preexisting = results.length,
2280
2281
2282				// Get initial elements from seed or context
2283				elems = seed || multipleContexts(selector || "*", context.nodeType ? [context] : context, []),
2284
2285
2286				// Prefilter to get matcher input, preserving a map for seed-results synchronization
2287				matcherIn = preFilter && (seed || !selector) ? condense(elems, preMap, preFilter, context, xml) : elems,
2288				    matcherOut = matcher ?
2289				// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
2290				postFinder || (seed ? preFilter : preexisting || postFilter) ?
2291
2292				// ...intermediate processing is necessary
2293				[] :
2294
2295				// ...otherwise use results directly
2296				results : matcherIn;
2297
2298				// Find primary matches
2299				if (matcher) {
2300					matcher(matcherIn, matcherOut, context, xml);
2301				}
2302
2303				// Apply postFilter
2304				if (postFilter) {
2305					temp = condense(matcherOut, postMap);
2306					postFilter(temp, [], context, xml);
2307
2308					// Un-match failing elements by moving them back to matcherIn
2309					i = temp.length;
2310					while (i--) {
2311						if (elem = temp[i]) {
2312							matcherOut[postMap[i]] = !(matcherIn[postMap[i]] = elem);
2313						}
2314					}
2315				}
2316
2317				if (seed) {
2318					if (postFinder || preFilter) {
2319						if (postFinder) {
2320							// Get the final matcherOut by condensing this intermediate into postFinder contexts
2321							temp = [];
2322							i = matcherOut.length;
2323							while (i--) {
2324								if (elem = matcherOut[i]) {
2325									// Restore matcherIn since elem is not yet a final match
2326									temp.push(matcherIn[i] = elem);
2327								}
2328							}
2329							postFinder(null, matcherOut = [], temp, xml);
2330						}
2331
2332						// Move matched elements from seed to results to keep them synchronized
2333						i = matcherOut.length;
2334						while (i--) {
2335							if ((elem = matcherOut[i]) && (temp = postFinder ? indexOf(seed, elem) : preMap[i]) > -1) {
2336
2337								seed[temp] = !(results[temp] = elem);
2338							}
2339						}
2340					}
2341
2342					// Add elements to results, through postFinder if defined
2343				} else {
2344					matcherOut = condense(matcherOut === results ? matcherOut.splice(preexisting, matcherOut.length) : matcherOut);
2345					if (postFinder) {
2346						postFinder(null, results, matcherOut, xml);
2347					} else {
2348						push.apply(results, matcherOut);
2349					}
2350				}
2351			});
2352		}
2353
2354		function matcherFromTokens(tokens) {
2355			var checkContext,
2356			    matcher,
2357			    j,
2358			    len = tokens.length,
2359			    leadingRelative = Expr.relative[tokens[0].type],
2360			    implicitRelative = leadingRelative || Expr.relative[" "],

2361			    i = leadingRelative ? 1 : 0,
2362
2363
2364			// The foundational matcher ensures that elements are reachable from top-level context(s)
2365			matchContext = addCombinator(function (elem) {
2366				return elem === checkContext;
2367			}, implicitRelative, true),
2368			    matchAnyContext = addCombinator(function (elem) {
2369				return indexOf(checkContext, elem) > -1;
2370			}, implicitRelative, true),
2371			    matchers = [function (elem, context, xml) {
2372				var ret = !leadingRelative && (xml || context !== outermostContext) || ((checkContext = context).nodeType ? matchContext(elem, context, xml) : matchAnyContext(elem, context, xml));
2373				// Avoid hanging onto element (issue #299)
2374				checkContext = null;
2375				return ret;
2376			}];
2377
2378			for (; i < len; i++) {
2379				if (matcher = Expr.relative[tokens[i].type]) {
2380					matchers = [addCombinator(elementMatcher(matchers), matcher)];
2381				} else {
2382					matcher = Expr.filter[tokens[i].type].apply(null, tokens[i].matches);
2383
2384					// Return special upon seeing a positional matcher
2385					if (matcher[expando]) {
2386						// Find the next relative operator (if any) for proper handling
2387						j = ++i;
2388						for (; j < len; j++) {
2389							if (Expr.relative[tokens[j].type]) {
2390								break;
2391							}
2392						}
2393						return setMatcher(i > 1 && elementMatcher(matchers), i > 1 && toSelector(
2394						// If the preceding token was a descendant combinator, insert an implicit any-element `*`
2395						tokens.slice(0, i - 1).concat({ value: tokens[i - 2].type === " " ? "*" : "" })).replace(rtrim, "$1"), matcher, i < j && matcherFromTokens(tokens.slice(i, j)), j < len && matcherFromTokens(tokens = tokens.slice(j)), j < len && toSelector(tokens));
2396					}
2397					matchers.push(matcher);
2398				}
2399			}
2400
2401			return elementMatcher(matchers);
2402		}
2403
2404		function matcherFromGroupMatchers(elementMatchers, setMatchers) {
2405			var bySet = setMatchers.length > 0,
2406			    byElement = elementMatchers.length > 0,
2407			    superMatcher = function (seed, context, xml, results, outermost) {
2408				var elem,
2409				    j,
2410				    matcher,
2411				    matchedCount = 0,
2412				    i = "0",
2413				    unmatched = seed && [],
2414				    setMatched = [],
2415				    contextBackup = outermostContext,
2416
2417				// We must always have either seed elements or outermost context
2418				elems = seed || byElement && Expr.find["TAG"]("*", outermost),
2419
2420				// Use integer dirruns iff this is the outermost matcher
2421				dirrunsUnique = dirruns += contextBackup == null ? 1 : Math.random() || 0.1,
2422				    len = elems.length;
2423
2424				if (outermost) {
2425					outermostContext = context === document || context || outermost;
2426				}
2427
2428				// Add elements passing elementMatchers directly to results
2429				// Support: IE<9, Safari
2430				// Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
2431				for (; i !== len && (elem = elems[i]) != null; i++) {
2432					if (byElement && elem) {
2433						j = 0;
2434						if (!context && elem.ownerDocument !== document) {
2435							setDocument(elem);
2436							xml = !documentIsHTML;
2437						}
2438						while (matcher = elementMatchers[j++]) {
2439							if (matcher(elem, context || document, xml)) {
2440								results.push(elem);
2441								break;
2442							}
2443						}
2444						if (outermost) {
2445							dirruns = dirrunsUnique;
2446						}
2447					}
2448
2449					// Track unmatched elements for set filters
2450					if (bySet) {
2451						// They will have gone through all possible matchers
2452						if (elem = !matcher && elem) {
2453							matchedCount--;
2454						}
2455
2456						// Lengthen the array for every element, matched or not
2457						if (seed) {
2458							unmatched.push(elem);
2459						}
2460					}
2461				}
2462
2463				// `i` is now the count of elements visited above, and adding it to `matchedCount`
2464				// makes the latter nonnegative.
2465				matchedCount += i;
2466
2467				// Apply set filters to unmatched elements
2468				// NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`
2469				// equals `i`), unless we didn't visit _any_ elements in the above loop because we have
2470				// no element matchers and no seed.
2471				// Incrementing an initially-string "0" `i` allows `i` to remain a string only in that
2472				// case, which will result in a "00" `matchedCount` that differs from `i` but is also
2473				// numerically zero.
2474				if (bySet && i !== matchedCount) {
2475					j = 0;
2476					while (matcher = setMatchers[j++]) {
2477						matcher(unmatched, setMatched, context, xml);
2478					}
2479
2480					if (seed) {
2481						// Reintegrate element matches to eliminate the need for sorting
2482						if (matchedCount > 0) {
2483							while (i--) {
2484								if (!(unmatched[i] || setMatched[i])) {
2485									setMatched[i] = pop.call(results);
2486								}
2487							}
2488						}
2489
2490						// Discard index placeholder values to get only actual matches
2491						setMatched = condense(setMatched);
2492					}
2493
2494					// Add matches to results
2495					push.apply(results, setMatched);
2496
2497					// Seedless set matches succeeding multiple successful matchers stipulate sorting
2498					if (outermost && !seed && setMatched.length > 0 && matchedCount + setMatchers.length > 1) {
2499
2500						Sizzle.uniqueSort(results);
2501					}
2502				}
2503
2504				// Override manipulation of globals by nested matchers
2505				if (outermost) {
2506					dirruns = dirrunsUnique;
2507					outermostContext = contextBackup;
2508				}
2509
2510				return unmatched;
2511			};
2512
2513			return bySet ? markFunction(superMatcher) : superMatcher;
2514		}
2515
2516		compile = Sizzle.compile = function (selector, match /* Internal Use Only */) {
2517			var i,
2518			    setMatchers = [],
2519			    elementMatchers = [],
2520			    cached = compilerCache[selector + " "];
2521
2522			if (!cached) {
2523				// Generate a function of recursive functions that can be used to check each element
2524				if (!match) {
2525					match = tokenize(selector);
2526				}
2527				i = match.length;
2528				while (i--) {
2529					cached = matcherFromTokens(match[i]);
2530					if (cached[expando]) {
2531						setMatchers.push(cached);
2532					} else {
2533						elementMatchers.push(cached);
2534					}
2535				}
2536
2537				// Cache the compiled function
2538				cached = compilerCache(selector, matcherFromGroupMatchers(elementMatchers, setMatchers));
2539
2540				// Save selector and tokenization
2541				cached.selector = selector;
2542			}
2543			return cached;
2544		};
2545
2546		/**
2547   * A low-level selection function that works with Sizzle's compiled
2548   *  selector functions
2549   * @param {String|Function} selector A selector or a pre-compiled
2550   *  selector function built with Sizzle.compile
2551   * @param {Element} context
2552   * @param {Array} [results]
2553   * @param {Array} [seed] A set of elements to match against
2554   */
2555		select = Sizzle.select = function (selector, context, results, seed) {
2556			var i,
2557			    tokens,
2558			    token,
2559			    type,
2560			    find,
2561			    compiled = typeof selector === "function" && selector,
2562			    match = !seed && tokenize(selector = compiled.selector || selector);
2563
2564			results = results || [];
2565
2566			// Try to minimize operations if there is only one selector in the list and no seed
2567			// (the latter of which guarantees us context)
2568			if (match.length === 1) {
2569
2570				// Reduce context if the leading compound selector is an ID
2571				tokens = match[0] = match[0].slice(0);
2572				if (tokens.length > 2 && (token = tokens[0]).type === "ID" && support.getById && context.nodeType === 9 && documentIsHTML && Expr.relative[tokens[1].type]) {
2573
2574					context = (Expr.find["ID"](token.matches[0].replace(runescape, funescape), context) || [])[0];
2575					if (!context) {
2576						return results;
2577
2578						// Precompiled matchers will still verify ancestry, so step up a level
2579					} else if (compiled) {
2580						context = context.parentNode;
2581					}
2582
2583					selector = selector.slice(tokens.shift().value.length);
2584				}
2585
2586				// Fetch a seed set for right-to-left matching
2587				i = matchExpr["needsContext"].test(selector) ? 0 : tokens.length;
2588				while (i--) {
2589					token = tokens[i];
2590
2591					// Abort if we hit a combinator
2592					if (Expr.relative[type = token.type]) {
2593						break;
2594					}
2595					if (find = Expr.find[type]) {
2596						// Search, expanding context for leading sibling combinators
2597						if (seed = find(token.matches[0].replace(runescape, funescape), rsibling.test(tokens[0].type) && testC

2597ontext(context.parentNode) || context)) {
2598
2599							// If seed is empty or no tokens remain, we can return early
2600							tokens.splice(i, 1);
2601							selector = seed.length && toSelector(tokens);
2602							if (!selector) {
2603								push.apply(results, seed);
2604								return results;
2605							}
2606
2607							break;
2608						}
2609					}
2610				}
2611			}
2612
2613			// Compile and execute a filtering function if one is not provided
2614			// Provide `match` to avoid retokenization if we modified the selector above
2615			(compiled || compile(selector, match))(seed, context, !documentIsHTML, results, !context || rsibling.test(selector) && testContext(context.parentNode) || context);
2616			return results;
2617		};
2618
2619		// One-time assignments
2620
2621		// Sort stability
2622		support.sortStable = expando.split("").sort(sortOrder).join("") === expando;
2623
2624		// Support: Chrome 14-35+
2625		// Always assume duplicates if they aren't passed to the comparison function
2626		support.detectDuplicates = !!hasDuplicate;
2627
2628		// Initialize against the default document
2629		setDocument();
2630
2631		// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
2632		// Detached nodes confoundingly follow *each other*
2633		support.sortDetached = assert(function (div1) {
2634			// Should return 1, but returns 4 (following)
2635			return div1.compareDocumentPosition(document.createElement("div")) & 1;
2636		});
2637
2638		// Support: IE<8
2639		// Prevent attribute/property "interpolation"
2640		// http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
2641		if (!assert(function (div) {
2642			div.innerHTML = "<a href='#'></a>";
2643			return div.firstChild.getAttribute("href") === "#";
2644		})) {
2645			addHandle("type|href|height|width", function (elem, name, isXML) {
2646				if (!isXML) {
2647					return elem.getAttribute(name, name.toLowerCase() === "type" ? 1 : 2);
2648				}
2649			});
2650		}
2651
2652		// Support: IE<9
2653		// Use defaultValue in place of getAttribute("value")
2654		if (!support.attributes || !assert(function (div) {
2655			div.innerHTML = "<input/>";
2656			div.firstChild.setAttribute("value", "");
2657			return div.firstChild.getAttribute("value") === "";
2658		})) {
2659			addHandle("value", function (elem, name, isXML) {
2660				if (!isXML && elem.nodeName.toLowerCase() === "input") {
2661					return elem.defaultValue;
2662				}
2663			});
2664		}
2665
2666		// Support: IE<9
2667		// Use getAttributeNode to fetch booleans when getAttribute lies
2668		if (!assert(function (div) {
2669			return div.getAttribute("disabled") == null;
2670		})) {
2671			addHandle(booleans, function (elem, name, isXML) {
2672				var val;
2673				if (!isXML) {
2674					return elem[name] === true ? name.toLowerCase() : (val = elem.getAttributeNode(name)) && val.specified ? val.value : null;
2675				}
2676			});
2677		}
2678
2679		return Sizzle;
2680	}(window);
2681
2682	jQuery.find = Sizzle;
2683	jQuery.expr = Sizzle.selectors;
2684	jQuery.expr[":"] = jQuery.expr.pseudos;
2685	jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;
2686	jQuery.text = Sizzle.getText;
2687	jQuery.isXMLDoc = Sizzle.isXML;
2688	jQuery.contains = Sizzle.contains;
2689
2690	var dir = function (elem, dir, until) {
2691		var matched = [],
2692		    truncate = until !== undefined;
2693
2694		while ((elem = elem[dir]) && elem.nodeType !== 9) {
2695			if (elem.nodeType === 1) {
2696				if (truncate && jQuery(elem).is(until)) {
2697					break;
2698				}
2699				matched.push(elem);
2700			}
2701		}
2702		return matched;
2703	};
2704
2705	var siblings = function (n, elem) {
2706		var matched = [];
2707
2708		for (; n; n = n.nextSibling) {
2709			if (n.nodeType === 1 && n !== elem) {
2710				matched.push(n);
2711			}
2712		}
2713
2714		return matched;
2715	};
2716
2717	var rneedsContext = jQuery.expr.match.needsContext;
2718
2719	var rsingleTag = /^<([\w-]+)\s*\/?>(?:<\/\1>|)$/;
2720
2721	var risSimple = /^.[^:#\[\.,]*$/;
2722
2723	// Implement the identical functionality for filter and not
2724	function winnow(elements, qualifier, not) {
2725		if (jQuery.isFunction(qualifier)) {
2726			return jQuery.grep(elements, function (elem, i) {
2727				/* jshint -W018 */
2728				return !!qualifier.call(elem, i, elem) !== not;
2729			});
2730		}
2731
2732		if (qualifier.nodeType) {
2733			return jQuery.grep(elements, function (elem) {
2734				return elem === qualifier !== not;
2735			});
2736		}
2737
2738		if (typeof qualifier === "string") {
2739			if (risSimple.test(qualifier)) {
2740				return jQuery.filter(qualifier, elements, not);
2741			}
2742
2743			qualifier = jQuery.filter(qualifier, elements);
2744		}
2745
2746		return jQuery.grep(elements, function (elem) {
2747			return jQuery.inArray(elem, qualifier) > -1 !== not;
2748		});
2749	}
2750
2751	jQuery.filter = function (expr, elems, not) {
2752		var elem = elems[0];
2753
2754		if (not) {
2755			expr = ":not(" + expr + ")";
2756		}
2757
2758		return elems.length === 1 && elem.nodeType === 1 ? jQuery.find.matchesSelector(elem, expr) ? [elem] : [] : jQuery.find.matches(expr, jQuery.grep(elems, function (elem) {
2759			return elem.nodeType === 1;
2760		}));
2761	};
2762
2763	jQuery.fn.extend({
2764		find: function (selector) {
2765			var i,
2766			    ret = [],
2767			    self = this,
2768			    len = self.length;
2769
2770			if (typeof selector !== "string") {
2771				return this.pushStack(jQuery(selector).filter(function () {
2772					for (i = 0; i < len; i++) {
2773						if (jQuery.contains(self[i], this)) {
2774							return true;
2775						}
2776					}
2777				}));
2778			}
2779
2780			for (i = 0; i < len; i++) {
2781				jQuery.find(selector, self[i], ret);
2782			}
2783
2784			// Needed because $( selector, context ) becomes $( context ).find( selector )
2785			ret = this.pushStack(len > 1 ? jQuery.unique(ret) : ret);
2786			ret.selector = this.selector ? this.selector + " " + selector : selector;
2787			return ret;
2788		},
2789		filter: function (selector) {
2790			return this.pushStack(winnow(this, selector || [], false));
2791		},
2792		not: function (selector) {
2793			return this.pushStack(winnow(this, selector || [], true));
2794		},
2795		is: function (selector) {
2796			return !!winnow(this,
2797
2798			// If this is a positional/relative selector, check membership in the returned set
2799			// so $("p:first").is("p:last") won't return true for a doc with two "p".
2800			typeof selector === "string" && rneedsContext.test(selector) ? jQuery(selector) : selector || [], false).length;
2801		}
2802	});
2803
2804	// Initialize a jQuery object
2805
2806
2807	// A central reference to the root jQuery(document)
2808	var rootjQuery,
2809
2810
2811	// A simple way to check for HTML strings