/files/galleriffic/2.0/js/jquery-1.3.2.js

/*!

 * jQuery JavaScript Library v1.3.2

 * http://jquery.com/

 *

 * Copyright (c) 2009 John Resig

 * Dual licensed under the MIT and GPL licenses.

 * http://docs.jquery.com/License

 *

 * Date: 2009-02-19 17:34:21 -0500 (Thu, 19 Feb 2009)

 * Revision: 6246

 */

(function(){



var 

	// Will speed up references to window, and allows munging its name.

	window = this,

	// Will speed up references to undefined, and allows munging its name.

	undefined,

	// Map over jQuery in case of overwrite

	_jQuery = window.jQuery,

	// Map over the $ in case of overwrite

	_$ = window.$,



	jQuery = window.jQuery = window.$ = function( selector, context ) {

		// The jQuery object is actually just the init constructor 'enhanced'

		return new jQuery.fn.init( selector, context );

	},



	// A simple way to check for HTML strings or ID strings

	// (both of which we optimize for)

	quickExpr = /^[^<]*(<(.|\s)+>)[^>]*$|^#([\w-]+)$/,

	// Is it a simple selector

	isSimple = /^.[^:#\[\.,]*$/;



jQuery.fn = jQuery.prototype = {

	init: function( selector, context ) {

		// Make sure that a selection was provided

		selector = selector || document;



		// Handle $(DOMElement)

		if ( selector.nodeType ) {

			this[0] = selector;

			this.length = 1;

			this.context = selector;

			return this;

		}

		// Handle HTML strings

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

			// Are we dealing with HTML string or an ID?

			var match = quickExpr.exec( selector );



			// Verify a match, and that no context was specified for #id

			if ( match && (match[1] || !context) ) {



				// HANDLE: $(html) -> $(array)

				if ( match[1] )

					selector = jQuery.clean( [ match[1] ], context );



				// HANDLE: $("#id")

				else {

					var elem = document.getElementById( match[3] );



					// Handle the case where IE and Opera return items

					// by name instead of ID

					if ( elem && elem.id != match[3] )

						return jQuery().find( selector );



					// Otherwise, we inject the element directly into the jQuery object

					var ret = jQuery( elem || [] );

					ret.context = document;

					ret.selector = selector;

					return ret;

				}



			// HANDLE: $(expr, [context])

			// (which is just equivalent to: $(content).find(expr)

			} else

				return jQuery( context ).find( selector );



		// HANDLE: $(function)

		// Shortcut for document ready

		} else if ( jQuery.isFunction( selector ) )

			return jQuery( document ).ready( selector );



		// Make sure that old selector state is passed along

		if ( selector.selector && selector.context ) {

			this.selector = selector.selector;

			this.context = selector.context;

		}



		return this.setArray(jQuery.isArray( selector ) ?

			selector :

			jQuery.makeArray(selector));

	},



	// Start with an empty selector

	selector: "",



	// The current version of jQuery being used

	jquery: "1.3.2",



	// The number of elements contained in the matched element set

	size: function() {

		return this.length;

	},



	// Get the Nth element in the matched element set OR

	// Get the whole matched element set as a clean array

	get: function( num ) {

		return num === undefined ?



			// Return a 'clean' array

			Array.prototype.slice.call( this ) :



			// Return just the object

			this[ num ];

	},



	// Take an array of elements and push it onto the stack

	// (returning the new matched element set)

	pushStack: function( elems, name, selector ) {

		// Build a new jQuery matched element set

		var ret = jQuery( elems );



		// Add the old object onto the stack (as a reference)

		ret.prevObject = this;



		ret.context = this.context;



		if ( name === "find" )

			ret.selector = this.selector + (this.selector ? " " : "") + selector;

		else if ( name )

			ret.selector = this.selector + "." + name + "(" + selector + ")";



		// Return the newly-formed element set

		return ret;

	},



	// Force the current matched set of elements to become

	// the specified array of elements (destroying the stack in the process)

	// You should use pushStack() in order to do this, but maintain the stack

	setArray: function( elems ) {

		// Resetting the length to 0, then using the native Array push

		// is a super-fast way to populate an object with array-like properties

		this.length = 0;

		Array.prototype.push.apply( this, elems );



		return this;

	},



	// Execute a callback for every element in the matched set.

	// (You can seed the arguments with an array of args, but this is

	// only used internally.)

	each: function( callback, args ) {

		return jQuery.each( this, callback, args );

	},



	// Determine the position of an element within

	// the matched set of elements

	index: function( elem ) {

		// Locate the position of the desired element

		return jQuery.inArray(

			// If it receives a jQuery object, the first element is used

			elem && elem.jquery ? elem[0] : elem

		, this );

	},



	attr: function( name, value, type ) {

		var options = name;



		// Look for the case where we're accessing a style value

		if ( typeof name === "string" )

			if ( value === undefined )

				return this[0] && jQuery[ type || "attr" ]( this[0], name );



			else {

				options = {};

				options[ name ] = value;

			}



		// Check to see if we're setting style values

		return this.each(function(i){

			// Set all the styles

			for ( name in options )

				jQuery.attr(

					type ?

						this.style :

						this,

					name, jQuery.prop( this, options[ name ], type, i, name )

				);

		});

	},



	css: function( key, value ) {

		// ignore negative width and height values

		if ( (key == 'width' || key == 'height') && parseFloat(value) < 0 )

			value = undefined;

		return this.attr( key, value, "curCSS" );

	},



	text: function( text ) {

		if ( typeof text !== "object" && text != null )

			return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );



		var ret = "";



		jQuery.each( text || this, function(){

			jQuery.each( this.childNodes, function(){

				if ( this.nodeType != 8 )

					ret += this.nodeType != 1 ?

						this.nodeValue :

						jQuery.fn.text( [ this ] );

			});

		});



		return ret;

	},



	wrapAll: function( html ) {

		if ( this[0] ) {

			// The elements to wrap the target around

			var wrap = jQuery( html, this[0].ownerDocument ).clone();



			if ( this[0].parentNode )

				wrap.insertBefore( this[0] );



			wrap.map(function(){

				var elem = this;



				while ( elem.firstChild )

					elem = elem.firstChild;



				return elem;

			}).append(this);

		}



		return this;

	},



	wrapInner: function( html ) {

		return this.each(function(){

			jQuery( this ).contents().wrapAll( html );

		});

	},



	wrap: function( html ) {

		return this.each(function(){

			jQuery( this ).wrapAll( html );

		});

	},



	append: function() {

		return this.domManip(arguments, true, function(elem){

			if (this.nodeType == 1)

				this.appendChild( elem );

		});

	},



	prepend: function() {

		return this.domManip(arguments, true, function(elem){

			if (this.nodeType == 1)

				this.insertBefore( elem, this.firstChild );

		});

	},



	before: function() {

		return this.domManip(arguments, false, function(elem){

			this.parentNode.insertBefore( elem, this );

		});

	},



	after: function() {

		return this.domManip(arguments, false, function(elem){

			this.parentNode.insertBefore( elem, this.nextSibling );

		});

	},



	end: function() {

		return this.prevObject || jQuery( [] );

	},



	// For internal use only.

	// Behaves like an Array's method, not like a jQuery method.

	push: [].push,

	sort: [].sort,

	splice: [].splice,



	find: function( selector ) {

		if ( this.length === 1 ) {

			var ret = this.pushStack( [], "find", selector );

			ret.length = 0;

			jQuery.find( selector, this[0], ret );

			return ret;

		} else {

			return this.pushStack( jQuery.unique(jQuery.map(this, function(elem){

				return jQuery.find( selector, elem );

			})), "find", selector );

		}

	},



	clone: function( events ) {

		// Do the clone

		var ret = this.map(function(){

			if ( !jQuery.support.noCloneEvent && !jQuery.isXMLDoc(this) ) {

				// IE copies events bound via attachEvent when

				// using cloneNode. Calling detachEvent on the

				// clone will also remove the events from the orignal

				// In order to get around this, we use innerHTML.

				// Unfortunately, this means some modifications to

				// attributes in IE that are actually only stored

				// as properties will not be copied (such as the

				// the name attribute on an input).

				var html = this.outerHTML;

				if ( !html ) {

					var div = this.ownerDocument.createElement("div");

					div.appendChild( this.cloneNode(true) );

					html = div.innerHTML;

				}



				return jQuery.clean([html.replace(/ jQuery\d+="(?:\d+|null)"/g, "").replace(/^\s*/, "")])[0];

			} else

				return this.cloneNode(true);

		});



		// Copy the events from the original to the clone

		if ( events === true ) {

			var orig = this.find("*").andSelf(), i = 0;



			ret.find("*").andSelf().each(function(){

				if ( this.nodeName !== orig[i].nodeName )

					return;



				var events = jQuery.data( orig[i], "events" );



				for ( var type in events ) {

					for ( var handler in events[ type ] ) {

						jQuery.event.add( this, type, events[ type ][ handler ], events[ type ][ handler ].data );

					}

				}



				i++;

			});

		}



		// Return the cloned set

		return ret;

	},



	filter: function( selector ) {

		return this.pushStack(

			jQuery.isFunction( selector ) &&

			jQuery.grep(this, function(elem, i){

				return selector.call( elem, i );

			}) ||



			jQuery.multiFilter( selector, jQuery.grep(this, function(elem){

				return elem.nodeType === 1;

			}) ), "filter", selector );

	},



	closest: function( selector ) {

		var pos = jQuery.expr.match.POS.test( selector ) ? jQuery(selector) : null,

			closer = 0;



		return this.map(function(){

			var cur = this;

			while ( cur && cur.ownerDocument ) {

				if ( pos ? pos.index(cur) > -1 : jQuery(cur).is(selector) ) {

					jQuery.data(cur, "closest", closer);

					return cur;

				}

				cur = cur.parentNode;

				closer++;

			}

		});

	},



	not: function( selector ) {

		if ( typeof selector === "string" )

			// test special case where just one selector is passed in

			if ( isSimple.test( selector ) )

				return this.pushStack( jQuery.multiFilter( selector, this, true ), "not", selector );

			else

				selector = jQuery.multiFilter( selector, this );



		var isArrayLike = selector.length && selector[selector.length - 1] !== undefined && !selector.nodeType;

		return this.filter(function() {

			return isArrayLike ? jQuery.inArray( this, selector ) < 0 : this != selector;

		});

	},



	add: function( selector ) {

		return this.pushStack( jQuery.unique( jQuery.merge(

			this.get(),

			typeof selector === "string" ?

				jQuery( selector ) :

				jQuery.makeArray( selector )

		)));

	},



	is: function( selector ) {

		return !!selector && jQuery.multiFilter( selector, this ).length > 0;

	},



	hasClass: function( selector ) {

		return !!selector && this.is( "." + selector );

	},



	val: function( value ) {

		if ( value === undefined ) {			

			var elem = this[0];



			if ( elem ) {

				if( jQuery.nodeName( elem, 'option' ) )

					return (elem.attributes.value || {}).specified ? elem.value : elem.text;

				

				// We need to handle select boxes special

				if ( jQuery.nodeName( elem, "select" ) ) {

					var index = elem.selectedIndex,

						values = [],

						options = elem.options,

						one = elem.type == "select-one";



					// Nothing was selected

					if ( index < 0 )

						return null;



					// Loop through all the selected options

					for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {

						var option = options[ i ];



						if ( option.selected ) {

							// Get the specifc value for the option

							value = jQuery(option).val();



							// We don't need an array for one selects

							if ( one )

								return value;



							// Multi-Selects return an array

							values.push( value );

						}

					}



					return values;				

				}



				// Everything else, we just grab the value

				return (elem.value || "").replace(/\r/g, "");



			}



			return undefined;

		}



		if ( typeof value === "number" )

			value += '';



		return this.each(function(){

			if ( this.nodeType != 1 )

				return;



			if ( jQuery.isArray(value) && /radio|checkbox/.test( this.type ) )

				this.checked = (jQuery.inArray(this.value, value) >= 0 ||

					jQuery.inArray(this.name, value) >= 0);



			else if ( jQuery.nodeName( this, "select" ) ) {

				var values = jQuery.makeArray(value);



				jQuery( "option", this ).each(function(){

					this.selected = (jQuery.inArray( this.value, values ) >= 0 ||

						jQuery.inArray( this.text, values ) >= 0);

				});



				if ( !values.length )

					this.selectedIndex = -1;



			} else

				this.value = value;

		});

	},



	html: function( value ) {

		return value === undefined ?

			(this[0] ?

				this[0].innerHTML.replace(/ jQuery\d+="(?:\d+|null)"/g, "") :

				null) :

			this.empty().append( value );

	},



	replaceWith: function( value ) {

		return this.after( value ).remove();

	},



	eq: function( i ) {

		return this.slice( i, +i + 1 );

	},



	slice: function() {

		return this.pushStack( Array.prototype.slice.apply( this, arguments ),

			"slice", Array.prototype.slice.call(arguments).join(",") );

	},



	map: function( callback ) {

		return this.pushStack( jQuery.map(this, function(elem, i){

			return callback.call( elem, i, elem );

		}));

	},



	andSelf: function() {

		return this.add( this.prevObject );

	},



	domManip: function( args, table, callback ) {

		if ( this[0] ) {

			var fragment = (this[0].ownerDocument || this[0]).createDocumentFragment(),

				scripts = jQuery.clean( args, (this[0].ownerDocument || this[0]), fragment ),

				first = fragment.firstChild;



			if ( first )

				for ( var i = 0, l = this.length; i < l; i++ )

					callback.call( root(this[i], first), this.length > 1 || i > 0 ?

							fragment.cloneNode(true) : fragment );

		

			if ( scripts )

				jQuery.each( scripts, evalScript );

		}



		return this;

		

		function root( elem, cur ) {

			return table && jQuery.nodeName(elem, "table") && jQuery.nodeName(cur, "tr") ?

				(elem.getElementsByTagName("tbody")[0] ||

				elem.appendChild(elem.ownerDocument.createElement("tbody"))) :

				elem;

		}

	}

};



// Give the init function the jQuery prototype for later instantiation

jQuery.fn.init.prototype = jQuery.fn;



function evalScript( i, elem ) {

	if ( elem.src )

		jQuery.ajax({

			url: elem.src,

			async: false,

			dataType: "script"

		});



	else

		jQuery.globalEval( elem.text || elem.textContent || elem.innerHTML || "" );



	if ( elem.parentNode )

		elem.parentNode.removeChild( elem );

}



function now(){

	return +new Date;

}



jQuery.extend = jQuery.fn.extend = function() {

	// copy reference to target object

	var target = arguments[0] || {}, i = 1, length = arguments.length, deep = false, options;



	// Handle a deep copy situation

	if ( typeof target === "boolean" ) {

		deep = target;

		target = arguments[1] || {};

		// skip the boolean and the target

		i = 2;

	}



	// Handle case when target is a string or something (possible in deep copy)

	if ( typeof target !== "object" && !jQuery.isFunction(target) )

		target = {};



	// extend jQuery itself if only one argument is passed

	if ( length == i ) {

		target = this;

		--i;

	}



	for ( ; i < length; i++ )

		// Only deal with non-null/undefined values

		if ( (options = arguments[ i ]) != null )

			// Extend the base object

			for ( var name in options ) {

				var src = target[ name ], copy = options[ name ];



				// Prevent never-ending loop

				if ( target === copy )

					continue;



				// Recurse if we're merging object values

				if ( deep && copy && typeof copy === "object" && !copy.nodeType )

					target[ name ] = jQuery.extend( deep, 

						// Never move original objects, clone them

						src || ( copy.length != null ? [ ] : { } )

					, copy );



				// Don't bring in undefined values

				else if ( copy !== undefined )

					target[ name ] = copy;



			}



	// Return the modified object

	return target;

};



// exclude the following css properties to add px

var	exclude = /z-?index|font-?weight|opacity|zoom|line-?height/i,

	// cache defaultView

	defaultView = document.defaultView || {},

	toString = Object.prototype.toString;



jQuery.extend({

	noConflict: function( deep ) {

		window.$ = _$;



		if ( deep )

			window.jQuery = _jQuery;



		return jQuery;

	},



	// See test/unit/core.js for details concerning isFunction.

	// Since version 1.3, DOM methods and functions like alert

	// aren't supported. They return false on IE (#2968).

	isFunction: function( obj ) {

		return toString.call(obj) === "[object Function]";

	},



	isArray: function( obj ) {

		return toString.call(obj) === "[object Array]";

	},



	// check if an element is in a (or is an) XML document

	isXMLDoc: function( elem ) {

		return elem.nodeType === 9 && elem.documentElement.nodeName !== "HTML" ||

			!!elem.ownerDocument && jQuery.isXMLDoc( elem.ownerDocument );

	},



	// Evalulates a script in a global context

	globalEval: function( data ) {

		if ( data && /\S/.test(data) ) {

			// Inspired by code by Andrea Giammarchi

			// http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html

			var head = document.getElementsByTagName("head")[0] || document.documentElement,

				script = document.createElement("script");



			script.type = "text/javascript";

			if ( jQuery.support.scriptEval )

				script.appendChild( document.createTextNode( data ) );

			else

				script.text = data;



			// Use insertBefore instead of appendChild  to circumvent an IE6 bug.

			// This arises when a base node is used (#2709).

			head.insertBefore( script, head.firstChild );

			head.removeChild( script );

		}

	},



	nodeName: function( elem, name ) {

		return elem.nodeName && elem.nodeName.toUpperCase() == name.toUpperCase();

	},



	// args is for internal usage only

	each: function( object, callback, args ) {

		var name, i = 0, length = object.length;



		if ( args ) {

			if ( length === undefined ) {

				for ( name in object )

					if ( callback.apply( object[ name ], args ) === false )

						break;

			} else

				for ( ; i < length; )

					if ( callback.apply( object[ i++ ], args ) === false )

						break;



		// A special, fast, case for the most common use of each

		} else {

			if ( length === undefined ) {

				for ( name in object )

					if ( callback.call( object[ name ], name, object[ name ] ) === false )

						break;

			} else

				for ( var value = object[0];

					i < length && callback.call( value, i, value ) !== false; value = object[++i] ){}

		}



		return object;

	},



	prop: function( elem, value, type, i, name ) {

		// Handle executable functions

		if ( jQuery.isFunction( value ) )

			value = value.call( elem, i );



		// Handle passing in a number to a CSS property

		return typeof value === "number" && type == "curCSS" && !exclude.test( name ) ?

			value + "px" :

			value;

	},



	className: {

		// internal only, use addClass("class")

		add: function( elem, classNames ) {

			jQuery.each((classNames || "").split(/\s+/), function(i, className){

				if ( elem.nodeType == 1 && !jQuery.className.has( elem.className, className ) )

					elem.className += (elem.className ? " " : "") + className;

			});

		},



		// internal only, use removeClass("class")

		remove: function( elem, classNames ) {

			if (elem.nodeType == 1)

				elem.className = classNames !== undefined ?

					jQuery.grep(elem.className.split(/\s+/), function(className){

						return !jQuery.className.has( classNames, className );

					}).join(" ") :

					"";

		},



		// internal only, use hasClass("class")

		has: function( elem, className ) {

			return elem && jQuery.inArray( className, (elem.className || elem).toString().split(/\s+/) ) > -1;

		}

	},



	// A method for quickly swapping in/out CSS properties to get correct calculations

	swap: function( elem, options, callback ) {

		var old = {};

		// Remember the old values, and insert the new ones

		for ( var name in options ) {

			old[ name ] = elem.style[ name ];

			elem.style[ name ] = options[ name ];

		}



		callback.call( elem );



		// Revert the old values

		for ( var name in options )

			elem.style[ name ] = old[ name ];

	},



	css: function( elem, name, force, extra ) {

		if ( name == "width" || name == "height" ) {

			var val, props = { position: "absolute", visibility: "hidden", display:"block" }, which = name == "width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ];



			function getWH() {

				val = name == "width" ? elem.offsetWidth : elem.offsetHeight;



				if ( extra === "border" )

					return;



				jQuery.each( which, function() {

					if ( !extra )

						val -= parseFloat(jQuery.curCSS( elem, "padding" + this, true)) || 0;

					if ( extra === "margin" )

						val += parseFloat(jQuery.curCSS( elem, "margin" + this, true)) || 0;

					else

						val -= parseFloat(jQuery.curCSS( elem, "border" + this + "Width", true)) || 0;

				});

			}



			if ( elem.offsetWidth !== 0 )

				getWH();

			else

				jQuery.swap( elem, props, getWH );



			return Math.max(0, Math.round(val));

		}



		return jQuery.curCSS( elem, name, force );

	},



	curCSS: function( elem, name, force ) {

		var ret, style = elem.style;



		// We need to handle opacity special in IE

		if ( name == "opacity" && !jQuery.support.opacity ) {

			ret = jQuery.attr( style, "opacity" );



			return ret == "" ?

				"1" :

				ret;

		}



		// Make sure we're using the right name for getting the float value

		if ( name.match( /float/i ) )

			name = styleFloat;



		if ( !force && style && style[ name ] )

			ret = style[ name ];



		else if ( defaultView.getComputedStyle ) {



			// Only "float" is needed here

			if ( name.match( /float/i ) )

				name = "float";



			name = name.replace( /([A-Z])/g, "-$1" ).toLowerCase();



			var computedStyle = defaultView.getComputedStyle( elem, null );



			if ( computedStyle )

				ret = computedStyle.getPropertyValue( name );



			// We should always get a number back from opacity

			if ( name == "opacity" && ret == "" )

				ret = "1";



		} else if ( elem.currentStyle ) {

			var camelCase = name.replace(/\-(\w)/g, function(all, letter){

				return letter.toUpperCase();

			});



			ret = elem.currentStyle[ name ] || elem.currentStyle[ camelCase ];



			// From the awesome hack by Dean Edwards

			// http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291



			// If we're not dealing with a regular pixel number

			// but a number that has a weird ending, we need to convert it to pixels

			if ( !/^\d+(px)?$/i.test( ret ) && /^\d/.test( ret ) ) {

				// Remember the original values

				var left = style.left, rsLeft = elem.runtimeStyle.left;



				// Put in the new values to get a computed value out

				elem.runtimeStyle.left = elem.currentStyle.left;

				style.left = ret || 0;

				ret = style.pixelLeft + "px";



				// Revert the changed values

				style.left = left;

				elem.runtimeStyle.left = rsLeft;

			}

		}



		return ret;

	},



	clean: function( elems, context, fragment ) {

		context = context || document;



		// !context.createElement fails in IE with an error but returns typeof 'object'

		if ( typeof context.createElement === "undefined" )

			context = context.ownerDocument || context[0] && context[0].ownerDocument || document;



		// If a single string is passed in and it's a single tag

		// just do a createElement and skip the rest

		if ( !fragment && elems.length === 1 && typeof elems[0] === "string" ) {

			var match = /^<(\w+)\s*\/?>$/.exec(elems[0]);

			if ( match )

				return [ context.createElement( match[1] ) ];

		}



		var ret = [], scripts = [], div = context.createElement("div");



		jQuery.each(elems, function(i, elem){

			if ( typeof elem === "number" )

				elem += '';



			if ( !elem )

				return;



			// Convert html string into DOM nodes

			if ( typeof elem === "string" ) {

				// Fix "XHTML"-style tags in all browsers

				elem = elem.replace(/(<(\w+)[^>]*?)\/>/g, function(all, front, tag){

					return tag.match(/^(abbr|br|col|img|input|link|meta|param|hr|area|embed)$/i) ?

						all :

						front + "></" + tag + ">";

				});



				// Trim whitespace, otherwise indexOf won't work as expected

				var tags = elem.replace(/^\s+/, "").substring(0, 10).toLowerCase();



				var wrap =

					// option or optgroup

					!tags.indexOf("<opt") &&

					[ 1, "<select multiple='multiple'>", "</select>" ] ||



					!tags.indexOf("<leg") &&

					[ 1, "<fieldset>", "</fieldset>" ] ||



					tags.match(/^<(thead|tbody|tfoot|colg|cap)/) &&

					[ 1, "<table>", "</table>" ] ||



					!tags.indexOf("<tr") &&

					[ 2, "<table><tbody>", "</tbody></table>" ] ||



				 	// <thead> matched above

					(!tags.indexOf("<td") || !tags.indexOf("<th")) &&

					[ 3, "<table><tbody><tr>", "</tr></tbody></table>" ] ||



					!tags.indexOf("<col") &&

					[ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ] ||



					// IE can't serialize <link> and <script> tags normally

					!jQuery.support.htmlSerialize &&

					[ 1, "div<div>", "</div>" ] ||



					[ 0, "", "" ];



				// Go to html and back, then peel off extra wrappers

				div.innerHTML = wrap[1] + elem + wrap[2];



				// Move to the right depth

				while ( wrap[0]-- )

					div = div.lastChild;



				// Remove IE's autoinserted <tbody> from table fragments

				if ( !jQuery.support.tbody ) {



					// String was a <table>, *may* have spurious <tbody>

					var hasBody = /<tbody/i.test(elem),

						tbody = !tags.indexOf("<table") && !hasBody ?

							div.firstChild && div.firstChild.childNodes :



						// String was a bare <thead> or <tfoot>

						wrap[1] == "<table>" && !hasBody ?

							div.childNodes :

							[];



					for ( var j = tbody.length - 1; j >= 0 ; --j )

						if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length )

							tbody[ j ].parentNode.removeChild( tbody[ j ] );



					}



				// IE completely kills leading whitespace when innerHTML is used

				if ( !jQuery.support.leadingWhitespace && /^\s/.test( elem ) )

					div.insertBefore( context.createTextNode( elem.match(/^\s*/)[0] ), div.firstChild );

				

				elem = jQuery.makeArray( div.childNodes );

			}



			if ( elem.nodeType )

				ret.push( elem );

			else

				ret = jQuery.merge( ret, elem );



		});



		if ( fragment ) {

			for ( var i = 0; ret[i]; i++ ) {

				if ( jQuery.nodeName( ret[i], "script" ) && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript") ) {

					scripts.push( ret[i].parentNode ? ret[i].parentNode.removeChild( ret[i] ) : ret[i] );

				} else {

					if ( ret[i].nodeType === 1 )

						ret.splice.apply( ret, [i + 1, 0].concat(jQuery.makeArray(ret[i].getElementsByTagName("script"))) );

					fragment.appendChild( ret[i] );

				}

			}

			

			return scripts;

		}



		return ret;

	},



	attr: function( elem, name, value ) {

		// don't set attributes on text and comment nodes

		if (!elem || elem.nodeType == 3 || elem.nodeType == 8)

			return undefined;



		var notxml = !jQuery.isXMLDoc( elem ),

			// Whether we are setting (or getting)

			set = value !== undefined;



		// Try to normalize/fix the name

		name = notxml && jQuery.props[ name ] || name;



		// Only do all the following if this is a node (faster for style)

		// IE elem.getAttribute passes even for style

		if ( elem.tagName ) {



			// These attributes require special treatment

			var special = /href|src|style/.test( name );



			// Safari mis-reports the default selected property of a hidden option

			// Accessing the parent's selectedIndex property fixes it

			if ( name == "selected" && elem.parentNode )

				elem.parentNode.selectedIndex;



			// If applicable, access the attribute via the DOM 0 way

			if ( name in elem && notxml && !special ) {

				if ( set ){

					// We can't allow the type property to be changed (since it causes problems in IE)

					if ( name == "type" && jQuery.nodeName( elem, "input" ) && elem.parentNode )

						throw "type property can't be changed";



					elem[ name ] = value;

				}



				// browsers index elements by id/name on forms, give priority to attributes.

				if( jQuery.nodeName( elem, "form" ) && elem.getAttributeNode(name) )

					return elem.getAttributeNode( name ).nodeValue;



				// elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set

				// http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/

				if ( name == "tabIndex" ) {

					var attributeNode = elem.getAttributeNode( "tabIndex" );

					return attributeNode && attributeNode.specified

						? attributeNode.value

						: elem.nodeName.match(/(button|input|object|select|textarea)/i)

							? 0

							: elem.nodeName.match(/^(a|area)$/i) && elem.href

								? 0

								: undefined;

				}



				return elem[ name ];

			}



			if ( !jQuery.support.style && notxml &&  name == "style" )

				return jQuery.attr( elem.style, "cssText", value );



			if ( set )

				// convert the value to a string (all browsers do this but IE) see #1070

				elem.setAttribute( name, "" + value );



			var attr = !jQuery.support.hrefNormalized && notxml && special

					// Some attributes require a special call on IE

					? elem.getAttribute( name, 2 )

					: elem.getAttribute( name );



			// Non-existent attributes return null, we normalize to undefined

			return attr === null ? undefined : attr;

		}



		// elem is actually elem.style ... set the style



		// IE uses filters for opacity

		if ( !jQuery.support.opacity && name == "opacity" ) {

			if ( set ) {

				// IE has trouble with opacity if it does not have layout

				// Force it by setting the zoom level

				elem.zoom = 1;



				// Set the alpha filter to set the opacity

				elem.filter = (elem.filter || "").replace( /alpha\([^)]*\)/, "" ) +

					(parseInt( value ) + '' == "NaN" ? "" : "alpha(opacity=" + value * 100 + ")");

			}



			return elem.filter && elem.filter.indexOf("opacity=") >= 0 ?

				(parseFloat( elem.filter.match(/opacity=([^)]*)/)[1] ) / 100) + '':

				"";

		}



		name = name.replace(/-([a-z])/ig, function(all, letter){

			return letter.toUpperCase();

		});



		if ( set )

			elem[ name ] = value;



		return elem[ name ];

	},



	trim: function( text ) {

		return (text || "").replace( /^\s+|\s+$/g, "" );

	},



	makeArray: function( array ) {

		var ret = [];



		if( array != null ){

			var i = array.length;

			// The window, strings (and functions) also have 'length'

			if( i == null || typeof array === "string" || jQuery.isFunction(array) || array.setInterval )

				ret[0] = array;

			else

				while( i )

					ret[--i] = array[i];

		}



		return ret;

	},



	inArray: function( elem, array ) {

		for ( var i = 0, length = array.length; i < length; i++ )

		// Use === because on IE, window == document

			if ( array[ i ] === elem )

				return i;



		return -1;

	},



	merge: function( first, second ) {

		// We have to loop this way because IE & Opera overwrite the length

		// expando of getElementsByTagName

		var i = 0, elem, pos = first.length;

		// Also, we need to make sure that the correct elements are being returned

		// (IE returns comment nodes in a '*' query)

		if ( !jQuery.support.getAll ) {

			while ( (elem = second[ i++ ]) != null )

				if ( elem.nodeType != 8 )

					first[ pos++ ] = elem;



		} else

			while ( (elem = second[ i++ ]) != null )

				first[ pos++ ] = elem;



		return first;

	},



	unique: function( array ) {

		var ret = [], done = {};



		try {



			for ( var i = 0, length = array.length; i < length; i++ ) {

				var id = jQuery.data( array[ i ] );



				if ( !done[ id ] ) {

					done[ id ] = true;

					ret.push( array[ i ] );

				}

			}



		} catch( e ) {

			ret = array;

		}



		return ret;

	},



	grep: function( elems, callback, inv ) {

		var ret = [];



		// Go through the array, only saving the items

		// that pass the validator function

		for ( var i = 0, length = elems.length; i < length; i++ )

			if ( !inv != !callback( elems[ i ], i ) )

				ret.push( elems[ i ] );



		return ret;

	},



	map: function( elems, callback ) {

		var ret = [];



		// Go through the array, translating each of the items to their

		// new value (or values).

		for ( var i = 0, length = elems.length; i < length; i++ ) {

			var value = callback( elems[ i ], i );



			if ( value != null )

				ret[ ret.length ] = value;

		}



		return ret.concat.apply( [], ret );

	}

});



// Use of jQuery.browser is deprecated.

// It's included for backwards compatibility and plugins,

// although they should work to migrate away.



var userAgent = navigator.userAgent.toLowerCase();



// Figure out what browser is being used

jQuery.browser = {

	version: (userAgent.match( /.+(?:rv|it|ra|ie)[\/: ]([\d.]+)/ ) || [0,'0'])[1],

	safari: /webkit/.test( userAgent ),

	opera: /opera/.test( userAgent ),

	msie: /msie/.test( userAgent ) && !/opera/.test( userAgent ),

	mozilla: /mozilla/.test( userAgent ) && !/(compatible|webkit)/.test( userAgent )

};



jQuery.each({

	parent: function(elem){return elem.parentNode;},

	parents: function(elem){return jQuery.dir(elem,"parentNode");},

	next: function(elem){return jQuery.nth(elem,2,"nextSibling");},

	prev: function(elem){return jQuery.nth(elem,2,"previousSibling");},

	nextAll: function(elem){return jQuery.dir(elem,"nextSibling");},

	prevAll: function(elem){return jQuery.dir(elem,"previousSibling");},

	siblings: function(elem){return jQuery.sibling(elem.parentNode.firstChild,elem);},

	children: function(elem){return jQuery.sibling(elem.firstChild);},

	contents: function(elem){return jQuery.nodeName(elem,"iframe")?elem.contentDocument||elem.contentWindow.document:jQuery.makeArray(elem.childNodes);}

}, function(name, fn){

	jQuery.fn[ name ] = function( selector ) {

		var ret = jQuery.map( this, fn );



		if ( selector && typeof selector == "string" )

			ret = jQuery.multiFilter( selector, ret );



		return this.pushStack( jQuery.unique( ret ), name, selector );

	};

});



jQuery.each({

	appendTo: "append",

	prependTo: "prepend",

	insertBefore: "before",

	insertAfter: "after",

	replaceAll: "replaceWith"

}, function(name, original){

	jQuery.fn[ name ] = function( selector ) {

		var ret = [], insert = jQuery( selector );



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

			var elems = (i > 0 ? this.clone(true) : this).get();

			jQuery.fn[ original ].apply( jQuery(insert[i]), elems );

			ret = ret.concat( elems );

		}



		return this.pushStack( ret, name, selector );

	};

});



jQuery.each({

	removeAttr: function( name ) {

		jQuery.attr( this, name, "" );

		if (this.nodeType == 1)

			this.removeAttribute( name );

	},



	addClass: function( classNames ) {

		jQuery.className.add( this, classNames );

	},



	removeClass: function( classNames ) {

		jQuery.className.remove( this, classNames );

	},



	toggleClass: function( classNames, state ) {

		if( typeof state !== "boolean" )

			state = !jQuery.className.has( this, classNames );

		jQuery.className[ state ? "add" : "remove" ]( this, classNames );

	},



	remove: function( selector ) {

		if ( !selector || jQuery.filter( selector, [ this ] ).length ) {

			// Prevent memory leaks

			jQuery( "*", this ).add([this]).each(function(){

				jQuery.event.remove(this);

				jQuery.removeData(this);

			});

			if (this.parentNode)

				this.parentNode.removeChild( this );

		}

	},



	empty: function() {

		// Remove element nodes and prevent memory leaks

		jQuery(this).children().remove();



		// Remove any remaining nodes

		while ( this.firstChild )

			this.removeChild( this.firstChild );

	}

}, function(name, fn){

	jQuery.fn[ name ] = function(){

		return this.each( fn, arguments );

	};

});



// Helper function used by the dimensions and offset modules

function num(elem, prop) {

	return elem[0] && parseInt( jQuery.curCSS(elem[0], prop, true), 10 ) || 0;

}

var expando = "jQuery" + now(), uuid = 0, windowData = {};



jQuery.extend({

	cache: {},



	data: function( elem, name, data ) {

		elem = elem == window ?

			windowData :

			elem;



		var id = elem[ expando ];



		// Compute a unique ID for the element

		if ( !id )

			id = elem[ expando ] = ++uuid;



		// Only generate the data cache if we're

		// trying to access or manipulate it

		if ( name && !jQuery.cache[ id ] )

			jQuery.cache[ id ] = {};



		// Prevent overriding the named cache with undefined values

		if ( data !== undefined )

			jQuery.cache[ id ][ name ] = data;



		// Return the named cache data, or the ID for the element

		return name ?

			jQuery.cache[ id ][ name ] :

			id;

	},



	removeData: function( elem, name ) {

		elem = elem == window ?

			windowData :

			elem;



		var id = elem[ expando ];



		// If we want to remove a specific section of the element's data

		if ( name ) {

			if ( jQuery.cache[ id ] ) {

				// Remove the section of cache data

				delete jQuery.cache[ id ][ name ];



				// If we've removed all the data, remove the element's cache

				name = "";



				for ( name in jQuery.cache[ id ] )

					break;



				if ( !name )

					jQuery.removeData( elem );

			}



		// Otherwise, we want to remove all of the element's data

		} else {

			// Clean up the element expando

			try {

				delete elem[ expando ];

			} catch(e){

				// IE has trouble directly removing the expando

				// but it's ok with using removeAttribute

				if ( elem.removeAttribute )

					elem.removeAttribute( expando );

			}



			// Completely remove the data cache

			delete jQuery.cache[ id ];

		}

	},

	queue: function( elem, type, data ) {

		if ( elem ){

	

			type = (type || "fx") + "queue";

	

			var q = jQuery.data( elem, type );

	

			if ( !q || jQuery.isArray(data) )

				q = jQuery.data( elem, type, jQuery.makeArray(data) );

			else if( data )

				q.push( data );

	

		}

		return q;

	},



	dequeue: function( elem, type ){

		var queue = jQuery.queue( elem, type ),

			fn = queue.shift();

		

		if( !type || type === "fx" )

			fn = queue[0];

			

		if( fn !== undefined )

			fn.call(elem);

	}

});



jQuery.fn.extend({

	data: function( key, value ){

		var parts = key.split(".");

		parts[1] = parts[1] ? "." + parts[1] : "";



		if ( value === undefined ) {

			var data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);



			if ( data === undefined && this.length )

				data = jQuery.data( this[0], key );



			return data === undefined && parts[1] ?

				this.data( parts[0] ) :

				data;

		} else

			return this.trigger("setData" + parts[1] + "!", [parts[0], value]).each(function(){

				jQuery.data( this, key, value );

			});

	},



	removeData: function( key ){

		return this.each(function(){

			jQuery.removeData( this, key );

		});

	},

	queue: function(type, data){

		if ( typeof type !== "string" ) {

			data = type;

			type = "fx";

		}



		if ( data === undefined )

			return jQuery.queue( this[0], type );



		return this.each(function(){

			var queue = jQuery.queue( this, type, data );

			

			 if( type == "fx" && queue.length == 1 )

				queue[0].call(this);

		});

	},

	dequeue: function(type){

		return this.each(function(){

			jQuery.dequeue( this, type );

		});

	}

});/*!

 * Sizzle CSS Selector Engine - v0.9.3

 *  Copyright 2009, The Dojo Foundation

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

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

 */

(function(){



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

	done = 0,

	toString = Object.prototype.toString;



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

	results = results || [];

	context = context || document;



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

		return [];

	

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

		return results;

	}



	var parts = [], m, set, checkSet, check, mode, extra, prune = true;

	

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

	chunker.lastIndex = 0;

	

	while ( (m = chunker.exec(selector)) !== null ) {

		parts.push( m[1] );

		

		if ( m[2] ) {

			extra = RegExp.rightContext;

			break;

		}

	}



	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 {

		var ret = seed ?

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

			Sizzle.find( parts.pop(), parts.length === 1 && context.parentNode ? context.parentNode : context, isXML(context) );

		set = Sizzle.filter( ret.expr, ret.set );



		if ( parts.length > 0 ) {

			checkSet = makeArray(set);

		} else {

			prune = false;

		}



		while ( parts.length ) {

			var cur = parts.pop(), pop = cur;



			if ( !Expr.relative[ cur ] ) {

				cur = "";

			} else {

				pop = parts.pop();

			}



			if ( pop == null ) {

				pop = context;

			}



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

		}

	}



	if ( !checkSet ) {

		checkSet = set;

	}



	if ( !checkSet ) {

		throw "Syntax error, unrecognized expression: " + (cur || selector);

	}



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

		if ( !prune ) {

			results.push.apply( results, checkSet );

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

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

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

					results.push( set[i] );

				}

			}

		} else {

			for ( var 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, context, results, seed );



		if ( sortOrder ) {

			hasDuplicate = false;

			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.find = function(expr, context, isXML){

	var set, match;



	if ( !expr ) {

		return [];

	}



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

		var type = Expr.order[i], match;

		

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

			var left = RegExp.leftContext;



			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 = context.getElementsByTagName("*");

	}



	return {set: set, expr: expr};

};



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

	var old = expr, result = [], curLoop = set, match, anyFound,

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



	while ( expr && set.length ) {

		for ( var type in Expr.filter ) {

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

				var filter = Expr.filter[ type ], found, item;

				anyFound = false;



				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 ) {

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

			} else {

				break;

			}

		}



		old = expr;

	}



	return curLoop;

};



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|)\s*\]/,

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

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

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

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

	},

	attrMap: {

		"class": "className",

		"for": "htmlFor"

	},

	attrHandle: {

		href: function(elem){

			return elem.getAttribute("href");

		}

	},

	relative: {

		"+": function(checkSet, part, isXML){

			var isPartStr = typeof part === "string",

				isTag = isPartStr && !/\W/.test(part),

				isPartStrNotTag = isPartStr && !isTag;



			if ( isTag && !isXML ) {

				part = part.toUpperCase();

			}



			for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) {

				if ( (elem = checkSet[i]) ) {

					while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {}



					checkSet[i] = isPartStrNotTag || elem && elem.nodeName === part ?

						elem || false :

						elem === part;

				}

			}



			if ( isPartStrNotTag ) {

				Sizzle.filter( part, checkSet, true );

			}

		},

		">": function(checkSet, part, isXML){

			var isPartStr = typeof part === "string";



			if ( isPartStr && !/\W/.test(part) ) {

				part = isXML ? part : part.toUpperCase();



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

					var elem = checkSet[i];

					if ( elem ) {

						var parent = elem.parentNode;

						checkSet[i] = parent.nodeName === part ? parent : false;

					}

				}

			} else {

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

					var elem = checkSet[i];

					if ( elem ) {

						checkSet[i] = isPartStr ?

							elem.parentNode :

							elem.parentNode === part;

					}

				}



				if ( isPartStr ) {

					Sizzle.filter( part, checkSet, true );

				}

			}

		},

		"": function(checkSet, part, isXML){

			var doneName = done++, checkFn = dirCheck;



			if ( !part.match(/\W/) ) {

				var nodeCheck = part = isXML ? part : part.toUpperCase();

				checkFn = dirNodeCheck;

			}



			checkFn("parentNode", part, doneName, checkSet, nodeCheck, isXML);

		},

		"~": function(checkSet, part, isXML){

			var doneName = done++, checkFn = dirCheck;



			if ( typeof part === "string" && !part.match(/\W/) ) {

				var nodeCheck = part = isXML ? part : part.toUpperCase();

				checkFn = dirNodeCheck;

			}



			checkFn("previousSibling", part, doneName, checkSet, nodeCheck, isXML);

		}

	},

	find: {

		ID: function(match, context, isXML){

			if ( typeof context.getElementById !== "undefined" && !isXML ) {

				var m = context.getElementById(match[1]);

				return m ? [m] : [];

			}

		},

		NAME: function(match, context, isXML){

			if ( typeof context.getElementsByName !== "undefined" ) {

				var ret = [], results = context.getElementsByName(match[1]);



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

					if ( results[i].getAttribute("name") === match[1] ) {

						ret.push( results[i] );

					}

				}



				return ret.length === 0 ? null : ret;

			}

		},

		TAG: function(match, context){

			return context.getElementsByTagName(match[1]);

		}

	},

	preFilter: {

		CLASS: function(match, curLoop, inplace, result, not, isXML){

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



			if ( isXML ) {

				return match;

			}



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

				if ( elem ) {

					if ( not ^ (elem.className && (" " + elem.className + " ").indexOf(match) >= 0) ) {

						if ( !inplace )

							result.push( elem );

					} else if ( inplace ) {

						curLoop[i] = false;

					}

				}

			}



			return false;

		},

		ID: function(match){

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

		},

		TAG: function(match, curLoop){

			for ( var i = 0; curLoop[i] === false; i++ ){}

			return curLoop[i] && isXML(curLoop[i]) ? match[1] : match[1].toUpperCase();

		},

		CHILD: function(match){

			if ( match[1] == "nth" ) {

				// parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'

				var test = /(-?)(\d*)n((?:\+|-)?\d*)/.e