https://shinhoglobal.com/js/custom/lyt-cn-news-list.js?jQ3zpo5rg6

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

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

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

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

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

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

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

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

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