https://mjosservice.no/assets/js/vendor.js?m=1787069055

167		// Support: Firefox 18+
168		// Can't be in strict mode, several libs including ASP.NET trace
169		// the stack via arguments.caller.callee and Firefox dies if
170		// you try to trace through "use strict" call chains. (#13335)
171		//
172
173		var arr = [];
174
175		var _slice = arr.slice;
176
177		var concat = arr.concat;
178
179		var push = arr.push;
180
181		var indexOf = arr.indexOf;
182
183		var class2type = {};
184
185		var toString = class2type.toString;
186
187		var hasOwn = class2type.hasOwnProperty;
188
189		var support = {};
190
191		var
192		// Use the correct document accordingly with window argument (sandbox)
193		document = window.document,
194		    version = "2.1.4",
195
196
197		// Define a local copy of jQuery
198		jQuery = function jQuery(selector, context) {
199			// The jQuery object is actually just the init constructor 'enhanced'
200			// Need init if jQuery is called (just allow error to be thrown if not included)
201			return new jQuery.fn.init(selector, context);
202		},
203
204
205		// Support: Android<4.1
206		// Make sure we trim BOM and NBSP
207		rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
208
209
210		// Matches dashed string for camelizing
211		rmsPrefix = /^-ms-/,
212		    rdashAlpha = /-([\da-z])/gi,
213
214
215		// Used by jQuery.camelCase as callback to replace()
216		fcamelCase = function fcamelCase(all, letter) {
217			return letter.toUpperCase();
218		};
219
220		jQuery.fn = jQuery.prototype = {
221			// The current version of jQuery being used
222			jquery: version,
223
224			constructor: jQuery,
225
226			// Start with an empty selector
227			selector: "",
228
229			// The default length of a jQuery object is 0
230			length: 0,
231
232			toArray: function toArray() {
233				return _slice.call(this);
234			},
235
236			// Get the Nth element in the matched element set OR
237			// Get the whole matched element set as a clean array
238			get: function get(num) {
239				return num != null ?
240
241				// Return just the one element from the set
242				num < 0 ? this[num + this.length] : this[num] :
243
244				// Return all the elements in a clean array
245				_slice.call(this);
246			},
247
248			// Take an array of elements and push it onto the stack
249			// (returning the new matched element set)
250			pushStack: function pushStack(elems) {
251
252				// Build a new jQuery matched element set
253				var ret = jQuery.merge(this.constructor(), elems);
254
255				// Add the old object onto the stack (as a reference)
256				ret.prevObject = this;
257				ret.context = this.context;
258
259				// Return the newly-formed element set
260				return ret;
261			},
262
263			// Execute a callback for every element in the matched set.
264			// (You can seed the arguments with an array of args, but this is
265			// only used internally.)
266			each: function each(callback, args) {
267				return jQuery.each(this, callback, args);
268			},
269
270			map: function map(callback) {
271				return this.pushStack(jQuery.map(this, function (elem, i) {
272					return callback.call(elem, i, elem);
273				}));
274			},
275
276			slice: function slice() {
277				return this.pushStack(_slice.apply(this, arguments));
278			},
279
280			first: function first() {
281				return this.eq(0);
282			},
283
284			last: function last() {
285				return this.eq(-1);
286			},
287
288			eq: function eq(i) {
289				var len = this.length,
290				    j = +i + (i < 0 ? len : 0);
291				return this.pushStack(j >= 0 && j < len ? [this[j]] : []);
292			},
293
294			end: function end() {
295				return this.prevObject || this.constructor(null);
296			},
297
298			// For internal use only.
299			// Behaves like an Array's method, not like a jQuery method.
300			push: push,
301			sort: arr.sort,
302			splice: arr.splice
303		};
304
305		jQuery.extend = jQuery.fn.extend = function () {
306			var options,
307			    name,
308			    src,
309			    copy,
310			    copyIsArray,
311			    clone,
312			    target = arguments[0] || {},
313			    i = 1,
314			    length = arguments.length,
315			    deep = false;
316
317			// Handle a deep copy situation
318			if (typeof target === "boolean") {
319				deep = target;
320
321				// Skip the boolean and the target
322				target = arguments[i] || {};
323				i++;
324			}
325
326			// Handle case when target is a string or something (possible in deep copy)
327			if ((typeof target === "undefined" ? "undefined" : (0, _typeof3.default)(target)) !== "object" && !jQuery.isFunction(target)) {
328				target = {};
329			}
330
331			// Extend jQuery itself if only one argument is passed
332			if (i === length) {
333				target = this;
334				i--;
335			}
336
337			for (; i < length; i++) {
338				// Only deal with non-null/undefined values
339				if ((options = arguments[i]) != null) {
340					// Extend the base object
341					for (name in options) {
342						src = target[name];
343						copy = options[name];
344
345						// Prevent never-ending loop
346						if (target === copy) {
347							continue;
348						}
349
350						// Recurse if we're merging plain objects or arrays
351						if (deep && copy && (jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)))) {
352							if (copyIsArray) {
353								copyIsArray = false;

523			// Support: Android<4.1
524			trim: function trim(text) {
525				return text == null ? "" : (text + "").replace(rtrim, "");
526			},
527
528			// results is for internal usage only
529			makeArray: function makeArray(arr, results) {
530				var ret = results || [];
531
532				if (arr != null) {
533					if (isArraylike(Object(arr))) {
534						jQuery.merge(ret, typeof arr === "string" ? [arr] : arr);
535					} else {
536						push.call(ret, arr);
537					}
538				}
539
540				return ret;
541			},
542
543			inArray: function inArray(elem, arr, i) {
544				return arr == null ? -1 : indexOf.call(arr, elem, i);
545			},
546
547			merge: function merge(first, second) {
548				var len = +second.length,
549				    j = 0,
550				    i = first.length;
551
552				for (; j < len; j++) {
553					first[i++] = second[j];
554				}
555
556				first.length = i;
557
558				return first;
559			},
560
561			grep: function grep(elems, callback, invert) {
562				var callbackInverse,
563				    matches = [],
564				    i = 0,
565				    length = elems.length,
566				    callbackExpect = !invert;
567
568				// Go through the array, only saving the items
569				// that pass the validator function
570				for (; i < length; i++) {
571					callbackInverse = !callback(elems[i], i);
572					if (callbackInverse !== callbackExpect) {
573						matches.push(elems[i]);
574					}
575				}
576
577				return matches;
578			},
579
580			// arg is for internal usage only
581			map: function map(elems, callback, arg) {
582				var value,
583				    i = 0,
584				    length = elems.length,
585				    isArray = isArraylike(elems),
586				    ret = [];
587
588				// Go through the array, translating each of the items to their new values
589				if (isArray) {
590					for (; i < length; i++) {
591						value = callback(elems[i], i, arg);
592
593						if (value != null) {
594							ret.push(value);
595						}
596					}
597
598					// Go through every key on the object,
599				} else {
600						for (i in elems) {
601							value = callback(elems[i], i, arg);
602
603							if (value != null) {
604								ret.push(value);
605							}
606						}
607					}
608
609				// Flatten any nested arrays
610				return concat.apply([], ret);
611			},
612
613			// A global GUID counter for objects
614			guid: 1,
615
616			// Bind a function to a context, optionally partially applying any
617			// arguments.
618			proxy: function proxy(fn, context) {
619				var tmp, args, proxy;
620
621				if (typeof context === "string") {
622					tmp = fn[context];
623					context = fn;
624					fn = tmp;
625				}
626
627				// Quick check to determine if target is callable, in the spec
628				// this throws a TypeError, but we will just return undefined.
629				if (!jQuery.isFunction(fn)) {
630					return undefined;
631				}
632
633				// Simulated bind
634				args = _slice.call(arguments, 2);
635				proxy = function proxy() {
636					return fn.apply(context || this, args.concat(_slice.call(arguments)));
637				};
638
639				// Set the guid of unique handler to the same of original handler, so it can be removed
640				proxy.guid = fn.guid = fn.guid || jQuery.guid++;
641
642				return proxy;
643			},
644
645			now: Date.now,
646
647			// jQuery.support is not used in Core but other projects attach their
648			// properties to it so it needs to exist.
649			support: support
650		});
651
652		// Populate the class2type map
653		jQuery.each("Boolean Number String Function Array Date RegExp Object Error".split(" "), function (i, name) {
654			class2type["[object " + name + "]"] = name.toLowerCase();
655		});
656
657		function isArraylike(obj) {
658
659			// Support: iOS 8.2 (not reproducible in simulator)
660			// `in` check used to prevent JIT error (gh-2145)
661			// hasOwn isn't used here due to false negatives
662			// regarding Nodelist length in IE
663			var length = "length" in obj && obj.length,
664			    type = jQuery.type(obj);
665
666			if (type === "function" || jQuery.isWindow(obj)) {
667				return false;
668			}
669
670			if (obj.nodeType === 1 && length) {
671				return true;
672			}
673
674			return type === "array" || length === 0 || typeof length === "number" && length > 0 && length - 1 in obj;
675		}
676		var Sizzle =
677		/*!
678	  * Sizzle CSS Selector Engine v2.2.0-pre
679	  * http://sizzlejs.com/
680	  *
681	  * Copyright 2008, 2014 jQuery Foundation, Inc. and other contributors
682	  * Released under the MIT license
683	  * http://jquery.org/license
684	  *
685	  * Date: 2014-12-16
686	  */
687		function (window) {
688
689			var i,
690			    support,
691			    Expr,
692			    getText,
693			    isXML,
694			    tokenize,
695			    compile,
696			    select,
697			    outermostContext,
698			    sortInput,
699			    hasDuplicate,
700
701
702			// Local document vars
703			setDocument,
704			    document,
705			    docElem,
706			    documentIsHTML,
707			    rbuggyQSA,
708			    rbuggyMatches,
709			    matches,
710			    contains,
711
712
713			// Instance-specific data
714			expando = "sizzle" + 1 * new Date(),
715			    preferredDoc = window.document,
716			    dirruns = 0,
717			    done = 0,
718			    classCache = createCache(),
719			    tokenCache = createCache(),
720			    compilerCache = createCache(),
721			    sortOrder = function sortOrder(a, b) {
722				if (a === b) {
723					hasDuplicate = true;
724				}
725				return 0;
726			},
727
728
729			// General-purpose constants
730			MAX_NEGATIVE = 1 << 31,
731
732
733			// Instance methods
734			hasOwn = {}.hasOwnProperty,
735			    arr = [],
736			    pop = arr.pop,
737			    push_native = arr.push,
738			    push = arr.push,
739			    slice = arr.slice,
740
741			// Use a stripped-down indexOf as it's faster than native
742			// http://jsperf.com/thor-indexof-vs-for/5
743			indexOf = function indexOf(list, elem) {
744				var i = 0,
745				    len = list.length;
746				for (; i < len; i++) {
747					if (list[i] === elem) {
748						return i;
749					}
750				}
751				return -1;
752			},
753			    booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",
754
755
756			// Regular expressions
757
758			// Whitespace characters http://www.w3.org/TR/css3-selectors/#whitespace
759			whitespace = "[\\x20\\t\\r\\n\\f]",
760
761			// http://www.w3.org/TR/css3-syntax/#characters
762			characterEncoding = "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+",
763
764
765			// Loosely modeled on CSS identifier characters
766			// An unquoted value should be a CSS identifier http://www.w3.org/TR/css3-selectors/#attribute-selectors
767			// Proper syntax: http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
768			identifier = characterEncoding.replace("w", "w#"),
769
770
771			// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
772			attributes = "\\[" + whitespace + "*(" + characterEncoding + ")(?:" + whitespace +
773			// Operator (capture 2)
774			"*([*^$|!~]?=)" + whitespace +
775			// "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"
776			"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace + "*\\]",
777			    pseudos = ":(" + characterEncoding + ")(?:\\((" +
778			// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
779			// 1. quoted (capture 3; capture 4 or capture 5)
780			"('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
781			// 2. simple (capture 6)
782			"((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
783			// 3. anything else (capture 2)
784			".*" + ")\\)|)",
785
786
787			// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
788			rwhitespace = new RegExp(whitespace + "+", "g"),
789			    rtrim = new RegExp("^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g"),
790			    rcomma = new RegExp("^" + whitespace + "*," + whitespace + "*"),
791			    rcombinators = new RegExp("^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*"),
792			    rattributeQuotes = new RegExp("=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g"),
793			    rpseudo = new RegExp(pseudos),
794			    ridentifier = new RegExp("^" + identifier + "$"),
795			    matchExpr = {
796				"ID": new RegExp("^#(" + characterEncoding + ")"),
797				"CLASS": new RegExp("^\\.(" + characterEncoding + ")"),
798				"TAG": new RegExp("^(" + characterEncoding.replace("w", "w*") + ")"),
799				"ATTR": new RegExp("^" + attributes),
800				"PSEUDO": new RegExp("^" + pseudos),
801				"CHILD": new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i"),
802				"bool": new RegExp("^(?:" + booleans + ")$", "i"),
803				// For use in libraries implementing .is()
804				// We use this for POS matching in `select`
805				"needsContext": new RegExp("^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i")
806			},
807			    rinputs = /^(?:input|select|textarea|button)$/i,
808			    rheader = /^h\d$/i,
809			    rnative = /^[^{]+\{\s*\[native \w/,
810
811
812			// Easily-parseable/retrievable ID or TAG or CLASS selectors
813			rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
814			    rsibling = /[+~]/,
815			    rescape = /'|\\/g,
816
817
818			// CSS escapes http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
819			runescape = new RegExp("\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig"),
820			    funescape = function funescape(_, escaped, escapedWhitespace) {
821				var high = "0x" + escaped - 0x10000;
822				// NaN means non-codepoint
823				// Support: Firefox<24
824				// Workaround erroneous numeric interpretation of +"0x"
825				return high !== high || escapedWhitespace ? escaped : high < 0 ?
826				// BMP codepoint
827				String.fromCharCode(high + 0x10000) :
828				// Supplemental Plane codepoint (surrogate pair)
829				String.fromCharCode(high >> 10 | 0xD800, high & 0x3FF | 0xDC00);
830			},
831
832
833			// Used for iframes
834			// See setDocument()
835			// Removing the function wrapper causes a "Permission Denied"
836			// error in IE
837			unloadHandler = function unloadHandler() {
838				setDocument();
839			};
840
841			// Optimize for push.apply( _, NodeList )
842			try {
843				push.apply(arr = slice.call(preferredDoc.childNodes), preferredDoc.childNodes);
844				// Support: Android<4.0
845				// Detect silently failing push.apply
846				arr[preferredDoc.childNodes.length].nodeType;
847			} catch (e) {
848				push = { apply: arr.length ?
849
850					// Leverage slice if possible
851					function (target, els) {
852						push_native.apply(target, slice.call(els));
853					} :
854
855					// Support: IE<9
856					// Otherwise append directly
857					function (target, els) {
858						var j = target.length,
859						    i = 0;
860						// Can't trust NodeList.length
861						while (target[j++] = els[i++]) {}
862						target.length = j - 1;
863					}
864				};
865			}
866
867			function Sizzle(selector, context, results, seed) {
868				var match, elem, m, nodeType,
869				// QSA vars
870				i, groups, old, nid, newContext, newSelector;
871
872				if ((context ? context.ownerDocument || context : preferredDoc) !== document) {
873					setDocument(context);
874				}
875
876				context = context || document;
877				results = results || [];
878				nodeType = context.nodeType;
879
880				if (typeof selector !== "string" || !selector || nodeType !== 1 && nodeType !== 9 && nodeType !== 11) {
881
882					return results;
883				}
884
885				if (!seed && documentIsHTML) {
886
887					// Try to shortcut find operations when possible (e.g., not under DocumentFragment)
888					if (nodeType !== 11 && (match = rquickExpr.exec(selector))) {
889						// Speed-up: Sizzle("#ID")
890						if (m = match[1]) {
891							if (nodeType === 9) {
892								elem = context.getElementById(m);
893								// Check parentNode to catch when Blackberry 4.6 returns
894								// nodes that are no longer in the document (jQuery #6963)
895								if (elem && elem.parentNode) {
896									// Handle the case where IE, Opera, and Webkit return items
897									// by name instead of ID
898									if (elem.id === m) {
899										results.push(elem);
900										return results;
901									}
902								} else {
903									return results;
904								}
905							} else {
906								// Context is not a document
907								if (context.ownerDocument && (elem = context.ownerDocument.getElementById(m)) && contains(context, elem) && elem.id === m) {
908									results.push(elem);
909									return results;
910								}
911							}
912
913							// Speed-up: Sizzle("TAG")
914						} else if (match[2]) {
915								push.apply(results, context.getElementsByTagName(selector));
916								return results;
917
918								// Speed-up: Sizzle(".CLASS")
919							} else if ((m = match[3]) && support.getElementsByClassName) {
920									push.apply(results, context.getElementsByClassName(m));
921									return results;
922								}
923					}
924
925					// QSA path
926					if (support.qsa && (!rbuggyQSA || !rbuggyQSA.test(selector))) {
927						nid = old = expando;
928						newContext = context;
929						newSelector = nodeType !== 1 && selector;
930
931						// qSA works strangely on Element-rooted queries
932						// We can work around this by specifying an extra ID on the root
933						// and working up from there (Thanks to Andrew Dupont for the technique)
934						// IE 8 doesn't work on object elements
935						if (nodeType === 1 && context.nodeName.toLowerCase() !== "object") {
936							groups = tokenize(selector);
937
938							if (old = context.getAttribute("id")) {
939								nid = old.replace(rescape, "\\$&");
940							} else {
941								context.setAttribute("id", nid);
942							}
943							nid = "[id='" + nid + "'] ";
944
945							i = groups.length;
946							while (i--) {
947								groups[i] = nid + toSelector(groups[i]);
948							}
949							newContext = rsibling.test(selector) && testContext(context.parentNode) || context;
950							newSelector = groups.join(",");
951						}
952
953						if (newSelector) {
954							try {
955								push.apply(results, newContext.querySelectorAll(newSelector));
956								return results;
957							} catch (qsaError) {} finally {
958								if (!old) {
959									context.removeAttribute("id");
960								}
961							}
962						}
963					}
964				}
965
966				// All others
967				return select(selector.replace(rtrim, "$1"), context, results, seed);
968			}
969
970			/**
971	   * Create key-value caches of limited size
972	   * @returns {Function(string, Object)} Returns the Object data after storing it on itself with
973	   *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
974	   *	deleting the oldest entry
975	   */
976			function createCache() {
977				var keys = [];
978
979				function cache(key, value) {
980					// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
981					if (keys.push(key + " ") > Expr.cacheLength) {
982						// Only keep the most recent entries
983						delete cache[keys.shift()];
984					}
985					return cache[key + " "] = value;
986				}
987				return cache;
988			}
989
990			/**
991	   * Mark a function for special use by Sizzle
992	   * @param {Function} fn The function to mark
993	   */
994			function markFunction(fn) {
995				fn[expando] = true;
996				return fn;
997			}
998
999			/**
1000	   * Support testing using an element
1001	   * @param {Function} fn Passed the created div and expects a boolean result
1002	   */
1003			function assert(fn) {
1004				var div = document.createElement("div");
1005
1006				try {
1007					return !!fn(div);
1008				} catch (e) {
1009					return false;
1010				} finally {
1011					// Remove from its parent by default
1012					if (div.parentNode) {
1013						div.parentNode.removeChild(div);
1014					}
1015					// release memory in IE
1016					div = null;
1017				}
1018			}
1019
1020			/**
1021	   * Adds the same handler for all of the specified attrs
1022	   * @param {String} attrs Pipe-separated list of attributes
1023	   * @param {Function} handler The method that will be applied
1024	   */
1025			function addHandle(attrs, handler) {
1026				var arr = attrs.split("|"),
1027				    i = attrs.length;
1028
1029				while (i--) {
1030					Expr.attrHandle[arr[i]] = handler;
1031				}
1032			}
1033
1034			/**
1035	   * Checks document order of two siblings
1036	   * @param {Element} a
1037	   * @param {Element} b
1038	   * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
1039	   */
1040			function siblingCheck(a, b) {
1041				var cur = b && a,
1042				    diff = cur && a.nodeType === 1 && b.nodeType === 1 && (~b.sourceIndex || MAX_NEGATIVE) - (~a.sourceIndex || MAX_NEGATIVE);
1043
1044				// Use IE sourceIndex if available on both nodes
1045				if (diff) {
1046					return diff;
1047				}
1048
1049				// Check if b follows a
1050				if (cur) {
1051					while (cur = cur.nextSibling) {
1052						if (cur === b) {
1053							return -1;
1054						}
1055					}
1056				}
1057
1058				return a ? 1 : -1;
1059			}
1060
1061			/**
1062	   * Returns a function to use in pseudos for input types
1063	   * @param {String} type
1064	   */
1065			function createInputPseudo(type) {
1066				return function (elem) {
1067					var name = elem.nodeName.toLowerCase();
1068					return name === "input" && elem.type === type;
1069				};
1070			}
1071
1072			/**
1073	   * Returns a function to use in pseudos for buttons
1074	   * @param {String} type
1075	   */
1076			function createButtonPseudo(type) {
1077				return function (elem) {
1078					var name = elem.nodeName.toLowerCase();
1079					return (name === "input" || name === "button") && elem.type === type;
1080				};
1081			}
1082
1083			/**
1084	   * Returns a function to use in pseudos for positionals
1085	   * @param {Function} fn
1086	   */
1087			function createPositionalPseudo(fn) {
1088				return markFunction(function (argument) {
1089					argument = +argument;
1090					return markFunction(function (seed, matches) {
1091						var j,
1092						    matchIndexes = fn([], seed.length, argument),
1093						    i = matchIndexes.length;
1094
1095						// Match elements found at the specified indexes
1096						while (i--) {
1097							if (seed[j = matchIndexes[i]]) {
1098								seed[j] = !(matches[j] = seed[j]);
1099							}
1100						}
1101					});
1102				});
1103			}
1104
1105			/**
1106	   * Checks a node for validity as a Sizzle context
1107	   * @param {Element|Object=} context
1108	   * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
1109	   */
1110			function testContext(context) {
1111				return context && typeof context.getElementsByTagName !== "undefined" && context;
1112			}
1113
1114			// Expose support vars for convenience
1115			support = Sizzle.support = {};
1116
1117			/**
1118	   * Detects XML nodes
1119	   * @param {Element|Object} elem An element or a document
1120	   * @returns {Boolean} True iff elem is a non-HTML XML node
1121	   */
1122			isXML = Sizzle.isXML = function (elem) {
1123				// documentElement is verified for cases where it doesn't yet exist
1124				// (such as loading iframes in IE - #4833)
1125				var documentElement = elem && (elem.ownerDocument || elem).documentElement;
1126				return documentElement ? documentElement.nodeName !== "HTML" : false;
1127			};
1128
1129			/**
1130	   * Sets document-related variables once based on the current document
1131	   * @param {Element|Object} [doc] An element or document object to use to set the document
1132	   * @returns {Object} Returns the current document
1133	   */
1134			setDocument = Sizzle.setDocument = function (node) {
1135				var hasCompare,
1136				    parent,
1137				    doc = node ? node.ownerDocument || node : preferredDoc;
1138
1139				// If no document and documentElement is available, return
1140				if (doc === document || doc.nodeType !== 9 || !doc.documentElement) {
1141					return document;
1142				}
1143
1144				// Set our document
1145				document = doc;
1146				docElem = doc.documentElement;
1147				parent = doc.defaultView;
1148
1149				// Support: IE>8
1150				// If iframe document is assigned to "document" variable and if iframe has been reloaded,
1151				// IE will throw "permission denied" error when accessing "document" variable, see jQuery #13936
1152				// IE6-8 do not support the defaultView property so parent will be undefined
1153				if (parent && parent !== parent.top) {
1154					// IE11 does not have attachEvent, so all must suffer
1155					if (parent.addEventListener) {
1156						parent.addEventListener("unload", unloadHandler, false);
1157					} else if (parent.attachEvent) {
1158						parent.attachEvent("onunload", unloadHandler);
1159					}
1160				}
1161
1162				/* Support tests
1163	   ---------------------------------------------------------------------- */
1164				documentIsHTML = !isXML(doc);
1165
1166				/* Attributes
1167	   ---------------------------------------------------------------------- */
1168
1169				// Support: IE<8
1170				// Verify that getAttribute really returns attributes and not properties
1171				// (excepting IE8 booleans)
1172				support.attributes = assert(function (div) {
1173					div.className = "i";
1174					return !div.getAttribute("className");
1175				});
1176
1177				/* getElement(s)By*
1178	   ---------------------------------------------------------------------- */
1179
1180				// Check if getElementsByTagName("*") returns only elements
1181				support.getElementsByTagName = assert(function (div) {
1182					div.appendChild(doc.createComment(""));
1183					return !div.getElementsByTagName("*").length;
1184				});
1185
1186				// Support: IE<9
1187				support.getElementsByClassName = rnative.test(doc.getElementsByClassName);
1188
1189				// Support: IE<10
1190				// Check if getElementById returns elements by name
1191				// The broken getElementById methods don't pick up programatically-set names,
1192				// so use a roundabout getElementsByName test
1193				support.getById = assert(function (div) {
1194					docElem.appendChild(div).id = expando;
1195					return !doc.getElementsByName || !doc.getElementsByName(expando).length;
1196				});
1197
1198				// ID find and filter
1199				if (support.getById) {
1200					Expr.find["ID"] = function (id, context) {
1201						if (typeof context.getElementById !== "undefined" && documentIsHTML) {
1202							var m = context.getElementById(id);
1203							// Check parentNode to catch when Blackberry 4.6 returns
1204							// nodes that are no longer in the document #6963
1205							return m && m.parentNode ? [m] : [];
1206						}
1207					};
1208					Expr.filter["ID"] = function (id) {
1209						var attrId = id.replace(runescape, funescape);
1210						return function (elem) {
1211							return elem.getAttribute("id") === attrId;
1212						};
1213					};
1214				} else {
1215					// Support: IE6/7
1216					// getElementById is not reliable as a find shortcut
1217					delete Expr.find["ID"];
1218
1219					Expr.filter["ID"] = function (id) {
1220						var attrId = id.replace(runescape, funescape);
1221						return function (elem) {
1222							var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
1223							return node && node.value === attrId;
1224						};
1225					};
1226				}
1227
1228				// Tag
1229				Expr.find["TAG"] = support.getElementsByTagName ? function (tag, context) {
1230					if (typeof context.getElementsByTagName !== "undefined") {
1231						return context.getElementsByTagName(tag);
1232
1233						// DocumentFragment nodes don't have gEBTN
1234					} else if (support.qsa) {
1235							return context.querySelectorAll(tag);
1236						}
1237				} : function (tag, context) {
1238					var elem,
1239					    tmp = [],
1240					    i = 0,
1241
1242					// By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
1243					results = context.getElementsByTagName(tag);
1244
1245					// Filter out possible comments
1246					if (tag === "*") {
1247						while (elem = results[i++]) {
1248							if (elem.nodeType === 1) {
1249								tmp.push(elem);
1250							}
1251						}
1252
1253						return tmp;
1254					}
1255					return results;
1256				};
1257
1258				// Class
1259				Expr.find["CLASS"] = support.getElementsByClassName && function (className, context) {
1260					if (documentIsHTML) {
1261						return context.getElementsByClassName(className);
1262					}
1263				};
1264
1265				/* QSA/matchesSelector
1266	   ---------------------------------------------------------------------- */
1267
1268				// QSA and matchesSelector support
1269
1270				// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
1271				rbuggyMatches = [];
1272
1273				// qSa(:focus) reports false when true (Chrome 21)
1274				// We allow this because of a bug in IE8/9 that throws an error
1275				// whenever `document.activeElement` is accessed on an iframe
1276				// So, we allow :focus to pass through QSA all the time to avoid the IE error
1277				// See http://bugs.jquery.com/ticket/13378
1278				rbuggyQSA = [];
1279
1280				if (support.qsa = rnative.test(doc.querySelectorAll)) {
1281					// Build QSA regex
1282					// Regex strategy adopted from Diego Perini
1283					assert(function (div) {
1284						// Select is set to empty string on purpose
1285						// This is to test IE's treatment of not explicitly
1286						// setting a boolean content attribute,
1287						// since its presence should be enough
1288						// http://bugs.jquery.com/ticket/12359
1289						docElem.appendChild(div).innerHTML = "<a id='" + expando + "'></a>" + "<select id='" + expando + "-\f]' msallowcapture=''>" + "<option selected=''></option></select>";
1290
1291						// Support: IE8, Opera 11-12.16
1292						// Nothing should be selected when empty strings follow ^= or $= or *=
1293						// The test attribute must be unknown in Opera but "safe" for WinRT
1294						// http://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
1295						if (div.querySelectorAll("[msallowcapture^='']").length) {
1296							rbuggyQSA.push("[*^$]=" + whitespace + "*(?:''|\"\")");
1297						}
1298
1299						// Support: IE8
1300						// Boolean attributes and "value" are not treated correctly
1301						if (!div.querySelectorAll("[selected]").length) {
1302							rbuggyQSA.push("\\[" + whitespace + "*(?:value|" + booleans + ")");
1303						}
1304
1305						// Support: Chrome<29, Android<4.2+, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.7+
1306						if (!div.querySelectorAll("[id~=" + expando + "-]").length) {
1307							rbuggyQSA.push("~=");
1308						}
1309
1310						// Webkit/Opera - :checked should return selected option elements
1311						// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
1312						// IE8 throws error here and will not see later tests
1313						if (!div.querySelectorAll(":checked").length) {
1314							rbuggyQSA.push(":checked");
1315						}
1316
1317						// Support: Safari 8+, iOS 8+
1318						// https://bugs.webkit.org/show_bug.cgi?id=136851
1319						// In-page `selector#id sibing-combinator selector` fails
1320						if (!div.querySelectorAll("a#" + expando + "+*").length) {
1321							rbuggyQSA.push(".#.+[+~]");
1322						}
1323					});
1324
1325					assert(function (div) {
1326						// Support: Windows 8 Native Apps
1327						// The type and name attributes are restricted during .innerHTML assignment
1328						var input = doc.createElement("input");
1329						input.setAttribute("type", "hidden");
1330						div.appendChild(input).setAttribute("name", "D");
1331
1332						// Support: IE8
1333						// Enforce case-sensitivity of name attribute
1334						if (div.querySelectorAll("[name=d]").length) {
1335							rbuggyQSA.push("name" + whitespace + "*[*^$|!~]?=");
1336						}
1337
1338						// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
1339						// IE8 throws error here and will not see later tests
1340						if (!div.querySelectorAll(":enabled").length) {
1341							rbuggyQSA.push(":enabled", ":disabled");
1342						}
1343
1344						// Opera 10-11 does not throw on post-comma invalid pseudos
1345						div.querySelectorAll("*,:x");
1346						rbuggyQSA.push(",.*:");
1347					});
1348				}
1349
1350				if (support.matchesSelector = rnative.test(matches = docElem.matches || docElem.webkitMatchesSelector || docElem.mozMatchesSelector || docElem.oMatchesSelector || docElem.msMatchesSelector)) {
1351
1352					assert(function (div) {
1353						// Check to see if it's possible to do matchesSelector
1354						// on a disconnected node (IE 9)
1355						support.disconnectedMatch = matches.call(div, "div");
1356
1357						// This should fail with an exception
1358						// Gecko does not error, returns false instead
1359						matches.call(div, "[s!='']:x");
1360						rbuggyMatches.push("!=", pseudos);
1361					});
1362				}
1363
1364				rbuggyQSA = rbuggyQSA.length && new RegExp(rbuggyQSA.join("|"));
1365				rbuggyMatches = rbuggyMatches.length && new RegExp(rbuggyMatches.join("|"));
1366
1367				/* Contains
1368	   ---------------------------------------------------------------------- */
1369				hasCompare = rnative.test(docElem.compareDocumentPosition);
1370
1371				// Element contains another
1372				// Purposefully does not implement inclusive descendent
1373				// As in, an element does not contain itself
1374				contains = hasCompare || rnative.test(docElem.contains) ? function (a, b) {
1375					var adown = a.nodeType === 9 ? a.documentElement : a,
1376					    bup = b && b.parentNode;
1377					return a === bup || !!(bup && bup.nodeType === 1 && (adown.contains ? adown.contains(bup) : a.compareDocumentPosition && a.compareDocumentPosition(bup) & 16));
1378				} : function (a, b) {
1379					if (b) {
1380						while (b = b.parentNode) {
1381							if (b === a) {
1382								return true;
1383							}
1384						}
1385					}
1386					return false;
1387				};
1388
1389				/* Sorting
1390	   ---------------------------------------------------------------------- */
1391
1392				// Document order sorting
1393				sortOrder = hasCompare ? function (a, b) {
1394
1395					// Flag for duplicate removal
1396					if (a === b) {
1397						hasDuplicate = true;
1398						return 0;
1399					}
1400
1401					// Sort on method existence if only one input has compareDocumentPosition
1402					var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
1403					if (compare) {
1404						return compare;
1405					}
1406
1407					// Calculate position if both inputs belong to the same document
1408					compare = (a.ownerDocument || a) === (b.ownerDocument || b) ? a.compareDocumentPosition(b) :
1409
1410					// Otherwise we know they are disconnected
1411					1;
1412
1413					// Disconnected nodes
1414					if (compare & 1 || !support.sortDetached && b.compareDocumentPosition(a) === compare) {
1415
1416						// Choose the first element that is related to our preferred document
1417						if (a === doc || a.ownerDocument === preferredDoc && contains(preferredDoc, a)) {
1418							return -1;
1419						}
1420						if (b === doc || b.ownerDocument === preferredDoc && contains(preferredDoc, b)) {
1421							return 1;
1422						}
1423
1424						// Maintain original order
1425						return sortInput ? indexOf(sortInput, a) - indexOf(sortInput, b) : 0;
1426					}
1427
1428					return compare & 4 ? -1 : 1;
1429				} : function (a, b) {
1430					// Exit early if the nodes are identical
1431					if (a === b) {
1432						hasDuplicate = true;
1433						return 0;
1434					}
1435
1436					var cur,
1437					    i = 0,
1438					    aup = a.parentNode,
1439					    bup = b.parentNode,
1440					    ap = [a],
1441					    bp = [b];
1442
1443					// Parentless nodes are either documents or disconnected
1444					if (!aup || !bup) {
1445						return a === doc ? -1 : b === doc ? 1 : aup ? -1 : bup ? 1 : sortInput ? indexOf(sortInput, a) - indexOf(sortInput, b) : 0;
1446
1447						// If the nodes are siblings, we can do a quick check
1448					} else if (aup === bup) {
1449							return siblingCheck(a, b);
1450						}
1451
1452					// Otherwise we need full lists of their ancestors for comparison
1453					cur = a;
1454					while (cur = cur.parentNode) {
1455						ap.unshift(cur);
1456					}
1457					cur = b;
1458					while (cur = cur.parentNode) {
1459						bp.unshift(cur);
1460					}
1461
1462					// Walk down the tree looking for a discrepancy
1463					while (ap[i] === bp[i]) {
1464						i++;
1465					}
1466
1467					return i ?
1468					// Do a sibling check if the nodes have a common ancestor
1469					siblingCheck(ap[i], bp[i]) :
1470
1471					// Otherwise nodes in our document sort first
1472					ap[i] === preferredDoc ? -1 : bp[i] === preferredDoc ? 1 : 0;
1473				};
1474
1475				return doc;
1476			};
1477
1478			Sizzle.matches = function (expr, elements) {
1479				return Sizzle(expr, null, null, elements);
1480			};
1481
1482			Sizzle.matchesSelector = function (elem, expr) {
1483				// Set document vars if needed
1484				if ((elem.ownerDocument || elem) !== document) {
1485					setDocument(elem);
1486				}
1487
1488				// Make sure that attribute selectors are quoted
1489				expr = expr.replace(rattributeQuotes, "='$1']");
1490
1491				if (support.matchesSelector && documentIsHTML && (!rbuggyMatches || !rbuggyMatches.test(expr)) && (!rbuggyQSA || !rbuggyQSA.test(expr))) {
1492
1493					try {
1494						var ret = matches.call(elem, expr);
1495
1496						// IE 9's matchesSelector returns false on disconnected nodes
1497						if (ret || support.disconnectedMatch ||
1498						// As well, disconnected nodes are said to be in a document
1499						// fragment in IE 9
1500						elem.document && elem.document.nodeType !== 11) {
1501							return ret;
1502						}
1503					} catch (e) {}
1504				}
1505
1506				return Sizzle(expr, document, null, [elem]).length > 0;
1507			};
1508
1509			Sizzle.contains = function (context, elem) {
1510				// Set document vars if needed
1511				if ((context.ownerDocument || context) !== document) {
1512					setDocument(context);
1513				}
1514				return contains(context, elem);
1515			};
1516
1517			Sizzle.attr = function (elem, name) {
1518				// Set document vars if needed
1519				if ((elem.ownerDocument || elem) !== document) {
1520					setDocument(elem);
1521				}
1522
1523				var fn = Expr.attrHandle[name.toLowerCase()],
1524
1525				// Don't get fooled by Object.prototype properties (jQuery #13807)
1526				val = fn && hasOwn.call(Expr.attrHandle, name.toLowerCase()) ? fn(elem, name, !documentIsHTML) : undefined;
1527
1528				return val !== undefined ? val : support.attributes || !documentIsHTML ? elem.getAttribute(name) : (val = elem.getAttributeNode(name)) && val.specified ? val.value : null;
1529			};
1530
1531			Sizzle.error = function (msg) {
1532				throw new Error("Syntax error, unrecognized expression: " + msg);
1533			};
1534
1535			/**
1536	   * Document sorting and removing duplicates
1537	   * @param {ArrayLike} results
1538	   */
1539			Sizzle.uniqueSort = function (results) {
1540				var elem,
1541				    duplicates = [],
1542				    j = 0,
1543				    i = 0;
1544
1545				// Unless we *know* we can detect duplicates, assume their presence
1546				hasDuplicate = !support.detectDuplicates;
1547				sortInput = !support.sortStable && results.slice(0);
1548				results.sort(sortOrder);
1549

1550				if (hasDuplicate) {
1551					while (elem = results[i++]) {
1552						if (elem === results[i]) {
1553							j = duplicates.push(i);
1554						}
1555					}
1556					while (j--) {
1557						results.splice(duplicates[j], 1);
1558					}
1559				}
1560
1561				// Clear input after sorting to release objects
1562				// See https://github.com/jquery/sizzle/pull/225
1563				sortInput = null;
1564
1565				return results;
1566			};
1567
1568			/**
1569	   * Utility function for retrieving the text value of an array of DOM nodes
1570	   * @param {Array|Element} elem
1571	   */
1572			getText = Sizzle.getText = function (elem) {
1573				var node,
1574				    ret = "",
1575				    i = 0,
1576				    nodeType = elem.nodeType;
1577
1578				if (!nodeType) {
1579					// If no nodeType, this is expected to be an array
1580					while (node = elem[i++]) {
1581						// Do not traverse comment nodes
1582						ret += getText(node);
1583					}
1584				} else if (nodeType === 1 || nodeType === 9 || nodeType === 11) {
1585					// Use textContent for elements
1586					// innerText usage removed for consistency of new lines (jQuery #11153)
1587					if (typeof elem.textContent === "string") {
1588						return elem.textContent;
1589					} else {
1590						// Traverse its children
1591						for (elem = elem.firstChild; elem; elem = elem.nextSibling) {
1592							ret += getText(elem);
1593						}
1594					}
1595				} else if (nodeType === 3 || nodeType === 4) {
1596					return elem.nodeValue;
1597				}
1598				// Do not include comment or processing instruction nodes
1599
1600				return ret;
1601			};
1602
1603			Expr = Sizzle.selectors = {
1604
1605				// Can be adjusted by the user
1606				cacheLength: 50,
1607
1608				createPseudo: markFunction,
1609
1610				match: matchExpr,
1611
1612				attrHandle: {},
1613
1614				find: {},
1615
1616				relative: {
1617					">": { dir: "parentNode", first: true },
1618					" ": { dir: "parentNode" },
1619					"+": { dir: "previousSibling", first: true },
1620					"~": { dir: "previousSibling" }
1621				},
1622
1623				preFilter: {
1624					"ATTR": function ATTR(match) {
1625						match[1] = match[1].replace(runescape, funescape);
1626
1627						// Move the given value to match[3] whether quoted or unquoted
1628						match[3] = (match[3] || match[4] || match[5] || "").replace(runescape, funescape);
1629
1630						if (match[2] === "~=") {
1631							match[3] = " " + match[3] + " ";
1632						}
1633
1634						return match.slice(0, 4);
1635					},
1636
1637					"CHILD": function CHILD(match) {
1638						/* matches from matchExpr["CHILD"]
1639	     	1 type (only|nth|...)
1640	     	2 what (child|of-type)
1641	     	3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
1642	     	4 xn-component of xn+y argument ([+-]?\d*n|)
1643	     	5 sign of xn-component
1644	     	6 x of xn-component
1645	     	7 sign of y-component
1646	     	8 y of y-component
1647	     */
1648						match[1] = match[1].toLowerCase();
1649
1650						if (match[1].slice(0, 3) === "nth") {
1651							// nth-* requires argument
1652							if (!match[3]) {
1653								Sizzle.error(match[0]);
1654							}
1655
1656							// numeric x and y parameters for Expr.filter.CHILD
1657							// remember that false/true cast respectively to 0/1
1658							match[4] = +(match[4] ? match[5] + (match[6] || 1) : 2 * (match[3] === "even" || match[3] === "odd"));
1659							match[5] = +(match[7] + match[8] || match[3] === "odd");
1660
1661							// other types prohibit arguments
1662						} else if (match[3]) {
1663								Sizzle.error(match[0]);
1664							}
1665
1666						return match;
1667					},
1668
1669					"PSEUDO": function PSEUDO(match) {
1670						var excess,
1671						    unquoted = !match[6] && match[2];
1672
1673						if (matchExpr["CHILD"].test(match[0])) {
1674							return null;
1675						}
1676
1677						// Accept quoted arguments as-is
1678						if (match[3]) {
1679							match[2] = match[4] || match[5] || "";
1680
1681							// Strip excess characters from unquoted arguments
1682						} else if (unquoted && rpseudo.test(unquoted) && (
1683							// Get excess from tokenize (recursively)
1684							excess = tokenize(unquoted, true)) && (
1685							// advance to the next closing parenthesis
1686							excess = unquoted.indexOf(")", unquoted.length - excess) - unquoted.length)) {
1687
1688								// excess is a negative index
1689								match[0] = match[0].slice(0, excess);
1690								match[2] = unquoted.slice(0, excess);
1691							}
1692
1693						// Return only captures needed by the pseudo filter method (type and argument)
1694						return match.slice(0, 3);
1695					}
1696				},
1697
1698				filter: {
1699
1700					"TAG": function TAG(nodeNameSelector) {
1701						var nodeName = nodeNameSelector.replace(runescape, funescape).toLowerCase();
1702						return nodeNameSelector === "*" ? function () {
1703							return true;
1704						} : function (elem) {
1705							return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
1706						};
1707					},
1708
1709					"CLASS": function CLASS(className) {
1710						var pattern = classCache[className + " "];
1711
1712						return pattern || (pattern = new RegExp("(^|" + whitespace + ")" + className + "(" + whitespace + "|$)")) && classCache(className, function (elem) {
1713							return pattern.test(typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "");
1714						});
1715					},
1716
1717					"ATTR": function ATTR(name, operator, check) {
1718						return function (elem) {
1719							var result = Sizzle.attr(elem, name);
1720
1721							if (result == null) {
1722								return operator === "!=";
1723							}
1724							if (!operator) {
1725								return true;
1726							}
1727
1728							result += "";
1729
1730							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;

1731						};
1732					},
1733
1734					"CHILD": function CHILD(type, what, argument, first, last) {
1735						var simple = type.slice(0, 3) !== "nth",
1736						    forward = type.slice(-4) !== "last",
1737						    ofType = what === "of-type";
1738
1739						return first === 1 && last === 0 ?
1740
1741						// Shortcut for :nth-*(n)
1742						function (elem) {
1743							return !!elem.parentNode;
1744						} : function (elem, context, xml) {
1745							var cache,
1746							    outerCache,
1747							    node,
1748							    diff,
1749							    nodeIndex,
1750							    start,
1751							    dir = simple !== forward ? "nextSibling" : "previousSibling",
1752							    parent = elem.parentNode,
1753							    name = ofType && elem.nodeName.toLowerCase(),
1754							    useCache = !xml && !ofType;
1755
1756							if (parent) {
1757
1758								// :(first|last|only)-(child|of-type)
1759								if (simple) {
1760									while (dir) {
1761										node = elem;
1762										while (node = node[dir]) {
1763											if (ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1) {
1764												return false;
1765											}
1766										}
1767										// Reverse direction for :only-* (if we haven't yet done so)
1768										start = dir = type === "only" && !start && "nextSibling";
1769									}
1770									return true;
1771								}
1772
1773								start = [forward ? parent.firstChild : parent.lastChild];
1774
1775								// non-xml :nth-child(...) stores cache data on `parent`
1776								if (forward && useCache) {
1777									// Seek `elem` from a previously-cached index
1778									outerCache = parent[expando] || (parent[expando] = {});
1779									cache = outerCache[type] || [];
1780									nodeIndex = cache[0] === dirruns && cache[1];
1781									diff = cache[0] === dirruns && cache[2];
1782									node = nodeIndex && parent.childNodes[nodeIndex];
1783
1784									while (node = ++nodeIndex && node && node[dir] || (
1785
1786									// Fallback to seeking `elem` from the start
1787									diff = nodeIndex = 0) || start.pop()) {
1788
1789										// When found, cache indexes on `parent` and break
1790										if (node.nodeType === 1 && ++diff && node === elem) {
1791											outerCache[type] = [dirruns, nodeIndex, diff];
1792											break;
1793										}
1794									}
1795
1796									// Use previously-cached element index if available
1797								} else if (useCache && (cache = (elem[expando] || (elem[expando] = {}))[type]) && cache[0] === dirruns) {
1798										diff = cache[1];
1799
1800										// xml :nth-child(...) or :nth-last-child(...) or :nth(-last)?-of-type(...)
1801									} else {
1802											// Use the same loop as above to seek `elem` from the start
1803											while (node = ++nodeIndex && node && node[dir] || (diff = nodeIndex = 0) || start.pop()) {
1804
1805												if ((ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1) && ++diff) {
1806													// Cache the index of each encountered element
1807													if (useCache) {
1808														(node[expando] || (node[expando] = {}))[type] = [dirruns, diff];
1809													}
1810
1811													if (node === elem) {
1812														break;
1813													}
1814												}
1815											}
1816										}
1817
1818								// Incorporate the offset, then check against cycle size
1819								diff -= last;
1820								return diff === first || diff % first === 0 && diff / first >= 0;
1821							}
1822						};
1823					},
1824
1825					"PSEUDO": function PSEUDO(pseudo, argument) {
1826						// pseudo-class names are case-insensitive
1827						// http://www.w3.org/TR/selectors/#pseudo-classes
1828						// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
1829						// Remember that setFilters inherits from pseudos
1830						var args,
1831						    fn = Expr.pseudos[pseudo] || Expr.setFilters[pseudo.toLowerCase()] || Sizzle.error("unsupported pseudo: " + pseudo);
1832
1833						// The user may use createPseudo to indicate that
1834						// arguments are needed to create the filter function
1835						// just as Sizzle does
1836						if (fn[expando]) {
1837							return fn(argument);
1838						}
1839
1840						// But maintain support for old signatures
1841						if (fn.length > 1) {
1842							args = [pseudo, pseudo, "", argument];
1843							return Expr.setFilters.hasOwnProperty(pseudo.toLowerCase()) ? markFunction(function (seed, matches) {
1844								var idx,
1845								    matched = fn(seed, argument),
1846								    i = matched.length;
1847								while (i--) {
1848									idx = indexOf(seed, matched[i]);
1849									seed[idx] = !(matches[idx] = matched[i]);
1850								}
1851							}) : function (elem) {
1852								return fn(elem, 0, args);
1853							};
1854						}
1855
1856						return fn;
1857					}
1858				},
1859
1860				pseudos: {
1861					// Potentially complex pseudos
1862					"not": markFunction(function (selector) {
1863						// Trim the selector passed to compile
1864						// to avoid treating leading and trailing
1865						// spaces as combinators
1866						var input = [],
1867						    results = [],
1868						    matcher = compile(selector.replace(rtrim, "$1"));
1869
1870						return matcher[expando] ? markFunction(function (seed, matches, context, xml) {
1871							var elem,
1872							    unmatched = matcher(seed, null, xml, []),
1873							    i = seed.length;
1874
1875							// Match elements unmatched by `matcher`
1876							while (i--) {
1877								if (elem = unmatched[i]) {
1878									seed[i] = !(matches[i] = elem);
1879								}
1880							}
1881						}) : function (elem, context, xml) {
1882							input[0] = elem;
1883							matcher(input, null, xml, results);
1884							// Don't keep the element (issue #299)
1885							input[0] = null;
1886							return !results.pop();
1887						};
1888					}),
1889
1890					"has": markFunction(function (selector) {
1891						return function (elem) {
1892							return Sizzle(selector, elem).length > 0;
1893						};
1894					}),
1895
1896					"contains": markFunction(function (text) {
1897						text = text.replace(runescape, funescape);
1898						return function (elem) {
1899							return (elem.textContent || elem.innerText || getText(elem)).indexOf(text) > -1;
1900						};
1901					}),
1902
1903					// "Whether an element is represented by a :lang() selector
1904					// is based solely on the element's language value
1905					// being equal to the identifier C,
1906					// or beginning with the identifier C immediately followed by "-".
1907					// The matching of C against the element's language value is performed case-insensitively.
1908					// The identifier C does not have to be a valid language name."
1909					// http://www.w3.org/TR/selectors/#lang-pseudo
1910					"lang": markFunction(function (lang) {
1911						// lang value must be a valid identifier
1912						if (!ridentifier.test(lang || "")) {
1913							Sizzle.error("unsupported lang: " + lang);
1914						}
1915						lang = lang.replace(runescape, funescape).toLowerCase();
1916						return function (elem) {
1917							var elemLang;
1918							do {
1919								if (elemLang = documentIsHTML ? elem.lang : elem.getAttribute("xml:lang") || elem.getAttribute("lang")) {
1920
1921									elemLang = elemLang.toLowerCase();
1922									return elemLang === lang || elemLang.indexOf(lang + "-") === 0;
1923								}
1924							} while ((elem = elem.parentNode) && elem.nodeType === 1);
1925							return false;

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

2080				    cached = tokenCache[selector + " "];
2081
2082				if (cached) {
2083					return parseOnly ? 0 : cached.slice(0);
2084				}
2085
2086				soFar = selector;
2087				groups = [];
2088				preFilters = Expr.preFilter;
2089
2090				while (soFar) {
2091
2092					// Comma and first run
2093					if (!matched || (match = rcomma.exec(soFar))) {
2094						if (match) {
2095							// Don't consume trailing commas as valid
2096							soFar = soFar.slice(match[0].length) || soFar;
2097						}
2098						groups.push(tokens = []);
2099					}
2100
2101					matched = false;
2102
2103					// Combinators
2104					if (match = rcombinators.exec(soFar)) {
2105						matched = match.shift();
2106						tokens.push({
2107							value: matched,
2108							// Cast descendant combinators to space
2109							type: match[0].replace(rtrim, " ")
2110						});
2111						soFar = soFar.slice(matched.length);
2112					}
2113
2114					// Filters
2115					for (type in Expr.filter) {
2116						if ((match = matchExpr[type].exec(soFar)) && (!preFilters[type] || (match = preFilters[type](match)))) {
2117							matched = match.shift();
2118							tokens.push({
2119								value: matched,
2120								type: type,
2121								matches: match
2122							});
2123							soFar = soFar.slice(matched.length);
2124						}
2125					}
2126
2127					if (!matched) {
2128						break;
2129					}
2130				}
2131
2132				// Return the length of the invalid excess
2133				// if we're just parsing
2134				// Otherwise, throw an error or return tokens
2135				return parseOnly ? soFar.length : soFar ? Sizzle.error(selector) :
2136				// Cache the tokens
2137				tokenCache(selector, groups).slice(0);
2138			};
2139
2140			function toSelector(tokens) {
2141				var i = 0,
2142				    len = tokens.length,
2143				    selector = "";
2144				for (; i < len; i++) {
2145					selector += tokens[i].value;
2146				}
2147				return selector;
2148			}
2149
2150			function addCombinator(matcher, combinator, base) {
2151				var dir = combinator.dir,
2152				    checkNonElements = base && dir === "parentNode",
2153				    doneName = done++;
2154
2155				return combinator.first ?
2156				// Check against closest ancestor/preceding element
2157				function (elem, context, xml) {
2158					while (elem = elem[dir]) {
2159						if (elem.nodeType === 1 || checkNonElements) {
2160							return matcher(elem, context, xml);
2161						}
2162					}
2163				} :
2164
2165				// Check against all ancestor/preceding elements
2166				function (elem, context, xml) {
2167					var oldCache,
2168					    outerCache,
2169					    newCache = [dirruns, doneName];
2170
2171					// We can't set arbitrary data on XML nodes, so they don't benefit from dir caching
2172					if (xml) {
2173						while (elem = elem[dir]) {
2174							if (elem.nodeType === 1 || checkNonElements) {
2175								if (matcher(elem, context, xml)) {
2176									return true;
2177								}
2178							}
2179						}
2180					} else {
2181						while (elem = elem[dir]) {
2182							if (elem.nodeType === 1 || checkNonElements) {
2183								outerCache = elem[expando] || (elem[expando] = {});
2184								if ((oldCache = outerCache[dir]) && oldCache[0] === dirruns && oldCache[1] === doneName) {
2185
2186									// Assign to newCache so results back-propagate to previous elements
2187									return newCache[2] = oldCache[2];
2188								} else {
2189									// Reuse newcache so results back-propagate to previous elements
2190									outerCache[dir] = newCache;
2191
2192									// A match means we're done; a fail means we have to keep checking
2193									if (newCache[2] = matcher(elem, context, xml)) {
2194										return true;
2195									}
2196								}
2197							}
2198						}
2199					}
2200				};
2201			}
2202
2203			function elementMatcher(matchers) {
2204				return matchers.length > 1 ? function (elem, context, xml) {
2205					var i = matchers.length;
2206					while (i--) {
2207						if (!matchers[i](elem, context, xml)) {
2208							return false;
2209						}
2210					}
2211					return true;
2212				} : matchers[0];
2213			}
2214
2215			function multipleContexts(selector, contexts, results) {
2216				var i = 0,
2217				    len = contexts.length;
2218				for (; i < len; i++) {
2219					Sizzle(selector, contexts[i], results);
2220				}
2221				return results;
2222			}
2223
2224			function condense(unmatched, map, filter, context, xml) {
2225				var elem,
2226				    newUnmatched = [],
2227				    i = 0,
2228				    len = unmatched.length,
2229				    mapped = map != null;
2230
2231				for (; i < len; i++) {
2232					if (elem = unmatched[i]) {
2233						if (!filter || filter(elem, context, xml)) {
2234							newUnmatched.push(elem);
2235							if (mapped) {
2236								map.push(i);
2237							}
2238						}
2239					}
2240				}
2241
2242				return newUnmatched;
2243			}
2244
2245			function setMatcher(preFilter, selector, matcher, postFilter, postFinder, postSelector) {
2246				if (postFilter && !postFilter[expando]) {
2247					postFilter = setMatcher(postFilter);
2248				}
2249				if (postFinder && !postFinder[expando]) {
2250					postFinder = setMatcher(postFinder, postSelector);
2251				}
2252				return markFunction(function (seed, results, context, xml) {
2253					var temp,
2254					    i,
2255					    elem,
2256					    preMap = [],
2257					    postMap = [],
2258					    preexisting = results.length,
2259
2260
2261					// Get initial elements from seed or context
2262					elems = seed || multipleContexts(selector || "*", context.nodeType ? [context] : context, []),
2263
2264
2265					// Prefilter to get matcher input, preserving a map for seed-results synchronization
2266					matcherIn = preFilter && (seed || !selector) ? condense(elems, preMap, preFilter, context, xml) : elems,
2267					    matcherOut = matcher ?
2268					// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
2269					postFinder || (seed ? preFilter : preexisting || postFilter) ?
2270
2271					// ...intermediate processing is necessary
2272					[] :
2273
2274					// ...otherwise use results directly
2275					results : matcherIn;
2276
2277					// Find primary matches
2278					if (matcher) {
2279						matcher(matcherIn, matcherOut, context, xml);
2280					}
2281
2282					// Apply postFilter
2283					if (postFilter) {
2284						temp = condense(matcherOut, postMap);
2285						postFilter(temp, [], context, xml);
2286
2287						// Un-match failing elements by moving them back to matcherIn
2288						i = temp.length;
2289						while (i--) {
2290							if (elem = temp[i]) {
2291								matcherOut[postMap[i]] = !(matcherIn[postMap[i]] = elem);
2292							}
2293						}
2294					}
2295
2296					if (seed) {
2297						if (postFinder || preFilter) {
2298							if (postFinder) {
2299								// Get the final matcherOut by condensing this intermediate into postFinder contexts
2300								temp = [];
2301								i = matcherOut.length;
2302								while (i--) {
2303									if (elem = matcherOut[i]) {
2304										// Restore matcherIn since elem is not yet a final match
2305										temp.push(matcherIn[i] = elem);
2306									}
2307								}
2308								postFinder(null, matcherOut = [], temp, xml);
2309							}
2310
2311							// Move matched elements from seed to results to keep them synchronized
2312							i = matcherOut.length;
2313							while (i--) {
2314								if ((elem = matcherOut[i]) && (temp = postFinder ? indexOf(seed, elem) : preMap[i]) > -1) {
2315
2316									seed[temp] = !(results[temp] = elem);
2317								}
2318							}
2319						}
2320
2321						// Add elements to results, through postFinder if defined
2322					} else {
2323							matcherOut = condense(matcherOut === results ? matcherOut.splice(preexisting, matcherOut.length) : matcherOut);
2324							if (postFinder) {
2325								postFinder(null, results, matcherOut, xml);
2326							} else {
2327								push.apply(results, matcherOut);
2328							}
2329						}
2330				});
2331			}
2332
2333			function matcherFromTokens(tokens) {
2334				var checkContext,
2335				    matcher,
2336				    j,
2337				    len = tokens.length,
2338				    leadingRelative = Expr.relative[tokens[0].type],
2339				    implicitRelative = leadingRelative || Expr.relative[" "],
2340				    i = leadingRelative ? 1 : 0,
2341
2342
2343				// The foundational matcher ensures that elements are reachable from top-level context(s)
2344				matchContext = addCombinator(function (elem) {
2345					return elem === checkContext;
2346				}, implicitRelative, true),
2347				    matchAnyContext = addCombinator(function (elem) {
2348					return indexOf(checkContext, elem) > -1;
2349				}, implicitRelative, true),
2350				    matchers = [function (elem, context, xml) {
2351					var ret = !leadingRelative && (xml || context !== outermostContext) || ((checkContext = context).nodeType ? matchContext(elem, context, xml) : matchAnyContext(elem, context, xml));
2352					// Avoid hanging onto element (issue #299)
2353					checkContext = null;
2354					return ret;
2355				}];
2356
2357				for (; i < len; i++) {
2358					if (matcher = Expr.relative[tokens[i].type]) {
2359						matchers = [addCombinator(elementMatcher(matchers), matcher)];
2360					} else {
2361						matcher = Expr.filter[tokens[i].type].apply(null, tokens[i].matches);
2362
2363						// Return special upon seeing a positional matcher
2364						if (matcher[expando]) {
2365							// Find the next relative operator (if any) for proper handling
2366							j = ++i;
2367							for (; j < len; j++) {
2368								if (Expr.relative[tokens[j].type]) {
2369									break;
2370								}
2371							}
2372							return setMatcher(i > 1 && elementMatcher(matchers), i > 1 && toSelector(
2373							// If the preceding token was a descendant combinator, insert an implicit any-element `*`
2374							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));
2375						}
2376						matchers.push(matcher);
2377					}
2378				}
2379
2380				return elementMatcher(matchers);
2381			}
2382
2383			function matcherFromGroupMatchers(elementMatchers, setMatchers) {
2384				var bySet = setMatchers.length > 0,
2385				    byElement = elementMatchers.length > 0,
2386				    superMatcher = function superMatcher(seed, context, xml, results, outermost) {
2387					var elem,
2388					    j,
2389					    matcher,
2390					    matchedCount = 0,
2391					    i = "0",
2392					    unmatched = seed && [],
2393					    setMatched = [],
2394					    contextBackup = outermostContext,
2395
2396					// We must always have either seed elements or outermost context
2397					elems = seed || byElement && Expr.find["TAG"]("*", outermost),
2398
2399					// Use integer dirruns iff this is the outermost matcher
2400					dirrunsUnique = dirruns += contextBackup == null ? 1 : Math.random() || 0.1,
2401					    len = elems.length;
2402
2403					if (outermost) {
2404						outermostContext = context !== document && context;
2405					}
2406
2407					// Add elements passing elementMatchers directly to results
2408					// Keep `i` a string if there are no elements so `matchedCount` will be "00" below
2409					// Support: IE<9, Safari
2410					// Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
2411					for (; i !== len && (elem = elems[i]) != null; i++) {
2412						if (byElement && elem) {
2413							j = 0;
2414							while (matcher = elementMatchers[j++]) {
2415								if (matcher(elem, context, xml)) {
2416									results.push(elem);
2417									break;
2418								}
2419							}
2420							if (outermost) {
2421								dirruns = dirrunsUnique;
2422							}
2423						}
2424
2425						// Track unmatched elements for set filters
2426						if (bySet) {
2427							// They will have gone through all possible matchers
2428							if (elem = !matcher && elem) {
2429								matchedCount--;
2430							}
2431
2432							// Lengthen the array for every element, matched or not
2433							if (seed) {
2434								unmatched.push(elem);
2435							}
2436						}
2437					}
2438
2439					// Apply set filters to unmatched elements
2440					matchedCount += i;
2441					if (bySet && i !== matchedCount) {
2442						j = 0;
2443						while (matcher = setMatchers[j++]) {
2444							matcher(unmatched, setMatched, context, xml);
2445						}
2446
2447						if (seed) {
2448							// Reintegrate element matches to eliminate the need for sorting
2449							if (matchedCount > 0) {
2450								while (i--) {
2451									if (!(unmatched[i] || setMatched[i])) {
2452										setMatched[i] = pop.call(results);
2453									}
2454								}
2455							}
2456
2457							// Discard index placeholder values to get only actual matches
2458							setMatched = condense(setMatched);
2459						}
2460
2461						// Add matches to results
2462						push.apply(results, setMatched);
2463
2464						// Seedless set matches succeeding multiple successful matchers stipulate sorting
2465						if (outermost && !seed && setMatched.length > 0 && matchedCount + setMatchers.length > 1) {
2466
2467							Sizzle.uniqueSort(results);
2468						}
2469					}
2470
2471					// Override manipulation of globals by nested matchers
2472					if (outermost) {
2473						dirruns = dirrunsUnique;
2474						outermostContext = contextBackup;
2475					}
2476
2477					return unmatched;
2478				};
2479
2480				return bySet ? markFunction(superMatcher) : superMatcher;
2481			}
2482
2483			compile = Sizzle.compile = function (selector, match /* Internal Use Only */) {
2484				var i,
2485				    setMatchers = [],
2486				    elementMatchers = [],
2487				    cached = compilerCache[selector + " "];
2488
2489				if (!cached) {
2490					// Generate a function of recursive functions that can be used to check each element
2491					if (!match) {
2492						match = tokenize(selector);
2493					}
2494					i = match.length;
2495					while (i--) {
2496						cached = matcherFromTokens(match[i]);
2497						if (cached[expando]) {
2498							setMatchers.push(cached);
2499						} else {
2500							elementMatchers.push(cached);
2501						}
2502					}
2503
2504					// Cache the compiled function
2505					cached = compilerCache(selector, matcherFromGroupMatchers(elementMatchers, setMatchers));
2506
2507					// Save selector and tokenization
2508					cached.selector = selector;
2509				}
2510				return cached;
2511			};
2512
2513			/**
2514	   * A low-level selection function that works with Sizzle's compiled
2515	   *  selector functions
2516	   * @param {String|Function} selector A selector or a pre-compiled
2517	   *  selector function built with Sizzle.compile
2518	   * @param {Element} context
2519	   * @param {Array} [results]
2520	   * @param {Array} [seed] A set of elements to match against
2521	   */
2522			select = Sizzle.select = function (selector, context, results, seed) {
2523				var i,
2524				    tokens,
2525				    token,
2526				    type,
2527				    find,
2528				    compiled = typeof selector === "function" && selector,
2529				    match = !seed && tokenize(selector = compiled.selector || selector);
2530
2531				results = results || [];
2532
2533				// Try to minimize operations if there is no seed and only one group
2534				if (match.length === 1) {
2535
2536					// Take a shortcut and set the context if the root selector is an ID
2537					tokens = match[0] = match[0].slice(0);
2538					if (tokens.length > 2 && (token = tokens[0]).type === "ID" && support.getById && context.nodeType === 9 && documentIsHTML && Expr.relative[tokens[1].type]) {
2539
2540						context = (Expr.find["ID"](token.matches[0].replace(runescape, funescape), context) || [])[0];
2541						if (!context) {
2542							return results;
2543
2544							// Precompiled matchers will still verify ancestry, so step up a level
2545						} else if (compiled) {
2546								context = context.parentNode;
2547							}
2548
2549						selector = selector.slice(tokens.shift().value.length);
2550					}
2551
2552					// Fetch a seed set for right-to-left matching
2553					i = matchExpr["needsContext"].test(selector) ? 0 : tokens.length;
2554					while (i--) {
2555						token = tokens[i];
2556
2557						// Abort if we hit a combinator
2558						if (Expr.relative[type = token.type]) {
2559							break;
2560						}
2561						if (find = Expr.find[type]) {
2562							// Search, expanding context for leading sibling combinators
2563							if (seed = find(token.matches[0].replace(runescape, funescape), rsibling.test(tokens[0].type) && testContext(context.parentNode) || context)) {
2564
2565								// If seed is empty or no tokens remain, we can return early
2566								tokens.splice(i, 1);
2567								selector = seed.length && toSelector(tokens);
2568								if (!selector) {
2569									push.apply(results, seed);
2570									return results;
2571								}
2572
2573								break;
2574							}
2575						}
2576					}
2577				}
2578
2579				// Compile and execute a filtering function if one is not provided
2580				// Provide `match` to avoid retokenization if we modified the selector above
2581				(compiled || compile(selector, match))(seed, context, !documentIsHTML, results, rsibling.test(selector) && testContext(context.parentNode) || context);
2582				return results;
2583			};
2584
2585			// One-time assignments
2586
2587			// Sort stability
2588			support.sortStable = expando.split("").sort(sortOrder).join("") === expando;
2589
2590			// Support: Chrome 14-35+
2591			// Always assume duplicates if they aren't passed to the comparison function
2592			support.detectDuplicates = !!hasDuplicate;
2593
2594			// Initialize against the default document
2595			setDocument();
2596
2597			// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
2598			// Detached nodes confoundingly follow *each other*
2599			support.sortDetached = assert(function (div1) {
2600				// Should return 1, but returns 4 (following)
2601				return div1.compareDocumentPosition(document.createElement("div")) & 1;
2602			});
2603
2604			// Support: IE<8
2605			// Prevent attribute/property "interpolation"
2606			// http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
2607			if (!assert(function (div) {
2608				div.innerHTML = "<a href='#'></a>";
2609				return div.firstChild.getAttribute("href") === "#";
2610			})) {
2611				addHandle("type|href|height|width", function (elem, name, isXML) {
2612					if (!isXML) {
2613						return elem.getAttribute(name, name.toLowerCase() === "type" ? 1 : 2);
2614					}
2615				});
2616			}
2617
2618			// Support: IE<9
2619			// Use defaultValue in place of getAttribute("value")
2620			if (!support.attributes || !assert(function (div) {
2621				div.innerHTML = "<input/>";
2622				div.firstChild.setAttribute("value", "");
2623				return div.firstChild.getAttribute("value") === "";
2624			})) {
2625				addHandle("value", function (elem, name, isXML) {
2626					if (!isXML && elem.nodeName.toLowerCase() === "input") {
2627						return elem.defaultValue;
2628					}
2629				});
2630			}
2631
2632			// Support: IE<9
2633			// Use getAttributeNode to fetch booleans when getAttribute lies
2634			if (!assert(function (div) {
2635				return div.getAttribute("disabled") == null;
2636			})) {
2637				addHandle(booleans, function (elem, name, isXML) {
2638					var val;
2639					if (!isXML) {
2640						return elem[name] === true ? name.toLowerCase() : (val = elem.getAttributeNode(name)) && val.specified ? val.value : null;
2641					}
2642				});
2643			}
2644
2645			return Sizzle;
2646		}(window);
2647
2648		jQuery.find = Sizzle;
2649		jQuery.expr = Sizzle.selectors;
2650		jQuery.expr[":"] = jQuery.expr.pseudos;
2651		jQuery.unique = Sizzle.uniqueSort;
2652		jQuery.text = Sizzle.getText;
2653		jQuery.isXMLDoc = Sizzle.isXML;
2654		jQuery.contains = Sizzle.contains;
2655
2656		var rneedsContext = jQuery.expr.match.needsContext;
2657
2658		var rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>|)$/;
2659
2660		var risSimple = /^.[^:#\[\.,]*$/;
2661
2662		// Implement the identical functionality for filter and not
2663		function winnow(elements, qualifier, not) {
2664			if (jQuery.isFunction(qualifier)) {
2665				return jQuery.grep(elements, function (elem, i) {
2666					/* jshint -W018 */
2667					return !!qualifier.call(elem, i, elem) !== not;
2668				});
2669			}
2670
2671			if (qualifier.nodeType) {
2672				return jQuery.grep(elements, function (elem) {
2673					return elem === qualifier !== not;
2674				});
2675			}
2676
2677			if (typeof qualifier === "string") {
2678				if (risSimple.test(qualifier)) {
2679					return jQuery.filter(qualifier, elements, not);
2680				}
2681
2682				qualifier = jQuery.filter(qualifier, elements);
2683			}
2684
2685			return jQuery.grep(elements, function (elem) {
2686				return indexOf.call(qualifier, elem) >= 0 !== not;
2687			});
2688		}
2689
2690		jQuery.filter = function (expr, elems, not) {
2691			var elem = elems[0];
2692
2693			if (not) {
2694				expr = ":not(" + expr + ")";
2695			}
2696
2697			return elems.length === 1 && elem.nodeType === 1 ? jQuery.find.matchesSelector(elem, expr) ? [elem] : [] : jQuery.find.matches(expr, jQuery.grep(elems, function (elem) {
2698				return elem.nodeType === 1;
2699			}));
2700		};
2701
2702		jQuery.fn.extend({
2703			find: function find(selector) {
2704				var i,
2705				    len = this.length,
2706				    ret = [],
2707				    self = this;
2708
2709				if (typeof selector !== "string") {
2710					return this.pushStack(jQuery(selector).filter(function () {
2711						for (i = 0; i < len; i++) {
2712							if (jQuery.contains(self[i], this)) {
2713								return true;
2714							}
2715						}
2716					}));
2717				}
2718
2719				for (i = 0; i < len; i++) {
2720					jQuery.find(selector, self[i], ret);
2721				}
2722
2723				// Needed because $( selector, context ) becomes $( context ).find( selector )
2724				ret = this.pushStack(len > 1 ? jQuery.unique(ret) : ret);
2725				ret.selector = this.selector ? this.selector + " " + selector : selector;
2726				return ret;
2727			},
2728			filter: function filter(selector) {
2729				return this.pushStack(winnow(this, selector || [], false));
2730			},
2731			not: function not(selector) {
2732				return this.pushStack(winnow(this, selector || [], true));
2733			},
2734			is: function is(selector) {
2735				return !!winnow(this,
2736
2737				// If this is a positional/relative selector, check membership in the returned set
2738				// so $("p:first").is("p:last") won't return true for a doc with two "p".
2739				typeof selector === "string" && rneedsContext.test(selector) ? jQuery(selector) : selector || [], false).length;
2740			}
2741		});
2742
2743		// Initialize a jQuery object
2744
2745		// A central reference to the root jQuery(document)
2746		var rootjQuery,
2747
2748
2749		// A simple way to check for HTML strings
2750		// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
2751		// Strict HTML recognition (#11290: must start with <)
2752		rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]*))$/,
2753		    init = jQuery.fn.init = function (selector, context) {
2754			var match, elem;
2755
2756			// HANDLE: $(""), $(null), $(undefined), $(false)
2757			if (!selector) {
2758				return this;
2759			}
2760
2761			// Handle HTML strings
2762			if (typeof selector === "string") {
2763				if (selector[0] === "<" && selector[selector.length - 1] === ">" && selector.length >= 3) {
2764					// Assume that strings that start and end with <> are HTML and skip the regex check
2765					match = [null, selector, null];
2766				} else {
2767					match = rquickExpr.exec(selector);
2768				}
2769
2770				// Match html or make sure no context is specified for #id
2771				if (match && (match[1] || !context)) {
2772
2773					// HANDLE: $(html) -> $(array)
2774					if (match[1]) {
2775						context = context instanceof jQuery ? context[0] : context;
2776
2777						// Option to run scripts is true for back-compat
2778						// Intentionally let the error be thrown if parseHTML is not present
2779						jQuery.merge(this, jQuery.parseHTML(match[1], context && context.nodeType ? context.ownerDocument || context : document, true));
2780
2781						// HANDLE: $(html, props)
2782						if (rsingleTag.test(match[1]) && jQuery.isPlainObject(context)) {
2783							for (match in context) {
2784								// Properties of context are called as methods if possible
2785								if (jQuery.isFunction(this[match])) {
2786									this[match](context[match]);
2787
2788									// ...and otherwise set as attributes
2789								} else {
2790										this.attr(match, context[match]);
2791									}
2792							}
2793						}
2794
2795						return this;
2796
2797						// HANDLE: $(#id)
2798					} else {
2799							elem = document.getElementById(match[2]);
2800
2801							// Support: Blackberry 4.6
2802							// gEBID returns nodes no longer in the document (#6963)
2803							if (elem && elem.parentNode) {
2804								// Inject the element directly into the jQuery object
2805								this.length = 1;
2806								this[0] = elem;
2807							}
2808
2809							this.context = document;
2810							this.selector = selector;
2811							return this;
2812						}
2813
2814					// HANDLE: $(expr, $(...))
2815				} else if (!context || context.jquery) {
2816						return (context || rootjQuery).find(selector);
2817
2818						// HANDLE: $(expr, context)
2819						// (which is just equivalent to: $(context).find(expr)
2820					} else {
2821							return this.constructor(context).find(selector);
2822						}
2823
2824				// HANDLE: $(DOMElement)
2825			} else if (selector.nodeType) {
2826					this.context = this[0] = selector;
2827					this.length = 1;
2828					return this;
2829
2830					// HANDLE: $(function)
2831					// Shortcut for document ready
2832				} else if (jQuery.isFunction(selector)) {
2833						return typeof rootjQuery.ready !== "undefined" ? rootjQuery.ready(selector) :
2834						// Execute immediately if ready is not present
2835						selector(jQuery);
2836					}
2837
2838			if (selector.selector !== undefined) {
2839				this.selector = selector.selector;
2840				this.context = selector.context;
2841			}
2842
2843			return jQuery.makeArray(selector, this);
2844		};
2845
2846		// Give the init function the jQuery prototype for later instantiation
2847		init.prototype = jQuery.fn;
2848
2849		// Initialize central reference
2850		rootjQuery = jQuery(document);
2851
2852		var rparentsprev = /^(?:parents|prev(?:Until|All))/,
2853
2854		// Methods guaranteed to produce a unique set when starting from a unique set
2855		guaranteedUnique = {
2856			children: true,
2857			contents: true,
2858			next: true,
2859			prev: true
2860		};
2861
2862		jQuery.extend({
2863			dir: function dir(elem, _dir, until) {
2864				var matched = [],
2865				    truncate = until !== undefined;
2866
2867				while ((elem = elem[_dir]) && elem.nodeType !== 9) {
2868					if (elem.nodeType === 1) {
2869						if (truncate && jQuery(elem).is(until)) {
2870							break;
2871						}
2872						matched.push(elem);
2873					}
2874				}
2875				return matched;
2876			},
2877
2878			sibling: function sibling(n, elem) {
2879				var matched = [];
2880
2881				for (; n; n = n.nextSibling) {
2882					if (n.nodeType === 1 && n !== elem) {
2883						matched.push(n);
2884					}
2885				}
2886
2887				return matched;
2888			}
2889		});
2890
2891		jQuery.fn.extend({
2892			has: function has(target) {
2893				var targets = jQuery(target, this),
2894				    l = targets.length;
2895
2896				return this.filter(function () {
2897					var i = 0;
2898					for (; i < l; i++) {
2899						if (jQuery.contains(this, targets[i])) {
2900							return true;
2901						}
2902					}
2903				});
2904			},
2905
2906			closest: function closest(selectors, context) {
2907				var cur,
2908				    i = 0,
2909				    l = this.length,
2910				    matched = [],
2911				    pos = rneedsContext.test(selectors) || typeof selectors !== "string" ? jQuery(selectors, context || this.context) : 0;
2912
2913				for (; i < l; i++) {
2914					for (cur = this[i]; cur && cur !== context; cur = cur.parentNode) {
2915						// Always skip document fragments
2916						if (cur.nodeType < 11 && (pos ? pos.index(cur) > -1 :
2917
2918						// Don't pass non-elements to Sizzle
2919						cur.nodeType === 1 && jQuery.find.matchesSelector(cur, selectors))) {
2920
2921							matched.push(cur);
2922							break;
2923						}
2924					}
2925				}
2926
2927				return this.pushStack(matched.length > 1 ? jQuery.unique(matched) : matched);
2928			},
2929
2930			// Determine the position of an element within the set
2931			index: function index(elem) {
2932
2933				// No argument, return index in parent
2934				if (!elem) {
2935					return this[0] && this[0].parentNode ? this.first().prevAll().length : -1;
2936				}
2937
2938				// Index in selector
2939				if (typeof elem === "string") {
2940					return indexOf.call(jQuery(elem), this[0]);
2941				}
2942
2943				// Locate the position of the desired element
2944				return indexOf.call(this,
2945
2946				// If it receives a jQuery object, the first element is used
2947				elem.jquery ? elem[0] : elem);
2948			},
2949
2950			add: function add(selector, context) {
2951				return this.pushStack(jQuery.unique(jQuery.merge(this.get(), jQuery(selector, context))));
2952			},
2953
2954			addBack: function addBack(selector) {
2955				return this.add(selector == null ? this.prevObject : this.prevObject.filter(selector));
2956			}
2957		});
2958
2959		function sibling(cur, dir) {
2960			while ((cur = cur[dir]) && cur.nodeType !== 1) {}
2961			return cur;
2962		}
2963
2964		jQuery.each({
2965			parent: function parent(elem) {
2966				var parent = elem.parentNode;
2967				return parent && parent.nodeType !== 11 ? parent : null;
2968			},
2969			parents: function parents(elem) {
2970				return jQuery.dir(elem, "parentNode");
2971			},
2972			parentsUntil: function parentsUntil(elem, i, until) {
2973				return jQuery.dir(elem, "parentNode", until);
2974			},
2975			next: function next(elem) {
2976				return sibling(elem, "nextSibling");
2977			},
2978			prev: function prev(elem) {
2979				return sibling(elem, "previousSibling");
2980			},
2981			nextAll: function nextAll(elem) {
2982				return jQuery.dir(elem, "nextSibling");
2983			},
2984			prevAll: function prevAll(elem) {
2985				return jQuery.dir(elem, "previousSibling");
2986			},
2987			nextUntil: function nextUntil(elem, i, until) {
2988				return jQuery.dir(elem, "nextSibling", until);
2989			},
2990			prevUntil: function prevUntil(elem, i, until) {
2991				return jQuery.dir(elem, "previousSibling", until);
2992			},
2993			siblings: function siblings(elem) {
2994				return jQuery.sibling((elem.parentNode || {}).firstChild, elem);
2995			},
2996			children: function children(elem) {
2997				return jQuery.sibling(elem.firstChild);
2998			},
2999			contents: function contents(elem) {
3000				return elem.contentDocument || jQuery.merge([], elem.childNodes);
3001			}
3002		}, function (name, fn) {
3003			jQuery.fn[name] = function (until, selector) {
3004				var matched = jQuery.map(this, fn, until);
3005
3006				if (name.slice(-5) !== "Until") {
3007					selector = until;
3008				}
3009
3010				if (selector && typeof selector === "string") {
3011					matched = jQuery.filter(selector, matched);
3012				}
3013
3014				if (this.length > 1) {
3015					// Remove duplicates
3016					if (!guaranteedUnique[name]) {
3017						jQuery.unique(matched);
3018					}
3019
3020					// Reverse order for parents* and prev-derivatives
3021					if (rparentsprev.test(name)) {
3022						matched.reverse();
3023					}
3024				}
3025
3026				return this.pushStack(matched);
3027			};
3028		});
3029		var rnotwhite = /\S+/g;
3030
3031		// String to Object options format cache
3032		var optionsCache = {};
3033
3034		// Convert String-formatted options into Object-formatted ones and store in cache
3035		function createOptions(options) {
3036			var object = optionsCache[options] = {};
3037			jQuery.each(options.match(rnotwhite) || [], function (_, flag) {
3038				object[flag] = true;
3039			});
3040			return object;
3041		}
3042
3043		/*
3044	  * Create a callback list using the following parameters:
3045	  *
3046	  *	options: an optional list of space-separated options that will change how
3047	  *			the callback list behaves or a more traditional option object
3048	  *
3049	  * By default a callback list will act like an event callback list and can be
3050	  * "fired" multiple times.
3051	  *
3052	  * Possible options:
3053	  *
3054	  *	once:			will ensure the callback list can only be fired once (like a Deferred)
3055	  *
3056	  *	memory:			will keep track of previous values and will call any callback added
3057	  *					after the list has been fired right away with the latest "memorized"
3058	  *					values (like a Deferred)
3059	  *
3060	  *	unique:			will ensure a callback can only be added once (no duplicate in the list)
3061	  *
3062	  *	stopOnFalse:	interrupt callings when a callback returns false
3063	  *
3064	  */
3065		jQuery.Callbacks = function (options) {
3066
3067			// Convert options from String-formatted to Object-formatted if needed
3068			// (we check in cache first)
3069			options = typeof options === "string" ? optionsCache[options] || createOptions(options) : jQuery.extend({}, options);
3070
3071			var // Last fire value (for non-forgettable lists)
3072			memory,
3073
3074			// Flag to know if list was already fired
3075			_fired,
3076
3077			// Flag to know if list is currently firing
3078			firing,
3079
3080			// First callback to fire (used internally by add and fireWith)
3081			firingStart,
3082
3083			// End of the loop when firing
3084			firingLength,
3085
3086			// Index of currently firing callback (modified by remove if needed)
3087			firingIndex,
3088
3089			// Actual callback list
3090			list = [],
3091
3092			// Stack of fire calls for repeatable lists
3093			stack = !options.once && [],
3094
3095			// Fire callbacks
3096			fire = function fire(data) {
3097				memory = options.memory && data;
3098				_fired = true;
3099				firingIndex = firingStart || 0;
3100				firingStart = 0;
3101				firingLength = list.length;
3102				firing = true;
3103				for (; list && firingIndex < firingLength; firingIndex++) {
3104					if (list[firingIndex].apply(data[0], data[1]) === false && options.stopOnFalse) {
3105						memory = false; // To prevent further calls using add
3106						break;
3107					}
3108				}
3109				firing = false;
3110				if (list) {
3111					if (stack) {
3112						if (stack.length) {
3113							fire(stack.shift());
3114						}
3115					} else if (memory) {
3116						list = [];
3117					} else {
3118						self.disable();
3119					}
3120				}
3121			},
3122
3123			// Actual Callbacks object
3124			self = {
3125				// Add a callback or a collection of callbacks to the list
3126				add: function add() {
3127					if (list) {
3128						// First, we save the current length
3129						var start = list.length;
3130						(function add(args) {
3131							jQuery.each(args, function (_, arg) {
3132								var type = jQuery.type(arg);
3133								if (type === "function") {
3134									if (!options.unique || !self.has(arg)) {
3135										list.push(arg);
3136									}
3137								} else if (arg && arg.length && type !== "string") {
3138									// Inspect recursively
3139									add(arg);
3140								}
3141							});
3142						})(arguments);
3143						// Do we need to add the callbacks to the
3144						// current firing batch?
3145						if (firing) {
3146							firingLength = list.length;
3147							// With memory, if we're not firing then
3148							// we should call right away
3149						} else if (memory) {
3150								firingStart = start;
3151								fire(memory);
3152							}
3153					}
3154					return this;
3155				},
3156				// Remove a callback from the list
3157				remove: function remove() {
3158					if (list) {
3159						jQuery.each(arguments, function (_, arg) {
3160							var index;
3161							while ((index = jQuery.inArray(arg, list, index)) > -1) {
3162								list.splice(index, 1);
3163								// Handle firing indexes
3164								if (firing) {
3165									if (index <= firingLength) {
3166										firingLength--;
3167									}
3168									if (index <= firingIndex) {
3169										firingIndex--;
3170									}
3171								}
3172							}
3173						});
3174					}
3175					return this;
3176				},
3177				// Check if a given callback is in the list.
3178				// If no argument is given, return whether or not list has callbacks attached.
3179				has: function has(fn) {
3180					return fn ? jQuery.inArray(fn, list) > -1 : !!(list && list.length);
3181				},
3182				// Remove all callbacks from the list
3183				empty: function empty() {
3184					list = [];
3185					firingLength = 0;
3186					return this;
3187				},
3188				// Have the list do nothing anymore
3189				disable: function disable() {
3190					list = stack = memory = undefined;
3191					return this;
3192				},
3193				// Is it disabled?
3194				disabled: function disabled() {
3195					return !list;
3196				},
3197				// Lock the list in its current state
3198				lock: function lock() {
3199					stack = undefined;
3200					if (!memory) {
3201						self.disable();
3202					}
3203					return this;
3204				},
3205				// Is it locked?
3206				locked: function locked() {
3207					return !stack;
3208				},
3209				// Call all callbacks with the given context and arguments
3210				fireWith: function fireWith(context, args) {
3211					if (list && (!_fired || stack)) {
3212						args = args || [];
3213						args = [context, args.slice ? args.slice() : args];
3214						if (firing) {
3215							stack.push(args);
3216						} else {
3217							fire(args);
3218						}
3219					}
3220					return this;
3221				},
3222				// Call all the callbacks with the given arguments
3223				fire: function fire() {
3224					self.fireWith(this, arguments);
3225					return this;
3226				},
3227				// To know if the callbacks have already been called at least once
3228				fired: function fired() {
3229					return !!_fired;
3230				}
3231			};
3232
3233			return self;
3234		};
3235
3236		jQuery.extend({
3237
3238			Deferred: function Deferred(func) {
3239				var tuples = [
3240				// action, add listener, listener list, final state
3241				["resolve", "done", jQuery.Callbacks("once memory"), "resolved"], ["reject", "fail", jQuery.Callbacks("once memory"), "rejected"], ["notify", "progress", jQuery.Callbacks("memory")]],
3242				    _state = "pending",
3243				    _promise = {
3244					state: function state() {
3245						return _state;
3246					},
3247					always: function always() {
3248						deferred.done(arguments).fail(arguments);
3249						return this;
3250					},
3251					then: function then() /* fnDone, fnFail, fnProgress */{
3252						var fns = arguments;
3253						return jQuery.Deferred(function (newDefer) {
3254							jQuery.each(tuples, function (i, tuple) {
3255								var fn = jQuery.isFunction(fns[i]) && fns[i];
3256								// deferred[ done | fail | progress ] for forwarding actions to newDefer
3257								deferred[tuple[1]](function () {
3258									var returned = fn && fn.apply(this, arguments);
3259									if (returned && jQuery.isFunction(returned.promise)) {
3260										returned.promise().done(newDefer.resolve).fail(newDefer.reject).progress(newDefer.notify);
3261									} else {
3262										newDefer[tuple[0] + "With"](this === _promise ? newDefer.promise() : this, fn ? [returned] : arguments);
3263									}
3264								});
3265							});
3266							fns = null;
3267						}).promise();
3268					},
3269					// Get a promise for this deferred
3270					// If obj is provided, the promise aspect is added to the object
3271					promise: function promise(obj) {
3272						return obj != null ? jQuery.extend(obj, _promise) : _promise;
3273					}
3274				},
3275				    deferred = {};
3276
3277				// Keep pipe for back-compat
3278				_promise.pipe = _promise.then;
3279
3280				// Add list-specific methods
3281				jQuery.each(tuples, function (i, tuple) {
3282					var list = tuple[2],
3283					    stateString = tuple[3];
3284
3285					// promise[ done | fail | progress ] = list.add
3286					_promise[tuple[1]] = list.add;
3287
3288					// Handle state
3289					if (stateString) {
3290						list.add(function () {
3291							// state = [ resolved | rejected ]
3292							_state = stateString;
3293
3294							// [ reject_list | resolve_list ].disable; progress_list.lock
3295						}, tuples[i ^ 1][2].disable, tuples[2][2].lock);
3296					}
3297
3298					// deferred[ resolve | reject | notify ]
3299					deferred[tuple[0]] = function () {
3300						deferred[tuple[0] + "With"](this === deferred ? _promise : this, arguments);
3301						return this;
3302					};
3303					deferred[tuple[0] + "With"] = list.fireWith;
3304				});
3305
3306				// Make the deferred a promise
3307				_promise.promise(deferred);
3308
3309				// Call given func if any
3310				if (func) {
3311					func.call(deferred, deferred);
3312				}
3313
3314				// All done!
3315				return deferred;
3316			},
3317
3318			// Deferred helper
3319			when: function when(subordinate /* , ..., subordinateN */) {
3320				var i = 0,
3321				    resolveValues = _slice.call(arguments),
3322				    length = resolveValues.length,
3323
3324
3325				// the count of uncompleted subordinates
3326				remaining = length !== 1 || subordinate && jQuery.isFunction(subordinate.promise) ? length : 0,
3327
3328
3329				// the master Deferred. If resolveValues consist of only a single Deferred, just use that.
3330				deferred = remaining === 1 ? subordinate : jQuery.Deferred(),
3331
3332
3333				// Update function for both resolve and progress values
3334				updateFunc = function updateFunc(i, contexts, values) {
3335					return function (value) {
3336						contexts[i] = this;
3337						values[i] = arguments.length > 1 ? _slice.call(arguments) : value;
3338						if (values === progressValues) {
3339							deferred.notifyWith(contexts, values);
3340						} else if (! --remaining) {
3341							deferred.resolveWith(contexts, values);
3342						}
3343					};
3344				},
3345				    progressValues,
3346				    progressContexts,
3347				    resolveContexts;
3348
3349				// Add listeners to Deferred subordinates; treat others as resolved
3350				if (length > 1) {
3351					progressValues = new Array(length);
3352					progressContexts = new Array(length);
3353					resolveContexts = new Array(length);
3354					for (; i < length; i++) {
3355						if (resolveValues[i] && jQuery.isFunction(resolveValues[i].promise)) {
3356							resolveValues[i].promise().done(updateFunc(i, resolveContexts, resolveValues)).fail(deferred.reject).progress(updateFunc(i, progressContexts, progressValues));
3357						} else {
3358							--remaining;
3359						}
3360					}
3361				}
3362
3363				// If we're not waiting on anything, resolve the master
3364				if (!remaining) {
3365					deferred.resolveWith(resolveContexts, resolveValues);
3366				}
3367
3368				return deferred.promise();
3369			}
3370		});
3371
3372		// The deferred used on DOM ready
3373		var readyList;
3374
3375		jQuery.fn.ready = function (fn) {
3376			// Add the callback
3377			jQuery.ready.promise().done(fn);
3378
3379			return this;
3380		};
3381
3382		jQuery.extend({
3383			// Is the DOM ready to be used? Set to true once it occurs.
3384			isReady: false,
3385
3386			// A counter to track how many items to wait for before
3387			// the ready event fires. See #6781
3388			readyWait: 1,
3389
3390			// Hold (or release) the ready event
3391			holdReady: function holdReady(hold) {
3392				if (hold) {
3393					jQuery.readyWait++;
3394				} else {
3395					jQuery.ready(true);
3396				}
3397			},
3398
3399			// Handle when the DOM is ready
3400			ready: function ready(wait) {
3401
3402				// Abort if there are pending holds or we're already ready
3403				if (wait === true ? --jQuery.readyWait : jQuery.isReady) {
3404					return;
3405				}
3406
3407				// Remember that the DOM is ready
3408				jQuery.isReady = true;
3409
3410				// If a normal DOM Ready event fired, decrement, and wait if need be
3411				if (wait !== true && --jQuery.readyWait > 0) {
3412					return;
3413				}
3414
3415				// If there are functions bound, to execute
3416				readyList.resolveWith(document, [jQuery]);
3417
3418				// Trigger any bound ready events
3419				if (jQuery.fn.triggerHandler) {
3420					jQuery(document).triggerHandler("ready");
3421					jQuery(document).off("ready");
3422				}
3423			}
3424		});
3425
3426		/**
3427	  * The ready event handler and self cleanup method
3428	  */
3429		function completed() {
3430			document.removeEventListener("DOMContentLoaded", completed, false);
3431			window.removeEventListener("load", completed, false);
3432			jQuery.ready();
3433		}
3434
3435		jQuery.ready.promise = function (obj) {
3436			if (!readyList) {
3437
3438				readyList = jQuery.Deferred();
3439
3440				// Catch cases where $(document).ready() is called after the browser event has already occurred.
3441				// We once tried to use readyState "interactive" here, but it caused issues like the one
3442				// discovered by ChrisS here: http://bugs.jquery.com/ticket/12282#comment:15
3443				if (document.readyState === "complete") {
3444					// Handle it asynchronously to allow scripts the opportunity to delay ready
3445					setTimeout(jQuery.ready);
3446				} else {
3447
3448					// Use the handy event callback
3449					document.addEventListener("DOMContentLoaded", completed, false);
3450
3451					// A fallback to window.onload, that will always work
3452					window.addEventListener("load", completed, false);
3453				}
3454			}
3455			return readyList.promise(obj);
3456		};
3457
3458		// Kick off the DOM ready check even if the user does not
3459		jQuery.ready.promise();
3460
3461		// Multifunctional method to get and set values of a collection
3462		// The value/s can optionally be executed if it's a function
3463		var access = jQuery.access = function (elems, fn, key, value, chainable, emptyGet, raw) {
3464			var i = 0,
3465			    len = elems.length,
3466			    bulk = key == null;
3467
3468			// Sets many values
3469			if (jQuery.type(key) === "object") {
3470				chainable = true;
3471				for (i in key) {
3472					jQuery.access(elems, fn, i, key[i], true, emptyGet, raw);
3473				}
3474
3475				// Sets one value
3476			} else if (value !== undefined) {
3477					chainable = true;
3478
3479					if (!jQuery.isFunction(value)) {
3480						raw = true;
3481					}
3482
3483					if (bulk) {
3484						// Bulk operations run against the entire set
3485						if (raw) {
3486							fn.call(elems, value);
3487							fn = null;
3488
3489							// ...except when executing function values
3490						} else {
3491								bulk = fn;
3492								fn = function fn(elem, key, value) {
3493									return bulk.call(jQuery(elem), value);
3494								};
3495							}
3496					}
3497
3498					if (fn) {
3499						for (; i < len; i++) {
3500							fn(elems[i], key, raw ? value : value.call(elems[i], i, fn(elems[i], key)));
3501						}
3502					}
3503				}
3504
3505			return chainable ? elems :
3506
3507			// Gets
3508			bulk ? fn.call(elems) : len ? fn(elems[0], key) : emptyGet;
3509		};
3510
3511		/**
3512	  * Determines whether an object can have data
3513	  */
3514		jQuery.acceptData = function (owner) {
3515			// Accepts only:
3516			//  - Node
3517			//    - Node.ELEMENT_NODE
3518			//    - Node.DOCUMENT_NODE
3519			//  - Object
3520			//    - Any
3521			/* jshint -W018 */
3522			return owner.nodeType === 1 || owner.nodeType === 9 || ! +owner.nodeType;
3523		};
3524
3525		function Data() {
3526			// Support: Android<4,
3527			// Old WebKit does not have Object.preventExtensions/freeze method,
3528			// return new empty object instead with no [[set]] accessor
3529			Object.defineProperty(this.cache = {}, 0, {
3530				get: function get() {
3531					return {};
3532				}
3533			});
3534
3535			this.expando = jQuery.expando + Data.uid++;
3536		}
3537
3538		Data.uid = 1;
3539		Data.accepts = jQuery.acceptData;
3540
3541		Data.prototype = {
3542			key: function key(owner) {
3543				// We can accept data for non-element nodes in modern browsers,
3544				// but we should not, see #8335.
3545				// Always return the key for a frozen object.
3546				if (!Data.accepts(owner)) {
3547					return 0;
3548				}
3549
3550				var descriptor = {},
3551
3552				// Check if the owner object already has a cache key
3553				unlock = owner[this.expando];
3554
3555				// If not, create one
3556				if (!unlock) {
3557					unlock = Data.uid++;
3558
3559					// Secure it in a non-enumerable, non-writable property
3560					try {
3561						descriptor[this.expando] = { value: unlock };
3562						(0, _defineProperties2.default)(owner, descriptor);
3563
3564						// Support: Android<4
3565						// Fallback to a less secure definition
3566					} catch (e) {
3567						descriptor[this.expando] = unlock;
3568						jQuery.extend(owner, descriptor);
3569					}
3570				}
3571
3572				// Ensure the cache object
3573				if (!this.cache[unlock]) {
3574					this.cache[unlock] = {};
3575				}
3576
3577				return unlock;
3578			},
3579			set: function set(owner, data, value) {
3580				var prop,
3581
3582				// There may be an unlock assigned to this node,
3583				// if there is no entry for this "owner", create one inline
3584				// and set the unlock as though an owner entry had always existed
3585				unlock = this.key(owner),
3586				    cache = this.cache[unlock];
3587
3588				// Handle: [ owner, key, value ] args
3589				if (typeof data === "string") {
3590					cache[data] = value;
3591
3592					// Handle: [ owner, { properties } ] args
3593				} else {
3594						// Fresh assignments by object are shallow copied
3595						if (jQuery.isEmptyObject(cache)) {
3596							jQuery.extend(this.cache[unlock], data);
3597							// Otherwise, copy the properties one-by-one to the cache object
3598						} else {
3599								for (prop in data) {
3600									cache[prop] = data[prop];
3601								}
3602							}
3603					}
3604				return cache;
3605			},
3606			get: function get(owner, key) {
3607				// Either a valid cache is found, or will be created.
3608				// New caches will be created and the unlock returned,
3609				// allowing direct access to the newly created
3610				// empty data object. A valid owner object must be provided.
3611				var cache = this.cache[this.key(owner)];
3612
3613				return key === undefined ? cache : cache[key];
3614			},
3615			access: function access(owner, key, value) {
3616				var stored;
3617				// In cases where either:
3618				//
3619				//   1. No key was specified
3620				//   2. A string key was specified, but no value provided
3621				//
3622				// Take the "read" path and allow the get method to determine
3623				// which value to return, respectively either:
3624				//
3625				//   1. The entire cache object
3626				//   2. The data stored at the key
3627				//
3628				if (key === undefined || key && typeof key === "string" && value === undefined) {
3629
3630					stored = this.get(owner, key);
3631
3632					return stored !== undefined ? stored : this.get(owner, jQuery.camelCase(key));
3633				}
3634
3635				// [*]When the key is not a string, or both a key and value
3636				// are specified, set or extend (existing objects) with either:
3637				//
3638				//   1. An object of properties
3639				//   2. A key and value
3640				//
3641				this.set(owner, key, value);
3642
3643				// Since the "set" path can have two possible entry points
3644				// return the expected data based on which path was taken[*]
3645				return value !== undefined ? value : key;
3646			},
3647			remove: function remove(owner, key) {
3648				var i,
3649				    name,
3650				    camel,
3651				    unlock = this.key(owner),
3652				    cache = this.cache[unlock];
3653
3654				if (key === undefined) {
3655					this.cache[unlock] = {};
3656				} else {
3657					// Support array or space separated string of keys
3658					if (jQuery.isArray(key)) {
3659						// If "name" is an array of keys...
3660						// When data is initially created, via ("key", "val") signature,
3661						// keys will be converted to camelCase.
3662						// Since there is no way to tell _how_ a key was added, remove
3663						// both plain key and camelCase key. #12786
3664						// This will only penalize the array argument path.
3665						name = key.concat(key.map(jQuery.camelCase));
3666					} else {
3667						camel = jQuery.camelCase(key);
3668						// Try the string as a key before any manipulation
3669						if (key in cache) {
3670							name = [key, camel];
3671						} else {
3672							// If a key with the spaces exists, use it.
3673							// Otherwise, create an array by matching non-whitespace
3674							name = camel;
3675							name = name in cache ? [name] : name.match(rnotwhite) || [];
3676						}
3677					}
3678
3679					i = name.length;
3680					while (i--) {
3681						delete cache[name[i]];
3682					}
3683				}
3684			},
3685			hasData: function hasData(owner) {
3686				return !jQuery.isEmptyObject(this.cache[owner[this.expando]] || {});
3687			},
3688			discard: function discard(owner) {
3689				if (owner[this.expando]) {
3690					delete this.cache[owner[this.expando]];
3691				}
3692			}
3693		};
3694		var data_priv = new Data();
3695
3696		var data_user = new Data();
3697
3698		//	Implementation Summary
3699		//
3700		//	1. Enforce API surface and semantic compatibility with 1.9.x branch
3701		//	2. Improve the module's maintainability by reducing the storage
3702		//		paths to a single mechanism.
3703		//	3. Use the same single mechanism to support "private" and "user" data.
3704		//	4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData)
3705		//	5. Avoid exposing implementation details on user objects (eg. expando properties)
3706		//	6. Provide a clear path for implementation upgrade to WeakMap in 2014
3707
3708		var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,
3709		    rmultiDash = /([A-Z])/g;
3710
3711		function dataAttr(elem, key, data) {
3712			var name;
3713
3714			// If nothing was found internally, try to fetch any
3715			// data from the HTML5 data-* attribute
3716			if (data === undefined && elem.nodeType === 1) {
3717				name = "data-" + key.replace(rmultiDash, "-$1").toLowerCase();
3718				data = elem.getAttribute(name);
3719
3720				if (typeof data === "string") {
3721					try {
3722						data = data === "true" ? true : data === "false" ? false : data === "null" ? null :
3723						// Only convert to a number if it doesn't change the string
3724						+data + "" === data ? +data : rbrace.test(data) ? jQuery.parseJSON(data) : data;
3725					} catch (e) {}
3726
3727					// Make sure we set the data so it isn't changed later
3728					data_user.set(elem, key, data);
3729				} else {
3730					data = undefined;
3731				}
3732			}
3733			return data;
3734		}
3735
3736		jQuery.extend({
3737			hasData: function hasData(elem) {
3738				return data_user.hasData(elem) || data_priv.hasData(elem);
3739			},
3740
3741			data: function data(elem, name, _data) {
3742				return data_user.access(elem, name, _data);
3743			},
3744
3745			removeData: function removeData(elem, name) {
3746				data_user.remove(elem, name);
3747			},
3748
3749			// TODO: Now that all calls to _data and _removeData have been replaced
3750			// with direct calls to data_priv methods, these can be deprecated.
3751			_data: function _data(elem, name, data) {
3752				return data_priv.access(elem, name, data);
3753			},
3754
3755			_removeData: function _removeData(elem, name) {
3756				data_priv.remove(elem, name);
3757			}
3758		});
3759
3760		jQuery.fn.extend({
3761			data: function data(key, value) {
3762				var i,
3763				    name,
3764				    data,
3765				    elem = this[0],
3766				    attrs = elem && elem.attributes;
3767
3768				// Gets all values
3769				if (key === undefined) {
3770					if (this.length) {
3771						data = data_user.get(elem);
3772
3773						if (elem.nodeType === 1 && !data_priv.get(elem, "hasDataAttrs")) {
3774							i = attrs.length;
3775							while (i--) {
3776
3777								// Support: IE11+
3778								// The attrs elements can be null (#14894)
3779								if (attrs[i]) {
3780									name = attrs[i].name;
3781									if (name.indexOf("data-") === 0) {
3782										name = jQuery.camelCase(name.slice(5));
3783										dataAttr(elem, name, data[name]);
3784									}
3785								}
3786							}
3787							data_priv.set(elem, "hasDataAttrs", true);
3788						}
3789					}
3790
3791					return data;
3792				}
3793
3794				// Sets multiple values
3795				if ((typeof key === "undefined" ? "undefined" : (0, _typeof3.default)(key)) === "object") {
3796					return this.each(function () {
3797						data_user.set(this, key);
3798					});
3799				}
3800
3801				return access(this, function (value) {
3802					var data,
3803					    camelKey = jQuery.camelCase(key);
3804
3805					// The calling jQuery object (element matches) is not empty
3806					// (and therefore has an element appears at this[ 0 ]) and the
3807					// `value` parameter was not undefined. An empty jQuery object
3808					// will result in `undefined` for elem = this[ 0 ] which will
3809					// throw an exception if an attempt to read a data cache is made.
3810					if (elem && value === undefined) {
3811						// Attempt to get data from the cache
3812						// with the key as-is
3813						data = data_user.get(elem, key);
3814						if (data !== undefined) {
3815							return data;
3816						}
3817
3818						// Attempt to get data from the cache
3819						// with the key camelized
3820						data = data_user.get(elem, camelKey);
3821						if (data !== undefined) {
3822							return data;
3823						}
3824
3825						// Attempt to "discover" the data in
3826						// HTML5 custom data-* attrs
3827						data = dataAttr(elem, camelKey, undefined);
3828						if (data !== undefined) {
3829							return data;
3830						}
3831
3832						// We tried really hard, but the data doesn't exist.
3833						return;
3834					}
3835
3836					// Set the data...
3837					this.each(function () {
3838						// First, attempt to store a copy or reference of any
3839						// data that might've been store with a camelCased key.
3840						var data = data_user.get(this, camelKey);
3841
3842						// For HTML5 data-* attribute interop, we have to
3843						// store property names with dashes in a camelCase form.
3844						// This might not apply to all properties...*
3845						data_user.set(this, camelKey, value);
3846
3847						// *... In the case of properties that might _actually_
3848						// have dashes, we need to also store a copy of that
3849						// unchanged property.
3850						if (key.indexOf("-") !== -1 && data !== undefined) {
3851							data_user.set(this, key, value);
3852						}
3853					});
3854				}, null, value, arguments.length > 1, null, true);
3855			},
3856
3857			removeData: function removeData(key) {
3858				return this.each(function () {
3859					data_user.remove(this, key);
3860				});
3861			}
3862		});
3863
3864		jQuery.extend({
3865			queue: function queue(elem, type, data) {
3866				var queue;
3867
3868				if (elem) {
3869					type = (type || "fx") + "queue";
3870					queue = data_priv.get(elem, type);
3871
3872					// Speed up dequeue by getting out quickly if this is just a lookup
3873					if (data) {
3874						if (!queue || jQuery.isArray(data)) {
3875							queue = data_priv.access(elem, type, jQuery.makeArray(data));
3876						} else {
3877							queue.push(data);
3878						}
3879					}
3880					return queue || [];
3881				}
3882			},
3883
3884			dequeue: function dequeue(elem, type) {
3885				type = type || "fx";
3886
3887				var queue = jQuery.queue(elem, type),
3888				    startLength = queue.length,
3889				    fn = queue.shift(),
3890				    hooks = jQuery._queueHooks(elem, type),
3891				    next = function next() {
3892					jQuery.dequeue(elem, type);
3893				};
3894
3895				// If the fx queue is dequeued, always remove the progress sentinel
3896				if (fn === "inprogress") {
3897					fn = queue.shift();
3898					startLength--;
3899				}
3900
3901				if (fn) {
3902
3903					// Add a progress sentinel to prevent the fx queue from being
3904					// automatically dequeued
3905					if (type === "fx") {
3906						queue.unshift("inprogress");
3907					}
3908
3909					// Clear up the last queue stop function
3910					delete hooks.stop;
3911					fn.call(elem, next, hooks);
3912				}
3913
3914				if (!startLength && hooks) {
3915					hooks.empty.fire();
3916				}
3917			},
3918
3919			// Not public - generate a queueHooks object, or return the current one
3920			_queueHooks: function _queueHooks(elem, type) {
3921				var key = type + "queueHooks";
3922				return data_priv.get(elem, key) || data_priv.access(elem, key, {
3923					empty: jQuery.Callbacks("once memory").add(function () {
3924						data_priv.remove(elem, [type + "queue", key]);
3925					})
3926				});
3927			}
3928		});
3929
3930		jQuery.fn.extend({
3931			queue: function queue(type, data) {
3932				var setter = 2;
3933
3934				if (typeof type !== "string") {
3935					data = type;
3936					type = "fx";
3937					setter--;
3938				}
3939
3940				if (arguments.length < setter) {
3941					return jQuery.queue(this[0], type);
3942				}
3943