/*!

 * Sizzle CSS Selector Engine

 *  Copyright 2011, The Dojo Foundation

 *  Released under the MIT, BSD, and GPL Licenses.

 *  More information: http://sizzlejs.com/

 */

(function(){

var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,

	done = 0,

	toString = Object.prototype.toString,

	hasDuplicate = false,

	baseHasDuplicate = true;

// Here we check if the JavaScript engine is using some sort of

// optimization where it does not always call our comparision

// function. If that is the case, discard the hasDuplicate value.

//   Thus far that includes Google Chrome.

[0, 0].sort(function() {

	baseHasDuplicate = false;

	return 0;

});

var Sizzle = function( selector, context, results, seed ) {

	results = results || [];

	context = context || document;

	var origContext = context;

	if ( context.nodeType !== 1 && context.nodeType !== 9 ) {

		return [];

	}

	if ( !selector || typeof selector !== "string" ) {

		return results;

	}

	var m, set, checkSet, extra, ret, cur, pop, i,

		prune = true,

		contextXML = Sizzle.isXML( context ),

		parts = [],

		soFar = selector;

	// Reset the position of the chunker regexp (start from head)

	do {

		chunker.exec( "" );

		m = chunker.exec( soFar );

		if ( m ) {

			soFar = m[3];

			parts.push( m[1] );

			if ( m[2] ) {

				extra = m[3];

				break;

			}

		}

	} while ( m );

	if ( parts.length > 1 && origPOS.exec( selector ) ) {

		if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {

			set = posProcess( parts[0] + parts[1], context );

		} else {

			set = Expr.relative[ parts[0] ] ?

				[ context ] :

				Sizzle( parts.shift(), context );

			while ( parts.length ) {

				selector = parts.shift();

				if ( Expr.relative[ selector ] ) {

					selector += parts.shift();

				}

				set = posProcess( selector, set );

			}

		}

	} else {

		// Take a shortcut and set the context if the root selector is an ID

		// (but not if it'll be faster if the inner selector is an ID)

		if ( !seed && parts.length > 1 && context.nodeType === 9 && !contextXML &&

				Expr.match.ID.test(parts[0]) && !Expr.match.ID.test(parts[parts.length - 1]) ) {

			ret = Sizzle.find( parts.shift(), context, contextXML );

			context = ret.expr ?

				Sizzle.filter( ret.expr, ret.set )[0] :

				ret.set[0];

		}

		if ( context ) {

			ret = seed ?

				{ expr: parts.pop(), set: makeArray(seed) } :

				Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" || parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML );

			set = ret.expr ?

				Sizzle.filter( ret.expr, ret.set ) :

				ret.set;

			if ( parts.length > 0 ) {

				checkSet = makeArray( set );

			} else {

				prune = false;

			}

			while ( parts.length ) {

				cur = parts.pop();

				pop = cur;

				if ( !Expr.relative[ cur ] ) {

					cur = "";

				} else {

					pop = parts.pop();

				}

				if ( pop == null ) {

					pop = context;

				}

				Expr.relative[ cur ]( checkSet, pop, contextXML );

			}

		} else {

			checkSet = parts = [];

		}

	}

	if ( !checkSet ) {

		checkSet = set;

	}

	if ( !checkSet ) {

		Sizzle.error( cur || selector );

	}

	if ( toString.call(checkSet) === "[object Array]" ) {

		if ( !prune ) {

			results.push.apply( results, checkSet );

		} else if ( context && context.nodeType === 1 ) {

			for ( i = 0; checkSet[i] != null; i++ ) {

				if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && Sizzle.contains(context, checkSet[i])) ) {

					results.push( set[i] );

				}

			}

		} else {

			for ( i = 0; checkSet[i] != null; i++ ) {

				if ( checkSet[i] && checkSet[i].nodeType === 1 ) {

					results.push( set[i] );

				}

			}

		}

	} else {

		makeArray( checkSet, results );

	}

	if ( extra ) {

		Sizzle( extra, origContext, results, seed );

		Sizzle.uniqueSort( results );

	}

	return results;

};

Sizzle.uniqueSort = function( results ) {

	if ( sortOrder ) {

		hasDuplicate = baseHasDuplicate;

		results.sort( sortOrder );

		if ( hasDuplicate ) {

			for ( var i = 1; i < results.length; i++ ) {

				if ( results[i] === results[ i - 1 ] ) {

					results.splice( i--, 1 );

				}

			}

		}

	}

	return results;

};

Sizzle.matches = function( expr, set ) {

	return Sizzle( expr, null, null, set );

};

Sizzle.matchesSelector = function( node, expr ) {

	return Sizzle( expr, null, null, [node] ).length > 0;

};

Sizzle.find = function( expr, context, isXML ) {

	var set;

	if ( !expr ) {

		return [];

	}

	for ( var i = 0, l = Expr.order.length; i < l; i++ ) {

		var match,

			type = Expr.order[i];

		if ( (match = Expr.leftMatch[ type ].exec( expr )) ) {

			var left = match[1];

			match.splice( 1, 1 );

			if ( left.substr( left.length - 1 ) !== "\\" ) {

				match[1] = (match[1] || "").replace(/\\/g, "");

				set = Expr.find[ type ]( match, context, isXML );

				if ( set != null ) {

					expr = expr.replace( Expr.match[ type ], "" );

					break;

				}

			}

		}

	}

	if ( !set ) {

		set = typeof context.getElementsByTagName !== "undefined" ?

			context.getElementsByTagName( "*" ) :

			[];

	}

	return { set: set, expr: expr };

};

Sizzle.filter = function( expr, set, inplace, not ) {

	var match, anyFound,

		old = expr,

		result = [],

		curLoop = set,

		isXMLFilter = set && set[0] && Sizzle.isXML( set[0] );

	while ( expr && set.length ) {

		for ( var type in Expr.filter ) {

			if ( (match = Expr.leftMatch[ type ].exec( expr )) != null && match[2] ) {

				var found, item,

					filter = Expr.filter[ type ],

					left = match[1];

				anyFound = false;

				match.splice(1,1);

				if ( left.substr( left.length - 1 ) === "\\" ) {

					continue;

				}

				if ( curLoop === result ) {

					result = [];

				}

				if ( Expr.preFilter[ type ] ) {

					match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter );

					if ( !match ) {

						anyFound = found = true;

					} else if ( match === true ) {

						continue;

					}

				}

				if ( match ) {

					for ( var i = 0; (item = curLoop[i]) != null; i++ ) {

						if ( item ) {

							found = filter( item, match, i, curLoop );

							var pass = not ^ !!found;

							if ( inplace && found != null ) {

								if ( pass ) {

									anyFound = true;

								} else {

									curLoop[i] = false;

								}

							} else if ( pass ) {

								result.push( item );

								anyFound = true;

							}

						}

					}

				}

				if ( found !== undefined ) {

					if ( !inplace ) {

						curLoop = result;

					}

					expr = expr.replace( Expr.match[ type ], "" );

					if ( !anyFound ) {

						return [];

					}

					break;

				}

			}

		}

		// Improper expression

		if ( expr === old ) {

			if ( anyFound == null ) {

				Sizzle.error( expr );

			} else {

				break;

			}

		}

		old = expr;

	}

	return curLoop;

};

Sizzle.error = function( msg ) {

	throw "Syntax error, unrecognized expression: " + msg;

};

var Expr = Sizzle.selectors = {

	order: [ "ID", "NAME", "TAG" ],

	match: {

		ID: /#((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,

		CLASS: /\.((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,

		NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF\-]|\\.)+)['"]*\]/,

		ATTR: /\[\s*((?:[\w\u00c0-\uFFFF\-]|\\.)+)\s*(?:(\S?=)\s*(?:(['"])(.*?)\3|(#?(?:[\w\u00c0-\uFFFF\-]|\\.)*)|)|)\s*\]/,

		TAG: /^((?:[\w\u00c0-\uFFFF\*\-]|\\.)+)/,

		CHILD: /:(only|nth|last|first)-child(?:\(\s*(even|odd|(?:[+\-]?\d+|(?:[+\-]?\d*)?n\s*(?:[+\-]\s*\d+)?))\s*\))?/,

		POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^\-]|$)/,

		PSEUDO: /:((?:[\w\u00c0-\uFFFF\-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/

	},

	leftMatch: {},

	attrMap: {

		"class": "className",

		"for": "htmlFor"

	},

	attrHandle: {

		href: function( elem ) {