https://www.kimberlydivad.com/assets/portfolio-5d14a9ecb8bfbc4b8b0060a89488e12d.js

1/*!
2 * jQuery JavaScript Library v1.10.2
3 * http://jquery.com/
4 *
5 * Includes Sizzle.js
6 * http://sizzlejs.com/
7 *
8 * Copyright 2005, 2013 jQuery Foundation, Inc. and other contributors
9 * Released under the MIT license
10 * http://jquery.org/license
11 *
12 * Date: 2013-07-03T13:48Z
13 */
14
15(function( window, undefined ) {
16
17// Can't do this because several apps including ASP.NET trace
18// the stack via arguments.caller.callee and Firefox dies if
19// you try to trace through "use strict" call chains. (#13335)
20// Support: Firefox 18+
21//"use strict";
22var
23	// The deferred used on DOM ready
24	readyList,
25
26	// A central reference to the root jQuery(document)
27	rootjQuery,
28
29	// Support: IE<10
30	// For `typeof xmlNode.method` instead of `xmlNode.method !== undefined`
31	core_strundefined = typeof undefined,
32
33	// Use the correct document accordingly with window argument (sandbox)
34	location = window.location,
35	document = window.document,
36	docElem = document.documentElement,
37
38	// Map over jQuery in case of overwrite
39	_jQuery = window.jQuery,
40
41	// Map over the $ in case of overwrite
42	_$ = window.$,
43
44	// [[Class]] -> type pairs
45	class2type = {},
46
47	// List of deleted data cache ids, so we can reuse them
48	core_deletedIds = [],
49
50	core_version = "1.10.2",
51
52	// Save a reference to some core methods
53	core_concat = core_deletedIds.concat,
54	core_push = core_deletedIds.push,
55	core_slice = core_deletedIds.slice,
56	core_indexOf = core_deletedIds.indexOf,
57	core_toString = class2type.toString,
58	core_hasOwn = class2type.hasOwnProperty,
59	core_trim = core_version.trim,
60
61	// Define a local copy of jQuery
62	jQuery = function( selector, context ) {
63		// The jQuery object is actually just the init constructor 'enhanced'
64		return new jQuery.fn.init( selector, context, rootjQuery );
65	},
66
67	// Used for matching numbers
68	core_pnum = /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,
69
70	// Used for splitting on whitespace
71	core_rnotwhite = /\S+/g,
72
73	// Make sure we trim BOM and NBSP (here's looking at you, Safari 5.0 and IE)
74	rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
75
76	// A simple way to check for HTML strings
77	// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
78	// Strict HTML recognition (#11290: must start with <)
79	rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]*))$/,
80
81	// Match a standalone tag
82	rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>|)$/,
83
84	// JSON RegExp
85	rvalidchars = /^[\],:{}\s]*$/,
86	rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
87	rvalidescape = /\\(?:["\\\/bfnrt]|u[\da-fA-F]{4})/g,
88	rvalidtokens = /"[^"\\\r\n]*"|true|false|null|-?(?:\d+\.|)\d+(?:[eE][+-]?\d+|)/g,
89
90	// Matches dashed string for camelizing
91	rmsPrefix = /^-ms-/,
92	rdashAlpha = /-([\da-z])/gi,
93
94	// Used by jQuery.camelCase as callback to replace()
95	fcamelCase = function( all, letter ) {
96		return letter.toUpperCase();
97	},
98
99	// The ready event handler
100	completed = function( event ) {
101
102		// readyState === "complete" is good enough for us to call the dom ready in oldIE
103		if ( document.addEventListener || event.type === "load" || document.readyState === "complete" ) {
104			detach();
105			jQuery.ready();
106		}
107	},
108	// Clean-up method for dom ready events
109	detach = function() {
110		if ( document.addEventListener ) {
111			document.removeEventListener( "DOMContentLoaded", completed, false );
112			window.removeEventListener( "load", completed, false );
113
114		} else {
115			document.detachEvent( "onreadystatechange", completed );
116			window.detachEvent( "onload", completed );
117		}
118	};
119
120jQuery.fn = jQuery.prototype = {
121	// The current version of jQuery being used
122	jquery: core_version,
123
124	constructor: jQuery,
125	init: function( selector, context, rootjQuery ) {
126		var match, elem;
127
128		// HANDLE: $(""), $(null), $(undefined), $(false)
129		if ( !selector ) {
130			return this;
131		}
132
133		// Handle HTML strings
134		if ( typeof selector === "string" ) {
135			if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
136				// Assume that strings that start and end with <> are HTML and skip the regex check
137				match = [ null, selector, null ];
138
139			} else {
140				match = rquickExpr.exec( selector );
141			}
142
143			// Match html or make sure no context is specified for #id
144			if ( match && (match[1] || !context) ) {
145
146				// HANDLE: $(html) -> $(array)
147				if ( match[1] ) {
148					context = context instanceof jQuery ? context[0] : context;
149
150					// scripts is true for back-compat
151					jQuery.merge( this, jQuery.parseHTML(
152						match[1],
153						context && context.nodeType ? context.ownerDocument || context : document,
154						true
155					) );
156
157					// HANDLE: $(html, props)
158					if ( rsingleTag.test( match[1] ) && jQuery.isPlainObject( context ) ) {
159						for ( match in context ) {
160							// Properties of context are called as methods if possible
161							if ( jQuery.isFunction( this[ match ] ) ) {
162								this[ match ]( context[ match ] );
163
164							// ...and otherwise set as attributes
165							} else {
166								this.attr( match, context[ match ] );
167							}
168						}
169					}
170
171					return this;
172
173				// HANDLE: $(#id)
174				} else {
175					elem = document.getElementById( match[2] );
176
177					// Check parentNode to catch when Blackberry 4.6 returns
178					// nodes that are no longer in the document #6963
179					if ( elem && elem.parentNode ) {
180						// Handle the case where IE and Opera return items
181						// by name instead of ID
182						if ( elem.id !== match[2] ) {
183							return rootjQuery.find( selector );
184						}
185
186						// Otherwise, we inject the element directly into the jQuery object
187						this.length = 1;
188						this[0] = elem;
189					}
190
191					this.context = document;
192					this.selector = selector;
193					return this;
194				}
195
196			// HANDLE: $(expr, $(...))
197			} else if ( !context || context.jquery ) {
198				return ( context || rootjQuery ).find( selector );
199
200			// HANDLE: $(expr, context)
201			// (which is just equivalent to: $(context).find(expr)
202			} else {
203				return this.constructor( context ).find( selector );
204			}
205
206		// HANDLE: $(DOMElement)
207		} else if ( selector.nodeType ) {
208			this.context = this[0] = selector;
209			this.length = 1;
210			return this;
211
212		// HANDLE: $(function)
213		// Shortcut for document ready
214		} else if ( jQuery.isFunction( selector ) ) {
215			return rootjQuery.ready( selector );
216		}
217
218		if ( selector.selector !== undefined ) {
219			this.selector = selector.selector;
220			this.context = selector.context;
221		}
222
223		return jQuery.makeArray( selector, this );
224	},
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() {
233		return core_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( num ) {
239		return num == null ?
240
241			// Return a 'clean' array
242			this.toArray() :
243
244			// Return just the object
245			( num < 0 ? this[ this.length + num ] : this[ num ] );
246	},
247
248	// Take an array of elements and push it onto the stack
249	// (returning the new matched element set)
250	pushStack: function( 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( callback, args ) {
267		return jQuery.each( this, callback, args );
268	},
269
270	ready: function( fn ) {
271		// Add the callback
272		jQuery.ready.promise().done( fn );
273
274		return this;
275	},
276
277	slice: function() {
278		return this.pushStack( core_slice.apply( this, arguments ) );
279	},
280
281	first: function() {
282		return this.eq( 0 );
283	},
284
285	last: function() {
286		return this.eq( -1 );
287	},
288
289	eq: function( i ) {
290		var len = this.length,
291			j = +i + ( i < 0 ? len : 0 );
292		return this.pushStack( j >= 0 && j < len ? [ this[j] ] : [] );
293	},
294
295	map: function( callback ) {
296		return this.pushStack( jQuery.map(this, function( elem, i ) {
297			return callback.call( elem, i, elem );
298		}));
299	},
300
301	end: function() {
302		return this.prevObject || this.constructor(null);
303	},
304
305	// For internal use only.
306	// Behaves like an Array's method, not like a jQuery method.
307	push: core_push,
308	sort: [].sort,
309	splice: [].splice
310};
311
312// Give the init function the jQuery prototype for later instantiation
313jQuery.fn.init.prototype = jQuery.fn;
314
315jQuery.extend = jQuery.fn.extend = function() {
316	var src, copyIsArray, copy, name, options, clone,
317		target = arguments[0] || {},
318		i = 1,
319		length = arguments.length,
320		deep = false;
321
322	// Handle a deep copy situation
323	if ( typeof target === "boolean" ) {
324		deep = target;
325		target = arguments[1] || {};
326		// skip the boolean and the target
327		i = 2;
328	}
329
330	// Handle case when target is a string or something (possible in deep copy)
331	if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
332		target = {};
333	}
334
335	// extend jQuery itself if only one argument is passed
336	if ( length === i ) {
337		target = this;
338		--i;
339	}
340
341	for ( ; i < length; i++ ) {
342		// Only deal with non-null/undefined values
343		if ( (options = arguments[ i ]) != null ) {
344			// Extend the base object
345			for ( name in options ) {
346				src = target[ name ];
347				copy = options[ name ];
348
349				// Prevent never-ending loop
350				if ( target === copy ) {
351					continue;
352				}
353
354				// Recurse if we're merging plain objects or arrays
355				if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
356					if ( copyIsArray ) {
357						copyIsArray = false;
358						clone = src && jQuery.isArray(src) ? src : [];
359
360					} else {
361						clone = src && jQuery.isPlainObject(src) ? src : {};
362					}
363
364					// Never move original objects, clone them
365					target[ name ] = jQuery.extend( deep, clone, copy );
366
367				// Don't bring in undefined values
368				} else if ( copy !== undefined ) {
369					target[ name ] = copy;
370				}
371			}
372		}
373	}
374
375	// Return the modified object
376	return target;
377};
378
379jQuery.extend({
380	// Unique for each copy of jQuery on the page
381	// Non-digits removed to match rinlinejQuery
382	expando: "jQuery" + ( core_version + Math.random() ).replace( /\D/g, "" ),
383
384	noConflict: function( deep ) {
385		if ( window.$ === jQuery ) {
386			window.$ = _$;
387		}
388
389		if ( deep && window.jQuery === jQuery ) {
390			window.jQuery = _jQuery;
391		}
392
393		return jQuery;
394	},
395
396	// Is the DOM ready to be used? Set to true once it occurs.
397	isReady: false,
398
399	// A counter to track how many items to wait for before
400	// the ready event fires. See #6781
401	readyWait: 1,
402
403	// Hold (or release) the ready event
404	holdReady: function( hold ) {
405		if ( hold ) {
406			jQuery.readyWait++;
407		} else {
408			jQuery.ready( true );
409		}
410	},
411
412	// Handle when the DOM is ready
413	ready: function( wait ) {
414
415		// Abort if there are pending holds or we're already ready
416		if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
417			return;
418		}
419
420		// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
421		if ( !document.body ) {
422			return setTimeout( jQuery.ready );
423		}
424
425		// Remember that the DOM is ready
426		jQuery.isReady = true;
427
428		// If a normal DOM Ready event fired, decrement, and wait if need be
429		if ( wait !== true && --jQuery.readyWait > 0 ) {
430			return;
431		}
432

1131	// Easily-parseable/retrievable ID or TAG or CLASS selectors
1132	rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
1133
1134	rinputs = /^(?:input|select|textarea|button)$/i,
1135	rheader = /^h\d$/i,
1136
1137	rescape = /'|\\/g,
1138
1139	// CSS escapes http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
1140	runescape = new RegExp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ),
1141	funescape = function( _, escaped, escapedWhitespace ) {
1142		var high = "0x" + escaped - 0x10000;
1143		// NaN means non-codepoint
1144		// Support: Firefox
1145		// Workaround erroneous numeric interpretation of +"0x"
1146		return high !== high || escapedWhitespace ?
1147			escaped :
1148			// BMP codepoint
1149			high < 0 ?
1150				String.fromCharCode( high + 0x10000 ) :
1151				// Supplemental Plane codepoint (surrogate pair)
1152				String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
1153	};
1154
1155// Optimize for push.apply( _, NodeList )
1156try {
1157	push.apply(
1158		(arr = slice.call( preferredDoc.childNodes )),
1159		preferredDoc.childNodes
1160	);
1161	// Support: Android<4.0
1162	// Detect silently failing push.apply
1163	arr[ preferredDoc.childNodes.length ].nodeType;
1164} catch ( e ) {
1165	push = { apply: arr.length ?
1166
1167		// Leverage slice if possible
1168		function( target, els ) {
1169			push_native.apply( target, slice.call(els) );
1170		} :
1171
1172		// Support: IE<9
1173		// Otherwise append directly
1174		function( target, els ) {
1175			var j = target.length,
1176				i = 0;
1177			// Can't trust NodeList.length
1178			while ( (target[j++] = els[i++]) ) {}
1179			target.length = j - 1;
1180		}
1181	};
1182}
1183
1184function Sizzle( selector, context, results, seed ) {
1185	var match, elem, m, nodeType,
1186		// QSA vars
1187		i, groups, old, nid, newContext, newSelector;
1188
1189	if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {
1190		setDocument( context );
1191	}
1192
1193	context = context || document;
1194	results = results || [];
1195
1196	if ( !selector || typeof selector !== "string" ) {
1197		return results;
1198	}
1199
1200	if ( (nodeType = context.nodeType) !== 1 && nodeType !== 9 ) {
1201		return [];
1202	}
1203
1204	if ( documentIsHTML && !seed ) {
1205
1206		// Shortcuts
1207		if ( (match = rquickExpr.exec( selector )) ) {
1208			// Speed-up: Sizzle("#ID")
1209			if ( (m = match[1]) ) {
1210				if ( nodeType === 9 ) {
1211					elem = context.getElementById( m );
1212					// Check parentNode to catch when Blackberry 4.6 returns
1213					// nodes that are no longer in the document #6963
1214					if ( elem && elem.parentNode ) {
1215						// Handle the case where IE, Opera, and Webkit return items
1216						// by name instead of ID
1217						if ( elem.id === m ) {
1218							results.push( elem );
1219							return results;
1220						}
1221					} else {
1222						return results;
1223					}
1224				} else {
1225					// Context is not a document
1226					if ( context.ownerDocument && (elem = context.ownerDocument.getElementById( m )) &&
1227						contains( context, elem ) && elem.id === m ) {
1228						results.push( elem );
1229						return results;
1230					}
1231				}
1232
1233			// Speed-up: Sizzle("TAG")
1234			} else if ( match[2] ) {
1235				push.apply( results, context.getElementsByTagName( selector ) );
1236				return results;
1237
1238			// Speed-up: Sizzle(".CLASS")
1239			} else if ( (m = match[3]) && support.getElementsByClassName && context.getElementsByClassName ) {
1240				push.apply( results, context.getElementsByClassName( m ) );
1241				return results;
1242			}
1243		}
1244
1245		// QSA path
1246		if ( support.qsa && (!rbuggyQSA || !rbuggyQSA.test( selector )) ) {
1247			nid = old = expando;
1248			newContext = context;
1249			newSelector = nodeType === 9 && selector;
1250
1251			// qSA works strangely on Element-rooted queries
1252			// We can work around this by specifying an extra ID on the root
1253			// and working up from there (Thanks to Andrew Dupont for the technique)
1254			// IE 8 doesn't work on object elements
1255			if ( nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) {
1256				groups = tokenize( selector );
1257
1258				if ( (old = context.getAttribute("id")) ) {
1259					nid = old.replace( rescape, "\\$&" );
1260				} else {
1261					context.setAttribute( "id", nid );
1262				}
1263				nid = "[id='" + nid + "'] ";
1264
1265				i = groups.length;
1266				while ( i-- ) {
1267					groups[i] = nid + toSelector( groups[i] );
1268				}
1269				newContext = rsibling.test( selector ) && context.parentNode || context;
1270				newSelector = groups.join(",");
1271			}
1272
1273			if ( newSelector ) {
1274				try {
1275					push.apply( results,
1276						newContext.querySelectorAll( newSelector )
1277					);
1278					return results;
1279				} catch(qsaError) {
1280				} finally {
1281					if ( !old ) {
1282						context.removeAttribute("id");
1283					}
1284				}
1285			}
1286		}
1287	}
1288
1289	// All others
1290	return select( selector.replace( rtrim, "$1" ), context, results, seed );
1291}
1292
1293/**
1294 * Create key-value caches of limited size
1295 * @returns {Function(string, Object)} Returns the Object data after storing it on itself with
1296 *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
1297 *	deleting the oldest entry
1298 */
1299function createCache() {
1300	var keys = [];
1301
1302	function cache( key, value ) {
1303		// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
1304		if ( keys.push( key += " " ) > Expr.cacheLength ) {
1305			// Only keep the most recent entries
1306			delete cache[ keys.shift() ];
1307		}
1308		return (cache[ key ] = value);
1309	}
1310	return cache;
1311}
1312
1313/**
1314 * Mark a function for special use by Sizzle
1315 * @param {Function} fn The function to mark
1316 */
1317function markFunction( fn ) {
1318	fn[ expando ] = true;
1319	return fn;
1320}
1321
1322/**
1323 * Support testing using an element
1324 * @param {Function} fn Passed the created div and expects a boolean result
1325 */
1326function assert( fn ) {
1327	var div = document.createElement("div");
1328
1329	try {
1330		return !!fn( div );
1331	} catch (e) {
1332		return false;
1333	} finally {
1334		// Remove from its parent by default
1335		if ( div.parentNode ) {
1336			div.parentNode.removeChild( div );
1337		}
1338		// release memory in IE
1339		div = null;
1340	}
1341}
1342
1343/**
1344 * Adds the same handler for all of the specified attrs
1345 * @param {String} attrs Pipe-separated list of attributes
1346 * @param {Function} handler The method that will be applied
1347 */
1348function addHandle( attrs, handler ) {
1349	var arr = attrs.split("|"),
1350		i = attrs.length;
1351
1352	while ( i-- ) {
1353		Expr.attrHandle[ arr[i] ] = handler;
1354	}
1355}
1356
1357/**
1358 * Checks document order of two siblings
1359 * @param {Element} a
1360 * @param {Element} b
1361 * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
1362 */
1363function siblingCheck( a, b ) {
1364	var cur = b && a,
1365		diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
1366			( ~b.sourceIndex || MAX_NEGATIVE ) -
1367			( ~a.sourceIndex || MAX_NEGATIVE );
1368
1369	// Use IE sourceIndex if available on both nodes
1370	if ( diff ) {
1371		return diff;
1372	}
1373
1374	// Check if b follows a
1375	if ( cur ) {
1376		while ( (cur = cur.nextSibling) ) {
1377			if ( cur === b ) {
1378				return -1;
1379			}
1380		}
1381	}
1382
1383	return a ? 1 : -1;
1384}
1385
1386/**
1387 * Returns a function to use in pseudos for input types
1388 * @param {String} type
1389 */
1390function createInputPseudo( type ) {
1391	return function( elem ) {
1392		var name = elem.nodeName.toLowerCase();
1393		return name === "input" && elem.type === type;
1394	};
1395}
1396
1397/**
1398 * Returns a function to use in pseudos for buttons
1399 * @param {String} type
1400 */
1401function createButtonPseudo( type ) {
1402	return function( elem ) {
1403		var name = elem.nodeName.toLowerCase();
1404		return (name === "input" || name === "button") && elem.type === type;
1405	};
1406}
1407
1408/**
1409 * Returns a function to use in pseudos for positionals
1410 * @param {Function} fn
1411 */
1412function createPositionalPseudo( fn ) {
1413	return markFunction(function( argument ) {
1414		argument = +argument;
1415		return markFunction(function( seed, matches ) {
1416			var j,
1417				matchIndexes = fn( [], seed.length, argument ),
1418				i = matchIndexes.length;
1419
1420			// Match elements found at the specified indexes
1421			while ( i-- ) {
1422				if ( seed[ (j = matchIndexes[i]) ] ) {
1423					seed[j] = !(matches[j] = seed[j]);
1424				}
1425			}
1426		});
1427	});
1428}
1429
1430/**
1431 * Detect xml
1432 * @param {Element|Object} elem An element or a document
1433 */
1434isXML = Sizzle.isXML = function( elem ) {
1435	// documentElement is verified for cases where it doesn't yet exist
1436	// (such as loading iframes in IE - #4833)
1437	var documentElement = elem && (elem.ownerDocument || elem).documentElement;
1438	return documentElement ? documentElement.nodeName !== "HTML" : false;
1439};
1440
1441// Expose support vars for convenience
1442support = Sizzle.support = {};
1443
1444/**
1445 * Sets document-related variables once based on the current document
1446 * @param {Element|Object} [doc] An element or document object to use to set the document
1447 * @returns {Object} Returns the current document
1448 */
1449setDocument = Sizzle.setDocument = function( node ) {
1450	var doc = node ? node.ownerDocument || node : preferredDoc,
1451		parent = doc.defaultView;
1452
1453	// If no document and documentElement is available, return
1454	if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {
1455		return document;
1456	}
1457
1458	// Set our document
1459	document = doc;
1460	docElem = doc.documentElement;
1461
1462	// Support tests
1463	documentIsHTML = !isXML( doc );
1464
1465	// Support: IE>8
1466	// If iframe document is assigned to "document" variable and if iframe has been reloaded,
1467	// IE will throw "permission denied" error when accessing "document" variable, see jQuery #13936
1468	// IE6-8 do not support the defaultView property so parent will be undefined
1469	if ( parent && parent.attachEvent && parent !== parent.top ) {
1470		parent.attachEvent( "onbeforeunload", function() {
1471			setDocument();
1472		});
1473	}
1474
1475	/* Attributes
1476	---------------------------------------------------------------------- */
1477
1478	// Support: IE<8
1479	// Verify that getAttribute really returns attributes and not properties (excepting IE8 booleans)
1480	support.attributes = assert(function( div ) {
1481		div.className = "i";
1482		return !div.getAttribute("className");
1483	});
1484
1485	/* getElement(s)By*
1486	---------------------------------------------------------------------- */
1487
1488	// Check if getElementsByTagName("*") returns only elements
1489	support.getElementsByTagName = assert(function( div ) {
1490		div.appendChild( doc.createComment("") );
1491		return !div.getElementsByTagName("*").length;
1492	});
1493
1494	// Check if getElementsByClassName can be trusted
1495	support.getElementsByClassName = assert(function( div ) {
1496		div.innerHTML = "<div class='a'></div><div class='a i'></div>";
1497
1498		// Support: Safari<4
1499		// Catch class over-caching
1500		div.firstChild.className = "i";
1501		// Support: Opera<10
1502		// Catch gEBCN failure to find non-leading classes
1503		return div.getElementsByClassName("i").length === 2;
1504	});
1505
1506	// Support: IE<10
1507	// Check if getElementById returns elements by name
1508	// The broken getElementById methods don't pick up programatically-set names,
1509	// so use a roundabout getElementsByName test
1510	support.getById = assert(function( div ) {
1511		docElem.appendChild( div ).id = expando;
1512		return !doc.getElementsByName || !doc.getElementsByName( expando ).length;
1513	});
1514
1515	// ID find and filter
1516	if ( support.getById ) {
1517		Expr.find["ID"] = function( id, context ) {
1518			if ( typeof context.getElementById !== strundefined && documentIsHTML ) {
1519				var m = context.getElementById( id );
1520				// Check parentNode to catch when Blackberry 4.6 returns
1521				// nodes that are no longer in the document #6963
1522				return m && m.parentNode ? [m] : [];
1523			}
1524		};
1525		Expr.filter["ID"] = function( id ) {
1526			var attrId = id.replace( runescape, funescape );
1527			return function( elem ) {
1528				return elem.getAttribute("id") === attrId;
1529			};
1530		};
1531	} else {
1532		// Support: IE6/7
1533		// getElementById is not reliable as a find shortcut
1534		delete Expr.find["ID"];
1535
1536		Expr.filter["ID"] =  function( id ) {
1537			var attrId = id.replace( runescape, funescape );
1538			return function( elem ) {
1539				var node = typeof elem.getAttributeNode !== strundefined && elem.getAttributeNode("id");
1540				return node && node.value === attrId;
1541			};
1542		};
1543	}
1544
1545	// Tag
1546	Expr.find["TAG"] = support.getElementsByTagName ?
1547		function( tag, context ) {
1548			if ( typeof context.getElementsByTagName !== strundefined ) {
1549				return context.getElementsByTagName( tag );
1550			}
1551		} :
1552		function( tag, context ) {
1553			var elem,
1554				tmp = [],
1555				i = 0,
1556				results = context.getElementsByTagName( tag );
1557
1558			// Filter out possible comments
1559			if ( tag === "*" ) {
1560				while ( (elem = results[i++]) ) {
1561					if ( elem.nodeType === 1 ) {
1562						tmp.push( elem );
1563					}
1564				}
1565
1566				return tmp;
1567			}
1568			return results;
1569		};
1570
1571	// Class
1572	Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) {
1573		if ( typeof context.getElementsByClassName !== strundefined && documentIsHTML ) {
1574			return context.getElementsByClassName( className );
1575		}
1576	};
1577
1578	/* QSA/matchesSelector
1579	---------------------------------------------------------------------- */
1580
1581	// QSA and matchesSelector support
1582
1583	// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
1584	rbuggyMatches = [];
1585
1586	// qSa(:focus) reports false when true (Chrome 21)
1587	// We allow this because of a bug in IE8/9 that throws an error
1588	// whenever `document.activeElement` is accessed on an iframe
1589	// So, we allow :focus to pass through QSA all the time to avoid the IE error
1590	// See http://bugs.jquery.com/ticket/13378
1591	rbuggyQSA = [];
1592
1593	if ( (support.qsa = rnative.test( doc.querySelectorAll )) ) {
1594		// Build QSA regex
1595		// Regex strategy adopted from Diego Perini
1596		assert(function( div ) {
1597			// Select is set to empty string on purpose
1598			// This is to test IE's treatment of not explicitly
1599			// setting a boolean content attribute,
1600			// since its presence should be enough
1601			// http://bugs.jquery.com/ticket/12359
1602			div.innerHTML = "<select><option selected=''></option></select>";
1603
1604			// Support: IE8
1605			// Boolean attributes and "value" are not treated correctly
1606			if ( !div.querySelectorAll("[selected]").length ) {
1607				rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
1608			}
1609
1610			// Webkit/Opera - :checked should return selected option elements
1611			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
1612			// IE8 throws error here and will not see later tests
1613			if ( !div.querySelectorAll(":checked").length ) {
1614				rbuggyQSA.push(":checked");
1615			}
1616		});
1617
1618		assert(function( div ) {
1619
1620			// Support: Opera 10-12/IE8
1621			// ^= $= *= and empty values
1622			// Should not select anything
1623			// Support: Windows 8 Native Apps
1624			// The type attribute is restricted during .innerHTML assignment
1625			var input = doc.createElement("input");
1626			input.setAttribute( "type", "hidden" );
1627			div.appendChild( input ).setAttribute( "t", "" );
1628
1629			if ( div.querySelectorAll("[t^='']").length ) {
1630				rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
1631			}
1632
1633			// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
1634			// IE8 throws error here and will not see later tests
1635			if ( !div.querySelectorAll(":enabled").length ) {
1636				rbuggyQSA.push( ":enabled", ":disabled" );
1637			}
1638
1639			// Opera 10-11 does not throw on post-comma invalid pseudos
1640			div.querySelectorAll("*,:x");
1641			rbuggyQSA.push(",.*:");
1642		});
1643	}
1644
1645	if ( (support.matchesSelector = rnative.test( (matches = docElem.webkitMatchesSelector ||
1646		docElem.mozMatchesSelector ||
1647		docElem.oMatchesSelector ||
1648		docElem.msMatchesSelector) )) ) {
1649
1650		assert(function( div ) {
1651			// Check to see if it's possible to do matchesSelector
1652			// on a disconnected node (IE 9)
1653			support.disconnectedMatch = matches.call( div, "div" );
1654
1655			// This should fail with an exception
1656			// Gecko does not error, returns false instead
1657			matches.call( div, "[s!='']:x" );
1658			rbuggyMatches.push( "!=", pseudos );
1659		});
1660	}
1661
1662	rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") );
1663	rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") );
1664
1665	/* Contains
1666	---------------------------------------------------------------------- */
1667
1668	// Element contains another
1669	// Purposefully does not implement inclusive descendent
1670	// As in, an element does not contain itself
1671	contains = rnative.test( docElem.contains ) || docElem.compareDocumentPosition ?
1672		function( a, b ) {
1673			var adown = a.nodeType === 9 ? a.documentElement : a,
1674				bup = b && b.parentNode;
1675			return a === bup || !!( bup && bup.nodeType === 1 && (
1676				adown.contains ?
1677					adown.contains( bup ) :
1678					a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
1679			));
1680		} :
1681		function( a, b ) {
1682			if ( b ) {
1683				while ( (b = b.parentNode) ) {
1684					if ( b === a ) {
1685						return true;
1686					}
1687				}
1688			}
1689			return false;
1690		};
1691
1692	/* Sorting
1693	---------------------------------------------------------------------- */
1694
1695	// Document order sorting
1696	sortOrder = docElem.compareDocumentPosition ?
1697	function( a, b ) {
1698
1699		// Flag for duplicate removal
1700		if ( a === b ) {
1701			hasDuplicate = true;
1702			return 0;
1703		}
1704
1705		var compare = b.compareDocumentPosition && a.compareDocumentPosition && a.compareDocumentPosition( b );
1706
1707		if ( compare ) {
1708			// Disconnected nodes
1709			if ( compare & 1 ||
1710				(!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {
1711
1712				// Choose the first element that is related to our preferred document
1713				if ( a === doc || contains(preferredDoc, a) ) {
1714					return -1;
1715				}
1716				if ( b === doc || contains(preferredDoc, b) ) {
1717					return 1;
1718				}
1719
1720				// Maintain original order
1721				return sortInput ?
1722					( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) :
1723					0;
1724			}
1725
1726			return compare & 4 ? -1 : 1;
1727		}
1728
1729		// Not directly comparable, sort on existence of method
1730		return a.compareDocumentPosition ? -1 : 1;
1731	} :
1732	function( a, b ) {
1733		var cur,
1734			i = 0,
1735			aup = a.parentNode,
1736			bup = b.parentNode,
1737			ap = [ a ],
1738			bp = [ b ];
1739
1740		// Exit early if the nodes are identical
1741		if ( a === b ) {
1742			hasDuplicate = true;
1743			return 0;
1744
1745		// Parentless nodes are either documents or disconnected
1746		} else if ( !aup || !bup ) {
1747			return a === doc ? -1 :
1748				b === doc ? 1 :
1749				aup ? -1 :
1750				bup ? 1 :
1751				sortInput ?
1752				( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) :
1753				0;
1754
1755		// If the nodes are siblings, we can do a quick check
1756		} else if ( aup === bup ) {
1757			return siblingCheck( a, b );
1758		}
1759
1760		// Otherwise we need full lists of their ancestors for comparison
1761		cur = a;
1762		while ( (cur = cur.parentNode) ) {
1763			ap.unshift( cur );
1764		}
1765		cur = b;
1766		while ( (cur = cur.parentNode) ) {
1767			bp.unshift( cur );
1768		}
1769
1770		// Walk down the tree looking for a discrepancy
1771		while ( ap[i] === bp[i] ) {
1772			i++;
1773		}
1774
1775		return i ?
1776			// Do a sibling check if the nodes have a common ancestor
1777			siblingCheck( ap[i], bp[i] ) :
1778
1779			// Otherwise nodes in our document sort first
1780			ap[i] === preferredDoc ? -1 :
1781			bp[i] === preferredDoc ? 1 :
1782			0;
1783	};
1784
1785	return doc;
1786};
1787
1788Sizzle.matches = function( expr, elements ) {
1789	return Sizzle( expr, null, null, elements );
1790};
1791
1792Sizzle.matchesSelector = function( elem, expr ) {
1793	// Set document vars if needed
1794	if ( ( elem.ownerDocument || elem ) !== document ) {
1795		setDocument( elem );
1796	}
1797
1798	// Make sure that attribute selectors are quoted
1799	expr = expr.replace( rattributeQuotes, "='$1']" );
1800
1801	if ( support.matchesSelector && documentIsHTML &&
1802		( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
1803		( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {
1804
1805		try {
1806			var ret = matches.call( elem, expr );
1807
1808			// IE 9's matchesSelector returns false on disconnected nodes
1809			if ( ret || support.disconnectedMatch ||
1810					// As well, disconnected nodes are said to be in a document
1811					// fragment in IE 9
1812					elem.document && elem.document.nodeType !== 11 ) {
1813				return ret;
1814			}
1815		} catch(e) {}
1816	}
1817
1818	return Sizzle( expr, document, null, [elem] ).length > 0;
1819};
1820
1821Sizzle.contains = function( context, elem ) {
1822	// Set document vars if needed
1823	if ( ( context.ownerDocument || context ) !== document ) {
1824		setDocument( context );
1825	}
1826	return contains( context, elem );
1827};
1828
1829Sizzle.attr = function( elem, name ) {
1830	// Set document vars if needed
1831	if ( ( elem.ownerDocument || elem ) !== document ) {
1832		setDocument( elem );
1833	}
1834
1835	var fn = Expr.attrHandle[ name.toLowerCase() ],
1836		// Don't get fooled by Object.prototype properties (jQuery #13807)
1837		val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
1838			fn( elem, name, !documentIsHTML ) :
1839			undefined;
1840
1841	return val === undefined ?
1842		support.attributes || !documentIsHTML ?
1843			elem.getAttribute( name ) :
1844			(val = elem.getAttributeNode(name)) && val.specified ?
1845				val.value :
1846				null :
1847		val;
1848};
1849
1850Sizzle.error = function( msg ) {
1851	throw new Error( "Syntax error, unrecognized expression: " + msg );
1852};
1853
1854/**
1855 * Document sorting and removing duplicates
1856 * @param {ArrayLike} results
1857 */
1858Sizzle.uniqueSort = function( results ) {
1859	var elem,
1860		duplicates = [],
1861		j = 0,
1862		i = 0;
1863
1864	// Unless we *know* we can detect duplicates, assume their presence
1865	hasDuplicate = !support.detectDuplicates;
1866	sortInput = !support.sortStable && results.slice( 0 );
1867	results.sort( sortOrder );
1868
1869	if ( hasDuplicate ) {
1870		while ( (elem = results[i++]) ) {
1871			if ( elem === results[ i ] ) {
1872				j = duplicates.push( i );
1873			}
1874		}
1875		while ( j-- ) {
1876			results.splice( duplicates[ j ], 1 );
1877		}
1878	}
1879
1880	return results;
1881};
1882
1883/**
1884 * Utility function for retrieving the text value of an array of DOM nodes
1885 * @param {Array|Element} elem
1886 */
1887getText = Sizzle.getText = function( elem ) {
1888	var node,
1889		ret = "",
1890		i = 0,
1891		nodeType = elem.nodeType;
1892
1893	if ( !nodeType ) {
1894		// If no nodeType, this is expected to be an array
1895		for ( ; (node = elem[i]); i++ ) {

1896			// Do not traverse comment nodes
1897			ret += getText( node );
1898		}
1899	} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
1900		// Use textContent for elements
1901		// innerText usage removed for consistency of new lines (see #11153)
1902		if ( typeof elem.textContent === "string" ) {
1903			return elem.textContent;
1904		} else {
1905			// Traverse its children
1906			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
1907				ret += getText( elem );
1908			}
1909		}
1910	} else if ( nodeType === 3 || nodeType === 4 ) {
1911		return elem.nodeValue;
1912	}
1913	// Do not include comment or processing instruction nodes
1914
1915	return ret;
1916};
1917
1918Expr = Sizzle.selectors = {
1919
1920	// Can be adjusted by the user
1921	cacheLength: 50,
1922
1923	createPseudo: markFunction,
1924
1925	match: matchExpr,
1926
1927	attrHandle: {},
1928
1929	find: {},
1930
1931	relative: {
1932		">": { dir: "parentNode", first: true },
1933		" ": { dir: "parentNode" },
1934		"+": { dir: "previousSibling", first: true },
1935		"~": { dir: "previousSibling" }
1936	},
1937
1938	preFilter: {
1939		"ATTR": function( match ) {
1940			match[1] = match[1].replace( runescape, funescape );
1941
1942			// Move the given value to match[3] whether quoted or unquoted
1943			match[3] = ( match[4] || match[5] || "" ).replace( runescape, funescape );
1944
1945			if ( match[2] === "~=" ) {
1946				match[3] = " " + match[3] + " ";
1947			}
1948
1949			return match.slice( 0, 4 );
1950		},
1951
1952		"CHILD": function( match ) {
1953			/* matches from matchExpr["CHILD"]
1954				1 type (only|nth|...)
1955				2 what (child|of-type)
1956				3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
1957				4 xn-component of xn+y argument ([+-]?\d*n|)
1958				5 sign of xn-component
1959				6 x of xn-component
1960				7 sign of y-component
1961				8 y of y-component
1962			*/
1963			match[1] = match[1].toLowerCase();
1964
1965			if ( match[1].slice( 0, 3 ) === "nth" ) {
1966				// nth-* requires argument
1967				if ( !match[3] ) {
1968					Sizzle.error( match[0] );
1969				}
1970
1971				// numeric x and y parameters for Expr.filter.CHILD
1972				// remember that false/true cast respectively to 0/1
1973				match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) );
1974				match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" );
1975
1976			// other types prohibit arguments
1977			} else if ( match[3] ) {
1978				Sizzle.error( match[0] );
1979			}
1980
1981			return match;
1982		},
1983
1984		"PSEUDO": function( match ) {
1985			var excess,
1986				unquoted = !match[5] && match[2];
1987
1988			if ( matchExpr["CHILD"].test( match[0] ) ) {
1989				return null;
1990			}
1991
1992			// Accept quoted arguments as-is
1993			if ( match[3] && match[4] !== undefined ) {
1994				match[2] = match[4]

1994;
1995
1996			// Strip excess characters from unquoted arguments
1997			} else if ( unquoted && rpseudo.test( unquoted ) &&
1998				// Get excess from tokenize (recursively)
1999				(excess = tokenize( unquoted, true )) &&
2000				// advance to the next closing parenthesis
2001				(excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) {
2002
2003				// excess is a negative index
2004				match[0] = match[0].slice( 0, excess );
2005				match[2] = unquoted.slice( 0, excess );
2006			}
2007
2008			// Return only captures needed by the pseudo filter method (type and argument)
2009			return match.slice( 0, 3 );
2010		}
2011	},
2012
2013	filter: {
2014
2015		"TAG": function( nodeNameSelector ) {
2016			var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
2017			return nodeNameSelector === "*" ?
2018				function() { return true; } :
2019				function( elem ) {
2020					return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
2021				};
2022		},
2023
2024		"CLASS": function( className ) {
2025			var pattern = classCache[ className + " " ];
2026
2027			return pattern ||
2028				(pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) &&
2029				classCache( className, function( elem ) {
2030					return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== strundefined && elem.getAttribute("class") || "" );
2031				});
2032		},
2033
2034		"ATTR": function( name, operator, check ) {
2035			return function( elem ) {
2036				var result = Sizzle.attr( elem, name );
2037
2038				if ( result == null ) {
2039					return operator === "!=";
2040				}
2041				if ( !operator ) {
2042					return true;
2043				}
2044
2045				result += "";
2046
2047				return operator === "=" ? result === check :
2048					operator === "!=" ? result !== check :
2049					operator === "^=" ? check && result.indexOf( check ) === 0 :
2050					operator === "*=" ? check && result.indexOf( check ) > -1 :
2051					operator === "$=" ? check && result.slice( -check.length ) === check :
2052					operator === "~=" ? ( " " + result + " " ).indexOf( check ) > -1 :
2053					operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
2054					false;
2055			};
2056		},
2057
2058		"CHILD": function( type, what, argument, first, last ) {
2059			var simple = type.slice( 0, 3 ) !== "nth",
2060				forward = type.slice( -4 ) !== "last",
2061				ofType = what === "of-type";
2062
2063			return first === 1 && last === 0 ?
2064
2065				// Shortcut for :nth-*(n)
2066				function( elem ) {
2067					return !!elem.parentNode;
2068				} :
2069
2070				function( elem, context, xml ) {
2071					var cache, outerCache, node, diff, nodeIndex, start,
2072						dir = simple !== forward ? "nextSibling" : "previousSibling",
2073						parent = elem.parentNode,
2074						name = ofType && elem.nodeName.toLowerCase(),
2075						useCache = !xml && !ofType;
2076
2077					if ( parent ) {
2078
2079						// :(first|last|only)-(child|of-type)
2080						if ( simple ) {
2081							while ( dir ) {
2082								node = elem;
2083								while ( (node = node[ dir ]) ) {
2084									if ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) {
2085										return false;
2086									}
2087								}
2088								// Reverse direction for :only-* (if we haven't yet done so)
2089								start = dir = type === "only" && !start && "nextSibling";
2090							}
2091							return true;
2092						}
2093
2094						start = [ forward ? parent.firstChild : parent.lastChild ];
2095
2096						// non-xml :nth-child(...) stores cache data on `parent`
2097						if ( forward && useCache ) {
2098							// Seek `elem` from a previously-cached index
2099							outerCache = parent[ expando ] || (parent[ expando ] = {});
2100							cache = outerCache[ type ] || [];
2101							nodeIndex = cache[0] === dirruns && cache[1];
2102							diff = cache[0] === dirruns && cache[2];
2103							node = nodeIndex && parent.childNodes[ nodeIndex ];
2104
2105							while ( (node = ++nodeIndex && node && node[ dir ] ||
2106
2107								// Fallback to seeking `elem` from the start
2108								(diff = nodeIndex = 0) || start.pop()) ) {
2109
2110								// When found, cache indexes on `parent` and break
2111								if ( node.nodeType === 1 && ++diff && node === elem ) {
2112									outerCache[ type ] = [ dirruns, nodeIndex, diff ];
2113									break;
2114								}
2115							}
2116
2117						// Use previously-cached element index if available
2118						} else if ( useCache && (cache = (elem[ expando ] || (elem[ expando ] = {}))[ type ]) && cache[0] === dirruns ) {
2119							diff = cache[1];
2120
2121						// xml :nth-child(...) or :nth-last-child(...) or :nth(-last)?-of-type(...)
2122						} else {
2123							// Use the same loop as above to seek `elem` from the start
2124							while ( (node = ++nodeIndex && node && node[ dir ] ||
2125								(diff = nodeIndex = 0) || start.pop()) ) {
2126
2127								if ( ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) && ++diff ) {
2128									// Cache the index of each encountered element
2129									if ( useCache ) {
2130										(node[ expando ] || (node[ expando ] = {}))[ type ] = [ dirruns, diff ];
2131									}
2132
2133									if ( node === elem ) {
2134										break;
2135									}
2136								}
2137							}
2138						}
2139
2140						// Incorporate the offset, then check against cycle size
2141						diff -= last;
2142						return diff === first || ( diff % first === 0 && diff / first >= 0 );
2143					}
2144				};
2145		},
2146
2147		"PSEUDO": function( pseudo, argument ) {
2148			// pseudo-class names are case-insensitive
2149			// http://www.w3.org/TR/selectors/#pseudo-classes
2150			// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
2151			// Remember that setFilters inherits from pseudos
2152			var args,
2153				fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
2154					Sizzle.error( "unsupported pseudo: " + pseudo );
2155
2156			// The user may use createPseudo to indicate that
2157			// arguments are needed to create the filter function
2158			// just as Sizzle does
2159			if ( fn[ expando ] ) {
2160				return fn( argument );
2161			}
2162
2163			// But maintain support for old signatures
2164			if ( fn.length > 1 ) {
2165				args = [ pseudo, pseudo, "", argument ];
2166				return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
2167					markFunction(function( seed, matches ) {
2168						var idx,
2169							matched = fn( seed, argument ),
2170							i = matched.length;
2171						while ( i-- ) {
2172							idx = indexOf.call( seed, matched[i] );
2173							seed[ idx ] = !( matches[ idx ] = matched[i] );
2174						}
2175					}) :
2176					function( elem ) {
2177						return fn( elem, 0, args );
2178					};
2179			}
2180
2181			return fn;
2182		}
2183	},
2184
2185	pseudos: {
2186		// Potentially complex pseudos
2187		"not": markFunction(function( selector ) {
2188			// Trim the selector passed to compile
2189			// to avoid treating leading and trailing
2190			// spaces as combinators
2191			var input = [],
2192				results = [],
2193				matcher = compile( selector.replace( rtrim, "$1" ) );
2194
2195			return matcher[ expando ] ?
2196				markFunction(function( seed, matches, context, xml ) {
2197					var elem,
2198						unmatched = matcher( seed, null, xml, [] ),
2199						i = seed.length;
2200
2201					// Match elements unmatched by `matcher`
2202					while ( i-- ) {
2203						if ( (elem = unmatched[i]) ) {
2204							seed[i] = !(matches[i] = elem);
2205						}
2206					}
2207				}) :
2208				function( elem, context, xml ) {
2209					input[0] = elem;
2210					matcher( input, null, xml, results );
2211					return !results.pop();
2212				};
2213		}),
2214
2215		"has": markFunction(function( selector ) {
2216			return function( elem ) {
2217				return Sizzle( selector, elem ).length > 0;
2218			};
2219		}),
2220
2221		"contains": markFunction(function( text ) {
2222			return function( elem ) {
2223				return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1;
2224			};
2225		}),
2226
2227		// "Whether an element is represented by a :lang() selector
2228		// is based solely on the element's language value
2229		// being equal to the identifier C,
2230		// or beginning with the identifier C immediately followed by "-".
2231		// The matching of C against the element's language value is performed case-insensitively.
2232		// The identifier C does not have to be a valid language name."
2233		// http://www.w3.org/TR/selectors/#lang-pseudo
2234		"lang": markFunction( function( lang ) {
2235			// lang value must be a valid identifier
2236			if ( !ridentifier.test(lang || "") ) {
2237				Sizzle.error( "unsupported lang: " + lang );
2238			}
2239			lang = lang.replace( runescape, funescape ).toLowerCase();
2240			return function( elem ) {
2241				var elemLang;
2242				do {
2243					if ( (elemLang = documentIsHTML ?
2244						elem.lang :
2245						elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) {
2246
2247						elemLang = elemLang.toLowerCase();
2248						return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
2249					}
2250				} while ( (elem = elem.parentNode) && elem.nodeType === 1 );
2251				return false;
2252			};
2253		}),
2254
2255		// Miscellaneous
2256		"target": function( elem ) {
2257			var hash = window.location && window.location.hash;
2258			return hash && hash.slice( 1 ) === elem.id;
2259		},
2260
2261		"root": function( elem ) {
2262			return elem === docElem;
2263		},
2264
2265		"focus": function( elem ) {
2266			return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
2267		},
2268
2269		// Boolean properties
2270		"enabled": function( elem ) {
2271			return elem.disabled === false;
2272		},
2273
2274		"disabled": function( elem ) {
2275			return elem.disabled === true;
2276		},
2277
2278		"checked": function( elem ) {
2279			// In CSS3, :checked should return both checked and selected elements
2280			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
2281			var nodeName = elem.nodeName.toLowerCase();
2282			return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);
2283		},
2284
2285		"selected": function( elem ) {
2286			// Accessing this property makes selected-by-default
2287			// options in Safari work properly
2288			if ( elem.parentNode ) {
2289				elem.parentNode.selectedIndex;
2290			}
2291
2292			return elem.selected === true;
2293		},
2294
2295		// Contents
2296		"empty": function( elem ) {
2297			// http://www.w3.org/TR/selectors/#empty-pseudo
2298			// :empty is 

2298only affected by element nodes and content nodes(including text(3), cdata(4)),
2299			//   not comment, processing instructions, or others
2300			// Thanks to Diego Perini for the nodeName shortcut
2301			//   Greater than "@" means alpha characters (specifically not starting with "#" or "?")
2302			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
2303				if ( elem.nodeName > "@" || elem.nodeType === 3 || elem.nodeType === 4 ) {
2304					return false;
2305				}
2306			}
2307			return true;
2308		},
2309
2310		"parent": function( elem ) {
2311			return !Expr.pseudos["empty"]( elem );
2312		},
2313
2314		// Element/input types
2315		"header": function( elem ) {
2316			return rheader.test( elem.nodeName );
2317		},
2318
2319		"input": function( elem ) {
2320			return rinputs.test( elem.nodeName );
2321		},
2322
2323		"button": function( elem ) {
2324			var name = elem.nodeName.toLowerCase();
2325			return name === "input" && elem.type === "button" || name === "button";
2326		},
2327
2328		"text": function( elem ) {
2329			var attr;
2330			// IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc)
2331			// use getAttribute instead to test this case
2332			return elem.nodeName.toLowerCase() === "input" &&
2333				elem.type === "text" &&
2334				( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === elem.type );
2335		},
2336
2337		// Position-in-collection
2338		"first": createPositionalPseudo(function() {
2339			return [ 0 ];
2340		}),
2341
2342		"last": createPositionalPseudo(function( matchIndexes, length ) {
2343			return [ length - 1 ];
2344		}),
2345
2346		"eq": createPositionalPseudo(function( matchIndexes, length, argument ) {
2347			return [ argument < 0 ? argument + length : argument ];
2348		}),
2349
2350		"even": createPositionalPseudo(function( matchIndexes, length ) {
2351			var i = 0;
2352			for ( ; i < length; i += 2 ) {
2353				matchIndexes.push( i );
2354			}
2355			return matchIndexes;
2356		}),
2357
2358		"odd": createPositionalPseudo(function( matchIndexes, length ) {
2359			var i = 1;
2360			for ( ; i < length; i += 2 ) {
2361				matchIndexes.push( i );
2362			}
2363			return matchIndexes;
2364		}),
2365
2366		"lt": createPositionalPseudo(function( matchIndexes, length, argument ) {
2367			var i = argument < 0 ? argument + length : argument;
2368			for ( ; --i >= 0; ) {
2369				matchIndexes.push( i );
2370			}
2371			return matchIndexes;
2372		}),
2373
2374		"gt": createPositionalPseudo(function( matchIndexes, length, argument ) {
2375			var i = argument < 0 ? argument + length : argument;
2376			for ( ; ++i < length; ) {
2377				matchIndexes.push( i );
2378			}
2379			return matchIndexes;
2380		})
2381	}
2382};
2383
2384Expr.pseudos["nth"] = Expr.pseudos["eq"];
2385
2386// Add button/input type pseudos
2387for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
2388	Expr.pseudos[ i ] = createInputPseudo( i );
2389}
2390for ( i in { submit: true, reset: true } ) {
2391	Expr.pseudos[ i ] = createButtonPseudo( i );
2392}
2393
2394// Easy API for creating new setFilters
2395function setFilters() {}
2396setFilters.prototype = Expr.filters = Expr.pseudos;
2397Expr.setFilters = new setFilters();
2398
2399function tokenize( selector, parseOnly ) {
2400	var matched, match, tokens, type,
2401		soFar, groups, preFilters,
2402		cached = tokenCache[ selector + " " ];
2403
2404	if ( cached ) {
2405		return parseOnly ? 0 : cached.slice( 0 );
2406	}
2407
2408	soFar = selector;
2409	groups = [];
2410	preFilters = Expr.preFilter;
2411
2412	while ( soFar ) {
2413
2414		// Comma and first run
2415		if ( !matched || (match = rcomma.exec( soFar )) ) {
2416			if ( match ) {
2417				// Don't consume trailing commas as valid
2418				soFar = soFar.slice( match[0].length ) || soFar;
2419			}
2420			groups.push( tokens = [] );
2421		}
2422
2423		matched = false;

2424
2425		// Combinators
2426		if ( (match = rcombinators.exec( soFar )) ) {
2427			matched = match.shift();
2428			tokens.push({
2429				value: matched,
2430				// Cast descendant combinators to space
2431				type: match[0].replace( rtrim, " " )
2432			});
2433			soFar = soFar.slice( matched.length );
2434		}
2435
2436		// Filters
2437		for ( type in Expr.filter ) {
2438			if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||
2439				(match = preFilters[ type ]( match ))) ) {
2440				matched = match.shift();
2441				tokens.push({
2442					value: matched,
2443					type: type,
2444					matches: match
2445				});
2446				soFar = soFar.slice( matched.length );
2447			}
2448		}
2449
2450		if ( !matched ) {
2451			break;
2452		}
2453	}
2454
2455	// Return the length of the invalid excess
2456	// if we're just parsing
2457	// Otherwise, throw an error or return tokens
2458	return parseOnly ?
2459		soFar.length :
2460		soFar ?
2461			Sizzle.error( selector ) :
2462			// Cache the tokens
2463			tokenCache( selector, groups ).slice( 0 );
2464}
2465
2466function toSelector( tokens ) {
2467	var i = 0,
2468		len = tokens.length,
2469		selector = "";
2470	for ( ; i < len; i++ ) {
2471		selector += tokens[i].value;
2472	}
2473	return selector;
2474}
2475
2476function addCombinator( matcher, combinator, base ) {
2477	var dir = combinator.dir,
2478		checkNonElements = base && dir === "parentNode",
2479		doneName = done++;
2480
2481	return combinator.first ?
2482		// Check against closest ancestor/preceding element
2483		function( elem, context, xml ) {
2484			while ( (elem = elem[ dir ]) ) {
2485				if ( elem.nodeType === 1 || checkNonElements ) {
2486					return matcher( elem, context, xml );
2487				}
2488			}
2489		} :
2490
2491		// Check against all ancestor/preceding elements
2492		function( elem, context, xml ) {
2493			var data, cache, outerCache,
2494				dirkey = dirruns + " " + doneName;
2495
2496			// We can't set arbitrary data on XML nodes, so they don't benefit from dir caching
2497			if ( xml ) {
2498				while ( (elem = elem[ dir ]) ) {
2499					if ( elem.nodeType === 1 || checkNonElements ) {
2500						if ( matcher( elem, context, xml ) ) {
2501							return true;
2502						}
2503					}
2504				}
2505			} else {
2506				while ( (elem = elem[ dir ]) ) {
2507					if ( elem.nodeType === 1 || checkNonElements ) {
2508						outerCache = elem[ expando ] || (elem[ expando ] = {});
2509						if ( (cache = outerCache[ dir ]) && cache[0] === dirkey ) {
2510							if ( (data = cache[1]) === true || data === cachedruns ) {
2511								return data === true;
2512							}
2513						} else {
2514							cache = outerCache[ dir ] = [ dirkey ];
2515							cache[1] = matcher( elem, context, xml ) || cachedruns;
2516							if ( cache[1] === true ) {
2517								return true;
2518							}
2519						}
2520					}
2521				}
2522			}
2523		};
2524}
2525
2526function elementMatcher( matchers ) {
2527	return matchers.length > 1 ?
2528		function( elem, context, xml ) {
2529			var i = matchers.length;
2530			while ( i-- ) {
2531				if ( !matchers[i]( elem, context, xml ) ) {
2532					return false;
2533				}
2534			}
2535			return true;
2536		} :
2537		matchers[0];
2538}
2539
2540function condense( unmatched, map, filter, context, xml ) {
2541	var elem,
2542		newUnmatched = [],
2543		i = 0,
2544		len = unmatched.length,
2545		mapped = map != null;
2546
2547	for ( ; i < len; i++ ) {
2548		if ( (elem = unmatched[i]) ) {
2549			if ( !filter || filter( elem, context, xml ) ) {
2550				newUnmatched.push( elem );
2551				if ( mapped ) {
2552					map.push( i );
2553				}
2554			}
2555		}
2556	}
2557
2558	return newUnmatched;
2559}
2560
2561function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
2562	if ( postFilter && !postFilter[ expando ] ) {
2563		postFilter = setMatcher( postFilter );
2564	}
2565	if ( postFinder && !postFinder[ expando ] ) {
2566		postFinder = setMatcher( postFinder, postSelector );
2567	}
2568	return markFunction(function( seed, results, context, xml ) {
2569		var temp, i, elem,
2570			preMap = [],
2571			postMap = [],
2572			preexisting = results.length,
2573
2574			// Get initial elements from seed or context
2575			elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ),
2576
2577			// Prefilter to get matcher input, preserving a map for seed-results synchronization
2578			matcherIn = preFilter && ( seed || !selector ) ?
2579				condense( elems, preMap, preFilter, context, xml ) :
2580				elems,
2581
2582			matcherOut = matcher ?
2583				// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
2584				postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
2585
2586					// ...intermediate processing is necessary
2587					[] :
2588
2589					// ...otherwise use results directly
2590					results :
2591				matcherIn;
2592
2593		// Find primary matches
2594		if ( matcher ) {
2595			matcher( matcherIn, matcherOut, context, xml );
2596		}
2597
2598		// Apply postFilter
2599		if ( postFilter ) {
2600			temp = condense( matcherOut, postMap );
2601			postFilter( temp, [], context, xml );
2602
2603			// Un-match failing elements by moving them back to matcherIn
2604			i = temp.length;
2605			while ( i-- ) {
2606				if ( (elem = temp[i]) ) {
2607					matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);
2608				}
2609			}
2610		}
2611
2612		if ( seed ) {
2613			if ( postFinder || preFilter ) {
2614				if ( postFinder ) {
2615					// Get the final matcherOut by condensing this intermediate into postFinder contexts
2616					temp = [];
2617					i = matcherOut.length;
2618					while ( i-- ) {
2619						if ( (elem = matcherOut[i]) ) {
2620							// Restore matcherIn since elem is not yet a final match
2621							temp.push( (matcherIn[i] = elem) );
2622						}
2623					}
2624					postFinder( null, (matcherOut = []), temp, xml );
2625				}
2626
2627				// Move matched elements from seed to results to keep them synchronized
2628				i = matcherOut.length;
2629				while ( i-- ) {
2630					if ( (elem = matcherOut[i]) &&
2631						(temp = postFinder ? indexOf.call( seed, elem ) : preMap[i]) > -1 ) {
2632
2633						seed[temp] = !(results[temp] = elem);
2634					}
2635				}
2636			}
2637
2638		// Add elements to results, through postFinder if defined
2639		} else {
2640			matcherOut = condense(
2641				matcherOut === results ?
2642					matcherOut.splice( preexisting, matcherOut.length ) :
2643					matcherOut
2644			);
2645			if ( postFinder ) {
2646				postFinder( null, results, matcherOut, xml );
2647			} else {
2648				push.apply( results, matcherOut );
2649			}
2650		}
2651	});
2652}
2653
2654function matcherFromTokens( tokens ) {
2655	var checkContext, matcher, j,
2656		len = tokens.length,
2657		leadingRelative = Expr.relative[ tokens[0].type ],
2658		implicitRelative = leadingRelative || Expr.relative[" "],
2659		i = leadingRelative ? 1 : 0,
2660
2661		// The foundational matcher ensures that elements are reachable from top-level context(s)
2662		matchContext = addCombinator( function( elem ) {
2663			return elem === checkContext;
2664		}, implicitRelative, true ),
2665		matchAnyContext = addCombinator( function( elem ) {
2666			return indexOf.call( checkContext, elem ) > -1;
2667		}, implicitRelative, true ),
2668		matchers = [ function( elem, context, xml ) {
2669			return ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
2670				(checkContext = context).nodeType ?
2671					matchContext( elem, context, xml ) :
2672					matchAnyContext( elem, context, xml ) );
2673		} ];
2674
2675	for ( ; i < len; i++ ) {
2676		if ( (matcher = Expr.relative[ tokens[i].type ]) ) {
2677			matchers = [ addCombinator(elementMatcher( matchers ), matcher) ];
2678		} else {
2679			matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );
2680
2681			// Return special upon seeing a positional matcher
2682			if ( matcher[ expando ] ) {
2683				// Find the next relative operator (if any) for proper handling
2684				j = ++i;
2685				for ( ; j < len; j++ ) {
2686					if ( Expr.relative[ tokens[j].type ] ) {
2687						break;
2688					}
2689				}
2690				return setMatcher(
2691					i > 1 && elementMatcher( matchers ),
2692					i > 1 && toSelector(
2693						// If the preceding token was a descendant combinator, insert an implicit any-element `*`
2694						tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" })
2695					).replace( rtrim, "$1" ),
2696					matcher,
2697					i < j && matcherFromTokens( tokens.slice( i, j ) ),
2698					j < len && matcherFromTokens( (tokens = tokens.slice( j )) ),
2699					j < len && toSelector( tokens )
2700				);
2701			}
2702			matchers.push( matcher );
2703		}
2704	}
2705
2706	return elementMatcher( matchers );
2707}
2708
2709function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
2710	// A counter to specify which element is currently being matched
2711	var matcherCachedRuns = 0,
2712		bySet = setMatchers.length > 0,
2713		byElement = elementMatchers.length > 0,
2714		superMatcher = function( seed, context, xml, results, expandContext ) {
2715			var elem, j, matcher,
2716				setMatched = [],
2717				matchedCount = 0,
2718				i = "0",
2719				unmatched = seed && [],
2720				outermost = expandContext != null,
2721				contextBackup = outermostContext,
2722				// We must always have either seed elements or context
2723				elems = seed || byElement && Expr.find["TAG"]( "*", expandContext && context.parentNode || context ),
2724				// Use integer dirruns iff this is the outermost matcher
2725				dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1);
2726
2727			if ( outermost ) {
2728				outermostContext = context !== document && context;
2729				cachedruns = matcherCachedRuns;
2730			}
2731
2732			// Add elements passing elementMatchers directly to results
2733			// Keep `i` a string if there are no elements so `matchedCount` will be "00" below
2734			for ( ; (elem = elems[i]) != null; i++ ) {
2735				if ( byElement && elem ) {
2736					j = 0;
2737					while ( (matcher = elementMatchers[j++]) ) {
2738						if ( matcher( elem, context, xml ) ) {
2739							results.push( elem );
2740							break;
2741						}
2742					}
2743					if ( outermost ) {
2744						dirruns = dirrunsUnique;
2745						cachedruns = ++matcherCachedRuns;
2746					}
2747				}
2748
2749				// Track unmatched elements for set filters
2750				if ( bySet ) {
2751					// They will have gone through all possible matchers
2752					if ( (elem = !matcher && elem) ) {
2753						matchedCount--;
2754					}
2755
2756					// Lengthen the array for every element, matched or not
2757					if ( seed ) {
2758						unmatched.push( elem );
2759					}
2760				}
2761			}
2762
2763			// Apply set filters to unmatched elements
2764			matchedCount += i;
2765			if ( bySet && i !== matchedCount ) {
2766				j = 0;
2767				while ( (matcher = setMatchers[j++]) ) {
2768					matcher( unmatched, setMatched, context, xml );
2769				}
2770
2771				if ( seed ) {
2772					// Reintegrate element matches to eliminate the need for sorting
2773					if ( matchedCount > 0 ) {
2774						while ( i-- ) {
2775							if ( !(unmatched[i] || setMatched[i]) ) {
2776								setMatched[i] = pop.call( results );
2777							}
2778						}
2779					}
2780
2781					// Discard index placeholder values to get only actual matches
2782					setMatched = condense( setMatched );
2783				}
2784
2785				// Add matches to results
2786				push.apply( results, setMatched );
2787
2788				// Seedless set matches succeeding multiple successful matchers stipulate sorting
2789				if ( outermost && !seed && setMatched.length > 0 &&
2790					( matchedCount + setMatchers.length ) > 1 ) {
2791
2792					Sizzle.uniqueSort( results );
2793				}
2794			}
2795
2796			// Override manipulation of globals by nested matchers
2797			if ( outermost ) {
2798				dirruns = dirrunsUnique;
2799				outermostContext = contextBackup;
2800			}
2801
2802			return unmatched;
2803		};
2804
2805	return bySet ?
2806		markFunction( superMatcher ) :
2807		superMatcher;
2808}
2809
2810compile = Sizzle.compile = function( selector, group /* Internal Use Only */ ) {
2811	var i,
2812		setMatchers = [],
2813		elementMatchers = [],
2814		cached = compilerCache[ selector + " " ];
2815
2816	if ( !cached ) {
2817		// Generate a function of recursive functions that can be used to check each element
2818		if ( !group ) {
2819			group = tokenize( selector );
2820		}
2821		i = group.length;
2822		while ( i-- ) {
2823			cached = matcherFromTokens( group[i] );
2824			if ( cached[ expando ] ) {
2825				setMatchers.push( cached );
2826			} else {
2827				elementMatchers.push( cached );
2828			}
2829		}
2830
2831		// Cache the compiled function
2832		cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );
2833	}
2834	return cached;
2835};
2836
2837function multipleContexts( selector, contexts, results ) {
2838	var i = 0,
2839		len = contexts.length;
2840	for ( ; i < len; i++ ) {
2841		Sizzle( selector, contexts[i], results );
2842	}
2843	return results;
2844}
2845
2846function select( selector, context, results, seed ) {
2847	var i, tokens, token, type, find,
2848		match = tokenize( selector );
2849
2850	if ( !seed ) {
2851		// Try to minimize operations if there is only one group
2852		if ( match.length === 1 ) {
2853
2854			// Take a shortcut and set the context if the root selector is an ID
2855			tokens = match[0] = match[0].slice( 0 );
2856			if ( tokens.length > 2 && (token = tokens[0]).type === "ID" &&
2857					support.getById && context.nodeType === 9 && documentIsHTML &&
2858					Expr.relative[ tokens[1].type ] ) {
2859
2860				context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0];
2861				if ( !context ) {
2862					return results;
2863				}
2864				selector = selector.slice( tokens.shift().value.length );
2865			}
2866
2867			// Fetch a seed set for right-to-left matching
2868			i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length;
2869			while ( i-- ) {
2870				token = tokens[i];
2871
2872				// Abort if we hit a combinator
2873				if ( Expr.relative[ (type = token.type) ] ) {
2874					break;
2875				}
2876				if ( (find = Expr.find[ type ]) ) {
2877					// Search, expanding context for leading sibling combinators
2878					if ( (seed = find(
2879						token.matches[0].replace( runescape, funescape ),
2880						rsibling.test( tokens[0].type ) && context.parentNode || context
2881					)) ) {
2882
2883						// If seed is empty or no tokens remain, we can return early
2884						tokens.splice( i, 1 );
2885						selector = seed.length && toSelector( tokens );
2886						if ( !selector ) {
2887							push.apply( results, seed );
2888							return results;
2889						}
2890
2891						break;
2892					}
2893				}
2894			}
2895		}
2896	}
2897
2898	// Compile and execute a filtering function
2899	// Provide `match` to avoid retokenization if we modified the selector above
2900	compile( selector, match )(
2901		seed,
2902		context,
2903		!documentIsHTML,
2904		results,
2905		rsibling.test( selector )
2906	);
2907	return results;
2908}
2909
2910// One-time assignments
2911
2912// Sort stability
2913support.sortStable = expando.split("").sort( sortOrder ).join("") === expando;
2914
2915// Support: Chrome<14
2916// Always assume duplicates if they aren't passed to the comparison function
2917support.detectDuplicates = hasDuplicate;
2918
2919// Initialize against the default document
2920setDocument();
2921
2922// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
2923// Detached nodes confoundingly follow *each other*
2924support.sortDetached = assert(function( div1 ) {
2925	// Should return 1, but returns 4 (following)
2926	return div1.compareDocumentPosition( document.createElement("div") ) & 1;
2927});
2928
2929// Support: IE<8
2930// Prevent attribute/property "interpolation"
2931// http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
2932if ( !assert(function( div ) {
2933	div.innerHTML = "<a href='#'></a>";
2934	return div.firstChild.getAttribute("href") === "#" ;
2935}) ) {
2936	addHandle( "type|href|height|width", function( elem, name, isXML ) {
2937		if ( !isXML ) {
2938			return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 );
2939		}
2940	});
2941}
2942
2943// Support: IE<9
2944// Use defaultValue in place of getAttribute("value")
2945if ( !support.attributes || !assert(function( div ) {
2946	div.innerHTML = "<input/>";
2947	div.firstChild.setAttribute( "value", "" );
2948	return div.firstChild.getAttribute( "value" ) === "";
2949}) ) {
2950	addHandle( "value", function( elem, name, isXML ) {
2951		if ( !isXML && elem.nodeName.toLowerCase() === "input" ) {
2952			return elem.defaultValue;
2953		}
2954	});
2955}
2956
2957// Support: IE<9
2958// Use getAttributeNode to fetch booleans when getAttribute lies
2959if ( !assert(function( div ) {
2960	return div.getAttribute("disabled") == null;
2961}) ) {
2962	addHandle( booleans, function( elem, name, isXML ) {
2963		var val;
2964		if ( !isXML ) {
2965			return (val = elem.getAttributeNode( name )) && val.specified ?
2966				val.value :
2967				elem[ name ] === true ? name.toLowerCase() : null;
2968		}
2969	});
2970}
2971
2972jQuery.find = Sizzle;
2973jQuery.expr = Sizzle.selectors;
2974jQuery.expr[":"] = jQuery.expr.pseudos;
2975jQuery.unique = Sizzle.uniqueSort;
2976jQuery.text = Sizzle.getText;
2977jQuery.isXMLDoc = Sizzle.isXML;
2978jQuery.contains = Sizzle.contains;
2979
2980
2981})( window );
2982// String to Object options format cache
2983var optionsCache = {};
2984
2985// Convert String-formatted options into Object-formatted ones and store in cache
2986function createOptions( options ) {
2987	var object = optionsCache[ options ] = {};
2988	jQuery.each( options.match( core_rnotwhite ) || [], function( _, flag ) {
2989		object[ flag ] = true;
2990	});
2991	return object;
2992}
2993
2994/*
2995 * Create a callback list using the following parameters:
2996 *
2997 *	options: an optional list of space-separated options that will change how
2998 *			the callback list behaves or a more traditional option object
2999 *
3000 * By default a callback list will act like an event callback list and can be
3001 * "fired" multiple times.
3002 *
3003 * Possible options:
3004 *
3005 *	once:			will ensure the callback list can only be fired once (like a Deferred)
3006 *
3007 *	memory:			will keep track of previous values and will call any callback added
3008 *					after the list has been fired right away with the latest "memorized"
3009 *					values (like a Deferred)
3010 *
3011 *	unique:			will ensure a callback can only be added once (no duplicate in the list)
3012 *
3013 *	stopOnFalse:	interrupt callings when a callback returns false
3014 *
3015 */
3016jQuery.Callbacks = function( options ) {
3017
3018	// Convert options from String-formatted to Object-formatted if needed
3019	// (we check in cache first)
3020	options = typeof options === "string" ?
3021		( optionsCache[ options ] || createOptions( options ) ) :
3022		jQuery.extend( {}, options );
3023
3024	var // Flag to know if list is currently firing
3025		firing,
3026		// Last fire value (for non-forgettable lists)
3027		memory,
3028		// Flag to know if list was already fired
3029		fired,
3030		// End of the loop when firing
3031		firingLength,
3032		// Index of currently firing callback (modified by remove if needed)
3033		firingIndex,
3034		// First callback to fire (used internally by add and fireWith)
3035		firingStart,
3036		// Actual callback list
3037		list = [],
3038		// Stack of fire calls for repeatable lists
3039		stack = !options.once && [],
3040		// Fire callbacks
3041		fire = function( data ) {
3042			memory = options.memory && data;
3043			fired = true;
3044			firingIndex = firingStart || 0;
3045			firingStart = 0;
3046			firingLength = list.length;
3047			firing = true;
3048			for ( ; list && firingIndex < firingLength; firingIndex++ ) {
3049				if ( list[ firingIndex ].apply( data[ 0 ], data[ 1 ] ) === false && options.stopOnFalse ) {
3050					memory = false; // To prevent further calls using add
3051					break;
3052				}
3053			}
3054			firing = false;
3055			if ( list ) {
3056				if ( stack ) {
3057					if ( stack.length ) {
3058						fire( stack.shift() );
3059					}
3060				} else if ( memory ) {
3061					list = [];
3062				} else {
3063					self.disable();
3064				}
3065			}
3066		},
3067		// Actual Callbacks object
3068		self = {
3069			// Add a callback or a collection of callbacks to the list
3070			add: function() {
3071				if ( list ) {
3072					// First, we save the current length
3073					var start = list.length;
3074					(function add( args ) {
3075						jQuery.each( args, function( _, arg ) {
3076							var type = jQuery.type( arg );
3077							if ( type === "function" ) {
3078								if ( !options.unique || !self.has( arg ) ) {
3079									list.push( arg );
3080								}
3081							} else if ( arg && arg.length && type !== "string" ) {
3082								// Inspect recursively
3083								add( arg );
3084							}
3085						});
3086					})( arguments );
3087					// Do we need to add the callbacks to the
3088					// current firing batch?
3089					if ( firing ) {
3090						firingLength = list.length;
3091					// With memory, if we're not firing then
3092					// we should call right away
3093					} else if ( memory ) {
3094						firingStart = start;
3095						fire( memory );
3096					}
3097				}
3098				return this;
3099			},
3100			// Remove a callback from the list
3101			remove: function() {
3102				if ( list ) {
3103					jQuery.each( arguments, function( _, arg ) {
3104						var index;
3105						while( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
3106							list.splice( index, 1 );
3107							// Handle firing indexes
3108							if ( firing ) {
3109								if ( index <= firingLength ) {
3110									firingLength--;
3111								}
3112								if ( index <= firingIndex ) {
3113									firingIndex--;
3114								}
3115							}
3116						}
3117					});
3118				}
3119				return this;
3120			},
3121			// Check if a given callback is in the list.
3122			// If no argument is given, return whether or not list has callbacks attached.
3123			has: function( fn ) {
3124				return fn ? jQuery.inArray( fn, list ) > -1 : !!( list && list.length );
3125			},
3126			// Remove all callbacks from the list
3127			empty: function() {
3128				list = [];
3129				firingLength = 0;
3130				return this;
3131			},
3132			// Have the list do nothing anymore
3133			disable: function() {
3134				list = stack = memory = undefined;
3135				return this;
3136			},
3137			// Is it disabled?
3138			disabled: function() {
3139				return !list;
3140			},
3141			// Lock the list in its current state
3142			lock: function() {
3143				stack = undefined;
3144				if ( !memory ) {
3145					self.disable();
3146				}
3147				return this;
3148			},
3149			// Is it locked?
3150			locked: function() {
3151				return !stack;
3152			},
3153			// Call all callbacks with the given context and arguments
3154			fireWith: function( context, args ) {
3155				if ( list && ( !fired || stack ) ) {
3156					args = args || [];
3157					args = [ context, args.slice ? args.slice() : args ];
3158					if ( firing ) {
3159						stack.push( args );
3160					} else {
3161						fire( args );
3162					}
3163				}
3164				return this;
3165			},
3166			// Call all the callbacks with the given arguments
3167			fire: function() {
3168				self.fireWith( this, arguments );
3169				return this;
3170			},
3171			// To know if the callbacks have already been called at least once
3172			fired: function() {
3173				return !!fired;
3174			}
3175		};
3176
3177	return self;
3178};
3179jQuery.extend({
3180
3181	Deferred: function( func ) {
3182		var tuples = [
3183				// action, add listener, listener list, final state
3184				[ "resolve", "done", jQuery.Callbacks("once memory"), "resolved" ],
3185				[ "reject", "fail", jQuery.Callbacks("once memory"), "rejected" ],
3186				[ "notify", "progress", jQuery.Callbacks("memory") ]
3187			],
3188			state = "pending",
3189			promise = {
3190				state: function() {
3191					return state;
3192				},
3193				always: function() {
3194					deferred.done( arguments ).fail( arguments );
3195					return this;
3196				},
3197				then: function( /* fnDone, fnFail, fnProgress */ ) {
3198					var fns = arguments;
3199					return jQuery.Deferred(function( newDefer ) {
3200						jQuery.each( tuples, function( i, tuple ) {
3201							var action = tuple[ 0 ],
3202								fn = jQuery.isFunction( fns[ i ] ) && fns[ i ];
3203							// deferred[ done | fail | progress ] for forwarding actions to newDefer
3204							deferred[ tuple[1] ](function() {
3205								var returned = fn && fn.apply( this, arguments );
3206								if ( returned && jQuery.isFunction( returned.promise ) ) {
3207									returned.promise()
3208										.done( newDefer.resolve )
3209										.fail( newDefer.reject )
3210										.progress( newDefer.notify );
3211								} else {
3212									newDefer[ action + "With" ]( this === promise ? newDefer.promise() : this, fn ? [ returned ] : arguments );
3213								}
3214							});
3215						});
3216						fns = null;
3217					}).promise();
3218				},
3219				// Get a promise for this deferred
3220				// If obj is provided, the promise aspect is added to the object
3221				promise: function( obj ) {
3222					return obj != null ? jQuery.extend( obj, promise ) : promise;
3223				}
3224			},
3225			deferred = {};
3226
3227		// Keep pipe for back-compat
3228		promise.pipe = promise.then;
3229
3230		// Add list-specific methods
3231		jQuery.each( tuples, function( i, tuple ) {
3232			var list = tuple[ 2 ],
3233				stateString = tuple[ 3 ];
3234
3235			// promise[ done | fail | progress ] = list.add
3236			promise[ tuple[1] ] = list.add;
3237
3238			// Handle state
3239			if ( stateString ) {
3240				list.add(function() {
3241					// state = [ resolved | rejected ]
3242					state = stateString;
3243
3244				// [ reject_list | resolve_list ].disable; progress_list.lock
3245				}, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock );
3246			}
3247
3248			// deferred[ resolve | reject | notify ]
3249			deferred[ tuple[0] ] = function() {
3250				deferred[ tuple[0] + "With" ]( this === deferred ? promise : this, arguments );
3251				return this;
3252			};
3253			deferred[ tuple[0] + "With" ] = list.fireWith;
3254		});
3255
3256		// Make the deferred a promise
3257		promise.promise( deferred );
3258
3259		// Call given func if any
3260		if ( func ) {
3261			func.call( deferred, deferred );
3262		}
3263
3264		// All done!
3265		return deferred;
3266	},
3267
3268	// Deferred helper
3269	when: function( subordinate /* , ..., subordinateN */ ) {
3270		var i = 0,
3271			resolveValues = core_slice.call( arguments ),
3272			length = resolveValues.length,
3273
3274			// the count of uncompleted subordinates
3275			remaining = length !== 1 || ( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0,
3276
3277			// the master Deferred. If resolveValues consist of only a single Deferred, just use that.
3278			deferred = remaining === 1 ? subordinate : jQuery.Deferred(),
3279
3280			// Update function for both resolve and progress values
3281			updateFunc = function( i, contexts, values ) {
3282				return function( value ) {
3283					contexts[ i ] = this;
3284					values[ i ] = arguments.length > 1 ? core_slice.call( arguments ) : value;
3285					if( values === progressValues ) {
3286						deferred.notifyWith( contexts, values );
3287					} else if ( !( --remaining ) ) {
3288						deferred.resolveWith( contexts, values );
3289					}
3290				};
3291			},
3292
3293			progressValues, progressContexts, resolveContexts;
3294
3295		// add listeners to Deferred subordinates; treat others as resolved
3296		if ( length > 1 ) {
3297			progressValues = new Array( length );
3298			progressContexts = new Array( length );
3299			resolveContexts = new Array( length );
3300			for ( ; i < length; i++ ) {
3301				if ( resolveValues[ i ] && jQuery.isFunction( resolveValues[ i ].promise ) ) {
3302					resolveValues[ i ].promise()
3303						.done( updateFunc( i, resolveContexts, resolveValues ) )
3304						.fail( deferred.reject )
3305						.progress( updateFunc( i, progressContexts, progressValues ) );
3306				} else {
3307					--remaining;
3308				}
3309			}
3310		}
3311
3312		// if we're not waiting on anything, resolve the master
3313		if ( !remaining ) {