https://assets.cgtrader.com/assets/application-2b6b37222f76dfac012…ead54c036dc1ec6f24538ae05aa1e386f522a5fe.js

1/*!
2 * jQuery JavaScript Library v1.11.0
3 * http://jquery.com/
4 *
5 * Includes Sizzle.js
6 * http://sizzlejs.com/
7 *
8 * Copyright 2005, 2014 jQuery Foundation, Inc. and other contributors
9 * Released under the MIT license
10 * http://jquery.org/license
11 *
12 * Date: 2014-01-23T21:02Z
13 */
14
15
16(function( global, factory ) {
17
18	if ( typeof module === "object" && typeof module.exports === "object" ) {
19		// For CommonJS and CommonJS-like environments where a proper window is present,
20		// execute the factory and get jQuery
21		// For environments that do not inherently posses a window with a document
22		// (such as Node.js), expose a jQuery-making factory as module.exports
23		// This accentuates the need for the creation of a real window
24		// e.g. var jQuery = require("jquery")(window);
25		// See ticket #14549 for more info
26		module.exports = global.document ?
27			factory( global, true ) :
28			function( w ) {
29				if ( !w.document ) {
30					throw new Error( "jQuery requires a window with a document" );
31				}
32				return factory( w );
33			};
34	} else {
35		factory( global );
36	}
37
38// Pass this if window is not defined yet
39}(typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
40
41// Can't do this because several apps including ASP.NET trace
42// the stack via arguments.caller.callee and Firefox dies if
43// you try to trace through "use strict" call chains. (#13335)
44// Support: Firefox 18+
45//
46
47var deletedIds = [];
48
49var slice = deletedIds.slice;
50
51var concat = deletedIds.concat;
52
53var push = deletedIds.push;
54
55var indexOf = deletedIds.indexOf;
56
57var class2type = {};
58
59var toString = class2type.toString;
60
61var hasOwn = class2type.hasOwnProperty;
62
63var trim = "".trim;
64
65var support = {};
66
67
68
69var
70	version = "1.11.0",
71
72	// Define a local copy of jQuery
73	jQuery = function( selector, context ) {
74		// The jQuery object is actually just the init constructor 'enhanced'
75		// Need init if jQuery is called (just allow error to be thrown if not included)
76		return new jQuery.fn.init( selector, context );
77	},
78
79	// Make sure we trim BOM and NBSP (here's looking at you, Safari 5.0 and IE)
80	rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
81
82	// Matches dashed string for camelizing
83	rmsPrefix = /^-ms-/,
84	rdashAlpha = /-([\da-z])/gi,
85
86	// Used by jQuery.camelCase as callback to replace()
87	fcamelCase = function( all, letter ) {
88		return letter.toUpperCase();
89	};
90
91jQuery.fn = jQuery.prototype = {
92	// The current version of jQuery being used
93	jquery: version,
94
95	constructor: jQuery,
96
97	// Start with an empty selector
98	selector: "",
99
100	// The default length of a jQuery object is 0
101	length: 0,
102
103	toArray: function() {
104		return slice.call( this );
105	},
106
107	// Get the Nth element in the matched element set OR
108	// Get the whole matched element set as a clean array
109	get: function( num ) {
110		return num != null ?
111
112			// Return a 'clean' array
113			( num < 0 ? this[ num + this.length ] : this[ num ] ) :
114
115			// Return just the object
116			slice.call( this );
117	},
118
119	// Take an array of elements and push it onto the stack
120	// (returning the new matched element set)
121	pushStack: function( elems ) {
122
123		// Build a new jQuery matched element set
124		var ret = jQuery.merge( this.constructor(), elems );
125
126		// Add the old object onto the stack (as a reference)
127		ret.prevObject = this;
128		ret.context = this.context;
129
130		// Return the newly-formed element set
131		return ret;
132	},
133
134	// Execute a callback for every element in the matched set.
135	// (You can seed the arguments with an array of args, but this is
136	// only used internally.)
137	each: function( callback, args ) {
138		return jQuery.each( this, callback, args );
139	},
140
141	map: function( callback ) {
142		return this.pushStack( jQuery.map(this, function( elem, i ) {
143			return callback.call( elem, i, elem );
144		}));
145	},
146
147	slice: function() {
148		return this.pushStack( slice.apply( this, arguments ) );
149	},
150
151	first: function() {
152		return this.eq( 0 );
153	},
154
155	last: function() {
156		return this.eq( -1 );
157	},
158
159	eq: function( i ) {
160		var len = this.length,
161			j = +i + ( i < 0 ? len : 0 );
162		return this.pushStack( j >= 0 && j < len ? [ this[j] ] : [] );
163	},
164
165	end: function() {
166		return this.prevObject || this.constructor(null);
167	},
168
169	// For internal use only.
170	// Behaves like an Array's method, not like a jQuery method.
171	push: push,
172	sort: deletedIds.sort,
173	splice: deletedIds.splice
174};
175
176jQuery.extend = jQuery.fn.extend = function() {
177	var src, copyIsArray, copy, name, options, clone,
178		target = arguments[0] || {},
179		i = 1,
180		length = arguments.length,
181		deep = false;

860				newContext = rsibling.test( selector ) && testContext( context.parentNode ) || context;
861				newSelector = groups.join(",");
862			}
863
864			if ( newSelector ) {
865				try {
866					push.apply( results,
867						newContext.querySelectorAll( newSelector )
868					);
869					return results;
870				} catch(qsaError) {
871				} finally {
872					if ( !old ) {
873						context.removeAttribute("id");
874					}
875				}
876			}
877		}
878	}
879
880	// All others
881	return select( selector.replace( rtrim, "$1" ), context, results, seed );
882}
883
884/**
885 * Create key-value caches of limited size
886 * @returns {Function(string, Object)} Returns the Object data after storing it on itself with
887 *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
888 *	deleting the oldest entry
889 */
890function createCache() {
891	var keys = [];
892
893	function cache( key, value ) {
894		// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
895		if ( keys.push( key + " " ) > Expr.cacheLength ) {
896			// Only keep the most recent entries
897			delete cache[ keys.shift() ];
898		}
899		return (cache[ key + " " ] = value);
900	}
901	return cache;
902}
903
904/**
905 * Mark a function for special use by Sizzle
906 * @param {Function} fn The function to mark
907 */
908function markFunction( fn ) {
909	fn[ expando ] = true;
910	return fn;
911}
912
913/**
914 * Support testing using an element
915 * @param {Function} fn Passed the created div and expects a boolean result
916 */
917function assert( fn ) {
918	var div = document.createElement("div");
919
920	try {
921		return !!fn( div );
922	} catch (e) {
923		return false;
924	} finally {
925		// Remove from its parent by default
926		if ( div.parentNode ) {
927			div.parentNode.removeChild( div );
928		}
929		// release memory in IE
930		div = null;
931	}
932}
933
934/**
935 * Adds the same handler for all of the specified attrs
936 * @param {String} attrs Pipe-separated list of attributes
937 * @param {Function} handler The method that will be applied
938 */
939function addHandle( attrs, handler ) {
940	var arr = attrs.split("|"),
941		i = attrs.length;
942
943	while ( i-- ) {
944		Expr.attrHandle[ arr[i] ] = handler;
945	}
946}
947
948/**
949 * Checks document order of two siblings
950 * @param {Element} a
951 * @param {Element} b
952 * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
953 */
954function siblingCheck( a, b ) {
955	var cur = b && a,
956		diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
957			( ~b.sourceIndex || MAX_NEGATIVE ) -
958			( ~a.sourceIndex || MAX_NEGATIVE );
959
960	// Use IE sourceIndex if available on both nodes
961	if ( diff ) {
962		return diff;
963	}
964
965	// Check if b follows a
966	if ( cur ) {
967		while ( (cur = cur.nextSibling) ) {
968			if ( cur === b ) {
969				return -1;
970			}
971		}
972	}
973
974	return a ? 1 : -1;
975}
976
977/**
978 * Returns a function to use in pseudos for input types
979 * @param {String} type
980 */
981function createInputPseudo( type ) {
982	return function( elem ) {
983		var name = elem.nodeName.toLowerCase();
984		return name === "input" && elem.type === type;
985	};
986}
987
988/**
989 * Returns a function to use in pseudos for buttons
990 * @param {String} type
991 */
992function createButtonPseudo( type ) {
993	return function( elem ) {
994		var name = elem.nodeName.toLowerCase();
995		return (name === "input" || name === "button") && elem.type === type;
996	};
997}
998
999/**
1000 * Returns a function to use in pseudos for positionals
1001 * @param {Function} fn
1002 */
1003function createPositionalPseudo( fn ) {
1004	return markFunction(function( argument ) {
1005		argument = +argument;
1006		return markFunction(function( seed, matches ) {
1007			var j,
1008				matchIndexes = fn( [], seed.length, argument ),
1009				i = matchIndexes.length;
1010
1011			// Match elements found at the specified indexes
1012			while ( i-- ) {
1013				if ( seed[ (j = matchIndexes[i]) ] ) {
1014					seed[j] = !(matches[j] = seed[j]);
1015				}
1016			}
1017		});
1018	});
1019}
1020
1021/**
1022 * Checks a node for validity as a Sizzle context
1023 * @param {Element|Object=} context
1024 * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
1025 */
1026function testContext( context ) {
1027	return context && typeof context.getElementsByTagName !== strundefined && context;
1028}
1029
1030// Expose support vars for convenience
1031support = Sizzle.support = {};
1032
1033/**
1034 * Detects XML nodes
1035 * @param {Element|Object} elem An element or a document
1036 * @returns {Boolean} True iff elem is a non-HTML XML node
1037 */
1038isXML = Sizzle.isXML = function( elem ) {
1039	// documentElement is verified for cases where it doesn't yet exist
1040	// (such as loading iframes in IE - #4833)
1041	var documentElement = elem && (elem.ownerDocument || elem).documentElement;
1042	return documentElement ? documentElement.nodeName !== "HTML" : false;

1141		// Support: IE6/7
1142		// getElementById is not reliable as a find shortcut
1143		delete Expr.find["ID"];
1144
1145		Expr.filter["ID"] =  function( id ) {
1146			var attrId = id.replace( runescape, funescape );
1147			return function( elem ) {
1148				var node = typeof elem.getAttributeNode !== strundefined && elem.getAttributeNode("id");
1149				return node && node.value === attrId;
1150			};
1151		};
1152	}
1153
1154	// Tag
1155	Expr.find["TAG"] = support.getElementsByTagName ?
1156		function( tag, context ) {
1157			if ( typeof context.getElementsByTagName !== strundefined ) {
1158				return context.getElementsByTagName( tag );
1159			}
1160		} :
1161		function( tag, context ) {
1162			var elem,
1163				tmp = [],
1164				i = 0,
1165				results = context.getElementsByTagName( tag );
1166
1167			// Filter out possible comments
1168			if ( tag === "*" ) {
1169				while ( (elem = results[i++]) ) {
1170					if ( elem.nodeType === 1 ) {
1171						tmp.push( elem );
1172					}
1173				}
1174
1175				return tmp;
1176			}
1177			return results;
1178		};
1179
1180	// Class
1181	Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) {
1182		if ( typeof context.getElementsByClassName !== strundefined && documentIsHTML ) {
1183			return context.getElementsByClassName( className );
1184		}
1185	};
1186
1187	/* QSA/matchesSelector
1188	---------------------------------------------------------------------- */
1189
1190	// QSA and matchesSelector support
1191
1192	// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
1193	rbuggyMatches = [];
1194
1195	// qSa(:focus) reports false when true (Chrome 21)
1196	// We allow this because of a bug in IE8/9 that throws an error
1197	// whenever `document.activeElement` is accessed on an iframe
1198	// So, we allow :focus to pass through QSA all the time to avoid the IE error
1199	// See http://bugs.jquery.com/ticket/13378
1200	rbuggyQSA = [];
1201
1202	if ( (support.qsa = rnative.test( doc.querySelectorAll )) ) {
1203		// Build QSA regex
1204		// Regex strategy adopted from Diego Perini
1205		assert(function( div ) {
1206			// Select is set to empty string on purpose
1207			// This is to test IE's treatment of not explicitly
1208			// setting a boolean content attribute,
1209			// since its presence should be enough
1210			// http://bugs.jquery.com/ticket/12359
1211			div.innerHTML = "<select t=''><option selected=''></option></select>";
1212
1213			// Support: IE8, Opera 10-12
1214			// Nothing should be selected when empty strings follow ^= or $= or *=
1215			if ( div.querySelectorAll("[t^='']").length ) {
1216				rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
1217			}
1218
1219			// Support: IE8
1220			// Boolean attributes and "value" are not treated correctly
1221			if ( !div.querySelectorAll("[selected]").length ) {
1222				rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
1223			}
1224
1225			// Webkit/Opera - :checked should return selected option elements
1226			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
1227			// IE8 throws error here and will not see later tests
1228			if ( !div.querySelectorAll(":checked").length ) {
1229				rbuggyQSA.push(":checked");
1230			}
1231		});
1232
1233		assert(function( div ) {
1234			// Support: Windows 8 Native Apps
1235			// The type and name attributes are restricted during .innerHTML assignment
1236			var input = doc.createElement("input");
1237			input.setAttribute( "type", "hidden" );
1238			div.appendChild( input ).setAttribute( "name", "D" );
1239
1240			// Support: IE8
1241			// Enforce case-sensitivity of name attribute
1242			if ( div.querySelectorAll("[name=d]").length ) {
1243				rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );
1244			}
1245
1246			// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
1247			// IE8 throws error here and will not see later tests
1248			if ( !div.querySelectorAll(":enabled").length ) {
1249				rbuggyQSA.push( ":enabled", ":disabled" );
1250			}
1251
1252			// Opera 10-11 does not throw on post-comma invalid pseudos
1253			div.querySelectorAll("*,:x");
1254			rbuggyQSA.push(",.*:");
1255		});
1256	}
1257
1258	if ( (support.matchesSelector = rnative.test( (matches = docElem.webkitMatchesSelector ||
1259		docElem.mozMatchesSelector ||
1260		docElem.oMatchesSelector ||
1261		docElem.msMatchesSelector) )) ) {
1262
1263		assert(function( div ) {
1264			// Check to see if it's possible to do matchesSelector
1265			// on a disconnected node (IE 9)
1266			support.disconnectedMatch = matches.call( div, "div" );
1267
1268			// This should fail with an exception
1269			// Gecko does not error, returns false instead
1270			matches.call( div, "[s!='']:x" );
1271			rbuggyMatches.push( "!=", pseudos );
1272		});
1273	}
1274
1275	rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") );
1276	rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") );
1277
1278	/* Contains
1279	---------------------------------------------------------------------- */
1280	hasCompare = rnative.test( docElem.compareDocumentPosition );
1281
1282	// Element contains another
1283	// Purposefully does not implement inclusive descendent
1284	// As in, an element does not contain itself
1285	contains = hasCompare || rnative.test( docElem.contains ) ?
1286		function( a, b ) {
1287			var adown = a.nodeType === 9 ? a.documentElement : a,
1288				bup = b && b.parentNode;
1289			return a === bup || !!( bup && bup.nodeType === 1 && (
1290				adown.contains ?
1291					adown.contains( bup ) :
1292					a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
1293			));
1294		} :
1295		function( a, b ) {
1296			if ( b ) {
1297				while ( (b = b.parentNode) ) {
1298					if ( b === a ) {
1299						return true;
1300					}
1301				}
1302			}
1303			return false;
1304		};
1305
1306	/* Sorting
1307	---------------------------------------------------------------------- */
1308
1309	// Document order sorting
1310	sortOrder = hasCompare ?
1311	function( a, b ) {
1312
1313		// Flag for duplicate removal
1314		if ( a === b ) {
1315			hasDuplicate = true;
1316			return 0;
1317		}
1318
1319		// Sort on method existence if only one input has compareDocumentPosition
1320		var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
1321		if ( compare ) {
1322			return compare;
1323		}
1324
1325		// Calculate position if both inputs belong to the same document
1326		compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?
1327			a.compareDocumentPosition( b ) :
1328
1329			// Otherwise we know they are disconnected
1330			1;
1331
1332		// Disconnected nodes
1333		if ( compare & 1 ||
1334			(!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {
1335
1336			// Choose the first element that is related to our preferred document
1337			if ( a === doc || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) {
1338				return -1;
1339			}
1340			if ( b === doc || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) {
1341				return 1;
1342			}
1343
1344			// Maintain original order
1345			return sortInput ?
1346				( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) :
1347				0;
1348		}
1349
1350		return compare & 4 ? -1 : 1;
1351	} :
1352	function( a, b ) {
1353		// Exit early if the nodes are identical
1354		if ( a === b ) {
1355			hasDuplicate = true;
1356			return 0;
1357		}
1358
1359		var cur,
1360			i = 0,
1361			aup = a.parentNode,
1362			bup = b.parentNode,
1363			ap = [ a ],
1364			bp = [ b ];
1365
1366		// Parentless nodes are either documents or disconnected
1367		if ( !aup || !bup ) {
1368			return a === doc ? -1 :
1369				b === doc ? 1 :
1370				aup ? -1 :
1371				bup ? 1 :
1372				sortInput ?
1373				( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) :
1374				0;
1375
1376		// If the nodes are siblings, we can do a quick check
1377		} else if ( aup === bup ) {
1378			return siblingCheck( a, b );
1379		}
1380
1381		// Otherwise we need full lists of their ancestors for comparison
1382		cur = a;
1383		while ( (cur = cur.parentNode) ) {
1384			ap.unshift( cur );
1385		}
1386		cur = b;
1387		while ( (cur = cur.parentNode) ) {
1388			bp.unshift( cur );
1389		}
1390
1391		// Walk down the tree looking for a discrepancy
1392		while ( ap[i] === bp[i] ) {
1393			i++;
1394		}
1395
1396		return i ?
1397			// Do a sibling check if the nodes have a common ancestor
1398			siblingCheck( ap[i], bp[i] ) :
1399
1400			// Otherwise nodes in our document sort first
1401			ap[i] === preferredDoc ? -1 :
1402			bp[i] === preferredDoc ? 1 :
1403			0;
1404	};
1405
1406	return doc;
1407};
1408
1409Sizzle.matches = function( expr, elements ) {
1410	return Sizzle( expr, null, null, elements );
1411};
1412
1413Sizzle.matchesSelector = function( elem, expr ) {
1414	// Set document vars if needed
1415	if ( ( elem.ownerDocument || elem ) !== document ) {
1416		setDocument( elem );
1417	}
1418
1419	// Make sure that attribute selectors are quoted
1420	expr = expr.replace( rattributeQuotes, "='$1']" );
1421
1422	if ( support.matchesSelector && documentIsHTML &&
1423		( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
1424		( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {
1425
1426		try {
1427			var ret = matches.call( elem, expr );
1428
1429			// IE 9's matchesSelector returns false on disconnected nodes
1430			if ( ret || support.disconnectedMatch ||
1431					// As well, disconnected nodes are said to be in a document
1432					// fragment in IE 9
1433					elem.document && elem.document.nodeType !== 11 ) {
1434				return ret;
1435			}
1436		} catch(e) {}
1437	}
1438
1439	return Sizzle( expr, document, null, [elem] ).length > 0;
1440};
1441
1442Sizzle.contains = function( context, elem ) {
1443	// Set document vars if needed
1444	if ( ( context.ownerDocument || context ) !== document ) {
1445		setDocument( context );
1446	}
1447	return contains( context, elem );
1448};
1449
1450Sizzle.attr = function( elem, name ) {
1451	// Set document vars if needed
1452	if ( ( elem.ownerDocument || elem ) !== document ) {
1453		setDocument( elem );
1454	}
1455
1456	var fn = Expr.attrHandle[ name.toLowerCase() ],
1457		// Don't get fooled by Object.prototype properties (jQuery #13807)
1458		val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
1459			fn( elem, name, !documentIsHTML ) :
1460			undefined;
1461
1462	return val !== undefined ?
1463		val :
1464		support.attributes || !documentIsHTML ?
1465			elem.getAttribute( name ) :
1466			(val = elem.getAttributeNode(name)) && val.specified ?
1467				val.value :
1468				null;
1469};
1470
1471Sizzle.error = function( msg ) {
1472	throw new Error( "Syntax error, unrecognized expression: " + msg );
1473};
1474
1475/**
1476 * Document sorting and removing duplicates
1477 * @param {ArrayLike} results
1478 */
1479Sizzle.uniqueSort = function( results ) {
1480	var elem,
1481		duplicates = [],
1482		j = 0,
1483		i = 0;
1484
1485	// Unless we *know* we can detect duplicates, assume their presence
1486	hasDuplicate = !support.detectDuplicates;
1487	sortInput = !support.sortStable && results.slice( 0 );
1488	results.sort( sortOrder );
1489
1490	if ( hasDuplicate ) {
1491		while ( (elem = results[i++]) ) {
1492			if ( elem === results[ i ] ) {
1493				j = duplicates.push( i );
1494			}
1495		}
1496		while ( j-- ) {
1497			results.splice( duplicates[ j ], 1 );
1498		}
1499	}
1500
1501	// Clear input after sorting to release objects
1502	// See https://github.com/jquery/sizzle/pull/225
1503	sortInput = null;
1504
1505	return results;
1506};
1507
1508/**
1509 * Utility function for retrieving the text value of an array of DOM nodes
1510 * @param {Array|Element} elem
1511 */
1512getText = Sizzle.getText = function( elem ) {
1513	var node,
1514		ret = "",
1515		i = 0,
1516		nodeType = elem.nodeType;
1517
1518	if ( !nodeType ) {
1519		// If no nodeType, this is expected to be an array
1520		while ( (node = elem[i++]) ) {
1521			// Do not traverse comment nodes
1522			ret += getText( node );
1523		}
1524	} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
1525		// Use textContent for elements
1526		// innerText usage removed for consistency of new lines (jQuery #11153)
1527		if ( typeof elem.textContent === "string" ) {
1528			return elem.textContent;
1529		} else {
1530			// Traverse its children
1531			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
1532				ret += getText( elem );
1533			}
1534		}
1535	} else if ( nodeType === 3 || nodeType === 4 ) {
1536		return elem.nodeValue;
1537	}
1538	// Do not include comment or processing instruction nodes
1539
1540	return ret;
1541};
1542
1543Expr = Sizzle.selectors = {
1544
1545	// Can be adjusted by the user
1546	cacheLength: 50,
1547
1548	createPseudo: markFunction,
1549
1550	match: matchExpr,
1551
1552	attrHandle: {},
1553
1554	find: {},
1555
1556	relative: {
1557		">": { dir: "parentNode", first: true },
1558		" ": { dir: "parentNode" },
1559		"+": { dir: "previousSibling", first: true },
1560		"~": { dir: "previousSibling" }
1561	},
1562
1563	preFilter: {
1564		"ATTR": function( match ) {
1565			match[1] = match[1].replace( runescape, funescape );
1566
1567			// Move the given value to match[3] whether quoted or unquoted
1568			match[3] = ( match[4] || match[5] || "" ).replace( runescape, funescape );
1569
1570			if ( match[2] === "~=" ) {
1571				match[3] = " " + match[3] + " ";
1572			}
1573
1574			return match.slice( 0, 4 );
1575		},
1576
1577		"CHILD": function( match ) {
1578			/* matches from matchExpr["CHILD"]
1579				1 type (only|nth|...)
1580				2 what (child|of-type)
1581				3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
1582				4 xn-component of xn+y argument ([+-]?\d*n|)
1583				5 sign of xn-component
1584				6 x of xn-component
1585				7 sign of y-component
1586				8 y of y-component
1587			*/
1588			match[1] = match[1].toLowerCase();
1589
1590			if ( match[1].slice( 0, 3 ) === "nth" ) {
1591				// nth-* requires argument
1592				if ( !match[3] ) {
1593					Sizzle.error( match[0] );
1594				}
1595
1596				// numeric x and y parameters for Expr.filter.CHILD
1597				// remember that false/true cast respectively to 0/1
1598				match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) );
1599				match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" );
1600
1601			// other types prohibit arguments
1602			} else if ( match[3] ) {
1603				Sizzle.error( match[0] );
1604			}
1605
1606			return match;
1607		},
1608
1609		"PSEUDO": function( match ) {
1610			var excess,
1611				unquoted = !match[5] && match[2];
1612
1613			if ( matchExpr["CHILD"].test( match[0] ) ) {
1614				return null;
1615			}
1616
1617			// Accept quoted arguments as-is
1618			if ( match[3] && match[4] !== undefined ) {
1619				match[2] = match[4];
1620
1621			// Strip excess characters from unquoted arguments
1622			} else if ( unquoted && rpseudo.test( unquoted ) &&
1623				// Get excess from tokenize (recursively)
1624				(excess = tokenize( unquoted, true )) &&
1625				// advance to the next closing parenthesis
1626				(excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) {
1627
1628				// excess is a negative index
1629				match[0] = match[0].slice( 0, excess );
1630				match[2] = unquoted.slice( 0, excess );
1631			}
1632
1633			// Return only captures needed by the pseudo filter method (type and argument)
1634			return match.slice( 0, 3 );
1635		}
1636	},
1637
1638	filter: {
1639
1640		"TAG": function( nodeNameSelector ) {
1641			var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
1642			return nodeNameSelector === "*" ?
1643				function() { return true; } :
1644				function( elem ) {
1645					return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
1646				};
1647		},
1648
1649		"CLASS": function( className ) {
1650			var pattern = classCache[ className + " " ];
1651
1652			return pattern ||
1653				(pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) &&
1654				classCache( className, function( elem ) {
1655					return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== strundefined && elem.getAttribute("class") || "" );
1656				});
1657		},
1658
1659		"ATTR": function( name, operator, check ) {
1660			return function( elem ) {
1661				var result = Sizzle.attr( elem, name );
1662
1663				if ( result == null ) {
1664					return operator === "!=";
1665				}
1666				if ( !operator ) {
1667					return true;
1668				}
1669
1670				result += "";
1671
1672				return operator === "=" ? result === check :
1673					operator === "!=" ? result !== check :
1674					operator === "^=" ? check && result.indexOf( check ) === 0 :
1675					operator === "*=" ? check && result.indexOf( check ) > -1 :
1676					operator === "$=" ? check && result.slice( -check.length ) === check :
1677					operator === "~=" ? ( " " + result + " " ).indexOf( check ) > -1 :
1678					operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
1679					false;
1680			};
1681		},
1682
1683		"CHILD": function( type, what, argument, first, last ) {
1684			var simple = type.slice( 0, 3 ) !== "nth",
1685				forward = type.slice( -4 ) !== "last",
1686				ofType = what === "of-type";
1687
1688			return first === 1 && last === 0 ?
1689
1690				// Shortcut for :nth-*(n)
1691				function( elem ) {
1692					return !!elem.parentNode;
1693				} :
1694
1695				function( elem, context, xml ) {
1696					var cache, outerCache, node, diff, nodeIndex, start,
1697						dir = simple !== forward ? "nextSibling" : "previousSibling",
1698						parent = elem.parentNode,
1699						name = ofType && elem.nodeName.toLowerCase(),
1700						useCache = !xml && !ofType;
1701
1702					if ( parent ) {
1703
1704						// :(first|last|only)-(child|of-type)
1705						if ( simple ) {
1706							while ( dir ) {
1707								node = elem;
1708								while ( (node = node[ dir ]) ) {
1709									if ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) {
1710										return false;
1711									}
1712								}
1713								// Reverse direction for :only-* (if we haven't yet done so)
1714								start = dir = type === "only" && !start && "nextSibling";
1715							}
1716							return true;
1717						}
1718
1719						start = [ forward ? parent.firstChild : parent.lastChild ];
1720
1721						// non-xml :nth-child(...) stores cache data on `parent`
1722						if ( forward && useCache ) {
1723							// Seek `elem` from a previously-cached index
1724							outerCache = parent[ expando ] || (parent[ expando ] = {});
1725							cache = outerCache[ type ] || [];
1726							nodeIndex = cache[0] === dirruns && cache[1];
1727							diff = cache[0] === dirruns && cache[2];
1728							node = nodeIndex && parent.childNodes[ nodeIndex ];
1729
1730							while ( (node = ++nodeIndex && node && node[ dir ] ||
1731
1732								// Fallback to seeking `elem` from the start
1733								(diff = nodeIndex = 0) || start.pop()) ) {
1734
1735								// When found, cache indexes on `parent` and break
1736								if ( node.nodeType === 1 && ++diff && node === elem ) {
1737									outerCache[ type ] = [ dirruns, nodeIndex, diff ];
1738									break;
1739								}
1740							}
1741
1742						// Use previously-cached element index if available
1743						} else if ( useCache && (cache = (elem[ expando ] || (elem[ expando ] = {}))[ type ]) && cache[0] === dirruns ) {
1744							diff = cache[1];
1745
1746						// xml :nth-child(...) or :nth-last-child(...) or :nth(-last)?-of-type(...)
1747						} else {
1748							// Use the same loop as above to seek `elem` from the start
1749							while ( (node = ++nodeIndex && node && node[ dir ] ||
1750								(diff = nodeIndex = 0) || start.pop()) ) {
1751
1752								if ( ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) && ++diff ) {
1753									// Cache the index of each encountered element
1754									if ( useCache ) {
1755										(node[ expando ] || (node[ expando ] = {}))[ type ] = [ dirruns, diff ];
1756									}
1757
1758									if ( node === elem ) {
1759										break;
1760									}
1761								}
1762							}
1763						}
1764
1765						// Incorporate the offset, then check against cycle size
1766						diff -= last;
1767						return diff === first || ( diff % first === 0 && diff / first >= 0 );
1768					}
1769				};
1770		},
1771
1772		"PSEUDO": function( pseudo, argument ) {
1773			// pseudo-class names are case-insensitive
1774			// http://www.w3.org/TR/selectors/#pseudo-classes
1775			// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
1776			// Remember that setFilters inherits from pseudos
1777			var args,
1778				fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
1779					Sizzle.error( "unsupported pseudo: " + pseudo );
1780
1781			// The user may use createPseudo to indicate that
1782			// arguments are needed to create the filter function
1783			// just as Sizzle does
1784			if ( fn[ expando ] ) {
1785				return fn( argument );
1786			}
1787
1788			// But maintain support for old signatures
1789			if ( fn.length > 1 ) {
1790				args = [ pseudo, pseudo, "", argument ];
1791				return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
1792					markFunction(function( seed, matches ) {
1793						var idx,
1794							matched = fn( seed, argument ),
1795							i = matched.length;
1796						while ( i-- ) {
1797							idx = indexOf.call( seed, matched[i] );
1798							seed[ idx ] = !( matches[ idx ] = matched[i] );
1799						}
1800					}) :
1801					function( elem ) {
1802						return fn( elem, 0, args );
1803					};
1804			}
1805
1806			return fn;
1807		}
1808	},
1809
1810	pseudos: {
1811		// Potentially complex pseudos
1812		"not": markFunction(function( selector ) {
1813			// Trim the selector passed to compile
1814			// to avoid treating leading and trailing
1815			// spaces as combinators
1816			var input = [],
1817				results = [],
1818				matcher = compile( selector.replace( rtrim, "$1" ) );
1819
1820			return matcher[ expando ] ?
1821				markFunction(function( seed, matches, context, xml ) {
1822					var elem,
1823						unmatched = matcher( seed, null, xml, [] ),
1824						i = seed.length;
1825
1826					// Match elements unmatched by `matcher`
1827					while ( i-- ) {
1828						if ( (elem = unmatched[i]) ) {
1829							seed[i] = !(matches[i] = elem);
1830						}
1831					}
1832				}) :
1833				function( elem, context, xml ) {
1834					input[0] = elem;
1835					matcher( input, null, xml, results );
1836					return !results.pop();
1837				};
1838		}),
1839
1840		"has": markFunction(function( selector ) {
1841			return function( elem ) {
1842				return Sizzle( selector, elem ).length > 0;
1843			};
1844		}),
1845
1846		"contains": markFunction(function( text ) {
1847			return function( elem ) {
1848				return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1;
1849			};
1850		}),
1851
1852		// "Whether an element is represented by a :lang() selector
1853		// is based solely on the element's language value
1854		// being equal to the identifier C,
1855		// or beginning with the identifier C immediately followed by "-".
1856		// The matching of C against the element's language value is performed case-insensitively.
1857		// The identifier C does not have to be a valid language name."
1858		// http://www.w3.org/TR/selectors/#lang-pseudo
1859		"lang": markFunction( function( lang ) {
1860			// lang value must be a valid identifier
1861			if ( !ridentifier.test(lang || "") ) {
1862				Sizzle.error( "unsupported lang: " + lang );
1863			}
1864			lang = lang.replace( runescape, funescape ).toLowerCase();
1865			return function( elem ) {
1866				var elemLang;
1867				do {
1868					if ( (elemLang = documentIsHTML ?
1869						elem.lang :
1870						elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) {
1871
1872						elemLang = elemLang.toLowerCase();
1873						return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
1874					}
1875				} while ( (elem = elem.parentNode) && elem.nodeType === 1 );
1876				return false;
1877			};
1878		}),
1879
1880		// Miscellaneous
1881		"target": function( elem ) {
1882			var hash = window.location && window.location.hash;
1883			return hash && hash.slice( 1 ) === elem.id;
1884		},
1885
1886		"root": function( elem ) {
1887			return elem === docElem;
1888		},
1889
1890		"focus": function( elem ) {
1891			return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
1892		},
1893
1894		// Boolean properties
1895		"enabled": function( elem ) {
1896			return elem.disabled === false;
1897		},
1898
1899		"disabled": function( elem ) {
1900			return elem.disabled === true;
1901		},
1902
1903		"checked": function( elem ) {
1904			// In CSS3, :checked should return both checked and selected elements
1905			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
1906			var nodeName = elem.nodeName.toLowerCase();
1907			return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);
1908		},
1909
1910		"selected": function( elem ) {
1911			// Accessing this property makes selected-by-default
1912			// options in Safari work properly
1913			if ( elem.parentNode ) {
1914				elem.parentNode.selectedIndex;
1915			}
1916
1917			return elem.selected === true;
1918		},
1919
1920		// Contents
1921		"empty": function( elem ) {
1922			// http://www.w3.org/TR/selectors/#empty-pseudo
1923			// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
1924			//   but not by others (comment: 8; processing instruction: 7; etc.)
1925			// nodeType < 6 works because attributes (2) do not appear as children
1926			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
1927				if ( elem.nodeType < 6 ) {
1928					return false;
1929				}
1930			}
1931			return true;
1932		},
1933
1934		"parent": function( elem ) {
1935			return !Expr.pseudos["empty"]( elem );
1936		},
1937
1938		// Element/input types
1939		"header": function( elem ) {
1940			return rheader.test( elem.nodeName );
1941		},
1942
1943		"input": function( elem ) {
1944			return rinputs.test( elem.nodeName );
1945		},
1946
1947		"button": function( elem ) {
1948			var name = elem.nodeName.toLowerCase();
1949			return name === "input" && elem.type === "button" || name === "button";
1950		},
1951
1952		"text": function( elem ) {
1953			var attr;
1954			return elem.nodeName.toLowerCase() === "input" &&
1955				elem.type === "text" &&
1956
1957				// Support: IE<8
1958				// New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
1959				( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text" );
1960		},
1961
1962		// Position-in-collection
1963		"first": createPositionalPseudo(function() {
1964			return [ 0 ];
1965		}),
1966
1967		"last": createPositionalPseudo(function( matchIndexes, length ) {
1968			return [ length - 1 ];
1969		}),
1970
1971		"eq": createPositionalPseudo(function( matchIndexes, length, argument ) {
1972			return [ argument < 0 ? argument + length : argument ];
1973		}),
1974
1975		"even": createPositionalPseudo(function( matchIndexes, length ) {
1976			var i = 0;
1977			for ( ; i < length; i += 2 ) {
1978				matchIndexes.push( i );
1979			}
1980			return matchIndexes;
1981		}),
1982
1983		"odd": createPositionalPseudo(function( matchIndexes, length ) {
1984			var i = 1;
1985			for ( ; i < length; i += 2 ) {
1986				matchIndexes.push( i );
1987			}
1988			return matchIndexes;
1989		}),
1990
1991		"lt": createPositionalPseudo(function( matchIndexes, length, argument ) {
1992			var i = argument < 0 ? argument + length : argument;
1993			for ( ; --i >= 0; ) {
1994				matchIndexes.push( i );
1995			}
1996			return matchIndexes;
1997		}),
1998
1999		"gt": createPositionalPseudo(function( matchIndexes, length, argument ) {
2000			var i = argument < 0 ? argument + length : argument;
2001			for ( ; ++i < length; ) {
2002				matchIndexes.push( i );
2003			}
2004			return matchIndexes;
2005		})
2006	}
2007};
2008
2009Expr.pseudos["nth"] = Expr.pseudos["eq"];
2010
2011// Add button/input type pseudos
2012for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
2013	Expr.pseudos[ i ] = createInputPseudo( i );
2014}
2015for ( i in { submit: true, reset: true } ) {
2016	Expr.pseudos[ i ] = createButtonPseudo( i );
2017}
2018
2019// Easy API for creating new setFilters
2020function setFilters() {}
2021setFilters.prototype = Expr.filters = Expr.pseudos;
2022Expr.setFilters = new setFilters();
2023
2024function tokenize( selector, parseOnly ) {
2025	var matched, match, tokens, type,
2026		soFar, groups, preFilters,
2027		cached = tokenCache[ selector + " " ];
2028
2029	if ( cached ) {
2030		return parseOnly ? 0 : cached.slice( 0 );
2031	}
2032
2033	soFar = selector;
2034	groups = [];
2035	preFilters = Expr.preFilter;
2036
2037	while ( soFar ) {
2038
2039		// Comma and first run
2040		if ( !matched || (match = rcomma.exec( soFar )) ) {
2041			if ( match ) {
2042				// Don't consume trailing commas as valid
2043				soFar = soFar.slice( match[0].length ) || soFar;
2044			}
2045			groups.push( (tokens = []) );
2046		}
2047
2048		matched = false;
2049
2050		// Combinators
2051		if ( (match = rcombinators.exec( soFar )) ) {
2052			matched = match.shift();
2053			tokens.push({
2054				value: matched,
2055				// Cast descendant combinators to space
2056				type: match[0].replace( rtrim, " " )
2057			});
2058			soFar = soFar.slice( matched.length );
2059		}
2060
2061		// Filters
2062		for ( type in Expr.filter ) {
2063			if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||
2064				(match = preFilters[ type ]( match ))) ) {
2065				matched = match.shift();
2066				tokens.push({
2067					value: matched,
2068					type: type,
2069					matches: match
2070				});
2071				soFar = soFar.slice( matched.length );
2072			}
2073		}
2074
2075		if ( !matched ) {
2076			break;
2077		}
2078	}
2079
2080	// Return the length of the invalid excess
2081	// if we're just parsing
2082	// Otherwise, throw an error or return tokens
2083	return parseOnly ?
2084		soFar.length :
2085		soFar ?
2086			Sizzle.error( selector ) :
2087			// Cache the tokens
2088			tokenCache( selector, groups ).slice( 0 );
2089}
2090
2091function toSelector( tokens ) {
2092	var i = 0,
2093		len = tokens.length,
2094		selector = "";
2095	for ( ; i < len; i++ ) {
2096		selector += tokens[i].value;
2097	}
2098	return selector;
2099}
2100
2101function addCombinator( matcher, combinator, base ) {
2102	var dir = combinator.dir,
2103		checkNonElements = base && dir === "parentNode",
2104		doneName = done++;
2105
2106	return combinator.first ?
2107		// Check against closest ancestor/preceding element
2108		function( elem, context, xml ) {
2109			while ( (elem = elem[ dir ]) ) {
2110				if ( elem.nodeType === 1 || checkNonElements ) {
2111					return matcher( elem, context, xml );
2112				}
2113			}
2114		} :
2115
2116		// Check against all ancestor/preceding elements
2117		function( elem, context, xml ) {
2118			var oldCache, outerCache,
2119				newCache = [ dirruns, doneName ];
2120
2121			// We can't set arbitrary data on XML nodes, so they don't benefit from dir caching
2122			if ( xml ) {
2123				while ( (elem = elem[ dir ]) ) {
2124					if ( elem.nodeType === 1 || checkNonElements ) {
2125						if ( matcher( elem, context, xml ) ) {
2126							return true;
2127						}
2128					}
2129				}
2130			} else {
2131				while ( (elem = elem[ dir ]) ) {
2132					if ( elem.nodeType === 1 || checkNonElements ) {
2133						outerCache = elem[ expando ] || (elem[ expando ] = {});
2134						if ( (oldCache = outerCache[ dir ]) &&
2135							oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {
2136
2137							// Assign to newCache so results back-propagate to previous elements
2138							return (newCache[ 2 ] = oldCache[ 2 ]);
2139						} else {
2140							// Reuse newcache so results back-propagate to previous elements
2141							outerCache[ dir ] = newCache;
2142
2143							// A match means we're done; a fail means we have to keep checking
2144							if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) {
2145								return true;
2146							}
2147						}
2148					}
2149				}
2150			}
2151		};
2152}
2153
2154function elementMatcher( matchers ) {
2155	return matchers.length > 1 ?
2156		function( elem, context, xml ) {
2157			var i = matchers.length;
2158			while ( i-- ) {
2159				if ( !matchers[i]( elem, context, xml ) ) {
2160					return false;
2161				}
2162			}
2163			return true;
2164		} :
2165		matchers[0];
2166}
2167
2168function condense( unmatched, map, filter, context, xml ) {
2169	var elem,
2170		newUnmatched = [],
2171		i = 0,
2172		len = unmatched.length,
2173		mapped = map != null;
2174
2175	for ( ; i < len; i++ ) {
2176		if ( (elem = unmatched[i]) ) {
2177			if ( !filter || filter( elem, context, xml ) ) {
2178				newUnmatched.push( elem );
2179				if ( mapped ) {
2180					map.push( i );
2181				}
2182			}
2183		}
2184	}
2185
2186	return newUnmatched;
2187}
2188
2189function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
2190	if ( postFilter && !postFilter[ expando ] ) {
2191		postFilter = setMatcher( postFilter );
2192	}
2193	if ( postFinder && !postFinder[ expando ] ) {
2194		postFinder = setMatcher( postFinder, postSelector );
2195	}
2196	return markFunction(function( seed, results, context, xml ) {
2197		var temp, i, elem,
2198			preMap = [],
2199			postMap = [],
2200			preexisting = results.length,
2201
2202			// Get initial elements from seed or context
2203			elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ),
2204
2205			// Prefilter to get matcher input, preserving a map for seed-results synchronization
2206			matcherIn = preFilter && ( seed || !selector ) ?
2207				condense( elems, preMap, preFilter, context, xml ) :
2208				elems,
2209
2210			matcherOut = matcher ?
2211				// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
2212				postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
2213
2214					// ...intermediate processing is necessary
2215					[] :
2216
2217					// ...otherwise use results directly
2218					results :
2219				matcherIn;
2220
2221		// Find primary matches
2222		if ( matcher ) {
2223			matcher( matcherIn, matcherOut, context, xml );
2224		}
2225
2226		// Apply postFilter
2227		if ( postFilter ) {
2228			temp = condense( matcherOut, postMap );
2229			postFilter( temp, [], context, xml );
2230
2231			// Un-match failing elements by moving them back to matcherIn
2232			i = temp.length;
2233			while ( i-- ) {
2234				if ( (elem = temp[i]) ) {
2235					matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);
2236				}
2237			}
2238		}
2239
2240		if ( seed ) {
2241			if ( postFinder || preFilter ) {
2242				if ( postFinder ) {
2243					// Get the final matcherOut by condensing this intermediate into postFinder contexts
2244					temp = [];
2245					i = matcherOut.length;
2246					while ( i-- ) {
2247						if ( (elem = matcherOut[i]) ) {
2248							// Restore matcherIn since elem is not yet a final match
2249							temp.push( (matcherIn[i] = elem) );
2250						}
2251					}
2252					postFinder( null, (matcherOut = []), temp, xml );
2253				}
2254
2255				// Move matched elements from seed to results to keep them synchronized
2256				i = matcherOut.length;
2257				while ( i-- ) {
2258					if ( (elem = matcherOut[i]) &&
2259						(temp = postFinder ? indexOf.call( seed, elem ) : preMap[i]) > -1 ) {
2260
2261						seed[temp] = !(results[temp] = elem);
2262					}
2263				}
2264			}
2265
2266		// Add elements to results, through postFinder if defined
2267		} else {
2268			matcherOut = condense(
2269				matcherOut === results ?
2270					matcherOut.splice( preexisting, matcherOut.length ) :
2271					matcherOut
2272			);
2273			if ( postFinder ) {
2274				postFinder( null, results, matcherOut, xml );
2275			} else {
2276				push.apply( results, matcherOut );
2277			}
2278		}
2279	});
2280}
2281
2282function matcherFromTokens( tokens ) {
2283	var checkContext, matcher, j,
2284		len = tokens.length,
2285		leadingRelative = Expr.relative[ tokens[0].type ],
2286		implicitRelative = leadingRelative || Expr.relative[" "],
2287		i = leadingRelative ? 1 : 0,
2288
2289		// The foundational matcher ensures that elements are reachable from top-level context(s)
2290		matchContext = addCombinator( function( elem ) {
2291			return elem === checkContext;
2292		}, implicitRelative, true ),
2293		matchAnyContext = addCombinator( function( elem ) {
2294			return indexOf.call( checkContext, elem ) > -1;
2295		}, implicitRelative, true ),
2296		matchers = [ function( elem, context, xml ) {
2297			return ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
2298				(checkContext = context).nodeType ?
2299					matchContext( elem, context, xml ) :
2300					matchAnyContext( elem, context, xml ) );
2301		} ];
2302
2303	for ( ; i < len; i++ ) {
2304		if ( (matcher = Expr.relative[ tokens[i].type ]) ) {
2305			matchers = [ addCombinator(elementMatcher( matchers ), matcher) ];
2306		} else {
2307			matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );
2308
2309			// Return special upon seeing a positional matcher
2310			if ( matcher[ expando ] ) {
2311				// Find the next relative operator (if any) for proper handling
2312				j = ++i;
2313				for ( ; j < len; j++ ) {
2314					if ( Expr.relative[ tokens[j].type ] ) {
2315						break;
2316					}
2317				}
2318				return setMatcher(
2319					i > 1 && elementMatcher( matchers ),
2320					i > 1 && toSelector(
2321						// If the preceding token was a descendant combinator, insert an implicit any-element `*`
2322						tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" })
2323					).replace( rtrim, "$1" ),
2324					matcher,
2325					i < j && matcherFromTokens( tokens.slice( i, j ) ),
2326					j < len && matcherFromTokens( (tokens = tokens.slice( j )) ),
2327					j < len && toSelector( tokens )
2328				);
2329			}
2330			matchers.push( matcher );
2331		}
2332	}
2333
2334	return elementMatcher( matchers );
2335}
2336
2337function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
2338	var bySet = setMatchers.length > 0,
2339		byElement = elementMatchers.length > 0,
2340		superMatcher = function( seed, context, xml, results, outermost ) {
2341			var elem, j, matcher,
2342				matchedCount = 0,
2343				i = "0",
2344				unmatched = seed && [],
2345				setMatched = [],
2346				contextBackup = outermostContext,
2347				// We must always have either seed elements or outermost context
2348				elems = seed || byElement && Expr.find["TAG"]( "*", outermost ),
2349				// Use integer dirruns iff this is the outermost matcher
2350				dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1),
2351				len = elems.length;
2352
2353			if ( outermost ) {
2354				outermostContext = context !== document && context;
2355			}
2356
2357			// Add elements passing elementMatchers directly to results
2358			// Keep `i` a string if there are no elements so `matchedCount` will be "00" below
2359			// Support: IE<9, Safari
2360			// Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
2361			for ( ; i !== len && (elem = elems[i]) != null; i++ ) {
2362				if ( byElement && elem ) {
2363					j = 0;
2364					while ( (matcher = elementMatchers[j++]) ) {
2365						if ( matcher( elem, context, xml ) ) {
2366							results.push( elem );
2367							break;
2368						}
2369					}
2370					if ( outermost ) {
2371						dirruns = dirrunsUnique;
2372					}
2373				}
2374
2375				// Track unmatched elements for set filters
2376				if ( bySet ) {
2377					// They will have gone through all possible matchers
2378					if ( (elem = !matcher && elem) ) {
2379						matchedCount--;
2380					}
2381
2382					// Lengthen the array for every element, matched or not
2383					if ( seed ) {
2384						unmatched.push( elem );
2385					}
2386				}
2387			}
2388
2389			// Apply set filters to unmatched elements
2390			matchedCount += i;
2391			if ( bySet && i !== matchedCount ) {
2392				j = 0;
2393				while ( (matcher = setMatchers[j++]) ) {
2394					matcher( unmatched, setMatched, context, xml );
2395				}
2396
2397				if ( seed ) {
2398					// Reintegrate element matches to eliminate the need for sorting
2399					if ( matchedCount > 0 ) {
2400						while ( i-- ) {
2401							if ( !(unmatched[i] || setMatched[i]) ) {
2402								setMatched[i] = pop.call( results );
2403							}
2404						}
2405					}
2406
2407					// Discard index placeholder values to get only actual matches
2408					setMatched = condense( setMatched );
2409				}
2410
2411				// Add matches to results
2412				push.apply( results, setMatched );
2413
2414				// Seedless set matches succeeding multiple successful matchers stipulate sorting
2415				if ( outermost && !seed && setMatched.length > 0 &&
2416					( matchedCount + setMatchers.length ) > 1 ) {
2417
2418					Sizzle.uniqueSort( results );
2419				}
2420			}
2421
2422			// Override manipulation of globals by nested matchers
2423			if ( outermost ) {
2424				dirruns = dirrunsUnique;
2425				outermostContext = contextBackup;
2426			}
2427
2428			return unmatched;
2429		};
2430
2431	return bySet ?
2432		markFunction( superMatcher ) :
2433		superMatcher;
2434}
2435
2436compile = Sizzle.compile = function( selector, group /* Internal Use Only */ ) {
2437	var i,
2438		setMatchers = [],
2439		elementMatchers = [],
2440		cached = compilerCache[ selector + " " ];
2441
2442	if ( !cached ) {
2443		// Generate a function of recursive functions that can be used to check each element
2444		if ( !group ) {
2445			group = tokenize( selector );
2446		}
2447		i = group.length;
2448		while ( i-- ) {
2449			cached = matcherFromTokens( group[i] );
2450			if ( cached[ expando ] ) {
2451				setMatchers.push( cached );
2452			} else {
2453				elementMatchers.push( cached );
2454			}
2455		}
2456
2457		// Cache the compiled function
2458		cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );
2459	}
2460	return cached;
2461};
2462
2463function multipleContexts( selector, contexts, results ) {
2464	var i = 0,
2465		len = contexts.length;
2466	for ( ; i < len; i++ ) {
2467		Sizzle( selector, contexts[i], results );
2468	}
2469	return results;
2470}
2471
2472function select( selector, context, results, seed ) {
2473	var i, tokens, token, type, find,
2474		match = tokenize( selector );
2475
2476	if ( !seed ) {
2477		// Try to minimize operations if there is only one group
2478		if ( match.length === 1 ) {
2479
2480			// Take a shortcut and set the context if the root selector is an ID
2481			tokens = match[0] = match[0].slice( 0 );
2482			if ( tokens.length > 2 && (token = tokens[0]).type === "ID" &&
2483					support.getById && context.nodeType === 9 && documentIsHTML &&
2484					Expr.relative[ tokens[1].type ] ) {
2485
2486				context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0];
2487				if ( !context ) {
2488					return results;
2489				}
2490				selector = selector.slice( tokens.shift().value.length );
2491			}
2492
2493			// Fetch a seed set for right-to-left matching
2494			i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length;
2495			while ( i-- ) {
2496				token = tokens[i];
2497
2498				// Abort if we hit a combinator
2499				if ( Expr.relative[ (type = token.type) ] ) {
2500					break;
2501				}
2502				if ( (find = Expr.find[ type ]) ) {
2503					// Search, expanding context for leading sibling combinators
2504					if ( (seed = find(
2505						token.matches[0].replace( runescape, funescape ),
2506						rsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context
2507					)) ) {
2508
2509						// If seed is empty or no tokens remain, we can return early
2510						tokens.splice( i, 1 );
2511						selector = seed.length && toSelector( tokens );
2512						if ( !selector ) {
2513							push.apply( results, seed );
2514							return results;
2515						}
2516
2517						break;
2518					}
2519				}
2520			}
2521		}
2522	}
2523
2524	// Compile and execute a filtering function
2525	// Provide `match` to avoid retokenization if we modified the selector above
2526	compile( selector, match )(
2527		seed,
2528		context,
2529		!documentIsHTML,
2530		results,
2531		rsibling.test( selector ) && testContext( context.parentNode ) || context
2532	);
2533	return results;
2534}
2535
2536// One-time assignments
2537
2538// Sort stability
2539support.sortStable = expando.split("").sort( sortOrder ).join("") === expando;
2540
2541// Support: Chrome<14
2542// Always assume duplicates if they aren't passed to the comparison function
2543support.detectDuplicates = !!hasDuplicate;
2544
2545// Initialize against the default document
2546setDocument();
2547
2548// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
2549// Detached nodes confoundingly follow *each other*
2550support.sortDetached = assert(function( div1 ) {
2551	// Should return 1, but returns 4 (following)
2552	return div1.compareDocumentPosition( document.createElement("div") ) & 1;
2553});
2554
2555// Support: IE<8
2556// Prevent attribute/property "interpolation"
2557// http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
2558if ( !assert(function( div ) {
2559	div.innerHTML = "<a href='#'></a>";
2560	return div.firstChild.getAttribute("href") === "#" ;
2561}) ) {
2562	addHandle( "type|href|height|width", function( elem, name, isXML ) {
2563		if ( !isXML ) {
2564			return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 );
2565		}
2566	});
2567}
2568
2569// Support: IE<9
2570// Use defaultValue in place of getAttribute("value")
2571if ( !support.attributes || !assert(function( div ) {
2572	div.innerHTML = "<input/>";
2573	div.firstChild.setAttribute( "value", "" );
2574	return div.firstChild.getAttribute( "value" ) === "";
2575}) ) {
2576	addHandle( "value", function( elem, name, isXML ) {
2577		if ( !isXML && elem.nodeName.toLowerCase() === "input" ) {
2578			return elem.defaultValue;
2579		}
2580	});
2581}
2582
2583// Support: IE<9
2584// Use getAttributeNode to fetch booleans when getAttribute lies
2585if ( !assert(function( div ) {
2586	return div.getAttribute("disabled") == null;
2587}) ) {
2588	addHandle( booleans, function( elem, name, isXML ) {
2589		var val;
2590		if ( !isXML ) {
2591			return elem[ name ] === true ? name.toLowerCase() :
2592					(val = elem.getAttributeNode( name )) && val.specified ?
2593					val.value :
2594				null;
2595		}
2596	});
2597}
2598
2599return Sizzle;
2600
2601})( window );
2602
2603
2604
2605jQuery.find = Sizzle;
2606jQuery.expr = Sizzle.selectors;
2607jQuery.expr[":"] = jQuery.expr.pseudos;
2608jQuery.unique = Sizzle.uniqueSort;
2609jQuery.text = Sizzle.getText;
2610jQuery.isXMLDoc = Sizzle.isXML;
2611jQuery.contains = Sizzle.contains;
2612
2613
2614
2615var rneedsContext = jQuery.expr.match.needsContext;
2616
2617var rsingleTag = (/^<(\w+)\s*\/?>(?:<\/\1>|)$/);
2618
2619
2620
2621var risSimple = /^.[^:#\[\.,]*$/;
2622
2623// Implement the identical functionality for filter and not
2624function winnow( elements, qualifier, not ) {
2625	if ( jQuery.isFunction( qualifier ) ) {
2626		return jQuery.grep( elements, function( elem, i ) {
2627			/* jshint -W018 */
2628			return !!qualifier.call( elem, i, elem ) !== not;
2629		});
2630
2631	}
2632
2633	if ( qualifier.nodeType ) {
2634		return jQuery.grep( elements, function( elem ) {
2635			return ( elem === qualifier ) !== not;
2636		});
2637
2638	}
2639
2640	if ( typeof qualifier === "string" ) {
2641		if ( risSimple.test( qualifier ) ) {
2642			return jQuery.filter( qualifier, elements, not );
2643		}
2644
2645		qualifier = jQuery.filter( qualifier, elements );
2646	}
2647
2648	return jQuery.grep( elements, function( elem ) {
2649		return ( jQuery.inArray( elem, qualifier ) >= 0 ) !== not;
2650	});
2651}
2652
2653jQuery.filter = function( expr, elems, not ) {
2654	var elem = elems[ 0 ];
2655
2656	if ( not ) {
2657		expr = ":not(" + expr + ")";
2658	}
2659
2660	return elems.length === 1 && elem.nodeType === 1 ?
2661		jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [] :
2662		jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {
2663			return elem.nodeType === 1;
2664		}));
2665};
2666
2667jQuery.fn.extend({
2668	find: function( selector ) {
2669		var i,
2670			ret = [],
2671			self = this,
2672			len = self.length;
2673
2674		if ( typeof selector !== "string" ) {