http://www.cambridgeworkinggroup.org/script.js

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

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