/*!
 * jquery javascript library v1.7.1
 * http://jquery.com/
 *
 * copyright 2011, john resig
 * dual licensed under the mit or gpl version 2 licenses.
 * http://jquery.org/license
 *
 * includes sizzle.js
 * http://sizzlejs.com/
 * copyright 2011, the dojo foundation
 * released under the mit, bsd, and gpl licenses.
 *
 * date: mon nov 21 21:11:03 2011 -0500
 */
(function( window, undefined ) {

// use the correct document accordingly with window argument (sandbox)
var document = window.document,
	navigator = window.navigator,
	location = window.location;
var jquery = (function() {

// define a local copy of jquery
var jquery = function( selector, context ) {
		// the jquery object is actually just the init constructor 'enhanced'
		return new jquery.fn.init( selector, context, rootjquery );
	},

	// map over jquery in case of overwrite
	_jquery = window.jquery,

	// map over the $ in case of overwrite
	_$ = window.$,

	// a central reference to the root jquery(document)
	rootjquery,

	// a simple way to check for html strings or id strings
	// prioritize #id over <tag> to avoid xss via location.hash (#9521)
	quickexpr = /^(?:[^#<]*(<[\w\w]+>)[^>]*$|#([\w\-]*)$)/,

	// check if a string has a non-whitespace character in it
	rnotwhite = /\s/,

	// used for trimming whitespace
	trimleft = /^\s+/,
	trimright = /\s+$/,

	// match a standalone tag
	rsingletag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/,

	// json regexp
	rvalidchars = /^[\],:{}\s]*$/,
	rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fa-f]{4})/g,
	rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[ee][+\-]?\d+)?/g,
	rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,

	// useragent regexp
	rwebkit = /(webkit)[ \/]([\w.]+)/,
	ropera = /(opera)(?:.*version)?[ \/]([\w.]+)/,
	rmsie = /(msie) ([\w.]+)/,
	rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/,

	// matches dashed string for camelizing
	rdashalpha = /-([a-z]|[0-9])/ig,
	rmsprefix = /^-ms-/,

	// used by jquery.camelcase as callback to replace()
	fcamelcase = function( all, letter ) {
		return ( letter + "" ).touppercase();
	},

	// keep a useragent string for use with jquery.browser
	useragent = navigator.useragent,

	// for matching the engine and version of the browser
	browsermatch,

	// the deferred used on dom ready
	readylist,

	// the ready event handler
	domcontentloaded,

	// save a reference to some core methods
	tostring = object.prototype.tostring,
	hasown = object.prototype.hasownproperty,
	push = array.prototype.push,
	slice = array.prototype.slice,
	trim = string.prototype.trim,
	indexof = array.prototype.indexof,

	// [[class]] -> type pairs
	class2type = {};

jquery.fn = jquery.prototype = {
	constructor: jquery,
	init: function( selector, context, rootjquery ) {
		var match, elem, ret, doc;

		// handle $(""), $(null), or $(undefined)
		if ( !selector ) {
			return this;
		}

		// handle $(domelement)
		if ( selector.nodetype ) {
			this.context = this[0] = selector;
			this.length = 1;
			return this;
		}

		// the body element only exists once, optimize finding it
		if ( selector === "body" && !context && document.body ) {
			this.context = document;
			this[0] = document.body;
			this.selector = selector;
			this.length = 1;
			return this;
		}

		// handle html strings
		if ( typeof selector === "string" ) {
			// are we dealing with html string or an id?
			if ( selector.charat(0) === "<" && selector.charat( selector.length - 1 ) === ">" && selector.length >= 3 ) {
				// assume that strings that start and end with <> are html and skip the regex check
				match = [ null, selector, null ];

			} else {
				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] ) {
					context = context instanceof jquery ? context[0] : context;
					doc = ( context ? context.ownerdocument || context : document );

					// if a single string is passed in and it's a single tag
					// just do a createelement and skip the rest
					ret = rsingletag.exec( selector );

					if ( ret ) {
						if ( jquery.isplainobject( context ) ) {
							selector = [ document.createelement( ret[1] ) ];
							jquery.fn.attr.call( selector, context, true );

						} else {
							selector = [ doc.createelement( ret[1] ) ];
						}

					} else {
						ret = jquery.buildfragment( [ match[1] ], [ doc ] );
						selector = ( ret.cacheable ? jquery.clone(ret.fragment) : ret.fragment ).childnodes;
					}

					return jquery.merge( this, selector );

				// handle: $("#id")
				} else {
					elem = document.getelementbyid( match[2] );

					// check parentnode to catch when blackberry 4.6 returns
					// nodes that are no longer in the document #6963
					if ( elem && elem.parentnode ) {
						// handle the case where ie and opera return items
						// by name instead of id
						if ( elem.id !== match[2] ) {
							return rootjquery.find( selector );
						}

						// otherwise, we inject the element directly into the jquery object
						this.length = 1;
						this[0] = elem;
					}

					this.context = document;
					this.selector = selector;
					return this;
				}

			// handle: $(expr, $(...))
			} else if ( !context || context.jquery ) {
				return ( context || rootjquery ).find( selector );

			// handle: $(expr, context)
			// (which is just equivalent to: $(context).find(expr)
			} else {
				return this.constructor( context ).find( selector );
			}

		// handle: $(function)
		// shortcut for document ready
		} else if ( jquery.isfunction( selector ) ) {
			return rootjquery.ready( selector );
		}

		if ( selector.selector !== undefined ) {
			this.selector = selector.selector;
			this.context = selector.context;
		}

		return jquery.makearray( selector, this );
	},

	// start with an empty selector
	selector: "",

	// the current version of jquery being used
	jquery: "1.7.1",

	// the default length of a jquery object is 0
	length: 0,

	// the number of elements contained in the matched element set
	size: function() {
		return this.length;
	},

	toarray: function() {
		return slice.call( this, 0 );
	},

	// 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 == null ?

			// return a 'clean' array
			this.toarray() :

			// return just the object
			( num < 0 ? this[ this.length + num ] : 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 = this.constructor();

		if ( jquery.isarray( elems ) ) {
			push.apply( ret, elems );

		} else {
			jquery.merge( ret, 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;
	},

	// 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 );
	},

	ready: function( fn ) {
		// attach the listeners
		jquery.bindready();

		// add the callback
		readylist.add( fn );

		return this;
	},

	eq: function( i ) {
		i = +i;
		return i === -1 ?
			this.slice( i ) :
			this.slice( i, i + 1 );
	},

	first: function() {
		return this.eq( 0 );
	},

	last: function() {
		return this.eq( -1 );
	},

	slice: function() {
		return this.pushstack( slice.apply( this, arguments ),
			"slice", slice.call(arguments).join(",") );
	},

	map: function( callback ) {
		return this.pushstack( jquery.map(this, function( elem, i ) {
			return callback.call( elem, i, elem );
		}));
	},

	end: function() {
		return this.prevobject || this.constructor(null);
	},

	// for internal use only.
	// behaves like an array's method, not like a jquery method.
	push: push,
	sort: [].sort,
	splice: [].splice
};

// give the init function the jquery prototype for later instantiation
jquery.fn.init.prototype = jquery.fn;

jquery.extend = jquery.fn.extend = function() {
	var options, name, src, copy, copyisarray, clone,
		target = arguments[0] || {},
		i = 1,
		length = arguments.length,
		deep = false;

	// 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 ( name in options ) {
				src = target[ name ];
				copy = options[ name ];

				// prevent never-ending loop
				if ( target === copy ) {
					continue;
				}

				// recurse if we're merging plain objects or arrays
				if ( deep && copy && ( jquery.isplainobject(copy) || (copyisarray = jquery.isarray(copy)) ) ) {
					if ( copyisarray ) {
						copyisarray = false;
						clone = src && jquery.isarray(src) ? src : [];

					} else {
						clone = src && jquery.isplainobject(src) ? src : {};
					}

					// never move original objects, clone them
					target[ name ] = jquery.extend( deep, clone, copy );

				// don't bring in undefined values
				} else if ( copy !== undefined ) {
					target[ name ] = copy;
				}
			}
		}
	}

	// return the modified object
	return target;
};

jquery.extend({
	noconflict: function( deep ) {
		if ( window.$ === jquery ) {
			window.$ = _$;
		}

		if ( deep && window.jquery === jquery ) {
			window.jquery = _jquery;
		}

		return jquery;
	},

	// is the dom ready to be used? set to true once it occurs.
	isready: false,

	// a counter to track how many items to wait for before
	// the ready event fires. see #6781
	readywait: 1,

	// hold (or release) the ready event
	holdready: function( hold ) {
		if ( hold ) {
			jquery.readywait++;
		} else {
			jquery.ready( true );
		}
	},

	// handle when the dom is ready
	ready: function( wait ) {
		// either a released hold or an domready/load event and not yet ready
		if ( (wait === true && !--jquery.readywait) || (wait !== true && !jquery.isready) ) {
			// make sure body exists, at least, in case ie gets a little overzealous (ticket #5443).
			if ( !document.body ) {
				return settimeout( jquery.ready, 1 );
			}

			// remember that the dom is ready
			jquery.isready = true;

			// if a normal dom ready event fired, decrement, and wait if need be
			if ( wait !== true && --jquery.readywait > 0 ) {
				return;
			}

			// if there are functions bound, to execute
			readylist.firewith( document, [ jquery ] );

			// trigger any bound ready events
			if ( jquery.fn.trigger ) {
				jquery( document ).trigger( "ready" ).off( "ready" );
			}
		}
	},

	bindready: function() {
		if ( readylist ) {
			return;
		}

		readylist = jquery.callbacks( "once memory" );

		// catch cases where $(document).ready() is called after the
		// browser event has already occurred.
		if ( document.readystate === "complete" ) {
			// handle it asynchronously to allow scripts the opportunity to delay ready
			return settimeout( jquery.ready, 1 );
		}

		// mozilla, opera and webkit nightlies currently support this event
		if ( document.addeventlistener ) {
			// use the handy event callback
			document.addeventlistener( "domcontentloaded", domcontentloaded, false );

			// a fallback to window.onload, that will always work
			window.addeventlistener( "load", jquery.ready, false );

		// if ie event model is used
		} else if ( document.attachevent ) {
			// ensure firing before onload,
			// maybe late but safe also for iframes
			document.attachevent( "onreadystatechange", domcontentloaded );

			// a fallback to window.onload, that will always work
			window.attachevent( "onload", jquery.ready );

			// if ie and not a frame
			// continually check to see if the document is ready
			var toplevel = false;

			try {
				toplevel = window.frameelement == null;
			} catch(e) {}

			if ( document.documentelement.doscroll && toplevel ) {
				doscrollcheck();
			}
		}
	},

	// 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 jquery.type(obj) === "function";
	},

	isarray: array.isarray || function( obj ) {
		return jquery.type(obj) === "array";
	},

	// a crude way of determining if an object is a window
	iswindow: function( obj ) {
		return obj && typeof obj === "object" && "setinterval" in obj;
	},

	isnumeric: function( obj ) {
		return !isnan( parsefloat(obj) ) && isfinite( obj );
	},

	type: function( obj ) {
		return obj == null ?
			string( obj ) :
			class2type[ tostring.call(obj) ] || "object";
	},

	isplainobject: function( obj ) {
		// must be an object.
		// because of ie, we also have to check the presence of the constructor property.
		// make sure that dom nodes and window objects don't pass through, as well
		if ( !obj || jquery.type(obj) !== "object" || obj.nodetype || jquery.iswindow( obj ) ) {
			return false;
		}

		try {
			// not own constructor property must be object
			if ( obj.constructor &&
				!hasown.call(obj, "constructor") &&
				!hasown.call(obj.constructor.prototype, "isprototypeof") ) {
				return false;
			}
		} catch ( e ) {
			// ie8,9 will throw exceptions on certain host objects #9897
			return false;
		}

		// own properties are enumerated firstly, so to speed up,
		// if last one is own, then all properties are own.

		var key;
		for ( key in obj ) {}

		return key === undefined || hasown.call( obj, key );
	},

	isemptyobject: function( obj ) {
		for ( var name in obj ) {
			return false;
		}
		return true;
	},

	error: function( msg ) {
		throw new error( msg );
	},

	parsejson: function( data ) {
		if ( typeof data !== "string" || !data ) {
			return null;
		}

		// make sure leading/trailing whitespace is removed (ie can't handle it)
		data = jquery.trim( data );

		// attempt to parse using the native json parser first
		if ( window.json && window.json.parse ) {
			return window.json.parse( data );
		}

		// make sure the incoming data is actual json
		// logic borrowed from http://json.org/json2.js
		if ( rvalidchars.test( data.replace( rvalidescape, "@" )
			.replace( rvalidtokens, "]" )
			.replace( rvalidbraces, "")) ) {

			return ( new function( "return " + data ) )();

		}
		jquery.error( "invalid json: " + data );
	},

	// cross-browser xml parsing
	parsexml: function( data ) {
		var xml, tmp;
		try {
			if ( window.domparser ) { // standard
				tmp = new domparser();
				xml = tmp.parsefromstring( data , "text/xml" );
			} else { // ie
				xml = new activexobject( "microsoft.xmldom" );
				xml.async = "false";
				xml.loadxml( data );
			}
		} catch( e ) {
			xml = undefined;
		}
		if ( !xml || !xml.documentelement || xml.getelementsbytagname( "parsererror" ).length ) {
			jquery.error( "invalid xml: " + data );
		}
		return xml;
	},

	noop: function() {},

	// evaluates a script in a global context
	// workarounds based on findings by jim driscoll
	// http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
	globaleval: function( data ) {
		if ( data && rnotwhite.test( data ) ) {
			// we use execscript on internet explorer
			// we use an anonymous function so that context is window
			// rather than jquery in firefox
			( window.execscript || function( data ) {
				window[ "eval" ].call( window, data );
			} )( data );
		}
	},

	// convert dashed to camelcase; used by the css and data modules
	// microsoft forgot to hump their vendor prefix (#9572)
	camelcase: function( string ) {
		return string.replace( rmsprefix, "ms-" ).replace( rdashalpha, fcamelcase );
	},

	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,
			isobj = length === undefined || jquery.isfunction( object );

		if ( args ) {
			if ( isobj ) {
				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 ( isobj ) {
				for ( name in object ) {
					if ( callback.call( object[ name ], name, object[ name ] ) === false ) {
						break;
					}
				}
			} else {
				for ( ; i < length; ) {
					if ( callback.call( object[ i ], i, object[ i++ ] ) === false ) {
						break;
					}
				}
			}
		}

		return object;
	},

	// use native string.trim function wherever possible
	trim: trim ?
		function( text ) {
			return text == null ?
				"" :
				trim.call( text );
		} :

		// otherwise use our own trimming functionality
		function( text ) {
			return text == null ?
				"" :
				text.tostring().replace( trimleft, "" ).replace( trimright, "" );
		},

	// results is for internal usage only
	makearray: function( array, results ) {
		var ret = results || [];

		if ( array != null ) {
			// the window, strings (and functions) also have 'length'
			// tweaked logic slightly to handle blackberry 4.7 regexp issues #6930
			var type = jquery.type( array );

			if ( array.length == null || type === "string" || type === "function" || type === "regexp" || jquery.iswindow( array ) ) {
				push.call( ret, array );
			} else {
				jquery.merge( ret, array );
			}
		}

		return ret;
	},

	inarray: function( elem, array, i ) {
		var len;

		if ( array ) {
			if ( indexof ) {
				return indexof.call( array, elem, i );
			}

			len = array.length;
			i = i ? i < 0 ? math.max( 0, len + i ) : i : 0;

			for ( ; i < len; i++ ) {
				// skip accessing in sparse arrays
				if ( i in array && array[ i ] === elem ) {
					return i;
				}
			}
		}

		return -1;
	},

	merge: function( first, second ) {
		var i = first.length,
			j = 0;

		if ( typeof second.length === "number" ) {
			for ( var l = second.length; j < l; j++ ) {
				first[ i++ ] = second[ j ];
			}

		} else {
			while ( second[j] !== undefined ) {
				first[ i++ ] = second[ j++ ];
			}
		}

		first.length = i;

		return first;
	},

	grep: function( elems, callback, inv ) {
		var ret = [], retval;
		inv = !!inv;

		// go through the array, only saving the items
		// that pass the validator function
		for ( var i = 0, length = elems.length; i < length; i++ ) {
			retval = !!callback( elems[ i ], i );
			if ( inv !== retval ) {
				ret.push( elems[ i ] );
			}
		}

		return ret;
	},

	// arg is for internal usage only
	map: function( elems, callback, arg ) {
		var value, key, ret = [],
			i = 0,
			length = elems.length,
			// jquery objects are treated as arrays
			isarray = elems instanceof jquery || length !== undefined && typeof length === "number" && ( ( length > 0 && elems[ 0 ] && elems[ length -1 ] ) || length === 0 || jquery.isarray( elems ) ) ;

		// go through the array, translating each of the items to their
		if ( isarray ) {
			for ( ; i < length; i++ ) {
				value = callback( elems[ i ], i, arg );

				if ( value != null ) {
					ret[ ret.length ] = value;
				}
			}

		// go through every key on the object,
		} else {
			for ( key in elems ) {
				value = callback( elems[ key ], key, arg );

				if ( value != null ) {
					ret[ ret.length ] = value;
				}
			}
		}

		// flatten any nested arrays
		return ret.concat.apply( [], ret );
	},

	// a global guid counter for objects
	guid: 1,

	// bind a function to a context, optionally partially applying any
	// arguments.
	proxy: function( fn, context ) {
		if ( typeof context === "string" ) {
			var tmp = fn[ context ];
			context = fn;
			fn = tmp;
		}

		// quick check to determine if target is callable, in the spec
		// this throws a typeerror, but we will just return undefined.
		if ( !jquery.isfunction( fn ) ) {
			return undefined;
		}

		// simulated bind
		var args = slice.call( arguments, 2 ),
			proxy = function() {
				return fn.apply( context, args.concat( slice.call( arguments ) ) );
			};

		// set the guid of unique handler to the same of original handler, so it can be removed
		proxy.guid = fn.guid = fn.guid || proxy.guid || jquery.guid++;

		return proxy;
	},

	// mutifunctional method to get and set values to a collection
	// the value/s can optionally be executed if it's a function
	access: function( elems, key, value, exec, fn, pass ) {
		var length = elems.length;

		// setting many attributes
		if ( typeof key === "object" ) {
			for ( var k in key ) {
				jquery.access( elems, k, key[k], exec, fn, value );
			}
			return elems;
		}

		// setting one attribute
		if ( value !== undefined ) {
			// optionally, function values get executed if exec is true
			exec = !pass && exec && jquery.isfunction(value);

			for ( var i = 0; i < length; i++ ) {
				fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
			}

			return elems;
		}

		// getting an attribute
		return length ? fn( elems[0], key ) : undefined;
	},

	now: function() {
		return ( new date() ).gettime();
	},

	// use of jquery.browser is frowned upon.
	// more details: http://docs.jquery.com/utilities/jquery.browser
	uamatch: function( ua ) {
		ua = ua.tolowercase();

		var match = rwebkit.exec( ua ) ||
			ropera.exec( ua ) ||
			rmsie.exec( ua ) ||
			ua.indexof("compatible") < 0 && rmozilla.exec( ua ) ||
			[];

		return { browser: match[1] || "", version: match[2] || "0" };
	},

	sub: function() {
		function jquerysub( selector, context ) {
			return new jquerysub.fn.init( selector, context );
		}
		jquery.extend( true, jquerysub, this );
		jquerysub.superclass = this;
		jquerysub.fn = jquerysub.prototype = this();
		jquerysub.fn.constructor = jquerysub;
		jquerysub.sub = this.sub;
		jquerysub.fn.init = function init( selector, context ) {
			if ( context && context instanceof jquery && !(context instanceof jquerysub) ) {
				context = jquerysub( context );
			}

			return jquery.fn.init.call( this, selector, context, rootjquerysub );
		};
		jquerysub.fn.init.prototype = jquerysub.fn;
		var rootjquerysub = jquerysub(document);
		return jquerysub;
	},

	browser: {}
});

// populate the class2type map
jquery.each("boolean number string function array date regexp object".split(" "), function(i, name) {
	class2type[ "[object " + name + "]" ] = name.tolowercase();
});

browsermatch = jquery.uamatch( useragent );
if ( browsermatch.browser ) {
	jquery.browser[ browsermatch.browser ] = true;
	jquery.browser.version = browsermatch.version;
}

// deprecated, use jquery.browser.webkit instead
if ( jquery.browser.webkit ) {
	jquery.browser.safari = true;
}

// ie doesn't match non-breaking spaces with \s
if ( rnotwhite.test( "\xa0" ) ) {
	trimleft = /^[\s\xa0]+/;
	trimright = /[\s\xa0]+$/;
}

// all jquery objects should point back to these
rootjquery = jquery(document);

// cleanup functions for the document ready method
if ( document.addeventlistener ) {
	domcontentloaded = function() {
		document.removeeventlistener( "domcontentloaded", domcontentloaded, false );
		jquery.ready();
	};

} else if ( document.attachevent ) {
	domcontentloaded = function() {
		// make sure body exists, at least, in case ie gets a little overzealous (ticket #5443).
		if ( document.readystate === "complete" ) {
			document.detachevent( "onreadystatechange", domcontentloaded );
			jquery.ready();
		}
	};
}

// the dom ready check for internet explorer
function doscrollcheck() {
	if ( jquery.isready ) {
		return;
	}

	try {
		// if ie is used, use the trick by diego perini
		// http://javascript.nwbox.com/iecontentloaded/
		document.documentelement.doscroll("left");
	} catch(e) {
		settimeout( doscrollcheck, 1 );
		return;
	}

	// and execute any waiting functions
	jquery.ready();
}

return jquery;

})();


// string to object flags format cache
var flagscache = {};

// convert string-formatted flags into object-formatted ones and store in cache
function createflags( flags ) {
	var object = flagscache[ flags ] = {},
		i, length;
	flags = flags.split( /\s+/ );
	for ( i = 0, length = flags.length; i < length; i++ ) {
		object[ flags[i] ] = true;
	}
	return object;
}

/*
 * create a callback list using the following parameters:
 *
 *	flags:	an optional list of space-separated flags that will change how
 *			the callback list behaves
 *
 * by default a callback list will act like an event callback list and can be
 * "fired" multiple times.
 *
 * possible flags:
 *
 *	once:			will ensure the callback list can only be fired once (like a deferred)
 *
 *	memory:			will keep track of previous values and will call any callback added
 *					after the list has been fired right away with the latest "memorized"
 *					values (like a deferred)
 *
 *	unique:			will ensure a callback can only be added once (no duplicate in the list)
 *
 *	stoponfalse:	interrupt callings when a callback returns false
 *
 */
jquery.callbacks = function( flags ) {

	// convert flags from string-formatted to object-formatted
	// (we check in cache first)
	flags = flags ? ( flagscache[ flags ] || createflags( flags ) ) : {};

	var // actual callback list
		list = [],
		// stack of fire calls for repeatable lists
		stack = [],
		// last fire value (for non-forgettable lists)
		memory,
		// flag to know if list is currently firing
		firing,
		// first callback to fire (used internally by add and firewith)
		firingstart,
		// end of the loop when firing
		firinglength,
		// index of currently firing callback (modified by remove if needed)
		firingindex,
		// add one or several callbacks to the list
		add = function( args ) {
			var i,
				length,
				elem,
				type,
				actual;
			for ( i = 0, length = args.length; i < length; i++ ) {
				elem = args[ i ];
				type = jquery.type( elem );
				if ( type === "array" ) {
					// inspect recursively
					add( elem );
				} else if ( type === "function" ) {
					// add if not in unique mode and callback is not in
					if ( !flags.unique || !self.has( elem ) ) {
						list.push( elem );
					}
				}
			}
		},
		// fire callbacks
		fire = function( context, args ) {
			args = args || [];
			memory = !flags.memory || [ context, args ];
			firing = true;
			firingindex = firingstart || 0;
			firingstart = 0;
			firinglength = list.length;
			for ( ; list && firingindex < firinglength; firingindex++ ) {
				if ( list[ firingindex ].apply( context, args ) === false && flags.stoponfalse ) {
					memory = true; // mark as halted
					break;
				}
			}
			firing = false;
			if ( list ) {
				if ( !flags.once ) {
					if ( stack && stack.length ) {
						memory = stack.shift();
						self.firewith( memory[ 0 ], memory[ 1 ] );
					}
				} else if ( memory === true ) {
					self.disable();
				} else {
					list = [];
				}
			}
		},
		// actual callbacks object
		self = {
			// add a callback or a collection of callbacks to the list
			add: function() {
				if ( list ) {
					var length = list.length;
					add( arguments );
					// do we need to add the callbacks to the
					// current firing batch?
					if ( firing ) {
						firinglength = list.length;
					// with memory, if we're not firing then
					// we should call right away, unless previous
					// firing was halted (stoponfalse)
					} else if ( memory && memory !== true ) {
						firingstart = length;
						fire( memory[ 0 ], memory[ 1 ] );
					}
				}
				return this;
			},
			// remove a callback from the list
			remove: function() {
				if ( list ) {
					var args = arguments,
						argindex = 0,
						arglength = args.length;
					for ( ; argindex < arglength ; argindex++ ) {
						for ( var i = 0; i < list.length; i++ ) {
							if ( args[ argindex ] === list[ i ] ) {
								// handle firingindex and firinglength
								if ( firing ) {
									if ( i <= firinglength ) {
										firinglength--;
										if ( i <= firingindex ) {
											firingindex--;
										}
									}
								}
								// remove the element
								list.splice( i--, 1 );
								// if we have some unicity property then
								// we only need to do this once
								if ( flags.unique ) {
									break;
								}
							}
						}
					}
				}
				return this;
			},
			// control if a given callback is in the list
			has: function( fn ) {
				if ( list ) {
					var i = 0,
						length = list.length;
					for ( ; i < length; i++ ) {
						if ( fn === list[ i ] ) {
							return true;
						}
					}
				}
				return false;
			},
			// remove all callbacks from the list
			empty: function() {
				list = [];
				return this;
			},
			// have the list do nothing anymore
			disable: function() {
				list = stack = memory = undefined;
				return this;
			},
			// is it disabled?
			disabled: function() {
				return !list;
			},
			// lock the list in its current state
			lock: function() {
				stack = undefined;
				if ( !memory || memory === true ) {
					self.disable();
				}
				return this;
			},
			// is it locked?
			locked: function() {
				return !stack;
			},
			// call all callbacks with the given context and arguments
			firewith: function( context, args ) {
				if ( stack ) {
					if ( firing ) {
						if ( !flags.once ) {
							stack.push( [ context, args ] );
						}
					} else if ( !( flags.once && memory ) ) {
						fire( context, args );
					}
				}
				return this;
			},
			// call all the callbacks with the given arguments
			fire: function() {
				self.firewith( this, arguments );
				return this;
			},
			// to know if the callbacks have already been called at least once
			fired: function() {
				return !!memory;
			}
		};

	return self;
};




var // static reference to slice
	slicedeferred = [].slice;

jquery.extend({

	deferred: function( func ) {
		var donelist = jquery.callbacks( "once memory" ),
			faillist = jquery.callbacks( "once memory" ),
			progresslist = jquery.callbacks( "memory" ),
			state = "pending",
			lists = {
				resolve: donelist,
				reject: faillist,
				notify: progresslist
			},
			promise = {
				done: donelist.add,
				fail: faillist.add,
				progress: progresslist.add,

				state: function() {
					return state;
				},

				// deprecated
				isresolved: donelist.fired,
				isrejected: faillist.fired,

				then: function( donecallbacks, failcallbacks, progresscallbacks ) {
					deferred.done( donecallbacks ).fail( failcallbacks ).progress( progresscallbacks );
					return this;
				},
				always: function() {
					deferred.done.apply( deferred, arguments ).fail.apply( deferred, arguments );
					return this;
				},
				pipe: function( fndone, fnfail, fnprogress ) {
					return jquery.deferred(function( newdefer ) {
						jquery.each( {
							done: [ fndone, "resolve" ],
							fail: [ fnfail, "reject" ],
							progress: [ fnprogress, "notify" ]
						}, function( handler, data ) {
							var fn = data[ 0 ],
								action = data[ 1 ],
								returned;
							if ( jquery.isfunction( fn ) ) {
								deferred[ handler ](function() {
									returned = fn.apply( this, arguments );
									if ( returned && jquery.isfunction( returned.promise ) ) {
										returned.promise().then( newdefer.resolve, newdefer.reject, newdefer.notify );
									} else {
										newdefer[ action + "with" ]( this === deferred ? newdefer : this, [ returned ] );
									}
								});
							} else {
								deferred[ handler ]( newdefer[ action ] );
							}
						});
					}).promise();
				},
				// get a promise for this deferred
				// if obj is provided, the promise aspect is added to the object
				promise: function( obj ) {
					if ( obj == null ) {
						obj = promise;
					} else {
						for ( var key in promise ) {
							obj[ key ] = promise[ key ];
						}
					}
					return obj;
				}
			},
			deferred = promise.promise({}),
			key;

		for ( key in lists ) {
			deferred[ key ] = lists[ key ].fire;
			deferred[ key + "with" ] = lists[ key ].firewith;
		}

		// handle state
		deferred.done( function() {
			state = "resolved";
		}, faillist.disable, progresslist.lock ).fail( function() {
			state = "rejected";
		}, donelist.disable, progresslist.lock );

		// call given func if any
		if ( func ) {
			func.call( deferred, deferred );
		}

		// all done!
		return deferred;
	},

	// deferred helper
	when: function( firstparam ) {
		var args = slicedeferred.call( arguments, 0 ),
			i = 0,
			length = args.length,
			pvalues = new array( length ),
			count = length,
			pcount = length,
			deferred = length <= 1 && firstparam && jquery.isfunction( firstparam.promise ) ?
				firstparam :
				jquery.deferred(),
			promise = deferred.promise();
		function resolvefunc( i ) {
			return function( value ) {
				args[ i ] = arguments.length > 1 ? slicedeferred.call( arguments, 0 ) : value;
				if ( !( --count ) ) {
					deferred.resolvewith( deferred, args );
				}
			};
		}
		function progressfunc( i ) {
			return function( value ) {
				pvalues[ i ] = arguments.length > 1 ? slicedeferred.call( arguments, 0 ) : value;
				deferred.notifywith( promise, pvalues );
			};
		}
		if ( length > 1 ) {
			for ( ; i < length; i++ ) {
				if ( args[ i ] && args[ i ].promise && jquery.isfunction( args[ i ].promise ) ) {
					args[ i ].promise().then( resolvefunc(i), deferred.reject, progressfunc(i) );
				} else {
					--count;
				}
			}
			if ( !count ) {
				deferred.resolvewith( deferred, args );
			}
		} else if ( deferred !== firstparam ) {
			deferred.resolvewith( deferred, length ? [ firstparam ] : [] );
		}
		return promise;
	}
});




jquery.support = (function() {

	var support,
		all,
		a,
		select,
		opt,
		input,
		margindiv,
		fragment,
		tds,
		events,
		eventname,
		i,
		issupported,
		div = document.createelement( "div" ),
		documentelement = document.documentelement;

	// preliminary tests
	div.setattribute("classname", "t");
	div.innerhtml = "   <link/><table></table><a href='/a' style='top:1px;float:left;opacity:.55;'>a</a><input type='checkbox'/>";

	all = div.getelementsbytagname( "*" );
	a = div.getelementsbytagname( "a" )[ 0 ];

	// can't get basic test support
	if ( !all || !all.length || !a ) {
		return {};
	}

	// first batch of supports tests
	select = document.createelement( "select" );
	opt = select.appendchild( document.createelement("option") );
	input = div.getelementsbytagname( "input" )[ 0 ];

	support = {
		// ie strips leading whitespace when .innerhtml is used
		leadingwhitespace: ( div.firstchild.nodetype === 3 ),

		// make sure that tbody elements aren't automatically inserted
		// ie will insert them into empty tables
		tbody: !div.getelementsbytagname("tbody").length,

		// make sure that link elements get serialized correctly by innerhtml
		// this requires a wrapper element in ie
		htmlserialize: !!div.getelementsbytagname("link").length,

		// get the style information from getattribute
		// (ie uses .csstext instead)
		style: /top/.test( a.getattribute("style") ),

		// make sure that urls aren't manipulated
		// (ie normalizes it by default)
		hrefnormalized: ( a.getattribute("href") === "/a" ),

		// make sure that element opacity exists
		// (ie uses filter instead)
		// use a regex to work around a webkit issue. see #5145
		opacity: /^0.55/.test( a.style.opacity ),

		// verify style float existence
		// (ie uses stylefloat instead of cssfloat)
		cssfloat: !!a.style.cssfloat,

		// make sure that if no value is specified for a checkbox
		// that it defaults to "on".
		// (webkit defaults to "" instead)
		checkon: ( input.value === "on" ),

		// make sure that a selected-by-default option has a working selected property.
		// (webkit defaults to false instead of true, ie too, if it's in an optgroup)
		optselected: opt.selected,

		// test setattribute on camelcase class. if it works, we need attrfixes when doing get/setattribute (ie6/7)
		getsetattribute: div.classname !== "t",

		// tests for enctype support on a form(#6743)
		enctype: !!document.createelement("form").enctype,

		// makes sure cloning an html5 element does not cause problems
		// where outerhtml is undefined, this still works
		html5clone: document.createelement("nav").clonenode( true ).outerhtml !== "<:nav></:nav>",

		// will be defined later
		submitbubbles: true,
		changebubbles: true,
		focusinbubbles: false,
		deleteexpando: true,
		nocloneevent: true,
		inlineblockneedslayout: false,
		shrinkwrapblocks: false,
		reliablemarginright: true
	};

	// make sure checked status is properly cloned
	input.checked = true;
	support.noclonechecked = input.clonenode( true ).checked;

	// make sure that the options inside disabled selects aren't marked as disabled
	// (webkit marks them as disabled)
	select.disabled = true;
	support.optdisabled = !opt.disabled;

	// test to see if it's possible to delete an expando from an element
	// fails in internet explorer
	try {
		delete div.test;
	} catch( e ) {
		support.deleteexpando = false;
	}

	if ( !div.addeventlistener && div.attachevent && div.fireevent ) {
		div.attachevent( "onclick", function() {
			// cloning a node shouldn't copy over any
			// bound event handlers (ie does this)
			support.nocloneevent = false;
		});
		div.clonenode( true ).fireevent( "onclick" );
	}

	// check if a radio maintains its value
	// after being appended to the dom
	input = document.createelement("input");
	input.value = "t";
	input.setattribute("type", "radio");
	support.radiovalue = input.value === "t";

	input.setattribute("checked", "checked");
	div.appendchild( input );
	fragment = document.createdocumentfragment();
	fragment.appendchild( div.lastchild );

	// webkit doesn't clone checked state correctly in fragments
	support.checkclone = fragment.clonenode( true ).clonenode( true ).lastchild.checked;

	// check if a disconnected checkbox will retain its checked
	// value of true after appended to the dom (ie6/7)
	support.appendchecked = input.checked;

	fragment.removechild( input );
	fragment.appendchild( div );

	div.innerhtml = "";

	// check if div with explicit width and no margin-right incorrectly
	// gets computed margin-right based on width of container. for more
	// info see bug #3333
	// fails in webkit before feb 2011 nightlies
	// webkit bug 13343 - getcomputedstyle returns wrong value for margin-right
	if ( window.getcomputedstyle ) {
		margindiv = document.createelement( "div" );
		margindiv.style.width = "0";
		margindiv.style.marginright = "0";
		div.style.width = "2px";
		div.appendchild( margindiv );
		support.reliablemarginright =
			( parseint( ( window.getcomputedstyle( margindiv, null ) || { marginright: 0 } ).marginright, 10 ) || 0 ) === 0;
	}

	// technique from juriy zaytsev
	// http://perfectionkills.com/detecting-event-support-without-browser-sniffing/
	// we only care about the case where non-standard event systems
	// are used, namely in ie. short-circuiting here helps us to
	// avoid an eval call (in setattribute) which can cause csp
	// to go haywire. see: https://developer.mozilla.org/en/security/csp
	if ( div.attachevent ) {
		for( i in {
			submit: 1,
			change: 1,
			focusin: 1
		}) {
			eventname = "on" + i;
			issupported = ( eventname in div );
			if ( !issupported ) {
				div.setattribute( eventname, "return;" );
				issupported = ( typeof div[ eventname ] === "function" );
			}
			support[ i + "bubbles" ] = issupported;
		}
	}

	fragment.removechild( div );

	// null elements to avoid leaks in ie
	fragment = select = opt = margindiv = div = input = null;

	// run tests that need a body at doc ready
	jquery(function() {
		var container, outer, inner, table, td, offsetsupport,
			conmargintop, ptlm, vb, style, html,
			body = document.getelementsbytagname("body")[0];

		if ( !body ) {
			// return for frameset docs that don't have a body
			return;
		}

		conmargintop = 1;
		ptlm = "position:absolute;top:0;left:0;width:1px;height:1px;margin:0;";
		vb = "visibility:hidden;border:0;";
		style = "style='" + ptlm + "border:5px solid #000;padding:0;'";
		html = "<div " + style + "><div></div></div>" +
			"<table " + style + " cellpadding='0' cellspacing='0'>" +
			"<tr><td></td></tr></table>";

		container = document.createelement("div");
		container.style.csstext = vb + "width:0;height:0;position:static;top:0;margin-top:" + conmargintop + "px";
		body.insertbefore( container, body.firstchild );

		// construct the test element
		div = document.createelement("div");
		container.appendchild( div );

		// check if table cells still have offsetwidth/height when they are set
		// to display:none and there are still other visible table cells in a
		// table row; if so, offsetwidth/height are not reliable for use when
		// determining if an element has been hidden directly using
		// display:none (it is still safe to use offsets if a parent element is
		// hidden; don safety goggles and see bug #4512 for more information).
		// (only ie 8 fails this test)
		div.innerhtml = "<table><tr><td style='padding:0;border:0;display:none'></td><td>t</td></tr></table>";
		tds = div.getelementsbytagname( "td" );
		issupported = ( tds[ 0 ].offsetheight === 0 );

		tds[ 0 ].style.display = "";
		tds[ 1 ].style.display = "none";

		// check if empty table cells still have offsetwidth/height
		// (ie <= 8 fail this test)
		support.reliablehiddenoffsets = issupported && ( tds[ 0 ].offsetheight === 0 );

		// figure out if the w3c box model works as expected
		div.innerhtml = "";
		div.style.width = div.style.paddingleft = "1px";
		jquery.boxmodel = support.boxmodel = div.offsetwidth === 2;

		if ( typeof div.style.zoom !== "undefined" ) {
			// check if natively block-level elements act like inline-block
			// elements when setting their display to 'inline' and giving
			// them layout
			// (ie < 8 does this)
			div.style.display = "inline";
			div.style.zoom = 1;
			support.inlineblockneedslayout = ( div.offsetwidth === 2 );

			// check if elements with layout shrink-wrap their children
			// (ie 6 does this)
			div.style.display = "";
			div.innerhtml = "<div style='width:4px;'></div>";
			support.shrinkwrapblocks = ( div.offsetwidth !== 2 );
		}

		div.style.csstext = ptlm + vb;
		div.innerhtml = html;

		outer = div.firstchild;
		inner = outer.firstchild;
		td = outer.nextsibling.firstchild.firstchild;

		offsetsupport = {
			doesnotaddborder: ( inner.offsettop !== 5 ),
			doesaddborderfortableandcells: ( td.offsettop === 5 )
		};

		inner.style.position = "fixed";
		inner.style.top = "20px";

		// safari subtracts parent border width here which is 5px
		offsetsupport.fixedposition = ( inner.offsettop === 20 || inner.offsettop === 15 );
		inner.style.position = inner.style.top = "";

		outer.style.overflow = "hidden";
		outer.style.position = "relative";

		offsetsupport.subtractsborderforoverflownotvisible = ( inner.offsettop === -5 );
		offsetsupport.doesnotincludemargininbodyoffset = ( body.offsettop !== conmargintop );

		body.removechild( container );
		div  = container = null;

		jquery.extend( support, offsetsupport );
	});

	return support;
})();




var rbrace = /^(?:\{.*\}|\[.*\])$/,
	rmultidash = /([a-z])/g;

jquery.extend({
	cache: {},

	// please use with caution
	uuid: 0,

	// unique for each copy of jquery on the page
	// non-digits removed to match rinlinejquery
	expando: "jquery" + ( jquery.fn.jquery + math.random() ).replace( /\d/g, "" ),

	// the following elements throw uncatchable exceptions if you
	// attempt to add expando properties to them.
	nodata: {
		"embed": true,
		// ban all objects except for flash (which handle expandos)
		"object": "clsid:d27cdb6e-ae6d-11cf-96b8-444553540000",
		"applet": true
	},

	hasdata: function( elem ) {
		elem = elem.nodetype ? jquery.cache[ elem[jquery.expando] ] : elem[ jquery.expando ];
		return !!elem && !isemptydataobject( elem );
	},

	data: function( elem, name, data, pvt /* internal use only */ ) {
		if ( !jquery.acceptdata( elem ) ) {
			return;
		}

		var privatecache, thiscache, ret,
			internalkey = jquery.expando,
			getbyname = typeof name === "string",

			// we have to handle dom nodes and js objects differently because ie6-7
			// can't gc object references properly across the dom-js boundary
			isnode = elem.nodetype,

			// only dom nodes need the global jquery cache; js object data is
			// attached directly to the object so gc can occur automatically
			cache = isnode ? jquery.cache : elem,

			// only defining an id for js objects if its cache already exists allows
			// the code to shortcut on the same path as a dom node with no cache
			id = isnode ? elem[ internalkey ] : elem[ internalkey ] && internalkey,
			isevents = name === "events";

		// avoid doing any more work than we need to when trying to get data on an
		// object that has no data at all
		if ( (!id || !cache[id] || (!isevents && !pvt && !cache[id].data)) && getbyname && data === undefined ) {
			return;
		}

		if ( !id ) {
			// only dom nodes need a new unique id for each element since their data
			// ends up in the global cache
			if ( isnode ) {
				elem[ internalkey ] = id = ++jquery.uuid;
			} else {
				id = internalkey;
			}
		}

		if ( !cache[ id ] ) {
			cache[ id ] = {};

			// avoids exposing jquery metadata on plain js objects when the object
			// is serialized using json.stringify
			if ( !isnode ) {
				cache[ id ].tojson = jquery.noop;
			}
		}

		// an object can be passed to jquery.data instead of a key/value pair; this gets
		// shallow copied over onto the existing cache
		if ( typeof name === "object" || typeof name === "function" ) {
			if ( pvt ) {
				cache[ id ] = jquery.extend( cache[ id ], name );
			} else {
				cache[ id ].data = jquery.extend( cache[ id ].data, name );
			}
		}

		privatecache = thiscache = cache[ id ];

		// jquery data() is stored in a separate object inside the object's internal data
		// cache in order to avoid key collisions between internal data and user-defined
		// data.
		if ( !pvt ) {
			if ( !thiscache.data ) {
				thiscache.data = {};
			}

			thiscache = thiscache.data;
		}

		if ( data !== undefined ) {
			thiscache[ jquery.camelcase( name ) ] = data;
		}

		// users should not attempt to inspect the internal events object using jquery.data,
		// it is undocumented and subject to change. but does anyone listen? no.
		if ( isevents && !thiscache[ name ] ) {
			return privatecache.events;
		}

		// check for both converted-to-camel and non-converted data property names
		// if a data property was specified
		if ( getbyname ) {

			// first try to find as-is property data
			ret = thiscache[ name ];

			// test for null|undefined property data
			if ( ret == null ) {

				// try to find the camelcased property
				ret = thiscache[ jquery.camelcase( name ) ];
			}
		} else {
			ret = thiscache;
		}

		return ret;
	},

	removedata: function( elem, name, pvt /* internal use only */ ) {
		if ( !jquery.acceptdata( elem ) ) {
			return;
		}

		var thiscache, i, l,

			// reference to internal data cache key
			internalkey = jquery.expando,

			isnode = elem.nodetype,

			// see jquery.data for more information
			cache = isnode ? jquery.cache : elem,

			// see jquery.data for more information
			id = isnode ? elem[ internalkey ] : internalkey;

		// if there is already no cache entry for this object, there is no
		// purpose in continuing
		if ( !cache[ id ] ) {
			return;
		}

		if ( name ) {

			thiscache = pvt ? cache[ id ] : cache[ id ].data;

			if ( thiscache ) {

				// support array or space separated string names for data keys
				if ( !jquery.isarray( name ) ) {

					// try the string as a key before any manipulation
					if ( name in thiscache ) {
						name = [ name ];
					} else {

						// split the camel cased version by spaces unless a key with the spaces exists
						name = jquery.camelcase( name );
						if ( name in thiscache ) {
							name = [ name ];
						} else {
							name = name.split( " " );
						}
					}
				}

				for ( i = 0, l = name.length; i < l; i++ ) {
					delete thiscache[ name[i] ];
				}

				// if there is no data left in the cache, we want to continue
				// and let the cache object itself get destroyed
				if ( !( pvt ? isemptydataobject : jquery.isemptyobject )( thiscache ) ) {
					return;
				}
			}
		}

		// see jquery.data for more information
		if ( !pvt ) {
			delete cache[ id ].data;

			// don't destroy the parent cache unless the internal data object
			// had been the only thing left in it
			if ( !isemptydataobject(cache[ id ]) ) {
				return;
			}
		}

		// browsers that fail expando deletion also refuse to delete expandos on
		// the window, but it will allow it on all other js objects; other browsers
		// don't care
		// ensure that `cache` is not a window object #10080
		if ( jquery.support.deleteexpando || !cache.setinterval ) {
			delete cache[ id ];
		} else {
			cache[ id ] = null;
		}

		// we destroyed the cache and need to eliminate the expando on the node to avoid
		// false lookups in the cache for entries that no longer exist
		if ( isnode ) {
			// ie does not allow us to delete expando properties from nodes,
			// nor does it have a removeattribute function on document nodes;
			// we must handle all of these cases
			if ( jquery.support.deleteexpando ) {
				delete elem[ internalkey ];
			} else if ( elem.removeattribute ) {
				elem.removeattribute( internalkey );
			} else {
				elem[ internalkey ] = null;
			}
		}
	},

	// for internal use only.
	_data: function( elem, name, data ) {
		return jquery.data( elem, name, data, true );
	},

	// a method for determining if a dom node can handle the data expando
	acceptdata: function( elem ) {
		if ( elem.nodename ) {
			var match = jquery.nodata[ elem.nodename.tolowercase() ];

			if ( match ) {
				return !(match === true || elem.getattribute("classid") !== match);
			}
		}

		return true;
	}
});

jquery.fn.extend({
	data: function( key, value ) {
		var parts, attr, name,
			data = null;

		if ( typeof key === "undefined" ) {
			if ( this.length ) {
				data = jquery.data( this[0] );

				if ( this[0].nodetype === 1 && !jquery._data( this[0], "parsedattrs" ) ) {
					attr = this[0].attributes;
					for ( var i = 0, l = attr.length; i < l; i++ ) {
						name = attr[i].name;

						if ( name.indexof( "data-" ) === 0 ) {
							name = jquery.camelcase( name.substring(5) );

							dataattr( this[0], name, data[ name ] );
						}
					}
					jquery._data( this[0], "parsedattrs", true );
				}
			}

			return data;

		} else if ( typeof key === "object" ) {
			return this.each(function() {
				jquery.data( this, key );
			});
		}

		parts = key.split(".");
		parts[1] = parts[1] ? "." + parts[1] : "";

		if ( value === undefined ) {
			data = this.triggerhandler("getdata" + parts[1] + "!", [parts[0]]);

			// try to fetch any internally stored data first
			if ( data === undefined && this.length ) {
				data = jquery.data( this[0], key );
				data = dataattr( this[0], key, data );
			}

			return data === undefined && parts[1] ?
				this.data( parts[0] ) :
				data;

		} else {
			return this.each(function() {
				var self = jquery( this ),
					args = [ parts[0], value ];

				self.triggerhandler( "setdata" + parts[1] + "!", args );
				jquery.data( this, key, value );
				self.triggerhandler( "changedata" + parts[1] + "!", args );
			});
		}
	},

	removedata: function( key ) {
		return this.each(function() {
			jquery.removedata( this, key );
		});
	}
});

function dataattr( elem, key, data ) {
	// if nothing was found internally, try to fetch any
	// data from the html5 data-* attribute
	if ( data === undefined && elem.nodetype === 1 ) {

		var name = "data-" + key.replace( rmultidash, "-$1" ).tolowercase();

		data = elem.getattribute( name );

		if ( typeof data === "string" ) {
			try {
				data = data === "true" ? true :
				data === "false" ? false :
				data === "null" ? null :
				jquery.isnumeric( data ) ? parsefloat( data ) :
					rbrace.test( data ) ? jquery.parsejson( data ) :
					data;
			} catch( e ) {}

			// make sure we set the data so it isn't changed later
			jquery.data( elem, key, data );

		} else {
			data = undefined;
		}
	}

	return data;
}

// checks a cache object for emptiness
function isemptydataobject( obj ) {
	for ( var name in obj ) {

		// if the public data object is empty, the private is still empty
		if ( name === "data" && jquery.isemptyobject( obj[name] ) ) {
			continue;
		}
		if ( name !== "tojson" ) {
			return false;
		}
	}

	return true;
}




function handlequeuemarkdefer( elem, type, src ) {
	var deferdatakey = type + "defer",
		queuedatakey = type + "queue",
		markdatakey = type + "mark",
		defer = jquery._data( elem, deferdatakey );
	if ( defer &&
		( src === "queue" || !jquery._data(elem, queuedatakey) ) &&
		( src === "mark" || !jquery._data(elem, markdatakey) ) ) {
		// give room for hard-coded callbacks to fire first
		// and eventually mark/queue something else on the element
		settimeout( function() {
			if ( !jquery._data( elem, queuedatakey ) &&
				!jquery._data( elem, markdatakey ) ) {
				jquery.removedata( elem, deferdatakey, true );
				defer.fire();
			}
		}, 0 );
	}
}

jquery.extend({

	_mark: function( elem, type ) {
		if ( elem ) {
			type = ( type || "fx" ) + "mark";
			jquery._data( elem, type, (jquery._data( elem, type ) || 0) + 1 );
		}
	},

	_unmark: function( force, elem, type ) {
		if ( force !== true ) {
			type = elem;
			elem = force;
			force = false;
		}
		if ( elem ) {
			type = type || "fx";
			var key = type + "mark",
				count = force ? 0 : ( (jquery._data( elem, key ) || 1) - 1 );
			if ( count ) {
				jquery._data( elem, key, count );
			} else {
				jquery.removedata( elem, key, true );
				handlequeuemarkdefer( elem, type, "mark" );
			}
		}
	},

	queue: function( elem, type, data ) {
		var q;
		if ( elem ) {
			type = ( type || "fx" ) + "queue";
			q = jquery._data( elem, type );

			// speed up dequeue by getting out quickly if this is just a lookup
			if ( data ) {
				if ( !q || jquery.isarray(data) ) {
					q = jquery._data( elem, type, jquery.makearray(data) );
				} else {
					q.push( data );
				}
			}
			return q || [];
		}
	},

	dequeue: function( elem, type ) {
		type = type || "fx";

		var queue = jquery.queue( elem, type ),
			fn = queue.shift(),
			hooks = {};

		// if the fx queue is dequeued, always remove the progress sentinel
		if ( fn === "inprogress" ) {
			fn = queue.shift();
		}

		if ( fn ) {
			// add a progress sentinel to prevent the fx queue from being
			// automatically dequeued
			if ( type === "fx" ) {
				queue.unshift( "inprogress" );
			}

			jquery._data( elem, type + ".run", hooks );
			fn.call( elem, function() {
				jquery.dequeue( elem, type );
			}, hooks );
		}

		if ( !queue.length ) {
			jquery.removedata( elem, type + "queue " + type + ".run", true );
			handlequeuemarkdefer( elem, type, "queue" );
		}
	}
});

jquery.fn.extend({
	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[0] !== "inprogress" ) {
				jquery.dequeue( this, type );
			}
		});
	},
	dequeue: function( type ) {
		return this.each(function() {
			jquery.dequeue( this, type );
		});
	},
	// based off of the plugin by clint helfers, with permission.
	// http://blindsignals.com/index.php/2009/07/jquery-delay/
	delay: function( time, type ) {
		time = jquery.fx ? jquery.fx.speeds[ time ] || time : time;
		type = type || "fx";

		return this.queue( type, function( next, hooks ) {
			var timeout = settimeout( next, time );
			hooks.stop = function() {
				cleartimeout( timeout );
			};
		});
	},
	clearqueue: function( type ) {
		return this.queue( type || "fx", [] );
	},
	// get a promise resolved when queues of a certain type
	// are emptied (fx is the type by default)
	promise: function( type, object ) {
		if ( typeof type !== "string" ) {
			object = type;
			type = undefined;
		}
		type = type || "fx";
		var defer = jquery.deferred(),
			elements = this,
			i = elements.length,
			count = 1,
			deferdatakey = type + "defer",
			queuedatakey = type + "queue",
			markdatakey = type + "mark",
			tmp;
		function resolve() {
			if ( !( --count ) ) {
				defer.resolvewith( elements, [ elements ] );
			}
		}
		while( i-- ) {
			if (( tmp = jquery.data( elements[ i ], deferdatakey, undefined, true ) ||
					( jquery.data( elements[ i ], queuedatakey, undefined, true ) ||
						jquery.data( elements[ i ], markdatakey, undefined, true ) ) &&
					jquery.data( elements[ i ], deferdatakey, jquery.callbacks( "once memory" ), true ) )) {
				count++;
				tmp.add( resolve );
			}
		}
		resolve();
		return defer.promise();
	}
});




var rclass = /[\n\t\r]/g,
	rspace = /\s+/,
	rreturn = /\r/g,
	rtype = /^(?:button|input)$/i,
	rfocusable = /^(?:button|input|object|select|textarea)$/i,
	rclickable = /^a(?:rea)?$/i,
	rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,
	getsetattribute = jquery.support.getsetattribute,
	nodehook, boolhook, fixspecified;

jquery.fn.extend({
	attr: function( name, value ) {
		return jquery.access( this, name, value, true, jquery.attr );
	},

	removeattr: function( name ) {
		return this.each(function() {
			jquery.removeattr( this, name );
		});
	},

	prop: function( name, value ) {
		return jquery.access( this, name, value, true, jquery.prop );
	},

	removeprop: function( name ) {
		name = jquery.propfix[ name ] || name;
		return this.each(function() {
			// try/catch handles cases where ie balks (such as removing a property on window)
			try {
				this[ name ] = undefined;
				delete this[ name ];
			} catch( e ) {}
		});
	},

	addclass: function( value ) {
		var classnames, i, l, elem,
			setclass, c, cl;

		if ( jquery.isfunction( value ) ) {
			return this.each(function( j ) {
				jquery( this ).addclass( value.call(this, j, this.classname) );
			});
		}

		if ( value && typeof value === "string" ) {
			classnames = value.split( rspace );

			for ( i = 0, l = this.length; i < l; i++ ) {
				elem = this[ i ];

				if ( elem.nodetype === 1 ) {
					if ( !elem.classname && classnames.length === 1 ) {
						elem.classname = value;

					} else {
						setclass = " " + elem.classname + " ";

						for ( c = 0, cl = classnames.length; c < cl; c++ ) {
							if ( !~setclass.indexof( " " + classnames[ c ] + " " ) ) {
								setclass += classnames[ c ] + " ";
							}
						}
						elem.classname = jquery.trim( setclass );
					}
				}
			}
		}

		return this;
	},

	removeclass: function( value ) {
		var classnames, i, l, elem, classname, c, cl;

		if ( jquery.isfunction( value ) ) {
			return this.each(function( j ) {
				jquery( this ).removeclass( value.call(this, j, this.classname) );
			});
		}

		if ( (value && typeof value === "string") || value === undefined ) {
			classnames = ( value || "" ).split( rspace );

			for ( i = 0, l = this.length; i < l; i++ ) {
				elem = this[ i ];

				if ( elem.nodetype === 1 && elem.classname ) {
					if ( value ) {
						classname = (" " + elem.classname + " ").replace( rclass, " " );
						for ( c = 0, cl = classnames.length; c < cl; c++ ) {
							classname = classname.replace(" " + classnames[ c ] + " ", " ");
						}
						elem.classname = jquery.trim( classname );

					} else {
						elem.classname = "";
					}
				}
			}
		}

		return this;
	},

	toggleclass: function( value, stateval ) {
		var type = typeof value,
			isbool = typeof stateval === "boolean";

		if ( jquery.isfunction( value ) ) {
			return this.each(function( i ) {
				jquery( this ).toggleclass( value.call(this, i, this.classname, stateval), stateval );
			});
		}

		return this.each(function() {
			if ( type === "string" ) {
				// toggle individual class names
				var classname,
					i = 0,
					self = jquery( this ),
					state = stateval,
					classnames = value.split( rspace );

				while ( (classname = classnames[ i++ ]) ) {
					// check each classname given, space seperated list
					state = isbool ? state : !self.hasclass( classname );
					self[ state ? "addclass" : "removeclass" ]( classname );
				}

			} else if ( type === "undefined" || type === "boolean" ) {
				if ( this.classname ) {
					// store classname if set
					jquery._data( this, "__classname__", this.classname );
				}

				// toggle whole classname
				this.classname = this.classname || value === false ? "" : jquery._data( this, "__classname__" ) || "";
			}
		});
	},

	hasclass: function( selector ) {
		var classname = " " + selector + " ",
			i = 0,
			l = this.length;
		for ( ; i < l; i++ ) {
			if ( this[i].nodetype === 1 && (" " + this[i].classname + " ").replace(rclass, " ").indexof( classname ) > -1 ) {
				return true;
			}
		}

		return false;
	},

	val: function( value ) {
		var hooks, ret, isfunction,
			elem = this[0];

		if ( !arguments.length ) {
			if ( elem ) {
				hooks = jquery.valhooks[ elem.nodename.tolowercase() ] || jquery.valhooks[ elem.type ];

				if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) {
					return ret;
				}

				ret = elem.value;

				return typeof ret === "string" ?
					// handle most common string cases
					ret.replace(rreturn, "") :
					// handle cases where value is null/undef or number
					ret == null ? "" : ret;
			}

			return;
		}

		isfunction = jquery.isfunction( value );

		return this.each(function( i ) {
			var self = jquery(this), val;

			if ( this.nodetype !== 1 ) {
				return;
			}

			if ( isfunction ) {
				val = value.call( this, i, self.val() );
			} else {
				val = value;
			}

			// treat null/undefined as ""; convert numbers to string
			if ( val == null ) {
				val = "";
			} else if ( typeof val === "number" ) {
				val += "";
			} else if ( jquery.isarray( val ) ) {
				val = jquery.map(val, function ( value ) {
					return value == null ? "" : value + "";
				});
			}

			hooks = jquery.valhooks[ this.nodename.tolowercase() ] || jquery.valhooks[ this.type ];

			// if set returns undefined, fall back to normal setting
			if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) {
				this.value = val;
			}
		});
	}
});

jquery.extend({
	valhooks: {
		option: {
			get: function( elem ) {
				// attributes.value is undefined in blackberry 4.7 but
				// uses .value. see #6932
				var val = elem.attributes.value;
				return !val || val.specified ? elem.value : elem.text;
			}
		},
		select: {
			get: function( elem ) {
				var value, i, max, option,
					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
				i = one ? index : 0;
				max = one ? index + 1 : options.length;
				for ( ; i < max; i++ ) {
					option = options[ i ];

					// don't return options that are disabled or in a disabled optgroup
					if ( option.selected && (jquery.support.optdisabled ? !option.disabled : option.getattribute("disabled") === null) &&
							(!option.parentnode.disabled || !jquery.nodename( option.parentnode, "optgroup" )) ) {

						// get the specific 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 );
					}
				}

				// fixes bug #2551 -- select.val() broken in ie after form.reset()
				if ( one && !values.length && options.length ) {
					return jquery( options[ index ] ).val();
				}

				return values;
			},

			set: function( elem, value ) {
				var values = jquery.makearray( value );

				jquery(elem).find("option").each(function() {
					this.selected = jquery.inarray( jquery(this).val(), values ) >= 0;
				});

				if ( !values.length ) {
					elem.selectedindex = -1;
				}
				return values;
			}
		}
	},

	attrfn: {
		val: true,
		css: true,
		html: true,
		text: true,
		data: true,
		width: true,
		height: true,
		offset: true
	},

	attr: function( elem, name, value, pass ) {
		var ret, hooks, notxml,
			ntype = elem.nodetype;

		// don't get/set attributes on text, comment and attribute nodes
		if ( !elem || ntype === 3 || ntype === 8 || ntype === 2 ) {
			return;
		}

		if ( pass && name in jquery.attrfn ) {
			return jquery( elem )[ name ]( value );
		}

		// fallback to prop when attributes are not supported
		if ( typeof elem.getattribute === "undefined" ) {
			return jquery.prop( elem, name, value );
		}

		notxml = ntype !== 1 || !jquery.isxmldoc( elem );

		// all attributes are lowercase
		// grab necessary hook if one is defined
		if ( notxml ) {
			name = name.tolowercase();
			hooks = jquery.attrhooks[ name ] || ( rboolean.test( name ) ? boolhook : nodehook );
		}

		if ( value !== undefined ) {

			if ( value === null ) {
				jquery.removeattr( elem, name );
				return;

			} else if ( hooks && "set" in hooks && notxml && (ret = hooks.set( elem, value, name )) !== undefined ) {
				return ret;

			} else {
				elem.setattribute( name, "" + value );
				return value;
			}

		} else if ( hooks && "get" in hooks && notxml && (ret = hooks.get( elem, name )) !== null ) {
			return ret;

		} else {

			ret = elem.getattribute( name );

			// non-existent attributes return null, we normalize to undefined
			return ret === null ?
				undefined :
				ret;
		}
	},

	removeattr: function( elem, value ) {
		var propname, attrnames, name, l,
			i = 0;

		if ( value && elem.nodetype === 1 ) {
			attrnames = value.tolowercase().split( rspace );
			l = attrnames.length;

			for ( ; i < l; i++ ) {
				name = attrnames[ i ];

				if ( name ) {
					propname = jquery.propfix[ name ] || name;

					// see #9699 for explanation of this approach (setting first, then removal)
					jquery.attr( elem, name, "" );
					elem.removeattribute( getsetattribute ? name : propname );

					// set corresponding property to false for boolean attributes
					if ( rboolean.test( name ) && propname in elem ) {
						elem[ propname ] = false;
					}
				}
			}
		}
	},

	attrhooks: {
		type: {
			set: function( elem, value ) {
				// we can't allow the type property to be changed (since it causes problems in ie)
				if ( rtype.test( elem.nodename ) && elem.parentnode ) {
					jquery.error( "type property can't be changed" );
				} else if ( !jquery.support.radiovalue && value === "radio" && jquery.nodename(elem, "input") ) {
					// setting the type on a radio button after the value resets the value in ie6-9
					// reset value to it's default in case type is set after value
					// this is for element creation
					var val = elem.value;
					elem.setattribute( "type", value );
					if ( val ) {
						elem.value = val;
					}
					return value;
				}
			}
		},
		// use the value property for back compat
		// use the nodehook for button elements in ie6/7 (#1954)
		value: {
			get: function( elem, name ) {
				if ( nodehook && jquery.nodename( elem, "button" ) ) {
					return nodehook.get( elem, name );
				}
				return name in elem ?
					elem.value :
					null;
			},
			set: function( elem, value, name ) {
				if ( nodehook && jquery.nodename( elem, "button" ) ) {
					return nodehook.set( elem, value, name );
				}
				// does not return so that setattribute is also used
				elem.value = value;
			}
		}
	},

	propfix: {
		tabindex: "tabindex",
		readonly: "readonly",
		"for": "htmlfor",
		"class": "classname",
		maxlength: "maxlength",
		cellspacing: "cellspacing",
		cellpadding: "cellpadding",
		rowspan: "rowspan",
		colspan: "colspan",
		usemap: "usemap",
		frameborder: "frameborder",
		contenteditable: "contenteditable"
	},

	prop: function( elem, name, value ) {
		var ret, hooks, notxml,
			ntype = elem.nodetype;

		// don't get/set properties on text, comment and attribute nodes
		if ( !elem || ntype === 3 || ntype === 8 || ntype === 2 ) {
			return;
		}

		notxml = ntype !== 1 || !jquery.isxmldoc( elem );

		if ( notxml ) {
			// fix name and attach hooks
			name = jquery.propfix[ name ] || name;
			hooks = jquery.prophooks[ name ];
		}

		if ( value !== undefined ) {
			if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {
				return ret;

			} else {
				return ( elem[ name ] = value );
			}

		} else {
			if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) {
				return ret;

			} else {
				return elem[ name ];
			}
		}
	},

	prophooks: {
		tabindex: {
			get: function( elem ) {
				// 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/
				var attributenode = elem.getattributenode("tabindex");

				return attributenode && attributenode.specified ?
					parseint( attributenode.value, 10 ) :
					rfocusable.test( elem.nodename ) || rclickable.test( elem.nodename ) && elem.href ?
						0 :
						undefined;
			}
		}
	}
});

// add the tabindex prophook to attrhooks for back-compat (different case is intentional)
jquery.attrhooks.tabindex = jquery.prophooks.tabindex;

// hook for boolean attributes
boolhook = {
	get: function( elem, name ) {
		// align boolean attributes with corresponding properties
		// fall back to attribute presence where some booleans are not supported
		var attrnode,
			property = jquery.prop( elem, name );
		return property === true || typeof property !== "boolean" && ( attrnode = elem.getattributenode(name) ) && attrnode.nodevalue !== false ?
			name.tolowercase() :
			undefined;
	},
	set: function( elem, value, name ) {
		var propname;
		if ( value === false ) {
			// remove boolean attributes when set to false
			jquery.removeattr( elem, name );
		} else {
			// value is true since we know at this point it's type boolean and not false
			// set boolean attributes to the same name and set the dom property
			propname = jquery.propfix[ name ] || name;
			if ( propname in elem ) {
				// only set the idl specifically if it already exists on the element
				elem[ propname ] = true;
			}

			elem.setattribute( name, name.tolowercase() );
		}
		return name;
	}
};

// ie6/7 do not support getting/setting some attributes with get/setattribute
if ( !getsetattribute ) {

	fixspecified = {
		name: true,
		id: true
	};

	// use this for any attribute in ie6/7
	// this fixes almost every ie6/7 issue
	nodehook = jquery.valhooks.button = {
		get: function( elem, name ) {
			var ret;
			ret = elem.getattributenode( name );
			return ret && ( fixspecified[ name ] ? ret.nodevalue !== "" : ret.specified ) ?
				ret.nodevalue :
				undefined;
		},
		set: function( elem, value, name ) {
			// set the existing or create a new attribute node
			var ret = elem.getattributenode( name );
			if ( !ret ) {
				ret = document.createattribute( name );
				elem.setattributenode( ret );
			}
			return ( ret.nodevalue = value + "" );
		}
	};

	// apply the nodehook to tabindex
	jquery.attrhooks.tabindex.set = nodehook.set;

	// set width and height to auto instead of 0 on empty string( bug #8150 )
	// this is for removals
	jquery.each([ "width", "height" ], function( i, name ) {
		jquery.attrhooks[ name ] = jquery.extend( jquery.attrhooks[ name ], {
			set: function( elem, value ) {
				if ( value === "" ) {
					elem.setattribute( name, "auto" );
					return value;
				}
			}
		});
	});

	// set contenteditable to false on removals(#10429)
	// setting to empty string throws an error as an invalid value
	jquery.attrhooks.contenteditable = {
		get: nodehook.get,
		set: function( elem, value, name ) {
			if ( value === "" ) {
				value = "false";
			}
			nodehook.set( elem, value, name );
		}
	};
}


// some attributes require a special call on ie
if ( !jquery.support.hrefnormalized ) {
	jquery.each([ "href", "src", "width", "height" ], function( i, name ) {
		jquery.attrhooks[ name ] = jquery.extend( jquery.attrhooks[ name ], {
			get: function( elem ) {
				var ret = elem.getattribute( name, 2 );
				return ret === null ? undefined : ret;
			}
		});
	});
}

if ( !jquery.support.style ) {
	jquery.attrhooks.style = {
		get: function( elem ) {
			// return undefined in the case of empty string
			// normalize to lowercase since ie uppercases css property names
			return elem.style.csstext.tolowercase() || undefined;
		},
		set: function( elem, value ) {
			return ( elem.style.csstext = "" + value );
		}
	};
}

// safari mis-reports the default selected property of an option
// accessing the parent's selectedindex property fixes it
if ( !jquery.support.optselected ) {
	jquery.prophooks.selected = jquery.extend( jquery.prophooks.selected, {
		get: function( elem ) {
			var parent = elem.parentnode;

			if ( parent ) {
				parent.selectedindex;

				// make sure that it also works with optgroups, see #5701
				if ( parent.parentnode ) {
					parent.parentnode.selectedindex;
				}
			}
			return null;
		}
	});
}

// ie6/7 call enctype encoding
if ( !jquery.support.enctype ) {
	jquery.propfix.enctype = "encoding";
}

// radios and checkboxes getter/setter
if ( !jquery.support.checkon ) {
	jquery.each([ "radio", "checkbox" ], function() {
		jquery.valhooks[ this ] = {
			get: function( elem ) {
				// handle the case where in webkit "" is returned instead of "on" if a value isn't specified
				return elem.getattribute("value") === null ? "on" : elem.value;
			}
		};
	});
}
jquery.each([ "radio", "checkbox" ], function() {
	jquery.valhooks[ this ] = jquery.extend( jquery.valhooks[ this ], {
		set: function( elem, value ) {
			if ( jquery.isarray( value ) ) {
				return ( elem.checked = jquery.inarray( jquery(elem).val(), value ) >= 0 );
			}
		}
	});
});




var rformelems = /^(?:textarea|input|select)$/i,
	rtypenamespace = /^([^\.]*)?(?:\.(.+))?$/,
	rhoverhack = /\bhover(\.\s+)?\b/,
	rkeyevent = /^key/,
	rmouseevent = /^(?:mouse|contextmenu)|click/,
	rfocusmorph = /^(?:focusinfocus|focusoutblur)$/,
	rquickis = /^(\w*)(?:#([\w\-]+))?(?:\.([\w\-]+))?$/,
	quickparse = function( selector ) {
		var quick = rquickis.exec( selector );
		if ( quick ) {
			//   0  1    2   3
			// [ _, tag, id, class ]
			quick[1] = ( quick[1] || "" ).tolowercase();
			quick[3] = quick[3] && new regexp( "(?:^|\\s)" + quick[3] + "(?:\\s|$)" );
		}
		return quick;
	},
	quickis = function( elem, m ) {
		var attrs = elem.attributes || {};
		return (
			(!m[1] || elem.nodename.tolowercase() === m[1]) &&
			(!m[2] || (attrs.id || {}).value === m[2]) &&
			(!m[3] || m[3].test( (attrs[ "class" ] || {}).value ))
		);
	},
	hoverhack = function( events ) {
		return jquery.event.special.hover ? events : events.replace( rhoverhack, "mouseenter$1 mouseleave$1" );
	};

/*
 * helper functions for managing events -- not part of the public interface.
 * props to dean edwards' addevent library for many of the ideas.
 */
jquery.event = {

	add: function( elem, types, handler, data, selector ) {

		var elemdata, eventhandle, events,
			t, tns, type, namespaces, handleobj,
			handleobjin, quick, handlers, special;

		// don't attach events to nodata or text/comment nodes (allow plain objects tho)
		if ( elem.nodetype === 3 || elem.nodetype === 8 || !types || !handler || !(elemdata = jquery._data( elem )) ) {
			return;
		}

		// caller can pass in an object of custom data in lieu of the handler
		if ( handler.handler ) {
			handleobjin = handler;
			handler = handleobjin.handler;
		}

		// make sure that the handler has a unique id, used to find/remove it later
		if ( !handler.guid ) {
			handler.guid = jquery.guid++;
		}

		// init the element's event structure and main handler, if this is the first
		events = elemdata.events;
		if ( !events ) {
			elemdata.events = events = {};
		}
		eventhandle = elemdata.handle;
		if ( !eventhandle ) {
			elemdata.handle = eventhandle = function( e ) {
				// discard the second event of a jquery.event.trigger() and
				// when an event is called after a page has unloaded
				return typeof jquery !== "undefined" && (!e || jquery.event.triggered !== e.type) ?
					jquery.event.dispatch.apply( eventhandle.elem, arguments ) :
					undefined;
			};
			// add elem as a property of the handle fn to prevent a memory leak with ie non-native events
			eventhandle.elem = elem;
		}

		// handle multiple events separated by a space
		// jquery(...).bind("mouseover mouseout", fn);
		types = jquery.trim( hoverhack(types) ).split( " " );
		for ( t = 0; t < types.length; t++ ) {

			tns = rtypenamespace.exec( types[t] ) || [];
			type = tns[1];
			namespaces = ( tns[2] || "" ).split( "." ).sort();

			// if event changes its type, use the special event handlers for the changed type
			special = jquery.event.special[ type ] || {};

			// if selector defined, determine special event api type, otherwise given type
			type = ( selector ? special.delegatetype : special.bindtype ) || type;

			// update special based on newly reset type
			special = jquery.event.special[ type ] || {};

			// handleobj is passed to all event handlers
			handleobj = jquery.extend({
				type: type,
				origtype: tns[1],
				data: data,
				handler: handler,
				guid: handler.guid,
				selector: selector,
				quick: quickparse( selector ),
				namespace: namespaces.join(".")
			}, handleobjin );

			// init the event handler queue if we're the first
			handlers = events[ type ];
			if ( !handlers ) {
				handlers = events[ type ] = [];
				handlers.delegatecount = 0;

				// only use addeventlistener/attachevent if the special events handler returns false
				if ( !special.setup || special.setup.call( elem, data, namespaces, eventhandle ) === false ) {
					// bind the global event handler to the element
					if ( elem.addeventlistener ) {
						elem.addeventlistener( type, eventhandle, false );

					} else if ( elem.attachevent ) {
						elem.attachevent( "on" + type, eventhandle );
					}
				}
			}

			if ( special.add ) {
				special.add.call( elem, handleobj );

				if ( !handleobj.handler.guid ) {
					handleobj.handler.guid = handler.guid;
				}
			}

			// add to the element's handler list, delegates in front
			if ( selector ) {
				handlers.splice( handlers.delegatecount++, 0, handleobj );
			} else {
				handlers.push( handleobj );
			}

			// keep track of which events have ever been used, for event optimization
			jquery.event.global[ type ] = true;
		}

		// nullify elem to prevent memory leaks in ie
		elem = null;
	},

	global: {},

	// detach an event or set of events from an element
	remove: function( elem, types, handler, selector, mappedtypes ) {

		var elemdata = jquery.hasdata( elem ) && jquery._data( elem ),
			t, tns, type, origtype, namespaces, origcount,
			j, events, special, handle, eventtype, handleobj;

		if ( !elemdata || !(events = elemdata.events) ) {
			return;
		}

		// once for each type.namespace in types; type may be omitted
		types = jquery.trim( hoverhack( types || "" ) ).split(" ");
		for ( t = 0; t < types.length; t++ ) {
			tns = rtypenamespace.exec( types[t] ) || [];
			type = origtype = tns[1];
			namespaces = tns[2];

			// unbind all events (on this namespace, if provided) for the element
			if ( !type ) {
				for ( type in events ) {
					jquery.event.remove( elem, type + types[ t ], handler, selector, true );
				}
				continue;
			}

			special = jquery.event.special[ type ] || {};
			type = ( selector? special.delegatetype : special.bindtype ) || type;
			eventtype = events[ type ] || [];
			origcount = eventtype.length;
			namespaces = namespaces ? new regexp("(^|\\.)" + namespaces.split(".").sort().join("\\.(?:.*\\.)?") + "(\\.|$)") : null;

			// remove matching events
			for ( j = 0; j < eventtype.length; j++ ) {
				handleobj = eventtype[ j ];

				if ( ( mappedtypes || origtype === handleobj.origtype ) &&
					 ( !handler || handler.guid === handleobj.guid ) &&
					 ( !namespaces || namespaces.test( handleobj.namespace ) ) &&
					 ( !selector || selector === handleobj.selector || selector === "**" && handleobj.selector ) ) {
					eventtype.splice( j--, 1 );

					if ( handleobj.selector ) {
						eventtype.delegatecount--;
					}
					if ( special.remove ) {
						special.remove.call( elem, handleobj );
					}
				}
			}

			// remove generic event handler if we removed something and no more handlers exist
			// (avoids potential for endless recursion during removal of special event handlers)
			if ( eventtype.length === 0 && origcount !== eventtype.length ) {
				if ( !special.teardown || special.teardown.call( elem, namespaces ) === false ) {
					jquery.removeevent( elem, type, elemdata.handle );
				}

				delete events[ type ];
			}
		}

		// remove the expando if it's no longer used
		if ( jquery.isemptyobject( events ) ) {
			handle = elemdata.handle;
			if ( handle ) {
				handle.elem = null;
			}

			// removedata also checks for emptiness and clears the expando if empty
			// so use it instead of delete
			jquery.removedata( elem, [ "events", "handle" ], true );
		}
	},

	// events that are safe to short-circuit if no handlers are attached.
	// native dom events should not be added, they may have inline handlers.
	customevent: {
		"getdata": true,
		"setdata": true,
		"changedata": true
	},

	trigger: function( event, data, elem, onlyhandlers ) {
		// don't do events on text and comment nodes
		if ( elem && (elem.nodetype === 3 || elem.nodetype === 8) ) {
			return;
		}

		// event object or event type
		var type = event.type || event,
			namespaces = [],
			cache, exclusive, i, cur, old, ontype, special, handle, eventpath, bubbletype;

		// focus/blur morphs to focusin/out; ensure we're not firing them right now
		if ( rfocusmorph.test( type + jquery.event.triggered ) ) {
			return;
		}

		if ( type.indexof( "!" ) >= 0 ) {
			// exclusive events trigger only for the exact event (no namespaces)
			type = type.slice(0, -1);
			exclusive = true;
		}

		if ( type.indexof( "." ) >= 0 ) {
			// namespaced trigger; create a regexp to match event type in handle()
			namespaces = type.split(".");
			type = namespaces.shift();
			namespaces.sort();
		}

		if ( (!elem || jquery.event.customevent[ type ]) && !jquery.event.global[ type ] ) {
			// no jquery handlers for this event type, and it can't have inline handlers
			return;
		}

		// caller can pass in an event, object, or just an event type string
		event = typeof event === "object" ?
			// jquery.event object
			event[ jquery.expando ] ? event :
			// object literal
			new jquery.event( type, event ) :
			// just the event type (string)
			new jquery.event( type );

		event.type = type;
		event.istrigger = true;
		event.exclusive = exclusive;
		event.namespace = namespaces.join( "." );
		event.namespace_re = event.namespace? new regexp("(^|\\.)" + namespaces.join("\\.(?:.*\\.)?") + "(\\.|$)") : null;
		ontype = type.indexof( ":" ) < 0 ? "on" + type : "";

		// handle a global trigger
		if ( !elem ) {

			// todo: stop taunting the data cache; remove global events and always attach to document
			cache = jquery.cache;
			for ( i in cache ) {
				if ( cache[ i ].events && cache[ i ].events[ type ] ) {
					jquery.event.trigger( event, data, cache[ i ].handle.elem, true );
				}
			}
			return;
		}

		// clean up the event in case it is being reused
		event.result = undefined;
		if ( !event.target ) {
			event.target = elem;
		}

		// clone any incoming data and prepend the event, creating the handler arg list
		data = data != null ? jquery.makearray( data ) : [];
		data.unshift( event );

		// allow special events to draw outside the lines
		special = jquery.event.special[ type ] || {};
		if ( special.trigger && special.trigger.apply( elem, data ) === false ) {
			return;
		}

		// determine event propagation path in advance, per w3c events spec (#9951)
		// bubble up to document, then to window; watch for a global ownerdocument var (#9724)
		eventpath = [[ elem, special.bindtype || type ]];
		if ( !onlyhandlers && !special.nobubble && !jquery.iswindow( elem ) ) {

			bubbletype = special.delegatetype || type;
			cur = rfocusmorph.test( bubbletype + type ) ? elem : elem.parentnode;
			old = null;
			for ( ; cur; cur = cur.parentnode ) {
				eventpath.push([ cur, bubbletype ]);
				old = cur;
			}

			// only add window if we got to document (e.g., not plain obj or detached dom)
			if ( old && old === elem.ownerdocument ) {
				eventpath.push([ old.defaultview || old.parentwindow || window, bubbletype ]);
			}
		}

		// fire handlers on the event path
		for ( i = 0; i < eventpath.length && !event.ispropagationstopped(); i++ ) {

			cur = eventpath[i][0];
			event.type = eventpath[i][1];

			handle = ( jquery._data( cur, "events" ) || {} )[ event.type ] && jquery._data( cur, "handle" );
			if ( handle ) {
				handle.apply( cur, data );
			}
			// note that this is a bare js function and not a jquery handler
			handle = ontype && cur[ ontype ];
			if ( handle && jquery.acceptdata( cur ) && handle.apply( cur, data ) === false ) {
				event.preventdefault();
			}
		}
		event.type = type;

		// if nobody prevented the default action, do it now
		if ( !onlyhandlers && !event.isdefaultprevented() ) {

			if ( (!special._default || special._default.apply( elem.ownerdocument, data ) === false) &&
				!(type === "click" && jquery.nodename( elem, "a" )) && jquery.acceptdata( elem ) ) {

				// call a native dom method on the target with the same name name as the event.
				// can't use an .isfunction() check here because ie6/7 fails that test.
				// don't do default actions on window, that's where global variables be (#6170)
				// ie<9 dies on focus/blur to hidden element (#1486)
				if ( ontype && elem[ type ] && ((type !== "focus" && type !== "blur") || event.target.offsetwidth !== 0) && !jquery.iswindow( elem ) ) {

					// don't re-trigger an onfoo event when we call its foo() method
					old = elem[ ontype ];

					if ( old ) {
						elem[ ontype ] = null;
					}

					// prevent re-triggering of the same event, since we already bubbled it above
					jquery.event.triggered = type;
					elem[ type ]();
					jquery.event.triggered = undefined;

					if ( old ) {
						elem[ ontype ] = old;
					}
				}
			}
		}

		return event.result;
	},

	dispatch: function( event ) {

		// make a writable jquery.event from the native event object
		event = jquery.event.fix( event || window.event );

		var handlers = ( (jquery._data( this, "events" ) || {} )[ event.type ] || []),
			delegatecount = handlers.delegatecount,
			args = [].slice.call( arguments, 0 ),
			run_all = !event.exclusive && !event.namespace,
			handlerqueue = [],
			i, j, cur, jqcur, ret, selmatch, matched, matches, handleobj, sel, related;

		// use the fix-ed jquery.event rather than the (read-only) native event
		args[0] = event;
		event.delegatetarget = this;

		// determine handlers that should run if there are delegated events
		// avoid disabled elements in ie (#6911) and non-left-click bubbling in firefox (#3861)
		if ( delegatecount && !event.target.disabled && !(event.button && event.type === "click") ) {

			// pregenerate a single jquery object for reuse with .is()
			jqcur = jquery(this);
			jqcur.context = this.ownerdocument || this;

			for ( cur = event.target; cur != this; cur = cur.parentnode || this ) {
				selmatch = {};
				matches = [];
				jqcur[0] = cur;
				for ( i = 0; i < delegatecount; i++ ) {
					handleobj = handlers[ i ];
					sel = handleobj.selector;

					if ( selmatch[ sel ] === undefined ) {
						selmatch[ sel ] = (
							handleobj.quick ? quickis( cur, handleobj.quick ) : jqcur.is( sel )
						);
					}
					if ( selmatch[ sel ] ) {
						matches.push( handleobj );
					}
				}
				if ( matches.length ) {
					handlerqueue.push({ elem: cur, matches: matches });
				}
			}
		}

		// add the remaining (directly-bound) handlers
		if ( handlers.length > delegatecount ) {
			handlerqueue.push({ elem: this, matches: handlers.slice( delegatecount ) });
		}

		// run delegates first; they may want to stop propagation beneath us
		for ( i = 0; i < handlerqueue.length && !event.ispropagationstopped(); i++ ) {
			matched = handlerqueue[ i ];
			event.currenttarget = matched.elem;

			for ( j = 0; j < matched.matches.length && !event.isimmediatepropagationstopped(); j++ ) {
				handleobj = matched.matches[ j ];

				// triggered event must either 1) be non-exclusive and have no namespace, or
				// 2) have namespace(s) a subset or equal to those in the bound event (both can have no namespace).
				if ( run_all || (!event.namespace && !handleobj.namespace) || event.namespace_re && event.namespace_re.test( handleobj.namespace ) ) {

					event.data = handleobj.data;
					event.handleobj = handleobj;

					ret = ( (jquery.event.special[ handleobj.origtype ] || {}).handle || handleobj.handler )
							.apply( matched.elem, args );

					if ( ret !== undefined ) {
						event.result = ret;
						if ( ret === false ) {
							event.preventdefault();
							event.stoppropagation();
						}
					}
				}
			}
		}

		return event.result;
	},

	// includes some event props shared by keyevent and mouseevent
	// *** attrchange attrname relatednode srcelement  are not normalized, non-w3c, deprecated, will be removed in 1.8 ***
	props: "attrchange attrname relatednode srcelement altkey bubbles cancelable ctrlkey currenttarget eventphase metakey relatedtarget shiftkey target timestamp view which".split(" "),

	fixhooks: {},

	keyhooks: {
		props: "char charcode key keycode".split(" "),
		filter: function( event, original ) {

			// add which for key events
			if ( event.which == null ) {
				event.which = original.charcode != null ? original.charcode : original.keycode;
			}

			return event;
		}
	},

	mousehooks: {
		props: "button buttons clientx clienty fromelement offsetx offsety pagex pagey screenx screeny toelement".split(" "),
		filter: function( event, original ) {
			var eventdoc, doc, body,
				button = original.button,
				fromelement = original.fromelement;

			// calculate pagex/y if missing and clientx/y available
			if ( event.pagex == null && original.clientx != null ) {
				eventdoc = event.target.ownerdocument || document;
				doc = eventdoc.documentelement;
				body = eventdoc.body;

				event.pagex = original.clientx + ( doc && doc.scrollleft || body && body.scrollleft || 0 ) - ( doc && doc.clientleft || body && body.clientleft || 0 );
				event.pagey = original.clienty + ( doc && doc.scrolltop  || body && body.scrolltop  || 0 ) - ( doc && doc.clienttop  || body && body.clienttop  || 0 );
			}

			// add relatedtarget, if necessary
			if ( !event.relatedtarget && fromelement ) {
				event.relatedtarget = fromelement === event.target ? original.toelement : fromelement;
			}

			// add which for click: 1 === left; 2 === middle; 3 === right
			// note: button is not normalized, so don't use it
			if ( !event.which && button !== undefined ) {
				event.which = ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) );
			}

			return event;
		}
	},

	fix: function( event ) {
		if ( event[ jquery.expando ] ) {
			return event;
		}

		// create a writable copy of the event object and normalize some properties
		var i, prop,
			originalevent = event,
			fixhook = jquery.event.fixhooks[ event.type ] || {},
			copy = fixhook.props ? this.props.concat( fixhook.props ) : this.props;

		event = jquery.event( originalevent );

		for ( i = copy.length; i; ) {
			prop = copy[ --i ];
			event[ prop ] = originalevent[ prop ];
		}

		// fix target property, if necessary (#1925, ie 6/7/8 & safari2)
		if ( !event.target ) {
			event.target = originalevent.srcelement || document;
		}

		// target should not be a text node (#504, safari)
		if ( event.target.nodetype === 3 ) {
			event.target = event.target.parentnode;
		}

		// for mouse/key events; add metakey if it's not there (#3368, ie6/7/8)
		if ( event.metakey === undefined ) {
			event.metakey = event.ctrlkey;
		}

		return fixhook.filter? fixhook.filter( event, originalevent ) : event;
	},

	special: {
		ready: {
			// make sure the ready event is setup
			setup: jquery.bindready
		},

		load: {
			// prevent triggered image.load events from bubbling to window.load
			nobubble: true
		},

		focus: {
			delegatetype: "focusin"
		},
		blur: {
			delegatetype: "focusout"
		},

		beforeunload: {
			setup: function( data, namespaces, eventhandle ) {
				// we only want to do this special case on windows
				if ( jquery.iswindow( this ) ) {
					this.onbeforeunload = eventhandle;
				}
			},

			teardown: function( namespaces, eventhandle ) {
				if ( this.onbeforeunload === eventhandle ) {
					this.onbeforeunload = null;
				}
			}
		}
	},

	simulate: function( type, elem, event, bubble ) {
		// piggyback on a donor event to simulate a different one.
		// fake originalevent to avoid donor's stoppropagation, but if the
		// simulated event prevents default then we do the same on the donor.
		var e = jquery.extend(
			new jquery.event(),
			event,
			{ type: type,
				issimulated: true,
				originalevent: {}
			}
		);
		if ( bubble ) {
			jquery.event.trigger( e, null, elem );
		} else {
			jquery.event.dispatch.call( elem, e );
		}
		if ( e.isdefaultprevented() ) {
			event.preventdefault();
		}
	}
};

// some plugins are using, but it's undocumented/deprecated and will be removed.
// the 1.7 special event interface should provide all the hooks needed now.
jquery.event.handle = jquery.event.dispatch;

jquery.removeevent = document.removeeventlistener ?
	function( elem, type, handle ) {
		if ( elem.removeeventlistener ) {
			elem.removeeventlistener( type, handle, false );
		}
	} :
	function( elem, type, handle ) {
		if ( elem.detachevent ) {
			elem.detachevent( "on" + type, handle );
		}
	};

jquery.event = function( src, props ) {
	// allow instantiation without the 'new' keyword
	if ( !(this instanceof jquery.event) ) {
		return new jquery.event( src, props );
	}

	// event object
	if ( src && src.type ) {
		this.originalevent = src;
		this.type = src.type;

		// events bubbling up the document may have been marked as prevented
		// by a handler lower down the tree; reflect the correct value.
		this.isdefaultprevented = ( src.defaultprevented || src.returnvalue === false ||
			src.getpreventdefault && src.getpreventdefault() ) ? returntrue : returnfalse;

	// event type
	} else {
		this.type = src;
	}

	// put explicitly provided properties onto the event object
	if ( props ) {
		jquery.extend( this, props );
	}

	// create a timestamp if incoming event doesn't have one
	this.timestamp = src && src.timestamp || jquery.now();

	// mark it as fixed
	this[ jquery.expando ] = true;
};

function returnfalse() {
	return false;
}
function returntrue() {
	return true;
}

// jquery.event is based on dom3 events as specified by the ecmascript language binding
// http://www.w3.org/tr/2003/wd-dom-level-3-events-20030331/ecma-script-binding.html
jquery.event.prototype = {
	preventdefault: function() {
		this.isdefaultprevented = returntrue;

		var e = this.originalevent;
		if ( !e ) {
			return;
		}

		// if preventdefault exists run it on the original event
		if ( e.preventdefault ) {
			e.preventdefault();

		// otherwise set the returnvalue property of the original event to false (ie)
		} else {
			e.returnvalue = false;
		}
	},
	stoppropagation: function() {
		this.ispropagationstopped = returntrue;

		var e = this.originalevent;
		if ( !e ) {
			return;
		}
		// if stoppropagation exists run it on the original event
		if ( e.stoppropagation ) {
			e.stoppropagation();
		}
		// otherwise set the cancelbubble property of the original event to true (ie)
		e.cancelbubble = true;
	},
	stopimmediatepropagation: function() {
		this.isimmediatepropagationstopped = returntrue;
		this.stoppropagation();
	},
	isdefaultprevented: returnfalse,
	ispropagationstopped: returnfalse,
	isimmediatepropagationstopped: returnfalse
};

// create mouseenter/leave events using mouseover/out and event-time checks
jquery.each({
	mouseenter: "mouseover",
	mouseleave: "mouseout"
}, function( orig, fix ) {
	jquery.event.special[ orig ] = {
		delegatetype: fix,
		bindtype: fix,

		handle: function( event ) {
			var target = this,
				related = event.relatedtarget,
				handleobj = event.handleobj,
				selector = handleobj.selector,
				ret;

			// for mousenter/leave call the handler if related is outside the target.
			// nb: no relatedtarget if the mouse left/entered the browser window
			if ( !related || (related !== target && !jquery.contains( target, related )) ) {
				event.type = handleobj.origtype;
				ret = handleobj.handler.apply( this, arguments );
				event.type = fix;
			}
			return ret;
		}
	};
});

// ie submit delegation
if ( !jquery.support.submitbubbles ) {

	jquery.event.special.submit = {
		setup: function() {
			// only need this for delegated form submit events
			if ( jquery.nodename( this, "form" ) ) {
				return false;
			}

			// lazy-add a submit handler when a descendant form may potentially be submitted
			jquery.event.add( this, "click._submit keypress._submit", function( e ) {
				// node name check avoids a vml-related crash in ie (#9807)
				var elem = e.target,
					form = jquery.nodename( elem, "input" ) || jquery.nodename( elem, "button" ) ? elem.form : undefined;
				if ( form && !form._submit_attached ) {
					jquery.event.add( form, "submit._submit", function( event ) {
						// if form was submitted by the user, bubble the event up the tree
						if ( this.parentnode && !event.istrigger ) {
							jquery.event.simulate( "submit", this.parentnode, event, true );
						}
					});
					form._submit_attached = true;
				}
			});
			// return undefined since we don't need an event listener
		},

		teardown: function() {
			// only need this for delegated form submit events
			if ( jquery.nodename( this, "form" ) ) {
				return false;
			}

			// remove delegated handlers; cleandata eventually reaps submit handlers attached above
			jquery.event.remove( this, "._submit" );
		}
	};
}

// ie change delegation and checkbox/radio fix
if ( !jquery.support.changebubbles ) {

	jquery.event.special.change = {

		setup: function() {

			if ( rformelems.test( this.nodename ) ) {
				// ie doesn't fire change on a check/radio until blur; trigger it on click
				// after a propertychange. eat the blur-change in special.change.handle.
				// this still fires onchange a second time for check/radio after blur.
				if ( this.type === "checkbox" || this.type === "radio" ) {
					jquery.event.add( this, "propertychange._change", function( event ) {
						if ( event.originalevent.propertyname === "checked" ) {
							this._just_changed = true;
						}
					});
					jquery.event.add( this, "click._change", function( event ) {
						if ( this._just_changed && !event.istrigger ) {
							this._just_changed = false;
							jquery.event.simulate( "change", this, event, true );
						}
					});
				}
				return false;
			}
			// delegated event; lazy-add a change handler on descendant inputs
			jquery.event.add( this, "beforeactivate._change", function( e ) {
				var elem = e.target;

				if ( rformelems.test( elem.nodename ) && !elem._change_attached ) {
					jquery.event.add( elem, "change._change", function( event ) {
						if ( this.parentnode && !event.issimulated && !event.istrigger ) {
							jquery.event.simulate( "change", this.parentnode, event, true );
						}
					});
					elem._change_attached = true;
				}
			});
		},

		handle: function( event ) {
			var elem = event.target;

			// swallow native change events from checkbox/radio, we already triggered them above
			if ( this !== elem || event.issimulated || event.istrigger || (elem.type !== "radio" && elem.type !== "checkbox") ) {
				return event.handleobj.handler.apply( this, arguments );
			}
		},

		teardown: function() {
			jquery.event.remove( this, "._change" );

			return rformelems.test( this.nodename );
		}
	};
}

// create "bubbling" focus and blur events
if ( !jquery.support.focusinbubbles ) {
	jquery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {

		// attach a single capturing handler while someone wants focusin/focusout
		var attaches = 0,
			handler = function( event ) {
				jquery.event.simulate( fix, event.target, jquery.event.fix( event ), true );
			};

		jquery.event.special[ fix ] = {
			setup: function() {
				if ( attaches++ === 0 ) {
					document.addeventlistener( orig, handler, true );
				}
			},
			teardown: function() {
				if ( --attaches === 0 ) {
					document.removeeventlistener( orig, handler, true );
				}
			}
		};
	});
}

jquery.fn.extend({

	on: function( types, selector, data, fn, /*internal*/ one ) {
		var origfn, type;

		// types can be a map of types/handlers
		if ( typeof types === "object" ) {
			// ( types-object, selector, data )
			if ( typeof selector !== "string" ) {
				// ( types-object, data )
				data = selector;
				selector = undefined;
			}
			for ( type in types ) {
				this.on( type, selector, data, types[ type ], one );
			}
			return this;
		}

		if ( data == null && fn == null ) {
			// ( types, fn )
			fn = selector;
			data = selector = undefined;
		} else if ( fn == null ) {
			if ( typeof selector === "string" ) {
				// ( types, selector, fn )
				fn = data;
				data = undefined;
			} else {
				// ( types, data, fn )
				fn = data;
				data = selector;
				selector = undefined;
			}
		}
		if ( fn === false ) {
			fn = returnfalse;
		} else if ( !fn ) {
			return this;
		}

		if ( one === 1 ) {
			origfn = fn;
			fn = function( event ) {
				// can use an empty set, since event contains the info
				jquery().off( event );
				return origfn.apply( this, arguments );
			};
			// use same guid so caller can remove using origfn
			fn.guid = origfn.guid || ( origfn.guid = jquery.guid++ );
		}
		return this.each( function() {
			jquery.event.add( this, types, fn, data, selector );
		});
	},
	one: function( types, selector, data, fn ) {
		return this.on.call( this, types, selector, data, fn, 1 );
	},
	off: function( types, selector, fn ) {
		if ( types && types.preventdefault && types.handleobj ) {
			// ( event )  dispatched jquery.event
			var handleobj = types.handleobj;
			jquery( types.delegatetarget ).off(
				handleobj.namespace? handleobj.type + "." + handleobj.namespace : handleobj.type,
				handleobj.selector,
				handleobj.handler
			);
			return this;
		}
		if ( typeof types === "object" ) {
			// ( types-object [, selector] )
			for ( var type in types ) {
				this.off( type, selector, types[ type ] );
			}
			return this;
		}
		if ( selector === false || typeof selector === "function" ) {
			// ( types [, fn] )
			fn = selector;
			selector = undefined;
		}
		if ( fn === false ) {
			fn = returnfalse;
		}
		return this.each(function() {
			jquery.event.remove( this, types, fn, selector );
		});
	},

	bind: function( types, data, fn ) {
		return this.on( types, null, data, fn );
	},
	unbind: function( types, fn ) {
		return this.off( types, null, fn );
	},

	live: function( types, data, fn ) {
		jquery( this.context ).on( types, this.selector, data, fn );
		return this;
	},
	die: function( types, fn ) {
		jquery( this.context ).off( types, this.selector || "**", fn );
		return this;
	},

	delegate: function( selector, types, data, fn ) {
		return this.on( types, selector, data, fn );
	},
	undelegate: function( selector, types, fn ) {
		// ( namespace ) or ( selector, types [, fn] )
		return arguments.length == 1? this.off( selector, "**" ) : this.off( types, selector, fn );
	},

	trigger: function( type, data ) {
		return this.each(function() {
			jquery.event.trigger( type, data, this );
		});
	},
	triggerhandler: function( type, data ) {
		if ( this[0] ) {
			return jquery.event.trigger( type, data, this[0], true );
		}
	},

	toggle: function( fn ) {
		// save reference to arguments for access in closure
		var args = arguments,
			guid = fn.guid || jquery.guid++,
			i = 0,
			toggler = function( event ) {
				// figure out which function to execute
				var lasttoggle = ( jquery._data( this, "lasttoggle" + fn.guid ) || 0 ) % i;
				jquery._data( this, "lasttoggle" + fn.guid, lasttoggle + 1 );

				// make sure that clicks stop
				event.preventdefault();

				// and execute the function
				return args[ lasttoggle ].apply( this, arguments ) || false;
			};

		// link all the functions, so any of them can unbind this click handler
		toggler.guid = guid;
		while ( i < args.length ) {
			args[ i++ ].guid = guid;
		}

		return this.click( toggler );
	},

	hover: function( fnover, fnout ) {
		return this.mouseenter( fnover ).mouseleave( fnout || fnover );
	}
});

jquery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
	"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
	"change select submit keydown keypress keyup error contextmenu").split(" "), function( i, name ) {

	// handle event binding
	jquery.fn[ name ] = function( data, fn ) {
		if ( fn == null ) {
			fn = data;
			data = null;
		}

		return arguments.length > 0 ?
			this.on( name, null, data, fn ) :
			this.trigger( name );
	};

	if ( jquery.attrfn ) {
		jquery.attrfn[ name ] = true;
	}

	if ( rkeyevent.test( name ) ) {
		jquery.event.fixhooks[ name ] = jquery.event.keyhooks;
	}

	if ( rmouseevent.test( name ) ) {
		jquery.event.fixhooks[ name ] = jquery.event.mousehooks;
	}
});



/*!
 * 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,
	expando = "sizcache" + (math.random() + '').replace('.', ''),
	done = 0,
	tostring = object.prototype.tostring,
	hasduplicate = false,
	basehasduplicate = true,
	rbackslash = /\\/g,
	rreturn = /\r\n/g,
	rnonword = /\w/;

// 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, seed );

		} 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, seed );
			}
		}

	} 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, i, len, match, type, left;

	if ( !expr ) {
		return [];
	}

	for ( i = 0, len = expr.order.length; i < len; i++ ) {
		type = expr.order[i];
		
		if ( (match = expr.leftmatch[ type ].exec( expr )) ) {
			left = match[1];
			match.splice( 1, 1 );

			if ( left.substr( left.length - 1 ) !== "\\" ) {
				match[1] = (match[1] || "").replace( rbackslash, "" );
				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,
		type, found, item, filter, left,
		i, pass,
		old = expr,
		result = [],
		curloop = set,
		isxmlfilter = set && set[0] && sizzle.isxml( set[0] );

	while ( expr && set.length ) {
		for ( type in expr.filter ) {
			if ( (match = expr.leftmatch[ type ].exec( expr )) != null && match[2] ) {
				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 ( i = 0; (item = curloop[i]) != null; i++ ) {
						if ( item ) {
							found = filter( item, match, i, curloop );
							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 new error( "syntax error, unrecognized expression: " + msg );
};

/**
 * utility function for retreiving the text value of an array of dom nodes
 * @param {array|element} elem
 */
var gettext = sizzle.gettext = function( elem ) {
    var i, node,
		nodetype = elem.nodetype,
		ret = "";

	if ( nodetype ) {
		if ( nodetype === 1 || nodetype === 9 ) {
			// use textcontent || innertext for elements
			if ( typeof elem.textcontent === 'string' ) {
				return elem.textcontent;
			} else if ( typeof elem.innertext === 'string' ) {
				// replace ie's carriage returns
				return elem.innertext.replace( rreturn, '' );
			} else {
				// traverse it's children
				for ( elem = elem.firstchild; elem; elem = elem.nextsibling) {
					ret += gettext( elem );
				}
			}
		} else if ( nodetype === 3 || nodetype === 4 ) {
			return elem.nodevalue;
		}
	} else {

		// if no nodetype, this is expected to be an array
		for ( i = 0; (node = elem[i]); i++ ) {
			// do not traverse comment nodes
			if ( node.nodetype !== 8 ) {
				ret += gettext( node );
			}
		}
	}
	return ret;
};

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 ) {
			return elem.getattribute( "href" );
		},
		type: function( elem ) {
			return elem.getattribute( "type" );
		}
	},

	relative: {
		"+": function(checkset, part){
			var ispartstr = typeof part === "string",
				istag = ispartstr && !rnonword.test( part ),
				ispartstrnottag = ispartstr && !istag;

			if ( istag ) {
				part = part.tolowercase();
			}

			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.tolowercase() === part ?
						elem || false :
						elem === part;
				}
			}

			if ( ispartstrnottag ) {
				sizzle.filter( part, checkset, true );
			}
		},

		">": function( checkset, part ) {
			var elem,
				ispartstr = typeof part === "string",
				i = 0,
				l = checkset.length;

			if ( ispartstr && !rnonword.test( part ) ) {
				part = part.tolowercase();

				for ( ; i < l; i++ ) {
					elem = checkset[i];

					if ( elem ) {
						var parent = elem.parentnode;
						checkset[i] = parent.nodename.tolowercase() === part ? parent : false;
					}
				}

			} else {
				for ( ; i < l; i++ ) {
					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 nodecheck,
				donename = done++,
				checkfn = dircheck;

			if ( typeof part === "string" && !rnonword.test( part ) ) {
				part = part.tolowercase();
				nodecheck = part;
				checkfn = dirnodecheck;
			}

			checkfn( "parentnode", part, donename, checkset, nodecheck, isxml );
		},

		"~": function( checkset, part, isxml ) {
			var nodecheck,
				donename = done++,
				checkfn = dircheck;

			if ( typeof part === "string" && !rnonword.test( part ) ) {
				part = part.tolowercase();
				nodecheck = part;
				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]);
				// check parentnode to catch when blackberry 4.6 returns
				// nodes that are no longer in the document #6963
				return m && m.parentnode ? [m] : [];
			}
		},

		name: function( match, context ) {
			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 ) {
			if ( typeof context.getelementsbytagname !== "undefined" ) {
				return context.getelementsbytagname( match[1] );
			}
		}
	},
	prefilter: {
		class: function( match, curloop, inplace, result, not, isxml ) {
			match = " " + match[1].replace( rbackslash, "" ) + " ";

			if ( isxml ) {
				return match;
			}

			for ( var i = 0, elem; (elem = curloop[i]) != null; i++ ) {
				if ( elem ) {
					if ( not ^ (elem.classname && (" " + elem.classname + " ").replace(/[\t\n\r]/g, " ").indexof(match) >= 0) ) {
						if ( !inplace ) {
							result.push( elem );
						}

					} else if ( inplace ) {
						curloop[i] = false;
					}
				}
			}

			return false;
		},

		id: function( match ) {
			return match[1].replace( rbackslash, "" );
		},

		tag: function( match, curloop ) {
			return match[1].replace( rbackslash, "" ).tolowercase();
		},

		child: function( match ) {
			if ( match[1] === "nth" ) {
				if ( !match[2] ) {
					sizzle.error( match[0] );
				}

				match[2] = match[2].replace(/^\+|\s*/g, '');

				// parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
				var test = /(-?)(\d*)(?:n([+\-]?\d*))?/.exec(
					match[2] === "even" && "2n" || match[2] === "odd" && "2n+1" ||
					!/\d/.test( match[2] ) && "0n+" + match[2] || match[2]);

				// calculate the numbers (first)n+(last) including if they are negative
				match[2] = (test[1] + (test[2] || 1)) - 0;
				match[3] = test[3] - 0;
			}
			else if ( match[2] ) {
				sizzle.error( match[0] );
			}

			// todo: move to normal caching system
			match[0] = done++;

			return match;
		},

		attr: function( match, curloop, inplace, result, not, isxml ) {
			var name = match[1] = match[1].replace( rbackslash, "" );
			
			if ( !isxml && expr.attrmap[name] ) {
				match[1] = expr.attrmap[name];
			}

			// handle if an un-quoted value was used
			match[4] = ( match[4] || match[5] || "" ).replace( rbackslash, "" );

			if ( match[2] === "~=" ) {
				match[4] = " " + match[4] + " ";
			}

			return match;
		},

		pseudo: function( match, curloop, inplace, result, not ) {
			if ( match[1] === "not" ) {
				// if we're dealing with a complex expression, or a simple one
				if ( ( chunker.exec(match[3]) || "" ).length > 1 || /^\w/.test(match[3]) ) {
					match[3] = sizzle(match[3], null, null, curloop);

				} else {
					var ret = sizzle.filter(match[3], curloop, inplace, true ^ not);

					if ( !inplace ) {
						result.push.apply( result, ret );
					}

					return false;
				}

			} else if ( expr.match.pos.test( match[0] ) || expr.match.child.test( match[0] ) ) {
				return true;
			}
			
			return match;
		},

		pos: function( match ) {
			match.unshift( true );

			return match;
		}
	},
	
	filters: {
		enabled: function( elem ) {
			return elem.disabled === false && elem.type !== "hidden";
		},

		disabled: function( elem ) {
			return elem.disabled === true;
		},

		checked: function( elem ) {
			return elem.checked === true;
		},
		
		selected: function( elem ) {
			// accessing this property makes selected-by-default
			// options in safari work properly
			if ( elem.parentnode ) {
				elem.parentnode.selectedindex;
			}
			
			return elem.selected === true;
		},

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

		empty: function( elem ) {
			return !elem.firstchild;
		},

		has: function( elem, i, match ) {
			return !!sizzle( match[3], elem ).length;
		},

		header: function( elem ) {
			return (/h\d/i).test( elem.nodename );
		},

		text: function( elem ) {
			var attr = elem.getattribute( "type" ), type = elem.type;
			// ie6 and 7 will map elem.type to 'text' for new html5 types (search, etc) 
			// use getattribute instead to test this case
			return elem.nodename.tolowercase() === "input" && "text" === type && ( attr === type || attr === null );
		},

		radio: function( elem ) {
			return elem.nodename.tolowercase() === "input" && "radio" === elem.type;
		},

		checkbox: function( elem ) {
			return elem.nodename.tolowercase() === "input" && "checkbox" === elem.type;
		},

		file: function( elem ) {
			return elem.nodename.tolowercase() === "input" && "file" === elem.type;
		},

		password: function( elem ) {
			return elem.nodename.tolowercase() === "input" && "password" === elem.type;
		},

		submit: function( elem ) {
			var name = elem.nodename.tolowercase();
			return (name === "input" || name === "button") && "submit" === elem.type;
		},

		image: function( elem ) {
			return elem.nodename.tolowercase() === "input" && "image" === elem.type;
		},

		reset: function( elem ) {
			var name = elem.nodename.tolowercase();
			return (name === "input" || name === "button") && "reset" === elem.type;
		},

		button: function( elem ) {
			var name = elem.nodename.tolowercase();
			return name === "input" && "button" === elem.type || name === "button";
		},

		input: function( elem ) {
			return (/input|select|textarea|button/i).test( elem.nodename );
		},

		focus: function( elem ) {
			return elem === elem.ownerdocument.activeelement;
		}
	},
	setfilters: {
		first: function( elem, i ) {
			return i === 0;
		},

		last: function( elem, i, match, array ) {
			return i === array.length - 1;
		},

		even: function( elem, i ) {
			return i % 2 === 0;
		},

		odd: function( elem, i ) {
			return i % 2 === 1;
		},

		lt: function( elem, i, match ) {
			return i < match[3] - 0;
		},

		gt: function( elem, i, match ) {
			return i > match[3] - 0;
		},

		nth: function( elem, i, match ) {
			return match[3] - 0 === i;
		},

		eq: function( elem, i, match ) {
			return match[3] - 0 === i;
		}
	},
	filter: {
		pseudo: function( elem, match, i, array ) {
			var name = match[1],
				filter = expr.filters[ name ];

			if ( filter ) {
				return filter( elem, i, match, array );

			} else if ( name === "contains" ) {
				return (elem.textcontent || elem.innertext || gettext([ elem ]) || "").indexof(match[3]) >= 0;

			} else if ( name === "not" ) {
				var not = match[3];

				for ( var j = 0, l = not.length; j < l; j++ ) {
					if ( not[j] === elem ) {
						return false;
					}
				}

				return true;

			} else {
				sizzle.error( name );
			}
		},

		child: function( elem, match ) {
			var first, last,
				donename, parent, cache,
				count, diff,
				type = match[1],
				node = elem;

			switch ( type ) {
				case "only":
				case "first":
					while ( (node = node.previoussibling) )	 {
						if ( node.nodetype === 1 ) { 
							return false; 
						}
					}

					if ( type === "first" ) { 
						return true; 
					}

					node = elem;

				case "last":
					while ( (node = node.nextsibling) )	 {
						if ( node.nodetype === 1 ) { 
							return false; 
						}
					}

					return true;

				case "nth":
					first = match[2];
					last = match[3];

					if ( first === 1 && last === 0 ) {
						return true;
					}
					
					donename = match[0];
					parent = elem.parentnode;
	
					if ( parent && (parent[ expando ] !== donename || !elem.nodeindex) ) {
						count = 0;
						
						for ( node = parent.firstchild; node; node = node.nextsibling ) {
							if ( node.nodetype === 1 ) {
								node.nodeindex = ++count;
							}
						} 

						parent[ expando ] = donename;
					}
					
					diff = elem.nodeindex - last;

					if ( first === 0 ) {
						return diff === 0;

					} else {
						return ( diff % first === 0 && diff / first >= 0 );
					}
			}
		},

		id: function( elem, match ) {
			return elem.nodetype === 1 && elem.getattribute("id") === match;
		},

		tag: function( elem, match ) {
			return (match === "*" && elem.nodetype === 1) || !!elem.nodename && elem.nodename.tolowercase() === match;
		},
		
		class: function( elem, match ) {
			return (" " + (elem.classname || elem.getattribute("class")) + " ")
				.indexof( match ) > -1;
		},

		attr: function( elem, match ) {
			var name = match[1],
				result = sizzle.attr ?
					sizzle.attr( elem, name ) :
					expr.attrhandle[ name ] ?
					expr.attrhandle[ name ]( elem ) :
					elem[ name ] != null ?
						elem[ name ] :
						elem.getattribute( name ),
				value = result + "",
				type = match[2],
				check = match[4];

			return result == null ?
				type === "!=" :
				!type && sizzle.attr ?
				result != null :
				type === "=" ?
				value === check :
				type === "*=" ?
				value.indexof(check) >= 0 :
				type === "~=" ?
				(" " + value + " ").indexof(check) >= 0 :
				!check ?
				value && result !== false :
				type === "!=" ?
				value !== check :
				type === "^=" ?
				value.indexof(check) === 0 :
				type === "$=" ?
				value.substr(value.length - check.length) === check :
				type === "|=" ?
				value === check || value.substr(0, check.length + 1) === check + "-" :
				false;
		},

		pos: function( elem, match, i, array ) {
			var name = match[2],
				filter = expr.setfilters[ name ];

			if ( filter ) {
				return filter( elem, i, match, array );
			}
		}
	}
};

var origpos = expr.match.pos,
	fescape = function(all, num){
		return "\\" + (num - 0 + 1);
	};

for ( var type in expr.match ) {
	expr.match[ type ] = new regexp( expr.match[ type ].source + (/(?![^\[]*\])(?![^\(]*\))/.source) );
	expr.leftmatch[ type ] = new regexp( /(^(?:.|\r|\n)*?)/.source + expr.match[ type ].source.replace(/\\(\d+)/g, fescape) );
}

var makearray = function( array, results ) {
	array = array.prototype.slice.call( array, 0 );

	if ( results ) {
		results.push.apply( results, array );
		return results;
	}
	
	return array;
};

// perform a simple check to determine if the browser is capable of
// converting a nodelist to an array using builtin methods.
// also verifies that the returned array holds dom nodes
// (which is not the case in the blackberry browser)
try {
	array.prototype.slice.call( document.documentelement.childnodes, 0 )[0].nodetype;

// provide a fallback method if it does not work
} catch( e ) {
	makearray = function( array, results ) {
		var i = 0,
			ret = results || [];

		if ( tostring.call(array) === "[object array]" ) {
			array.prototype.push.apply( ret, array );

		} else {
			if ( typeof array.length === "number" ) {
				for ( var l = array.length; i < l; i++ ) {
					ret.push( array[i] );
				}

			} else {
				for ( ; array[i]; i++ ) {
					ret.push( array[i] );
				}
			}
		}

		return ret;
	};
}

var sortorder, siblingcheck;

if ( document.documentelement.comparedocumentposition ) {
	sortorder = function( a, b ) {
		if ( a === b ) {
			hasduplicate = true;
			return 0;
		}

		if ( !a.comparedocumentposition || !b.comparedocumentposition ) {
			return a.comparedocumentposition ? -1 : 1;
		}

		return a.comparedocumentposition(b) & 4 ? -1 : 1;
	};

} else {
	sortorder = function( a, b ) {
		// the nodes are identical, we can exit early
		if ( a === b ) {
			hasduplicate = true;
			return 0;

		// fallback to using sourceindex (in ie) if it's available on both nodes
		} else if ( a.sourceindex && b.sourceindex ) {
			return a.sourceindex - b.sourceindex;
		}

		var al, bl,
			ap = [],
			bp = [],
			aup = a.parentnode,
			bup = b.parentnode,
			cur = aup;

		// if the nodes are siblings (or identical) we can do a quick check
		if ( aup === bup ) {
			return siblingcheck( a, b );

		// if no parents were found then the nodes are disconnected
		} else if ( !aup ) {
			return -1;

		} else if ( !bup ) {
			return 1;
		}

		// otherwise they're somewhere else in the tree so we need
		// to build up a full list of the parentnodes for comparison
		while ( cur ) {
			ap.unshift( cur );
			cur = cur.parentnode;
		}

		cur = bup;

		while ( cur ) {
			bp.unshift( cur );
			cur = cur.parentnode;
		}

		al = ap.length;
		bl = bp.length;

		// start walking down the tree looking for a discrepancy
		for ( var i = 0; i < al && i < bl; i++ ) {
			if ( ap[i] !== bp[i] ) {
				return siblingcheck( ap[i], bp[i] );
			}
		}

		// we ended someplace up the tree so do a sibling check
		return i === al ?
			siblingcheck( a, bp[i], -1 ) :
			siblingcheck( ap[i], b, 1 );
	};

	siblingcheck = function( a, b, ret ) {
		if ( a === b ) {
			return ret;
		}

		var cur = a.nextsibling;

		while ( cur ) {
			if ( cur === b ) {
				return -1;
			}

			cur = cur.nextsibling;
		}

		return 1;
	};
}

// check to see if the browser returns elements by name when
// querying by getelementbyid (and provide a workaround)
(function(){
	// we're going to inject a fake input element with a specified name
	var form = document.createelement("div"),
		id = "script" + (new date()).gettime(),
		root = document.documentelement;

	form.innerhtml = "<a name='" + id + "'/>";

	// inject it into the root element, check its status, and remove it quickly
	root.insertbefore( form, root.firstchild );

	// the workaround has to do additional checks after a getelementbyid
	// which slows things down for other browsers (hence the branching)
	if ( document.getelementbyid( id ) ) {
		expr.find.id = function( match, context, isxml ) {
			if ( typeof context.getelementbyid !== "undefined" && !isxml ) {
				var m = context.getelementbyid(match[1]);

				return m ?
					m.id === match[1] || typeof m.getattributenode !== "undefined" && m.getattributenode("id").nodevalue === match[1] ?
						[m] :
						undefined :
					[];
			}
		};

		expr.filter.id = function( elem, match ) {
			var node = typeof elem.getattributenode !== "undefined" && elem.getattributenode("id");

			return elem.nodetype === 1 && node && node.nodevalue === match;
		};
	}

	root.removechild( form );

	// release memory in ie
	root = form = null;
})();

(function(){
	// check to see if the browser returns only elements
	// when doing getelementsbytagname("*")

	// create a fake element
	var div = document.createelement("div");
	div.appendchild( document.createcomment("") );

	// make sure no comments are found
	if ( div.getelementsbytagname("*").length > 0 ) {
		expr.find.tag = function( match, context ) {
			var results = context.getelementsbytagname( match[1] );

			// filter out possible comments
			if ( match[1] === "*" ) {
				var tmp = [];

				for ( var i = 0; results[i]; i++ ) {
					if ( results[i].nodetype === 1 ) {
						tmp.push( results[i] );
					}
				}

				results = tmp;
			}

			return results;
		};
	}

	// check to see if an attribute returns normalized href attributes
	div.innerhtml = "<a href='#'></a>";

	if ( div.firstchild && typeof div.firstchild.getattribute !== "undefined" &&
			div.firstchild.getattribute("href") !== "#" ) {

		expr.attrhandle.href = function( elem ) {
			return elem.getattribute( "href", 2 );
		};
	}

	// release memory in ie
	div = null;
})();

if ( document.queryselectorall ) {
	(function(){
		var oldsizzle = sizzle,
			div = document.createelement("div"),
			id = "__sizzle__";

		div.innerhtml = "<p class='test'></p>";

		// safari can't handle uppercase or unicode characters when
		// in quirks mode.
		if ( div.queryselectorall && div.queryselectorall(".test").length === 0 ) {
			return;
		}
	
		sizzle = function( query, context, extra, seed ) {
			context = context || document;

			// only use queryselectorall on non-xml documents
			// (id selectors don't work in non-html documents)
			if ( !seed && !sizzle.isxml(context) ) {
				// see if we find a selector to speed up
				var match = /^(\w+$)|^\.([\w\-]+$)|^#([\w\-]+$)/.exec( query );
				
				if ( match && (context.nodetype === 1 || context.nodetype === 9) ) {
					// speed-up: sizzle("tag")
					if ( match[1] ) {
						return makearray( context.getelementsbytagname( query ), extra );
					
					// speed-up: sizzle(".class")
					} else if ( match[2] && expr.find.class && context.getelementsbyclassname ) {
						return makearray( context.getelementsbyclassname( match[2] ), extra );
					}
				}
				
				if ( context.nodetype === 9 ) {
					// speed-up: sizzle("body")
					// the body element only exists once, optimize finding it
					if ( query === "body" && context.body ) {
						return makearray( [ context.body ], extra );
						
					// speed-up: sizzle("#id")
					} else if ( match && match[3] ) {
						var elem = context.getelementbyid( match[3] );

						// check parentnode to catch when blackberry 4.6 returns
						// nodes that are no longer in the document #6963
						if ( elem && elem.parentnode ) {
							// handle the case where ie and opera return items
							// by name instead of id
							if ( elem.id === match[3] ) {
								return makearray( [ elem ], extra );
							}
							
						} else {
							return makearray( [], extra );
						}
					}
					
					try {
						return makearray( context.queryselectorall(query), extra );
					} catch(qsaerror) {}

				// qsa works strangely on element-rooted queries
				// we can work around this by specifying an extra id on the root
				// and working up from there (thanks to andrew dupont for the technique)
				// ie 8 doesn't work on object elements
				} else if ( context.nodetype === 1 && context.nodename.tolowercase() !== "object" ) {
					var oldcontext = context,
						old = context.getattribute( "id" ),
						nid = old || id,
						hasparent = context.parentnode,
						relativehierarchyselector = /^\s*[+~]/.test( query );

					if ( !old ) {
						context.setattribute( "id", nid );
					} else {
						nid = nid.replace( /'/g, "\\$&" );
					}
					if ( relativehierarchyselector && hasparent ) {
						context = context.parentnode;
					}

					try {
						if ( !relativehierarchyselector || hasparent ) {
							return makearray( context.queryselectorall( "[id='" + nid + "'] " + query ), extra );
						}

					} catch(pseudoerror) {
					} finally {
						if ( !old ) {
							oldcontext.removeattribute( "id" );
						}
					}
				}
			}
		
			return oldsizzle(query, context, extra, seed);
		};

		for ( var prop in oldsizzle ) {
			sizzle[ prop ] = oldsizzle[ prop ];
		}

		// release memory in ie
		div = null;
	})();
}

(function(){
	var html = document.documentelement,
		matches = html.matchesselector || html.mozmatchesselector || html.webkitmatchesselector || html.msmatchesselector;

	if ( matches ) {
		// check to see if it's possible to do matchesselector
		// on a disconnected node (ie 9 fails this)
		var disconnectedmatch = !matches.call( document.createelement( "div" ), "div" ),
			pseudoworks = false;

		try {
			// this should fail with an exception
			// gecko does not error, returns false instead
			matches.call( document.documentelement, "[test!='']:sizzle" );
	
		} catch( pseudoerror ) {
			pseudoworks = true;
		}

		sizzle.matchesselector = function( node, expr ) {
			// make sure that attribute selectors are quoted
			expr = expr.replace(/\=\s*([^'"\]]*)\s*\]/g, "='$1']");

			if ( !sizzle.isxml( node ) ) {
				try { 
					if ( pseudoworks || !expr.match.pseudo.test( expr ) && !/!=/.test( expr ) ) {
						var ret = matches.call( node, expr );

						// ie 9's matchesselector returns false on disconnected nodes
						if ( ret || !disconnectedmatch ||
								// as well, disconnected nodes are said to be in a document
								// fragment in ie 9, so check for that
								node.document && node.document.nodetype !== 11 ) {
							return ret;
						}
					}
				} catch(e) {}
			}

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

(function(){
	var div = document.createelement("div");

	div.innerhtml = "<div class='test e'></div><div class='test'></div>";

	// opera can't find a second classname (in 9.6)
	// also, make sure that getelementsbyclassname actually exists
	if ( !div.getelementsbyclassname || div.getelementsbyclassname("e").length === 0 ) {
		return;
	}

	// safari caches class attributes, doesn't catch changes (in 3.2)
	div.lastchild.classname = "e";

	if ( div.getelementsbyclassname("e").length === 1 ) {
		return;
	}
	
	expr.order.splice(1, 0, "class");
	expr.find.class = function( match, context, isxml ) {
		if ( typeof context.getelementsbyclassname !== "undefined" && !isxml ) {
			return context.getelementsbyclassname(match[1]);
		}
	};

	// release memory in ie
	div = null;
})();

function dirnodecheck( dir, cur, donename, checkset, nodecheck, isxml ) {
	for ( var i = 0, l = checkset.length; i < l; i++ ) {
		var elem = checkset[i];

		if ( elem ) {
			var match = false;

			elem = elem[dir];

			while ( elem ) {
				if ( elem[ expando ] === donename ) {
					match = checkset[elem.sizset];
					break;
				}

				if ( elem.nodetype === 1 && !isxml ){
					elem[ expando ] = donename;
					elem.sizset = i;
				}

				if ( elem.nodename.tolowercase() === cur ) {
					match = elem;
					break;
				}

				elem = elem[dir];
			}

			checkset[i] = match;
		}
	}
}

function dircheck( dir, cur, donename, checkset, nodecheck, isxml ) {
	for ( var i = 0, l = checkset.length; i < l; i++ ) {
		var elem = checkset[i];

		if ( elem ) {
			var match = false;
			
			elem = elem[dir];

			while ( elem ) {
				if ( elem[ expando ] === donename ) {
					match = checkset[elem.sizset];
					break;
				}

				if ( elem.nodetype === 1 ) {
					if ( !isxml ) {
						elem[ expando ] = donename;
						elem.sizset = i;
					}

					if ( typeof cur !== "string" ) {
						if ( elem === cur ) {
							match = true;
							break;
						}

					} else if ( sizzle.filter( cur, [elem] ).length > 0 ) {
						match = elem;
						break;
					}
				}

				elem = elem[dir];
			}

			checkset[i] = match;
		}
	}
}

if ( document.documentelement.contains ) {
	sizzle.contains = function( a, b ) {
		return a !== b && (a.contains ? a.contains(b) : true);
	};

} else if ( document.documentelement.comparedocumentposition ) {
	sizzle.contains = function( a, b ) {
		return !!(a.comparedocumentposition(b) & 16);
	};

} else {
	sizzle.contains = function() {
		return false;
	};
}

sizzle.isxml = function( elem ) {
	// documentelement is verified for cases where it doesn't yet exist
	// (such as loading iframes in ie - #4833) 
	var documentelement = (elem ? elem.ownerdocument || elem : 0).documentelement;

	return documentelement ? documentelement.nodename !== "html" : false;
};

var posprocess = function( selector, context, seed ) {
	var match,
		tmpset = [],
		later = "",
		root = context.nodetype ? [context] : context;

	// position selectors must be done after the filter
	// and so must :not(positional) so we move all pseudos to the end
	while ( (match = expr.match.pseudo.exec( selector )) ) {
		later += match[0];
		selector = selector.replace( expr.match.pseudo, "" );
	}

	selector = expr.relative[selector] ? selector + "*" : selector;

	for ( var i = 0, l = root.length; i < l; i++ ) {
		sizzle( selector, root[i], tmpset, seed );
	}

	return sizzle.filter( later, tmpset );
};

// expose
// override sizzle attribute retrieval
sizzle.attr = jquery.attr;
sizzle.selectors.attrmap = {};
jquery.find = sizzle;
jquery.expr = sizzle.selectors;
jquery.expr[":"] = jquery.expr.filters;
jquery.unique = sizzle.uniquesort;
jquery.text = sizzle.gettext;
jquery.isxmldoc = sizzle.isxml;
jquery.contains = sizzle.contains;


})();


var runtil = /until$/,
	rparentsprev = /^(?:parents|prevuntil|prevall)/,
	// note: this regexp should be improved, or likely pulled from sizzle
	rmultiselector = /,/,
	issimple = /^.[^:#\[\.,]*$/,
	slice = array.prototype.slice,
	pos = jquery.expr.match.pos,
	// methods guaranteed to produce a unique set when starting from a unique set
	guaranteedunique = {
		children: true,
		contents: true,
		next: true,
		prev: true
	};

jquery.fn.extend({
	find: function( selector ) {
		var self = this,
			i, l;

		if ( typeof selector !== "string" ) {
			return jquery( selector ).filter(function() {
				for ( i = 0, l = self.length; i < l; i++ ) {
					if ( jquery.contains( self[ i ], this ) ) {
						return true;
					}
				}
			});
		}

		var ret = this.pushstack( "", "find", selector ),
			length, n, r;

		for ( i = 0, l = this.length; i < l; i++ ) {
			length = ret.length;
			jquery.find( selector, this[i], ret );

			if ( i > 0 ) {
				// make sure that the results are unique
				for ( n = length; n < ret.length; n++ ) {
					for ( r = 0; r < length; r++ ) {
						if ( ret[r] === ret[n] ) {
							ret.splice(n--, 1);
							break;
						}
					}
				}
			}
		}

		return ret;
	},

	has: function( target ) {
		var targets = jquery( target );
		return this.filter(function() {
			for ( var i = 0, l = targets.length; i < l; i++ ) {
				if ( jquery.contains( this, targets[i] ) ) {
					return true;
				}
			}
		});
	},

	not: function( selector ) {
		return this.pushstack( winnow(this, selector, false), "not", selector);
	},

	filter: function( selector ) {
		return this.pushstack( winnow(this, selector, true), "filter", selector );
	},

	is: function( selector ) {
		return !!selector && ( 
			typeof selector === "string" ?
				// if this is a positional selector, check membership in the returned set
				// so $("p:first").is("p:last") won't return true for a doc with two "p".
				pos.test( selector ) ? 
					jquery( selector, this.context ).index( this[0] ) >= 0 :
					jquery.filter( selector, this ).length > 0 :
				this.filter( selector ).length > 0 );
	},

	closest: function( selectors, context ) {
		var ret = [], i, l, cur = this[0];
		
		// array (deprecated as of jquery 1.7)
		if ( jquery.isarray( selectors ) ) {
			var level = 1;

			while ( cur && cur.ownerdocument && cur !== context ) {
				for ( i = 0; i < selectors.length; i++ ) {

					if ( jquery( cur ).is( selectors[ i ] ) ) {
						ret.push({ selector: selectors[ i ], elem: cur, level: level });
					}
				}

				cur = cur.parentnode;
				level++;
			}

			return ret;
		}

		// string
		var pos = pos.test( selectors ) || typeof selectors !== "string" ?
				jquery( selectors, context || this.context ) :
				0;

		for ( i = 0, l = this.length; i < l; i++ ) {
			cur = this[i];

			while ( cur ) {
				if ( pos ? pos.index(cur) > -1 : jquery.find.matchesselector(cur, selectors) ) {
					ret.push( cur );
					break;

				} else {
					cur = cur.parentnode;
					if ( !cur || !cur.ownerdocument || cur === context || cur.nodetype === 11 ) {
						break;
					}
				}
			}
		}

		ret = ret.length > 1 ? jquery.unique( ret ) : ret;

		return this.pushstack( ret, "closest", selectors );
	},

	// determine the position of an element within
	// the matched set of elements
	index: function( elem ) {

		// no argument, return index in parent
		if ( !elem ) {
			return ( this[0] && this[0].parentnode ) ? this.prevall().length : -1;
		}

		// index in selector
		if ( typeof elem === "string" ) {
			return jquery.inarray( this[0], jquery( elem ) );
		}

		// locate the position of the desired element
		return jquery.inarray(
			// if it receives a jquery object, the first element is used
			elem.jquery ? elem[0] : elem, this );
	},

	add: function( selector, context ) {
		var set = typeof selector === "string" ?
				jquery( selector, context ) :
				jquery.makearray( selector && selector.nodetype ? [ selector ] : selector ),
			all = jquery.merge( this.get(), set );

		return this.pushstack( isdisconnected( set[0] ) || isdisconnected( all[0] ) ?
			all :
			jquery.unique( all ) );
	},

	andself: function() {
		return this.add( this.prevobject );
	}
});

// a painfully simple check to see if an element is disconnected
// from a document (should be improved, where feasible).
function isdisconnected( node ) {
	return !node || !node.parentnode || node.parentnode.nodetype === 11;
}

jquery.each({
	parent: function( elem ) {
		var parent = elem.parentnode;
		return parent && parent.nodetype !== 11 ? parent : null;
	},
	parents: function( elem ) {
		return jquery.dir( elem, "parentnode" );
	},
	parentsuntil: function( elem, i, until ) {
		return jquery.dir( elem, "parentnode", until );
	},
	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" );
	},
	nextuntil: function( elem, i, until ) {
		return jquery.dir( elem, "nextsibling", until );
	},
	prevuntil: function( elem, i, until ) {
		return jquery.dir( elem, "previoussibling", until );
	},
	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( until, selector ) {
		var ret = jquery.map( this, fn, until );

		if ( !runtil.test( name ) ) {
			selector = until;
		}

		if ( selector && typeof selector === "string" ) {
			ret = jquery.filter( selector, ret );
		}

		ret = this.length > 1 && !guaranteedunique[ name ] ? jquery.unique( ret ) : ret;

		if ( (this.length > 1 || rmultiselector.test( selector )) && rparentsprev.test( name ) ) {
			ret = ret.reverse();
		}

		return this.pushstack( ret, name, slice.call( arguments ).join(",") );
	};
});

jquery.extend({
	filter: function( expr, elems, not ) {
		if ( not ) {
			expr = ":not(" + expr + ")";
		}

		return elems.length === 1 ?
			jquery.find.matchesselector(elems[0], expr) ? [ elems[0] ] : [] :
			jquery.find.matches(expr, elems);
	},

	dir: function( elem, dir, until ) {
		var matched = [],
			cur = elem[ dir ];

		while ( cur && cur.nodetype !== 9 && (until === undefined || cur.nodetype !== 1 || !jquery( cur ).is( until )) ) {
			if ( cur.nodetype === 1 ) {
				matched.push( cur );
			}
			cur = cur[dir];
		}
		return matched;
	},

	nth: function( cur, result, dir, elem ) {
		result = result || 1;
		var num = 0;

		for ( ; cur; cur = cur[dir] ) {
			if ( cur.nodetype === 1 && ++num === result ) {
				break;
			}
		}

		return cur;
	},

	sibling: function( n, elem ) {
		var r = [];

		for ( ; n; n = n.nextsibling ) {
			if ( n.nodetype === 1 && n !== elem ) {
				r.push( n );
			}
		}

		return r;
	}
});

// implement the identical functionality for filter and not
function winnow( elements, qualifier, keep ) {

	// can't pass null or undefined to indexof in firefox 4
	// set to 0 to skip string check
	qualifier = qualifier || 0;

	if ( jquery.isfunction( qualifier ) ) {
		return jquery.grep(elements, function( elem, i ) {
			var retval = !!qualifier.call( elem, i, elem );
			return retval === keep;
		});

	} else if ( qualifier.nodetype ) {
		return jquery.grep(elements, function( elem, i ) {
			return ( elem === qualifier ) === keep;
		});

	} else if ( typeof qualifier === "string" ) {
		var filtered = jquery.grep(elements, function( elem ) {
			return elem.nodetype === 1;
		});

		if ( issimple.test( qualifier ) ) {
			return jquery.filter(qualifier, filtered, !keep);
		} else {
			qualifier = jquery.filter( qualifier, filtered );
		}
	}

	return jquery.grep(elements, function( elem, i ) {
		return ( jquery.inarray( elem, qualifier ) >= 0 ) === keep;
	});
}




function createsafefragment( document ) {
	var list = nodenames.split( "|" ),
	safefrag = document.createdocumentfragment();

	if ( safefrag.createelement ) {
		while ( list.length ) {
			safefrag.createelement(
				list.pop()
			);
		}
	}
	return safefrag;
}

var nodenames = "abbr|article|aside|audio|canvas|datalist|details|figcaption|figure|footer|" +
		"header|hgroup|mark|meter|nav|output|progress|section|summary|time|video",
	rinlinejquery = / jquery\d+="(?:\d+|null)"/g,
	rleadingwhitespace = /^\s+/,
	rxhtmltag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig,
	rtagname = /<([\w:]+)/,
	rtbody = /<tbody/i,
	rhtml = /<|&#?\w+;/,
	rnoinnerhtml = /<(?:script|style)/i,
	rnocache = /<(?:script|object|embed|option|style)/i,
	rnoshimcache = new regexp("<(?:" + nodenames + ")", "i"),
	// checked="checked" or checked
	rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
	rscripttype = /\/(java|ecma)script/i,
	rcleanscript = /^\s*<!(?:\[cdata\[|\-\-)/,
	wrapmap = {
		option: [ 1, "<select multiple='multiple'>", "</select>" ],
		legend: [ 1, "<fieldset>", "</fieldset>" ],
		thead: [ 1, "<table>", "</table>" ],
		tr: [ 2, "<table><tbody>", "</tbody></table>" ],
		td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
		col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ],
		area: [ 1, "<map>", "</map>" ],
		_default: [ 0, "", "" ]
	},
	safefragment = createsafefragment( document );

wrapmap.optgroup = wrapmap.option;
wrapmap.tbody = wrapmap.tfoot = wrapmap.colgroup = wrapmap.caption = wrapmap.thead;
wrapmap.th = wrapmap.td;

// ie can't serialize <link> and <script> tags normally
if ( !jquery.support.htmlserialize ) {
	wrapmap._default = [ 1, "div<div>", "</div>" ];
}

jquery.fn.extend({
	text: function( text ) {
		if ( jquery.isfunction(text) ) {
			return this.each(function(i) {
				var self = jquery( this );

				self.text( text.call(this, i, self.text()) );
			});
		}

		if ( typeof text !== "object" && text !== undefined ) {
			return this.empty().append( (this[0] && this[0].ownerdocument || document).createtextnode( text ) );
		}

		return jquery.text( this );
	},

	wrapall: function( html ) {
		if ( jquery.isfunction( html ) ) {
			return this.each(function(i) {
				jquery(this).wrapall( html.call(this, i) );
			});
		}

		if ( this[0] ) {
			// the elements to wrap the target around
			var wrap = jquery( html, this[0].ownerdocument ).eq(0).clone(true);

			if ( this[0].parentnode ) {
				wrap.insertbefore( this[0] );
			}

			wrap.map(function() {
				var elem = this;

				while ( elem.firstchild && elem.firstchild.nodetype === 1 ) {
					elem = elem.firstchild;
				}

				return elem;
			}).append( this );
		}

		return this;
	},

	wrapinner: function( html ) {
		if ( jquery.isfunction( html ) ) {
			return this.each(function(i) {
				jquery(this).wrapinner( html.call(this, i) );
			});
		}

		return this.each(function() {
			var self = jquery( this ),
				contents = self.contents();

			if ( contents.length ) {
				contents.wrapall( html );

			} else {
				self.append( html );
			}
		});
	},

	wrap: function( html ) {
		var isfunction = jquery.isfunction( html );

		return this.each(function(i) {
			jquery( this ).wrapall( isfunction ? html.call(this, i) : html );
		});
	},

	unwrap: function() {
		return this.parent().each(function() {
			if ( !jquery.nodename( this, "body" ) ) {
				jquery( this ).replacewith( this.childnodes );
			}
		}).end();
	},

	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() {
		if ( this[0] && this[0].parentnode ) {
			return this.dommanip(arguments, false, function( elem ) {
				this.parentnode.insertbefore( elem, this );
			});
		} else if ( arguments.length ) {
			var set = jquery.clean( arguments );
			set.push.apply( set, this.toarray() );
			return this.pushstack( set, "before", arguments );
		}
	},

	after: function() {
		if ( this[0] && this[0].parentnode ) {
			return this.dommanip(arguments, false, function( elem ) {
				this.parentnode.insertbefore( elem, this.nextsibling );
			});
		} else if ( arguments.length ) {
			var set = this.pushstack( this, "after", arguments );
			set.push.apply( set, jquery.clean(arguments) );
			return set;
		}
	},

	// keepdata is for internal use only--do not document
	remove: function( selector, keepdata ) {
		for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
			if ( !selector || jquery.filter( selector, [ elem ] ).length ) {
				if ( !keepdata && elem.nodetype === 1 ) {
					jquery.cleandata( elem.getelementsbytagname("*") );
					jquery.cleandata( [ elem ] );
				}

				if ( elem.parentnode ) {
					elem.parentnode.removechild( elem );
				}
			}
		}

		return this;
	},

	empty: function() {
		for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
			// remove element nodes and prevent memory leaks
			if ( elem.nodetype === 1 ) {
				jquery.cleandata( elem.getelementsbytagname("*") );
			}

			// remove any remaining nodes
			while ( elem.firstchild ) {
				elem.removechild( elem.firstchild );
			}
		}

		return this;
	},

	clone: function( dataandevents, deepdataandevents ) {
		dataandevents = dataandevents == null ? false : dataandevents;
		deepdataandevents = deepdataandevents == null ? dataandevents : deepdataandevents;

		return this.map( function () {
			return jquery.clone( this, dataandevents, deepdataandevents );
		});
	},

	html: function( value ) {
		if ( value === undefined ) {
			return this[0] && this[0].nodetype === 1 ?
				this[0].innerhtml.replace(rinlinejquery, "") :
				null;

		// see if we can take a shortcut and just use innerhtml
		} else if ( typeof value === "string" && !rnoinnerhtml.test( value ) &&
			(jquery.support.leadingwhitespace || !rleadingwhitespace.test( value )) &&
			!wrapmap[ (rtagname.exec( value ) || ["", ""])[1].tolowercase() ] ) {

			value = value.replace(rxhtmltag, "<$1></$2>");

			try {
				for ( var i = 0, l = this.length; i < l; i++ ) {
					// remove element nodes and prevent memory leaks
					if ( this[i].nodetype === 1 ) {
						jquery.cleandata( this[i].getelementsbytagname("*") );
						this[i].innerhtml = value;
					}
				}

			// if using innerhtml throws an exception, use the fallback method
			} catch(e) {
				this.empty().append( value );
			}

		} else if ( jquery.isfunction( value ) ) {
			this.each(function(i){
				var self = jquery( this );

				self.html( value.call(this, i, self.html()) );
			});

		} else {
			this.empty().append( value );
		}

		return this;
	},

	replacewith: function( value ) {
		if ( this[0] && this[0].parentnode ) {
			// make sure that the elements are removed from the dom before they are inserted
			// this can help fix replacing a parent with child elements
			if ( jquery.isfunction( value ) ) {
				return this.each(function(i) {
					var self = jquery(this), old = self.html();
					self.replacewith( value.call( this, i, old ) );
				});
			}

			if ( typeof value !== "string" ) {
				value = jquery( value ).detach();
			}

			return this.each(function() {
				var next = this.nextsibling,
					parent = this.parentnode;

				jquery( this ).remove();

				if ( next ) {
					jquery(next).before( value );
				} else {
					jquery(parent).append( value );
				}
			});
		} else {
			return this.length ?
				this.pushstack( jquery(jquery.isfunction(value) ? value() : value), "replacewith", value ) :
				this;
		}
	},

	detach: function( selector ) {
		return this.remove( selector, true );
	},

	dommanip: function( args, table, callback ) {
		var results, first, fragment, parent,
			value = args[0],
			scripts = [];

		// we can't clonenode fragments that contain checked, in webkit
		if ( !jquery.support.checkclone && arguments.length === 3 && typeof value === "string" && rchecked.test( value ) ) {
			return this.each(function() {
				jquery(this).dommanip( args, table, callback, true );
			});
		}

		if ( jquery.isfunction(value) ) {
			return this.each(function(i) {
				var self = jquery(this);
				args[0] = value.call(this, i, table ? self.html() : undefined);
				self.dommanip( args, table, callback );
			});
		}

		if ( this[0] ) {
			parent = value && value.parentnode;

			// if we're in a fragment, just use that instead of building a new one
			if ( jquery.support.parentnode && parent && parent.nodetype === 11 && parent.childnodes.length === this.length ) {
				results = { fragment: parent };

			} else {
				results = jquery.buildfragment( args, this, scripts );
			}

			fragment = results.fragment;

			if ( fragment.childnodes.length === 1 ) {
				first = fragment = fragment.firstchild;
			} else {
				first = fragment.firstchild;
			}

			if ( first ) {
				table = table && jquery.nodename( first, "tr" );

				for ( var i = 0, l = this.length, lastindex = l - 1; i < l; i++ ) {
					callback.call(
						table ?
							root(this[i], first) :
							this[i],
						// make sure that we do not leak memory by inadvertently discarding
						// the original fragment (which might have attached data) instead of
						// using it; in addition, use the original fragment object for the last
						// item instead of first because it can end up being emptied incorrectly
						// in certain situations (bug #8070).
						// fragments from the fragment cache must always be cloned and never used
						// in place.
						results.cacheable || ( l > 1 && i < lastindex ) ?
							jquery.clone( fragment, true, true ) :
							fragment
					);
				}
			}

			if ( scripts.length ) {
				jquery.each( scripts, evalscript );
			}
		}

		return this;
	}
});

function root( elem, cur ) {
	return jquery.nodename(elem, "table") ?
		(elem.getelementsbytagname("tbody")[0] ||
		elem.appendchild(elem.ownerdocument.createelement("tbody"))) :
		elem;
}

function clonecopyevent( src, dest ) {

	if ( dest.nodetype !== 1 || !jquery.hasdata( src ) ) {
		return;
	}

	var type, i, l,
		olddata = jquery._data( src ),
		curdata = jquery._data( dest, olddata ),
		events = olddata.events;

	if ( events ) {
		delete curdata.handle;
		curdata.events = {};

		for ( type in events ) {
			for ( i = 0, l = events[ type ].length; i < l; i++ ) {
				jquery.event.add( dest, type + ( events[ type ][ i ].namespace ? "." : "" ) + events[ type ][ i ].namespace, events[ type ][ i ], events[ type ][ i ].data );
			}
		}
	}

	// make the cloned public data object a copy from the original
	if ( curdata.data ) {
		curdata.data = jquery.extend( {}, curdata.data );
	}
}

function clonefixattributes( src, dest ) {
	var nodename;

	// we do not need to do anything for non-elements
	if ( dest.nodetype !== 1 ) {
		return;
	}

	// clearattributes removes the attributes, which we don't want,
	// but also removes the attachevent events, which we *do* want
	if ( dest.clearattributes ) {
		dest.clearattributes();
	}

	// mergeattributes, in contrast, only merges back on the
	// original attributes, not the events
	if ( dest.mergeattributes ) {
		dest.mergeattributes( src );
	}

	nodename = dest.nodename.tolowercase();

	// ie6-8 fail to clone children inside object elements that use
	// the proprietary classid attribute value (rather than the type
	// attribute) to identify the type of content to display
	if ( nodename === "object" ) {
		dest.outerhtml = src.outerhtml;

	} else if ( nodename === "input" && (src.type === "checkbox" || src.type === "radio") ) {
		// ie6-8 fails to persist the checked state of a cloned checkbox
		// or radio button. worse, ie6-7 fail to give the cloned element
		// a checked appearance if the defaultchecked value isn't also set
		if ( src.checked ) {
			dest.defaultchecked = dest.checked = src.checked;
		}

		// ie6-7 get confused and end up setting the value of a cloned
		// checkbox/radio button to an empty string instead of "on"
		if ( dest.value !== src.value ) {
			dest.value = src.value;
		}

	// ie6-8 fails to return the selected option to the default selected
	// state when cloning options
	} else if ( nodename === "option" ) {
		dest.selected = src.defaultselected;

	// ie6-8 fails to set the defaultvalue to the correct value when
	// cloning other types of input fields
	} else if ( nodename === "input" || nodename === "textarea" ) {
		dest.defaultvalue = src.defaultvalue;
	}

	// event data gets referenced instead of copied if the expando
	// gets copied too
	dest.removeattribute( jquery.expando );
}

jquery.buildfragment = function( args, nodes, scripts ) {
	var fragment, cacheable, cacheresults, doc,
	first = args[ 0 ];

	// nodes may contain either an explicit document object,
	// a jquery collection or context object.
	// if nodes[0] contains a valid object to assign to doc
	if ( nodes && nodes[0] ) {
		doc = nodes[0].ownerdocument || nodes[0];
	}

	// ensure that an attr object doesn't incorrectly stand in as a document object
	// chrome and firefox seem to allow this to occur and will throw exception
	// fixes #8950
	if ( !doc.createdocumentfragment ) {
		doc = document;
	}

	// only cache "small" (1/2 kb) html strings that are associated with the main document
	// cloning options loses the selected state, so don't cache them
	// ie 6 doesn't like it when you put <object> or <embed> elements in a fragment
	// also, webkit does not clone 'checked' attributes on clonenode, so don't cache
	// lastly, ie6,7,8 will not correctly reuse cached fragments that were created from unknown elems #10501
	if ( args.length === 1 && typeof first === "string" && first.length < 512 && doc === document &&
		first.charat(0) === "<" && !rnocache.test( first ) &&
		(jquery.support.checkclone || !rchecked.test( first )) &&
		(jquery.support.html5clone || !rnoshimcache.test( first )) ) {

		cacheable = true;

		cacheresults = jquery.fragments[ first ];
		if ( cacheresults && cacheresults !== 1 ) {
			fragment = cacheresults;
		}
	}

	if ( !fragment ) {
		fragment = doc.createdocumentfragment();
		jquery.clean( args, doc, fragment, scripts );
	}

	if ( cacheable ) {
		jquery.fragments[ first ] = cacheresults ? fragment : 1;
	}

	return { fragment: fragment, cacheable: cacheable };
};

jquery.fragments = {};

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 ),
			parent = this.length === 1 && this[0].parentnode;

		if ( parent && parent.nodetype === 11 && parent.childnodes.length === 1 && insert.length === 1 ) {
			insert[ original ]( this[0] );
			return this;

		} else {
			for ( var i = 0, l = insert.length; i < l; i++ ) {
				var elems = ( i > 0 ? this.clone(true) : this ).get();
				jquery( insert[i] )[ original ]( elems );
				ret = ret.concat( elems );
			}

			return this.pushstack( ret, name, insert.selector );
		}
	};
});

function getall( elem ) {
	if ( typeof elem.getelementsbytagname !== "undefined" ) {
		return elem.getelementsbytagname( "*" );

	} else if ( typeof elem.queryselectorall !== "undefined" ) {
		return elem.queryselectorall( "*" );

	} else {
		return [];
	}
}

// used in clean, fixes the defaultchecked property
function fixdefaultchecked( elem ) {
	if ( elem.type === "checkbox" || elem.type === "radio" ) {
		elem.defaultchecked = elem.checked;
	}
}
// finds all inputs and passes them to fixdefaultchecked
function findinputs( elem ) {
	var nodename = ( elem.nodename || "" ).tolowercase();
	if ( nodename === "input" ) {
		fixdefaultchecked( elem );
	// skip scripts, get other children
	} else if ( nodename !== "script" && typeof elem.getelementsbytagname !== "undefined" ) {
		jquery.grep( elem.getelementsbytagname("input"), fixdefaultchecked );
	}
}

// derived from: http://www.iecss.com/shimprove/javascript/shimprove.1-0-1.js
function shimclonenode( elem ) {
	var div = document.createelement( "div" );
	safefragment.appendchild( div );

	div.innerhtml = elem.outerhtml;
	return div.firstchild;
}

jquery.extend({
	clone: function( elem, dataandevents, deepdataandevents ) {
		var srcelements,
			destelements,
			i,
			// ie<=8 does not properly clone detached, unknown element nodes
			clone = jquery.support.html5clone || !rnoshimcache.test( "<" + elem.nodename ) ?
				elem.clonenode( true ) :
				shimclonenode( elem );

		if ( (!jquery.support.nocloneevent || !jquery.support.noclonechecked) &&
				(elem.nodetype === 1 || elem.nodetype === 11) && !jquery.isxmldoc(elem) ) {
			// ie copies events bound via attachevent when using clonenode.
			// calling detachevent on the clone will also remove the events
			// from the original. in order to get around this, we use some
			// proprietary methods to clear the events. thanks to mootools
			// guys for this hotness.

			clonefixattributes( elem, clone );

			// using sizzle here is crazy slow, so we use getelementsbytagname instead
			srcelements = getall( elem );
			destelements = getall( clone );

			// weird iteration because ie will replace the length property
			// with an element if you are cloning the body and one of the
			// elements on the page has a name or id of "length"
			for ( i = 0; srcelements[i]; ++i ) {
				// ensure that the destination node is not null; fixes #9587
				if ( destelements[i] ) {
					clonefixattributes( srcelements[i], destelements[i] );
				}
			}
		}

		// copy the events from the original to the clone
		if ( dataandevents ) {
			clonecopyevent( elem, clone );

			if ( deepdataandevents ) {
				srcelements = getall( elem );
				destelements = getall( clone );

				for ( i = 0; srcelements[i]; ++i ) {
					clonecopyevent( srcelements[i], destelements[i] );
				}
			}
		}

		srcelements = destelements = null;

		// return the cloned set
		return clone;
	},

	clean: function( elems, context, fragment, scripts ) {
		var checkscripttype;

		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;
		}

		var ret = [], j;

		for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
			if ( typeof elem === "number" ) {
				elem += "";
			}

			if ( !elem ) {
				continue;
			}

			// convert html string into dom nodes
			if ( typeof elem === "string" ) {
				if ( !rhtml.test( elem ) ) {
					elem = context.createtextnode( elem );
				} else {
					// fix "xhtml"-style tags in all browsers
					elem = elem.replace(rxhtmltag, "<$1></$2>");

					// trim whitespace, otherwise indexof won't work as expected
					var tag = ( rtagname.exec( elem ) || ["", ""] )[1].tolowercase(),
						wrap = wrapmap[ tag ] || wrapmap._default,
						depth = wrap[0],
						div = context.createelement("div");

					// append wrapper element to unknown element safe doc fragment
					if ( context === document ) {
						// use the fragment we've already created for this document
						safefragment.appendchild( div );
					} else {
						// use a fragment created with the owner document
						createsafefragment( context ).appendchild( div );
					}

					// go to html and back, then peel off extra wrappers
					div.innerhtml = wrap[1] + elem + wrap[2];

					// move to the right depth
					while ( depth-- ) {
						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 = rtbody.test(elem),
							tbody = tag === "table" && !hasbody ?
								div.firstchild && div.firstchild.childnodes :

								// string was a bare <thead> or <tfoot>
								wrap[1] === "<table>" && !hasbody ?
									div.childnodes :
									[];

						for ( 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 && rleadingwhitespace.test( elem ) ) {
						div.insertbefore( context.createtextnode( rleadingwhitespace.exec(elem)[0] ), div.firstchild );
					}

					elem = div.childnodes;
				}
			}

			// resets defaultchecked for any radios and checkboxes
			// about to be appended to the dom in ie 6/7 (#8060)
			var len;
			if ( !jquery.support.appendchecked ) {
				if ( elem[0] && typeof (len = elem.length) === "number" ) {
					for ( j = 0; j < len; j++ ) {
						findinputs( elem[j] );
					}
				} else {
					findinputs( elem );
				}
			}

			if ( elem.nodetype ) {
				ret.push( elem );
			} else {
				ret = jquery.merge( ret, elem );
			}
		}

		if ( fragment ) {
			checkscripttype = function( elem ) {
				return !elem.type || rscripttype.test( elem.type );
			};
			for ( i = 0; ret[i]; i++ ) {
				if ( scripts && 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 ) {
						var jstags = jquery.grep( ret[i].getelementsbytagname( "script" ), checkscripttype );

						ret.splice.apply( ret, [i + 1, 0].concat( jstags ) );
					}
					fragment.appendchild( ret[i] );
				}
			}
		}

		return ret;
	},

	cleandata: function( elems ) {
		var data, id,
			cache = jquery.cache,
			special = jquery.event.special,
			deleteexpando = jquery.support.deleteexpando;

		for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
			if ( elem.nodename && jquery.nodata[elem.nodename.tolowercase()] ) {
				continue;
			}

			id = elem[ jquery.expando ];

			if ( id ) {
				data = cache[ id ];

				if ( data && data.events ) {
					for ( var type in data.events ) {
						if ( special[ type ] ) {
							jquery.event.remove( elem, type );

						// this is a shortcut to avoid jquery.event.remove's overhead
						} else {
							jquery.removeevent( elem, type, data.handle );
						}
					}

					// null the dom reference to avoid ie6/7/8 leak (#7054)
					if ( data.handle ) {
						data.handle.elem = null;
					}
				}

				if ( deleteexpando ) {
					delete elem[ jquery.expando ];

				} else if ( elem.removeattribute ) {
					elem.removeattribute( jquery.expando );
				}

				delete cache[ id ];
			}
		}
	}
});

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 || "" ).replace( rcleanscript, "/*$0*/" ) );
	}

	if ( elem.parentnode ) {
		elem.parentnode.removechild( elem );
	}
}




var ralpha = /alpha\([^)]*\)/i,
	ropacity = /opacity=([^)]*)/,
	// fixed for ie9, see #8346
	rupper = /([a-z]|^ms)/g,
	rnumpx = /^-?\d+(?:px)?$/i,
	rnum = /^-?\d/,
	rrelnum = /^([\-+])=([\-+.\de]+)/,

	cssshow = { position: "absolute", visibility: "hidden", display: "block" },
	csswidth = [ "left", "right" ],
	cssheight = [ "top", "bottom" ],
	curcss,

	getcomputedstyle,
	currentstyle;

jquery.fn.css = function( name, value ) {
	// setting 'undefined' is a no-op
	if ( arguments.length === 2 && value === undefined ) {
		return this;
	}

	return jquery.access( this, name, value, true, function( elem, name, value ) {
		return value !== undefined ?
			jquery.style( elem, name, value ) :
			jquery.css( elem, name );
	});
};

jquery.extend({
	// add in style property hooks for overriding the default
	// behavior of getting and setting a style property
	csshooks: {
		opacity: {
			get: function( elem, computed ) {
				if ( computed ) {
					// we should always get a number back from opacity
					var ret = curcss( elem, "opacity", "opacity" );
					return ret === "" ? "1" : ret;

				} else {
					return elem.style.opacity;
				}
			}
		}
	},

	// exclude the following css properties to add px
	cssnumber: {
		"fillopacity": true,
		"fontweight": true,
		"lineheight": true,
		"opacity": true,
		"orphans": true,
		"widows": true,
		"zindex": true,
		"zoom": true
	},

	// add in properties whose names you wish to fix before
	// setting or getting the value
	cssprops: {
		// normalize float css property
		"float": jquery.support.cssfloat ? "cssfloat" : "stylefloat"
	},

	// get and set the style property on a dom node
	style: function( elem, name, value, extra ) {
		// don't set styles on text and comment nodes
		if ( !elem || elem.nodetype === 3 || elem.nodetype === 8 || !elem.style ) {
			return;
		}

		// make sure that we're working with the right name
		var ret, type, origname = jquery.camelcase( name ),
			style = elem.style, hooks = jquery.csshooks[ origname ];

		name = jquery.cssprops[ origname ] || origname;

		// check if we're setting a value
		if ( value !== undefined ) {
			type = typeof value;

			// convert relative number strings (+= or -=) to relative numbers. #7345
			if ( type === "string" && (ret = rrelnum.exec( value )) ) {
				value = ( +( ret[1] + 1) * +ret[2] ) + parsefloat( jquery.css( elem, name ) );
				// fixes bug #9237
				type = "number";
			}

			// make sure that nan and null values aren't set. see: #7116
			if ( value == null || type === "number" && isnan( value ) ) {
				return;
			}

			// if a number was passed in, add 'px' to the (except for certain css properties)
			if ( type === "number" && !jquery.cssnumber[ origname ] ) {
				value += "px";
			}

			// if a hook was provided, use that value, otherwise just set the specified value
			if ( !hooks || !("set" in hooks) || (value = hooks.set( elem, value )) !== undefined ) {
				// wrapped to prevent ie from throwing errors when 'invalid' values are provided
				// fixes bug #5509
				try {
					style[ name ] = value;
				} catch(e) {}
			}

		} else {
			// if a hook was provided get the non-computed value from there
			if ( hooks && "get" in hooks && (ret = hooks.get( elem, false, extra )) !== undefined ) {
				return ret;
			}

			// otherwise just get the value from the style object
			return style[ name ];
		}
	},

	css: function( elem, name, extra ) {
		var ret, hooks;

		// make sure that we're working with the right name
		name = jquery.camelcase( name );
		hooks = jquery.csshooks[ name ];
		name = jquery.cssprops[ name ] || name;

		// cssfloat needs a special treatment
		if ( name === "cssfloat" ) {
			name = "float";
		}

		// if a hook was provided get the computed value from there
		if ( hooks && "get" in hooks && (ret = hooks.get( elem, true, extra )) !== undefined ) {
			return ret;

		// otherwise, if a way to get the computed value exists, use that
		} else if ( curcss ) {
			return curcss( elem, name );
		}
	},

	// 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 ( name in options ) {
			elem.style[ name ] = old[ name ];
		}
	}
});

// deprecated, use jquery.css() instead
jquery.curcss = jquery.css;

jquery.each(["height", "width"], function( i, name ) {
	jquery.csshooks[ name ] = {
		get: function( elem, computed, extra ) {
			var val;

			if ( computed ) {
				if ( elem.offsetwidth !== 0 ) {
					return getwh( elem, name, extra );
				} else {
					jquery.swap( elem, cssshow, function() {
						val = getwh( elem, name, extra );
					});
				}

				return val;
			}
		},

		set: function( elem, value ) {
			if ( rnumpx.test( value ) ) {
				// ignore negative width and height values #1599
				value = parsefloat( value );

				if ( value >= 0 ) {
					return value + "px";
				}

			} else {
				return value;
			}
		}
	};
});

if ( !jquery.support.opacity ) {
	jquery.csshooks.opacity = {
		get: function( elem, computed ) {
			// ie uses filters for opacity
			return ropacity.test( (computed && elem.currentstyle ? elem.currentstyle.filter : elem.style.filter) || "" ) ?
				( parsefloat( regexp.$1 ) / 100 ) + "" :
				computed ? "1" : "";
		},

		set: function( elem, value ) {
			var style = elem.style,
				currentstyle = elem.currentstyle,
				opacity = jquery.isnumeric( value ) ? "alpha(opacity=" + value * 100 + ")" : "",
				filter = currentstyle && currentstyle.filter || style.filter || "";

			// ie has trouble with opacity if it does not have layout
			// force it by setting the zoom level
			style.zoom = 1;

			// if setting opacity to 1, and no other filters exist - attempt to remove filter attribute #6652
			if ( value >= 1 && jquery.trim( filter.replace( ralpha, "" ) ) === "" ) {

				// setting style.filter to null, "" & " " still leave "filter:" in the csstext
				// if "filter:" is present at all, cleartype is disabled, we want to avoid this
				// style.removeattribute is ie only, but so apparently is this code path...
				style.removeattribute( "filter" );

				// if there there is no filter style applied in a css rule, we are done
				if ( currentstyle && !currentstyle.filter ) {
					return;
				}
			}

			// otherwise, set new filter values
			style.filter = ralpha.test( filter ) ?
				filter.replace( ralpha, opacity ) :
				filter + " " + opacity;
		}
	};
}

jquery(function() {
	// this hook cannot be added until dom ready because the support test
	// for it is not run until after dom ready
	if ( !jquery.support.reliablemarginright ) {
		jquery.csshooks.marginright = {
			get: function( elem, computed ) {
				// webkit bug 13343 - getcomputedstyle returns wrong value for margin-right
				// work around by temporarily setting element display to inline-block
				var ret;
				jquery.swap( elem, { "display": "inline-block" }, function() {
					if ( computed ) {
						ret = curcss( elem, "margin-right", "marginright" );
					} else {
						ret = elem.style.marginright;
					}
				});
				return ret;
			}
		};
	}
});

if ( document.defaultview && document.defaultview.getcomputedstyle ) {
	getcomputedstyle = function( elem, name ) {
		var ret, defaultview, computedstyle;

		name = name.replace( rupper, "-$1" ).tolowercase();

		if ( (defaultview = elem.ownerdocument.defaultview) &&
				(computedstyle = defaultview.getcomputedstyle( elem, null )) ) {
			ret = computedstyle.getpropertyvalue( name );
			if ( ret === "" && !jquery.contains( elem.ownerdocument.documentelement, elem ) ) {
				ret = jquery.style( elem, name );
			}
		}

		return ret;
	};
}

if ( document.documentelement.currentstyle ) {
	currentstyle = function( elem, name ) {
		var left, rsleft, uncomputed,
			ret = elem.currentstyle && elem.currentstyle[ name ],
			style = elem.style;

		// avoid setting ret to empty string here
		// so we don't default to auto
		if ( ret === null && style && (uncomputed = style[ name ]) ) {
			ret = uncomputed;
		}

		// 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 ( !rnumpx.test( ret ) && rnum.test( ret ) ) {

			// remember the original values
			left = style.left;
			rsleft = elem.runtimestyle && elem.runtimestyle.left;

			// put in the new values to get a computed value out
			if ( rsleft ) {
				elem.runtimestyle.left = elem.currentstyle.left;
			}
			style.left = name === "fontsize" ? "1em" : ( ret || 0 );
			ret = style.pixelleft + "px";

			// revert the changed values
			style.left = left;
			if ( rsleft ) {
				elem.runtimestyle.left = rsleft;
			}
		}

		return ret === "" ? "auto" : ret;
	};
}

curcss = getcomputedstyle || currentstyle;

function getwh( elem, name, extra ) {

	// start with offset property
	var val = name === "width" ? elem.offsetwidth : elem.offsetheight,
		which = name === "width" ? csswidth : cssheight,
		i = 0,
		len = which.length;

	if ( val > 0 ) {
		if ( extra !== "border" ) {
			for ( ; i < len; i++ ) {
				if ( !extra ) {
					val -= parsefloat( jquery.css( elem, "padding" + which[ i ] ) ) || 0;
				}
				if ( extra === "margin" ) {
					val += parsefloat( jquery.css( elem, extra + which[ i ] ) ) || 0;
				} else {
					val -= parsefloat( jquery.css( elem, "border" + which[ i ] + "width" ) ) || 0;
				}
			}
		}

		return val + "px";
	}

	// fall back to computed then uncomputed css if necessary
	val = curcss( elem, name, name );
	if ( val < 0 || val == null ) {
		val = elem.style[ name ] || 0;
	}
	// normalize "", auto, and prepare for extra
	val = parsefloat( val ) || 0;

	// add padding, border, margin
	if ( extra ) {
		for ( ; i < len; i++ ) {
			val += parsefloat( jquery.css( elem, "padding" + which[ i ] ) ) || 0;
			if ( extra !== "padding" ) {
				val += parsefloat( jquery.css( elem, "border" + which[ i ] + "width" ) ) || 0;
			}
			if ( extra === "margin" ) {
				val += parsefloat( jquery.css( elem, extra + which[ i ] ) ) || 0;
			}
		}
	}

	return val + "px";
}

if ( jquery.expr && jquery.expr.filters ) {
	jquery.expr.filters.hidden = function( elem ) {
		var width = elem.offsetwidth,
			height = elem.offsetheight;

		return ( width === 0 && height === 0 ) || (!jquery.support.reliablehiddenoffsets && ((elem.style && elem.style.display) || jquery.css( elem, "display" )) === "none");
	};

	jquery.expr.filters.visible = function( elem ) {
		return !jquery.expr.filters.hidden( elem );
	};
}




var r20 = /%20/g,
	rbracket = /\[\]$/,
	rcrlf = /\r?\n/g,
	rhash = /#.*$/,
	rheaders = /^(.*?):[ \t]*([^\r\n]*)\r?$/mg, // ie leaves an \r character at eol
	rinput = /^(?:color|date|datetime|datetime-local|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i,
	// #7653, #8125, #8152: local protocol detection
	rlocalprotocol = /^(?:about|app|app\-storage|.+\-extension|file|res|widget):$/,
	rnocontent = /^(?:get|head)$/,
	rprotocol = /^\/\//,
	rquery = /\?/,
	rscript = /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,
	rselecttextarea = /^(?:select|textarea)/i,
	rspacesajax = /\s+/,
	rts = /([?&])_=[^&]*/,
	rurl = /^([\w\+\.\-]+:)(?:\/\/([^\/?#:]*)(?::(\d+))?)?/,

	// keep a copy of the old load method
	_load = jquery.fn.load,

	/* prefilters
	 * 1) they are useful to introduce custom datatypes (see ajax/jsonp.js for an example)
	 * 2) these are called:
	 *    - before asking for a transport
	 *    - after param serialization (s.data is a string if s.processdata is true)
	 * 3) key is the datatype
	 * 4) the catchall symbol "*" can be used
	 * 5) execution will start with transport datatype and then continue down to "*" if needed
	 */
	prefilters = {},

	/* transports bindings
	 * 1) key is the datatype
	 * 2) the catchall symbol "*" can be used
	 * 3) selection will start with transport datatype and then go to "*" if needed
	 */
	transports = {},

	// document location
	ajaxlocation,

	// document location segments
	ajaxlocparts,

	// avoid comment-prolog char sequence (#10098); must appease lint and evade compression
	alltypes = ["*/"] + ["*"];

// #8138, ie may throw an exception when accessing
// a field from window.location if document.domain has been set
try {
	ajaxlocation = location.href;
} catch( e ) {
	// use the href attribute of an a element
	// since ie will modify it given document.location
	ajaxlocation = document.createelement( "a" );
	ajaxlocation.href = "";
	ajaxlocation = ajaxlocation.href;
}

// segment location into parts
ajaxlocparts = rurl.exec( ajaxlocation.tolowercase() ) || [];

// base "constructor" for jquery.ajaxprefilter and jquery.ajaxtransport
function addtoprefiltersortransports( structure ) {

	// datatypeexpression is optional and defaults to "*"
	return function( datatypeexpression, func ) {

		if ( typeof datatypeexpression !== "string" ) {
			func = datatypeexpression;
			datatypeexpression = "*";
		}

		if ( jquery.isfunction( func ) ) {
			var datatypes = datatypeexpression.tolowercase().split( rspacesajax ),
				i = 0,
				length = datatypes.length,
				datatype,
				list,
				placebefore;

			// for each datatype in the datatypeexpression
			for ( ; i < length; i++ ) {
				datatype = datatypes[ i ];
				// we control if we're asked to add before
				// any existing element
				placebefore = /^\+/.test( datatype );
				if ( placebefore ) {
					datatype = datatype.substr( 1 ) || "*";
				}
				list = structure[ datatype ] = structure[ datatype ] || [];
				// then we add to the structure accordingly
				list[ placebefore ? "unshift" : "push" ]( func );
			}
		}
	};
}

// base inspection function for prefilters and transports
function inspectprefiltersortransports( structure, options, originaloptions, jqxhr,
		datatype /* internal */, inspected /* internal */ ) {

	datatype = datatype || options.datatypes[ 0 ];
	inspected = inspected || {};

	inspected[ datatype ] = true;

	var list = structure[ datatype ],
		i = 0,
		length = list ? list.length : 0,
		executeonly = ( structure === prefilters ),
		selection;

	for ( ; i < length && ( executeonly || !selection ); i++ ) {
		selection = list[ i ]( options, originaloptions, jqxhr );
		// if we got redirected to another datatype
		// we try there if executing only and not done already
		if ( typeof selection === "string" ) {
			if ( !executeonly || inspected[ selection ] ) {
				selection = undefined;
			} else {
				options.datatypes.unshift( selection );
				selection = inspectprefiltersortransports(
						structure, options, originaloptions, jqxhr, selection, inspected );
			}
		}
	}
	// if we're only executing or nothing was selected
	// we try the catchall datatype if not done already
	if ( ( executeonly || !selection ) && !inspected[ "*" ] ) {
		selection = inspectprefiltersortransports(
				structure, options, originaloptions, jqxhr, "*", inspected );
	}
	// unnecessary when only executing (prefilters)
	// but it'll be ignored by the caller in that case
	return selection;
}

// a special extend for ajax options
// that takes "flat" options (not to be deep extended)
// fixes #9887
function ajaxextend( target, src ) {
	var key, deep,
		flatoptions = jquery.ajaxsettings.flatoptions || {};
	for ( key in src ) {
		if ( src[ key ] !== undefined ) {
			( flatoptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];
		}
	}
	if ( deep ) {
		jquery.extend( true, target, deep );
	}
}

jquery.fn.extend({
	load: function( url, params, callback ) {
		if ( typeof url !== "string" && _load ) {
			return _load.apply( this, arguments );

		// don't do a request if no elements are being requested
		} else if ( !this.length ) {
			return this;
		}

		var off = url.indexof( " " );
		if ( off >= 0 ) {
			var selector = url.slice( off, url.length );
			url = url.slice( 0, off );
		}

		// default to a get request
		var type = "get";

		// if the second parameter was provided
		if ( params ) {
			// if it's a function
			if ( jquery.isfunction( params ) ) {
				// we assume that it's the callback
				callback = params;
				params = undefined;

			// otherwise, build a param string
			} else if ( typeof params === "object" ) {
				params = jquery.param( params, jquery.ajaxsettings.traditional );
				type = "post";
			}
		}

		var self = this;

		// request the remote document
		jquery.ajax({
			url: url,
			type: type,
			datatype: "html",
			data: params,
			// complete callback (responsetext is used internally)
			complete: function( jqxhr, status, responsetext ) {
				// store the response as specified by the jqxhr object
				responsetext = jqxhr.responsetext;
				// if successful, inject the html into all the matched elements
				if ( jqxhr.isresolved() ) {
					// #4825: get the actual response in case
					// a datafilter is present in ajaxsettings
					jqxhr.done(function( r ) {
						responsetext = r;
					});
					// see if a selector was specified
					self.html( selector ?
						// create a dummy div to hold the results
						jquery("<div>")
							// inject the contents of the document in, removing the scripts
							// to avoid any 'permission denied' errors in ie
							.append(responsetext.replace(rscript, ""))

							// locate the specified elements
							.find(selector) :

						// if not, just inject the full result
						responsetext );
				}

				if ( callback ) {
					self.each( callback, [ responsetext, status, jqxhr ] );
				}
			}
		});

		return this;
	},

	serialize: function() {
		return jquery.param( this.serializearray() );
	},

	serializearray: function() {
		return this.map(function(){
			return this.elements ? jquery.makearray( this.elements ) : this;
		})
		.filter(function(){
			return this.name && !this.disabled &&
				( this.checked || rselecttextarea.test( this.nodename ) ||
					rinput.test( this.type ) );
		})
		.map(function( i, elem ){
			var val = jquery( this ).val();

			return val == null ?
				null :
				jquery.isarray( val ) ?
					jquery.map( val, function( val, i ){
						return { name: elem.name, value: val.replace( rcrlf, "\r\n" ) };
					}) :
					{ name: elem.name, value: val.replace( rcrlf, "\r\n" ) };
		}).get();
	}
});

// attach a bunch of functions for handling common ajax events
jquery.each( "ajaxstart ajaxstop ajaxcomplete ajaxerror ajaxsuccess ajaxsend".split( " " ), function( i, o ){
	jquery.fn[ o ] = function( f ){
		return this.on( o, f );
	};
});

jquery.each( [ "get", "post" ], function( i, method ) {
	jquery[ method ] = function( url, data, callback, type ) {
		// shift arguments if data argument was omitted
		if ( jquery.isfunction( data ) ) {
			type = type || callback;
			callback = data;
			data = undefined;
		}

		return jquery.ajax({
			type: method,
			url: url,
			data: data,
			success: callback,
			datatype: type
		});
	};
});

jquery.extend({

	getscript: function( url, callback ) {
		return jquery.get( url, undefined, callback, "script" );
	},

	getjson: function( url, data, callback ) {
		return jquery.get( url, data, callback, "json" );
	},

	// creates a full fledged settings object into target
	// with both ajaxsettings and settings fields.
	// if target is omitted, writes into ajaxsettings.
	ajaxsetup: function( target, settings ) {
		if ( settings ) {
			// building a settings object
			ajaxextend( target, jquery.ajaxsettings );
		} else {
			// extending ajaxsettings
			settings = target;
			target = jquery.ajaxsettings;
		}
		ajaxextend( target, settings );
		return target;
	},

	ajaxsettings: {
		url: ajaxlocation,
		islocal: rlocalprotocol.test( ajaxlocparts[ 1 ] ),
		global: true,
		type: "get",
		contenttype: "application/x-www-form-urlencoded",
		processdata: true,
		async: true,
		/*
		timeout: 0,
		data: null,
		datatype: null,
		username: null,
		password: null,
		cache: null,
		traditional: false,
		headers: {},
		*/

		accepts: {
			xml: "application/xml, text/xml",
			html: "text/html",
			text: "text/plain",
			json: "application/json, text/javascript",
			"*": alltypes
		},

		contents: {
			xml: /xml/,
			html: /html/,
			json: /json/
		},

		responsefields: {
			xml: "responsexml",
			text: "responsetext"
		},

		// list of data converters
		// 1) key format is "source_type destination_type" (a single space in-between)
		// 2) the catchall symbol "*" can be used for source_type
		converters: {

			// convert anything to text
			"* text": window.string,

			// text to html (true = no transformation)
			"text html": true,

			// evaluate text as a json expression
			"text json": jquery.parsejson,

			// parse text as xml
			"text xml": jquery.parsexml
		},

		// for options that shouldn't be deep extended:
		// you can add your own custom options here if
		// and when you create one that shouldn't be
		// deep extended (see ajaxextend)
		flatoptions: {
			context: true,
			url: true
		}
	},

	ajaxprefilter: addtoprefiltersortransports( prefilters ),
	ajaxtransport: addtoprefiltersortransports( transports ),

	// main method
	ajax: function( url, options ) {

		// if url is an object, simulate pre-1.5 signature
		if ( typeof url === "object" ) {
			options = url;
			url = undefined;
		}

		// force options to be an object
		options = options || {};

		var // create the final options object
			s = jquery.ajaxsetup( {}, options ),
			// callbacks context
			callbackcontext = s.context || s,
			// context for global events
			// it's the callbackcontext if one was provided in the options
			// and if it's a dom node or a jquery collection
			globaleventcontext = callbackcontext !== s &&
				( callbackcontext.nodetype || callbackcontext instanceof jquery ) ?
						jquery( callbackcontext ) : jquery.event,
			// deferreds
			deferred = jquery.deferred(),
			completedeferred = jquery.callbacks( "once memory" ),
			// status-dependent callbacks
			statuscode = s.statuscode || {},
			// ifmodified key
			ifmodifiedkey,
			// headers (they are sent all at once)
			requestheaders = {},
			requestheadersnames = {},
			// response headers
			responseheadersstring,
			responseheaders,
			// transport
			transport,
			// timeout handle
			timeouttimer,
			// cross-domain detection vars
			parts,
			// the jqxhr state
			state = 0,
			// to know if global events are to be dispatched
			fireglobals,
			// loop variable
			i,
			// fake xhr
			jqxhr = {

				readystate: 0,

				// caches the header
				setrequestheader: function( name, value ) {
					if ( !state ) {
						var lname = name.tolowercase();
						name = requestheadersnames[ lname ] = requestheadersnames[ lname ] || name;
						requestheaders[ name ] = value;
					}
					return this;
				},

				// raw string
				getallresponseheaders: function() {
					return state === 2 ? responseheadersstring : null;
				},

				// builds headers hashtable if needed
				getresponseheader: function( key ) {
					var match;
					if ( state === 2 ) {
						if ( !responseheaders ) {
							responseheaders = {};
							while( ( match = rheaders.exec( responseheadersstring ) ) ) {
								responseheaders[ match[1].tolowercase() ] = match[ 2 ];
							}
						}
						match = responseheaders[ key.tolowercase() ];
					}
					return match === undefined ? null : match;
				},

				// overrides response content-type header
				overridemimetype: function( type ) {
					if ( !state ) {
						s.mimetype = type;
					}
					return this;
				},

				// cancel the request
				abort: function( statustext ) {
					statustext = statustext || "abort";
					if ( transport ) {
						transport.abort( statustext );
					}
					done( 0, statustext );
					return this;
				}
			};

		// callback for when everything is done
		// it is defined here because jslint complains if it is declared
		// at the end of the function (which would be more logical and readable)
		function done( status, nativestatustext, responses, headers ) {

			// called once
			if ( state === 2 ) {
				return;
			}

			// state is "done" now
			state = 2;

			// clear timeout if it exists
			if ( timeouttimer ) {
				cleartimeout( timeouttimer );
			}

			// dereference transport for early garbage collection
			// (no matter how long the jqxhr object will be used)
			transport = undefined;

			// cache response headers
			responseheadersstring = headers || "";

			// set readystate
			jqxhr.readystate = status > 0 ? 4 : 0;

			var issuccess,
				success,
				error,
				statustext = nativestatustext,
				response = responses ? ajaxhandleresponses( s, jqxhr, responses ) : undefined,
				lastmodified,
				etag;

			// if successful, handle type chaining
			if ( status >= 200 && status < 300 || status === 304 ) {

				// set the if-modified-since and/or if-none-match header, if in ifmodified mode.
				if ( s.ifmodified ) {

					if ( ( lastmodified = jqxhr.getresponseheader( "last-modified" ) ) ) {
						jquery.lastmodified[ ifmodifiedkey ] = lastmodified;
					}
					if ( ( etag = jqxhr.getresponseheader( "etag" ) ) ) {
						jquery.etag[ ifmodifiedkey ] = etag;
					}
				}

				// if not modified
				if ( status === 304 ) {

					statustext = "notmodified";
					issuccess = true;

				// if we have data
				} else {

					try {
						success = ajaxconvert( s, response );
						statustext = "success";
						issuccess = true;
					} catch(e) {
						// we have a parsererror
						statustext = "parsererror";
						error = e;
					}
				}
			} else {
				// we extract error from statustext
				// then normalize statustext and status for non-aborts
				error = statustext;
				if ( !statustext || status ) {
					statustext = "error";
					if ( status < 0 ) {
						status = 0;
					}
				}
			}

			// set data for the fake xhr object
			jqxhr.status = status;
			jqxhr.statustext = "" + ( nativestatustext || statustext );

			// success/error
			if ( issuccess ) {
				deferred.resolvewith( callbackcontext, [ success, statustext, jqxhr ] );
			} else {
				deferred.rejectwith( callbackcontext, [ jqxhr, statustext, error ] );
			}

			// status-dependent callbacks
			jqxhr.statuscode( statuscode );
			statuscode = undefined;

			if ( fireglobals ) {
				globaleventcontext.trigger( "ajax" + ( issuccess ? "success" : "error" ),
						[ jqxhr, s, issuccess ? success : error ] );
			}

			// complete
			completedeferred.firewith( callbackcontext, [ jqxhr, statustext ] );

			if ( fireglobals ) {
				globaleventcontext.trigger( "ajaxcomplete", [ jqxhr, s ] );
				// handle the global ajax counter
				if ( !( --jquery.active ) ) {
					jquery.event.trigger( "ajaxstop" );
				}
			}
		}

		// attach deferreds
		deferred.promise( jqxhr );
		jqxhr.success = jqxhr.done;
		jqxhr.error = jqxhr.fail;
		jqxhr.complete = completedeferred.add;

		// status-dependent callbacks
		jqxhr.statuscode = function( map ) {
			if ( map ) {
				var tmp;
				if ( state < 2 ) {
					for ( tmp in map ) {
						statuscode[ tmp ] = [ statuscode[tmp], map[tmp] ];
					}
				} else {
					tmp = map[ jqxhr.status ];
					jqxhr.then( tmp, tmp );
				}
			}
			return this;
		};

		// remove hash character (#7531: and string promotion)
		// add protocol if not provided (#5866: ie7 issue with protocol-less urls)
		// we also use the url parameter if available
		s.url = ( ( url || s.url ) + "" ).replace( rhash, "" ).replace( rprotocol, ajaxlocparts[ 1 ] + "//" );

		// extract datatypes list
		s.datatypes = jquery.trim( s.datatype || "*" ).tolowercase().split( rspacesajax );

		// determine if a cross-domain request is in order
		if ( s.crossdomain == null ) {
			parts = rurl.exec( s.url.tolowercase() );
			s.crossdomain = !!( parts &&
				( parts[ 1 ] != ajaxlocparts[ 1 ] || parts[ 2 ] != ajaxlocparts[ 2 ] ||
					( parts[ 3 ] || ( parts[ 1 ] === "http:" ? 80 : 443 ) ) !=
						( ajaxlocparts[ 3 ] || ( ajaxlocparts[ 1 ] === "http:" ? 80 : 443 ) ) )
			);
		}

		// convert data if not already a string
		if ( s.data && s.processdata && typeof s.data !== "string" ) {
			s.data = jquery.param( s.data, s.traditional );
		}

		// apply prefilters
		inspectprefiltersortransports( prefilters, s, options, jqxhr );

		// if request was aborted inside a prefiler, stop there
		if ( state === 2 ) {
			return false;
		}

		// we can fire global events as of now if asked to
		fireglobals = s.global;

		// uppercase the type
		s.type = s.type.touppercase();

		// determine if request has content
		s.hascontent = !rnocontent.test( s.type );

		// watch for a new set of requests
		if ( fireglobals && jquery.active++ === 0 ) {
			jquery.event.trigger( "ajaxstart" );
		}

		// more options handling for requests with no content
		if ( !s.hascontent ) {

			// if data is available, append data to url
			if ( s.data ) {
				s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.data;
				// #9682: remove data so that it's not used in an eventual retry
				delete s.data;
			}

			// get ifmodifiedkey before adding the anti-cache parameter
			ifmodifiedkey = s.url;

			// add anti-cache in url if needed
			if ( s.cache === false ) {

				var ts = jquery.now(),
					// try replacing _= if it is there
					ret = s.url.replace( rts, "$1_=" + ts );

				// if nothing was replaced, add timestamp to the end
				s.url = ret + ( ( ret === s.url ) ? ( rquery.test( s.url ) ? "&" : "?" ) + "_=" + ts : "" );
			}
		}

		// set the correct header, if data is being sent
		if ( s.data && s.hascontent && s.contenttype !== false || options.contenttype ) {
			jqxhr.setrequestheader( "content-type", s.contenttype );
		}

		// set the if-modified-since and/or if-none-match header, if in ifmodified mode.
		if ( s.ifmodified ) {
			ifmodifiedkey = ifmodifiedkey || s.url;
			if ( jquery.lastmodified[ ifmodifiedkey ] ) {
				jqxhr.setrequestheader( "if-modified-since", jquery.lastmodified[ ifmodifiedkey ] );
			}
			if ( jquery.etag[ ifmodifiedkey ] ) {
				jqxhr.setrequestheader( "if-none-match", jquery.etag[ ifmodifiedkey ] );
			}
		}

		// set the accepts header for the server, depending on the datatype
		jqxhr.setrequestheader(
			"accept",
			s.datatypes[ 0 ] && s.accepts[ s.datatypes[0] ] ?
				s.accepts[ s.datatypes[0] ] + ( s.datatypes[ 0 ] !== "*" ? ", " + alltypes + "; q=0.01" : "" ) :
				s.accepts[ "*" ]
		);

		// check for headers option
		for ( i in s.headers ) {
			jqxhr.setrequestheader( i, s.headers[ i ] );
		}

		// allow custom headers/mimetypes and early abort
		if ( s.beforesend && ( s.beforesend.call( callbackcontext, jqxhr, s ) === false || state === 2 ) ) {
				// abort if not done already
				jqxhr.abort();
				return false;

		}

		// install callbacks on deferreds
		for ( i in { success: 1, error: 1, complete: 1 } ) {
			jqxhr[ i ]( s[ i ] );
		}

		// get transport
		transport = inspectprefiltersortransports( transports, s, options, jqxhr );

		// if no transport, we auto-abort
		if ( !transport ) {
			done( -1, "no transport" );
		} else {
			jqxhr.readystate = 1;
			// send global event
			if ( fireglobals ) {
				globaleventcontext.trigger( "ajaxsend", [ jqxhr, s ] );
			}
			// timeout
			if ( s.async && s.timeout > 0 ) {
				timeouttimer = settimeout( function(){
					jqxhr.abort( "timeout" );
				}, s.timeout );
			}

			try {
				state = 1;
				transport.send( requestheaders, done );
			} catch (e) {
				// propagate exception as error if not done
				if ( state < 2 ) {
					done( -1, e );
				// simply rethrow otherwise
				} else {
					throw e;
				}
			}
		}

		return jqxhr;
	},

	// serialize an array of form elements or a set of
	// key/values into a query string
	param: function( a, traditional ) {
		var s = [],
			add = function( key, value ) {
				// if value is a function, invoke it and return its value
				value = jquery.isfunction( value ) ? value() : value;
				s[ s.length ] = encodeuricomponent( key ) + "=" + encodeuricomponent( value );
			};

		// set traditional to true for jquery <= 1.3.2 behavior.
		if ( traditional === undefined ) {
			traditional = jquery.ajaxsettings.traditional;
		}

		// if an array was passed in, assume that it is an array of form elements.
		if ( jquery.isarray( a ) || ( a.jquery && !jquery.isplainobject( a ) ) ) {
			// serialize the form elements
			jquery.each( a, function() {
				add( this.name, this.value );
			});

		} else {
			// if traditional, encode the "old" way (the way 1.3.2 or older
			// did it), otherwise encode params recursively.
			for ( var prefix in a ) {
				buildparams( prefix, a[ prefix ], traditional, add );
			}
		}

		// return the resulting serialization
		return s.join( "&" ).replace( r20, "+" );
	}
});

function buildparams( prefix, obj, traditional, add ) {
	if ( jquery.isarray( obj ) ) {
		// serialize array item.
		jquery.each( obj, function( i, v ) {
			if ( traditional || rbracket.test( prefix ) ) {
				// treat each array item as a scalar.
				add( prefix, v );

			} else {
				// if array item is non-scalar (array or object), encode its
				// numeric index to resolve deserialization ambiguity issues.
				// note that rack (as of 1.0.0) can't currently deserialize
				// nested arrays properly, and attempting to do so may cause
				// a server error. possible fixes are to modify rack's
				// deserialization algorithm or to provide an option or flag
				// to force array serialization to be shallow.
				buildparams( prefix + "[" + ( typeof v === "object" || jquery.isarray(v) ? i : "" ) + "]", v, traditional, add );
			}
		});

	} else if ( !traditional && obj != null && typeof obj === "object" ) {
		// serialize object item.
		for ( var name in obj ) {
			buildparams( prefix + "[" + name + "]", obj[ name ], traditional, add );
		}

	} else {
		// serialize scalar item.
		add( prefix, obj );
	}
}

// this is still on the jquery object... for now
// want to move this to jquery.ajax some day
jquery.extend({

	// counter for holding the number of active queries
	active: 0,

	// last-modified header cache for next request
	lastmodified: {},
	etag: {}

});

/* handles responses to an ajax request:
 * - sets all responsexxx fields accordingly
 * - finds the right datatype (mediates between content-type and expected datatype)
 * - returns the corresponding response
 */
function ajaxhandleresponses( s, jqxhr, responses ) {

	var contents = s.contents,
		datatypes = s.datatypes,
		responsefields = s.responsefields,
		ct,
		type,
		finaldatatype,
		firstdatatype;

	// fill responsexxx fields
	for ( type in responsefields ) {
		if ( type in responses ) {
			jqxhr[ responsefields[type] ] = responses[ type ];
		}
	}

	// remove auto datatype and get content-type in the process
	while( datatypes[ 0 ] === "*" ) {
		datatypes.shift();
		if ( ct === undefined ) {
			ct = s.mimetype || jqxhr.getresponseheader( "content-type" );
		}
	}

	// check if we're dealing with a known content-type
	if ( ct ) {
		for ( type in contents ) {
			if ( contents[ type ] && contents[ type ].test( ct ) ) {
				datatypes.unshift( type );
				break;
			}
		}
	}

	// check to see if we have a response for the expected datatype
	if ( datatypes[ 0 ] in responses ) {
		finaldatatype = datatypes[ 0 ];
	} else {
		// try convertible datatypes
		for ( type in responses ) {
			if ( !datatypes[ 0 ] || s.converters[ type + " " + datatypes[0] ] ) {
				finaldatatype = type;
				break;
			}
			if ( !firstdatatype ) {
				firstdatatype = type;
			}
		}
		// or just use first one
		finaldatatype = finaldatatype || firstdatatype;
	}

	// if we found a datatype
	// we add the datatype to the list if needed
	// and return the corresponding response
	if ( finaldatatype ) {
		if ( finaldatatype !== datatypes[ 0 ] ) {
			datatypes.unshift( finaldatatype );
		}
		return responses[ finaldatatype ];
	}
}

// chain conversions given the request and the original response
function ajaxconvert( s, response ) {

	// apply the datafilter if provided
	if ( s.datafilter ) {
		response = s.datafilter( response, s.datatype );
	}

	var datatypes = s.datatypes,
		converters = {},
		i,
		key,
		length = datatypes.length,
		tmp,
		// current and previous datatypes
		current = datatypes[ 0 ],
		prev,
		// conversion expression
		conversion,
		// conversion function
		conv,
		// conversion functions (transitive conversion)
		conv1,
		conv2;

	// for each datatype in the chain
	for ( i = 1; i < length; i++ ) {

		// create converters map
		// with lowercased keys
		if ( i === 1 ) {
			for ( key in s.converters ) {
				if ( typeof key === "string" ) {
					converters[ key.tolowercase() ] = s.converters[ key ];
				}
			}
		}

		// get the datatypes
		prev = current;
		current = datatypes[ i ];

		// if current is auto datatype, update it to prev
		if ( current === "*" ) {
			current = prev;
		// if no auto and datatypes are actually different
		} else if ( prev !== "*" && prev !== current ) {

			// get the converter
			conversion = prev + " " + current;
			conv = converters[ conversion ] || converters[ "* " + current ];

			// if there is no direct converter, search transitively
			if ( !conv ) {
				conv2 = undefined;
				for ( conv1 in converters ) {
					tmp = conv1.split( " " );
					if ( tmp[ 0 ] === prev || tmp[ 0 ] === "*" ) {
						conv2 = converters[ tmp[1] + " " + current ];
						if ( conv2 ) {
							conv1 = converters[ conv1 ];
							if ( conv1 === true ) {
								conv = conv2;
							} else if ( conv2 === true ) {
								conv = conv1;
							}
							break;
						}
					}
				}
			}
			// if we found no converter, dispatch an error
			if ( !( conv || conv2 ) ) {
				jquery.error( "no conversion from " + conversion.replace(" "," to ") );
			}
			// if found converter is not an equivalence
			if ( conv !== true ) {
				// convert with 1 or 2 converters accordingly
				response = conv ? conv( response ) : conv2( conv1(response) );
			}
		}
	}
	return response;
}




var jsc = jquery.now(),
	jsre = /(\=)\?(&|$)|\?\?/i;

// default jsonp settings
jquery.ajaxsetup({
	jsonp: "callback",
	jsonpcallback: function() {
		return jquery.expando + "_" + ( jsc++ );
	}
});

// detect, normalize options and install callbacks for jsonp requests
jquery.ajaxprefilter( "json jsonp", function( s, originalsettings, jqxhr ) {

	var inspectdata = s.contenttype === "application/x-www-form-urlencoded" &&
		( typeof s.data === "string" );

	if ( s.datatypes[ 0 ] === "jsonp" ||
		s.jsonp !== false && ( jsre.test( s.url ) ||
				inspectdata && jsre.test( s.data ) ) ) {

		var responsecontainer,
			jsonpcallback = s.jsonpcallback =
				jquery.isfunction( s.jsonpcallback ) ? s.jsonpcallback() : s.jsonpcallback,
			previous = window[ jsonpcallback ],
			url = s.url,
			data = s.data,
			replace = "$1" + jsonpcallback + "$2";

		if ( s.jsonp !== false ) {
			url = url.replace( jsre, replace );
			if ( s.url === url ) {
				if ( inspectdata ) {
					data = data.replace( jsre, replace );
				}
				if ( s.data === data ) {
					// add callback manually
					url += (/\?/.test( url ) ? "&" : "?") + s.jsonp + "=" + jsonpcallback;
				}
			}
		}

		s.url = url;
		s.data = data;

		// install callback
		window[ jsonpcallback ] = function( response ) {
			responsecontainer = [ response ];
		};

		// clean-up function
		jqxhr.always(function() {
			// set callback back to previous value
			window[ jsonpcallback ] = previous;
			// call if it was a function and we have a response
			if ( responsecontainer && jquery.isfunction( previous ) ) {
				window[ jsonpcallback ]( responsecontainer[ 0 ] );
			}
		});

		// use data converter to retrieve json after script execution
		s.converters["script json"] = function() {
			if ( !responsecontainer ) {
				jquery.error( jsonpcallback + " was not called" );
			}
			return responsecontainer[ 0 ];
		};

		// force json datatype
		s.datatypes[ 0 ] = "json";

		// delegate to script
		return "script";
	}
});




// install script datatype
jquery.ajaxsetup({
	accepts: {
		script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
	},
	contents: {
		script: /javascript|ecmascript/
	},
	converters: {
		"text script": function( text ) {
			jquery.globaleval( text );
			return text;
		}
	}
});

// handle cache's special case and global
jquery.ajaxprefilter( "script", function( s ) {
	if ( s.cache === undefined ) {
		s.cache = false;
	}
	if ( s.crossdomain ) {
		s.type = "get";
		s.global = false;
	}
});

// bind script tag hack transport
jquery.ajaxtransport( "script", function(s) {

	// this transport only deals with cross domain requests
	if ( s.crossdomain ) {

		var script,
			head = document.head || document.getelementsbytagname( "head" )[0] || document.documentelement;

		return {

			send: function( _, callback ) {

				script = document.createelement( "script" );

				script.async = "async";

				if ( s.scriptcharset ) {
					script.charset = s.scriptcharset;
				}

				script.src = s.url;

				// attach handlers for all browsers
				script.onload = script.onreadystatechange = function( _, isabort ) {

					if ( isabort || !script.readystate || /loaded|complete/.test( script.readystate ) ) {

						// handle memory leak in ie
						script.onload = script.onreadystatechange = null;

						// remove the script
						if ( head && script.parentnode ) {
							head.removechild( script );
						}

						// dereference the script
						script = undefined;

						// callback if not abort
						if ( !isabort ) {
							callback( 200, "success" );
						}
					}
				};
				// use insertbefore instead of appendchild  to circumvent an ie6 bug.
				// this arises when a base node is used (#2709 and #4378).
				head.insertbefore( script, head.firstchild );
			},

			abort: function() {
				if ( script ) {
					script.onload( 0, 1 );
				}
			}
		};
	}
});




var // #5280: internet explorer will keep connections alive if we don't abort on unload
	xhronunloadabort = window.activexobject ? function() {
		// abort all pending requests
		for ( var key in xhrcallbacks ) {
			xhrcallbacks[ key ]( 0, 1 );
		}
	} : false,
	xhrid = 0,
	xhrcallbacks;

// functions to create xhrs
function createstandardxhr() {
	try {
		return new window.xmlhttprequest();
	} catch( e ) {}
}

function createactivexhr() {
	try {
		return new window.activexobject( "microsoft.xmlhttp" );
	} catch( e ) {}
}

// create the request object
// (this is still attached to ajaxsettings for backward compatibility)
jquery.ajaxsettings.xhr = window.activexobject ?
	/* microsoft failed to properly
	 * implement the xmlhttprequest in ie7 (can't request local files),
	 * so we use the activexobject when it is available
	 * additionally xmlhttprequest can be disabled in ie7/ie8 so
	 * we need a fallback.
	 */
	function() {
		return !this.islocal && createstandardxhr() || createactivexhr();
	} :
	// for all other browsers, use the standard xmlhttprequest object
	createstandardxhr;

// determine support properties
(function( xhr ) {
	jquery.extend( jquery.support, {
		ajax: !!xhr,
		cors: !!xhr && ( "withcredentials" in xhr )
	});
})( jquery.ajaxsettings.xhr() );

// create transport if the browser can provide an xhr
if ( jquery.support.ajax ) {

	jquery.ajaxtransport(function( s ) {
		// cross domain only allowed if supported through xmlhttprequest
		if ( !s.crossdomain || jquery.support.cors ) {

			var callback;

			return {
				send: function( headers, complete ) {

					// get a new xhr
					var xhr = s.xhr(),
						handle,
						i;

					// open the socket
					// passing null username, generates a login popup on opera (#2865)
					if ( s.username ) {
						xhr.open( s.type, s.url, s.async, s.username, s.password );
					} else {
						xhr.open( s.type, s.url, s.async );
					}

					// apply custom fields if provided
					if ( s.xhrfields ) {
						for ( i in s.xhrfields ) {
							xhr[ i ] = s.xhrfields[ i ];
						}
					}

					// override mime type if needed
					if ( s.mimetype && xhr.overridemimetype ) {
						xhr.overridemimetype( s.mimetype );
					}

					// x-requested-with header
					// for cross-domain requests, seeing as conditions for a preflight are
					// akin to a jigsaw puzzle, we simply never set it to be sure.
					// (it can always be set on a per-request basis or even using ajaxsetup)
					// for same-domain requests, won't change header if already provided.
					if ( !s.crossdomain && !headers["x-requested-with"] ) {
						headers[ "x-requested-with" ] = "xmlhttprequest";
					}

					// need an extra try/catch for cross domain requests in firefox 3
					try {
						for ( i in headers ) {
							xhr.setrequestheader( i, headers[ i ] );
						}
					} catch( _ ) {}

					// do send the request
					// this may raise an exception which is actually
					// handled in jquery.ajax (so no try/catch here)
					xhr.send( ( s.hascontent && s.data ) || null );

					// listener
					callback = function( _, isabort ) {

						var status,
							statustext,
							responseheaders,
							responses,
							xml;

						// firefox throws exceptions when accessing properties
						// of an xhr when a network error occured
						// http://helpful.knobs-dials.com/index.php/component_returned_failure_code:_0x80040111_(ns_error_not_available)
						try {

							// was never called and is aborted or complete
							if ( callback && ( isabort || xhr.readystate === 4 ) ) {

								// only called once
								callback = undefined;

								// do not keep as active anymore
								if ( handle ) {
									xhr.onreadystatechange = jquery.noop;
									if ( xhronunloadabort ) {
										delete xhrcallbacks[ handle ];
									}
								}

								// if it's an abort
								if ( isabort ) {
									// abort it manually if needed
									if ( xhr.readystate !== 4 ) {
										xhr.abort();
									}
								} else {
									status = xhr.status;
									responseheaders = xhr.getallresponseheaders();
									responses = {};
									xml = xhr.responsexml;

									// construct response list
									if ( xml && xml.documentelement /* #4958 */ ) {
										responses.xml = xml;
									}
									responses.text = xhr.responsetext;

									// firefox throws an exception when accessing
									// statustext for faulty cross-domain requests
									try {
										statustext = xhr.statustext;
									} catch( e ) {
										// we normalize with webkit giving an empty statustext
										statustext = "";
									}

									// filter status for non standard behaviors

									// if the request is local and we have data: assume a success
									// (success with no data won't get notified, that's the best we
									// can do given current implementations)
									if ( !status && s.islocal && !s.crossdomain ) {
										status = responses.text ? 200 : 404;
									// ie - #1450: sometimes returns 1223 when it should be 204
									} else if ( status === 1223 ) {
										status = 204;
									}
								}
							}
						} catch( firefoxaccessexception ) {
							if ( !isabort ) {
								complete( -1, firefoxaccessexception );
							}
						}

						// call complete if needed
						if ( responses ) {
							complete( status, statustext, responses, responseheaders );
						}
					};

					// if we're in sync mode or it's in cache
					// and has been retrieved directly (ie6 & ie7)
					// we need to manually fire the callback
					if ( !s.async || xhr.readystate === 4 ) {
						callback();
					} else {
						handle = ++xhrid;
						if ( xhronunloadabort ) {
							// create the active xhrs callbacks list if needed
							// and attach the unload handler
							if ( !xhrcallbacks ) {
								xhrcallbacks = {};
								jquery( window ).unload( xhronunloadabort );
							}
							// add to list of active xhrs callbacks
							xhrcallbacks[ handle ] = callback;
						}
						xhr.onreadystatechange = callback;
					}
				},

				abort: function() {
					if ( callback ) {
						callback(0,1);
					}
				}
			};
		}
	});
}




var elemdisplay = {},
	iframe, iframedoc,
	rfxtypes = /^(?:toggle|show|hide)$/,
	rfxnum = /^([+\-]=)?([\d+.\-]+)([a-z%]*)$/i,
	timerid,
	fxattrs = [
		// height animations
		[ "height", "margintop", "marginbottom", "paddingtop", "paddingbottom" ],
		// width animations
		[ "width", "marginleft", "marginright", "paddingleft", "paddingright" ],
		// opacity animations
		[ "opacity" ]
	],
	fxnow;

jquery.fn.extend({
	show: function( speed, easing, callback ) {
		var elem, display;

		if ( speed || speed === 0 ) {
			return this.animate( genfx("show", 3), speed, easing, callback );

		} else {
			for ( var i = 0, j = this.length; i < j; i++ ) {
				elem = this[ i ];

				if ( elem.style ) {
					display = elem.style.display;

					// reset the inline display of this element to learn if it is
					// being hidden by cascaded rules or not
					if ( !jquery._data(elem, "olddisplay") && display === "none" ) {
						display = elem.style.display = "";
					}

					// set elements which have been overridden with display: none
					// in a stylesheet to whatever the default browser style is
					// for such an element
					if ( display === "" && jquery.css(elem, "display") === "none" ) {
						jquery._data( elem, "olddisplay", defaultdisplay(elem.nodename) );
					}
				}
			}

			// set the display of most of the elements in a second loop
			// to avoid the constant reflow
			for ( i = 0; i < j; i++ ) {
				elem = this[ i ];

				if ( elem.style ) {
					display = elem.style.display;

					if ( display === "" || display === "none" ) {
						elem.style.display = jquery._data( elem, "olddisplay" ) || "";
					}
				}
			}

			return this;
		}
	},

	hide: function( speed, easing, callback ) {
		if ( speed || speed === 0 ) {
			return this.animate( genfx("hide", 3), speed, easing, callback);

		} else {
			var elem, display,
				i = 0,
				j = this.length;

			for ( ; i < j; i++ ) {
				elem = this[i];
				if ( elem.style ) {
					display = jquery.css( elem, "display" );

					if ( display !== "none" && !jquery._data( elem, "olddisplay" ) ) {
						jquery._data( elem, "olddisplay", display );
					}
				}
			}

			// set the display of the elements in a second loop
			// to avoid the constant reflow
			for ( i = 0; i < j; i++ ) {
				if ( this[i].style ) {
					this[i].style.display = "none";
				}
			}

			return this;
		}
	},

	// save the old toggle function
	_toggle: jquery.fn.toggle,

	toggle: function( fn, fn2, callback ) {
		var bool = typeof fn === "boolean";

		if ( jquery.isfunction(fn) && jquery.isfunction(fn2) ) {
			this._toggle.apply( this, arguments );

		} else if ( fn == null || bool ) {
			this.each(function() {
				var state = bool ? fn : jquery(this).is(":hidden");
				jquery(this)[ state ? "show" : "hide" ]();
			});

		} else {
			this.animate(genfx("toggle", 3), fn, fn2, callback);
		}

		return this;
	},

	fadeto: function( speed, to, easing, callback ) {
		return this.filter(":hidden").css("opacity", 0).show().end()
					.animate({opacity: to}, speed, easing, callback);
	},

	animate: function( prop, speed, easing, callback ) {
		var optall = jquery.speed( speed, easing, callback );

		if ( jquery.isemptyobject( prop ) ) {
			return this.each( optall.complete, [ false ] );
		}

		// do not change referenced properties as per-property easing will be lost
		prop = jquery.extend( {}, prop );

		function doanimation() {
			// xxx 'this' does not always have a nodename when running the
			// test suite

			if ( optall.queue === false ) {
				jquery._mark( this );
			}

			var opt = jquery.extend( {}, optall ),
				iselement = this.nodetype === 1,
				hidden = iselement && jquery(this).is(":hidden"),
				name, val, p, e,
				parts, start, end, unit,
				method;

			// will store per property easing and be used to determine when an animation is complete
			opt.animatedproperties = {};

			for ( p in prop ) {

				// property name normalization
				name = jquery.camelcase( p );
				if ( p !== name ) {
					prop[ name ] = prop[ p ];
					delete prop[ p ];
				}

				val = prop[ name ];

				// easing resolution: per property > opt.specialeasing > opt.easing > 'swing' (default)
				if ( jquery.isarray( val ) ) {
					opt.animatedproperties[ name ] = val[ 1 ];
					val = prop[ name ] = val[ 0 ];
				} else {
					opt.animatedproperties[ name ] = opt.specialeasing && opt.specialeasing[ name ] || opt.easing || 'swing';
				}

				if ( val === "hide" && hidden || val === "show" && !hidden ) {
					return opt.complete.call( this );
				}

				if ( iselement && ( name === "height" || name === "width" ) ) {
					// make sure that nothing sneaks out
					// record all 3 overflow attributes because ie does not
					// change the overflow attribute when overflowx and
					// overflowy are set to the same value
					opt.overflow = [ this.style.overflow, this.style.overflowx, this.style.overflowy ];

					// set display property to inline-block for height/width
					// animations on inline elements that are having width/height animated
					if ( jquery.css( this, "display" ) === "inline" &&
							jquery.css( this, "float" ) === "none" ) {

						// inline-level elements accept inline-block;
						// block-level elements need to be inline with layout
						if ( !jquery.support.inlineblockneedslayout || defaultdisplay( this.nodename ) === "inline" ) {
							this.style.display = "inline-block";

						} else {
							this.style.zoom = 1;
						}
					}
				}
			}

			if ( opt.overflow != null ) {
				this.style.overflow = "hidden";
			}

			for ( p in prop ) {
				e = new jquery.fx( this, opt, p );
				val = prop[ p ];

				if ( rfxtypes.test( val ) ) {

					// tracks whether to show or hide based on private
					// data attached to the element
					method = jquery._data( this, "toggle" + p ) || ( val === "toggle" ? hidden ? "show" : "hide" : 0 );
					if ( method ) {
						jquery._data( this, "toggle" + p, method === "show" ? "hide" : "show" );
						e[ method ]();
					} else {
						e[ val ]();
					}

				} else {
					parts = rfxnum.exec( val );
					start = e.cur();

					if ( parts ) {
						end = parsefloat( parts[2] );
						unit = parts[3] || ( jquery.cssnumber[ p ] ? "" : "px" );

						// we need to compute starting value
						if ( unit !== "px" ) {
							jquery.style( this, p, (end || 1) + unit);
							start = ( (end || 1) / e.cur() ) * start;
							jquery.style( this, p, start + unit);
						}

						// if a +=/-= token was provided, we're doing a relative animation
						if ( parts[1] ) {
							end = ( (parts[ 1 ] === "-=" ? -1 : 1) * end ) + start;
						}

						e.custom( start, end, unit );

					} else {
						e.custom( start, val, "" );
					}
				}
			}

			// for js strict compliance
			return true;
		}

		return optall.queue === false ?
			this.each( doanimation ) :
			this.queue( optall.queue, doanimation );
	},

	stop: function( type, clearqueue, gotoend ) {
		if ( typeof type !== "string" ) {
			gotoend = clearqueue;
			clearqueue = type;
			type = undefined;
		}
		if ( clearqueue && type !== false ) {
			this.queue( type || "fx", [] );
		}

		return this.each(function() {
			var index,
				hadtimers = false,
				timers = jquery.timers,
				data = jquery._data( this );

			// clear marker counters if we know they won't be
			if ( !gotoend ) {
				jquery._unmark( true, this );
			}

			function stopqueue( elem, data, index ) {
				var hooks = data[ index ];
				jquery.removedata( elem, index, true );
				hooks.stop( gotoend );
			}

			if ( type == null ) {
				for ( index in data ) {
					if ( data[ index ] && data[ index ].stop && index.indexof(".run") === index.length - 4 ) {
						stopqueue( this, data, index );
					}
				}
			} else if ( data[ index = type + ".run" ] && data[ index ].stop ){
				stopqueue( this, data, index );
			}

			for ( index = timers.length; index--; ) {
				if ( timers[ index ].elem === this && (type == null || timers[ index ].queue === type) ) {
					if ( gotoend ) {

						// force the next step to be the last
						timers[ index ]( true );
					} else {
						timers[ index ].savestate();
					}
					hadtimers = true;
					timers.splice( index, 1 );
				}
			}

			// start the next in the queue if the last step wasn't forced
			// timers currently will call their complete callbacks, which will dequeue
			// but only if they were gotoend
			if ( !( gotoend && hadtimers ) ) {
				jquery.dequeue( this, type );
			}
		});
	}

});

// animations created synchronously will run synchronously
function createfxnow() {
	settimeout( clearfxnow, 0 );
	return ( fxnow = jquery.now() );
}

function clearfxnow() {
	fxnow = undefined;
}

// generate parameters to create a standard animation
function genfx( type, num ) {
	var obj = {};

	jquery.each( fxattrs.concat.apply([], fxattrs.slice( 0, num )), function() {
		obj[ this ] = type;
	});

	return obj;
}

// generate shortcuts for custom animations
jquery.each({
	slidedown: genfx( "show", 1 ),
	slideup: genfx( "hide", 1 ),
	slidetoggle: genfx( "toggle", 1 ),
	fadein: { opacity: "show" },
	fadeout: { opacity: "hide" },
	fadetoggle: { opacity: "toggle" }
}, function( name, props ) {
	jquery.fn[ name ] = function( speed, easing, callback ) {
		return this.animate( props, speed, easing, callback );
	};
});

jquery.extend({
	speed: function( speed, easing, fn ) {
		var opt = speed && typeof speed === "object" ? jquery.extend( {}, speed ) : {
			complete: fn || !fn && easing ||
				jquery.isfunction( speed ) && speed,
			duration: speed,
			easing: fn && easing || easing && !jquery.isfunction( easing ) && easing
		};

		opt.duration = jquery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
			opt.duration in jquery.fx.speeds ? jquery.fx.speeds[ opt.duration ] : jquery.fx.speeds._default;

		// normalize opt.queue - true/undefined/null -> "fx"
		if ( opt.queue == null || opt.queue === true ) {
			opt.queue = "fx";
		}

		// queueing
		opt.old = opt.complete;

		opt.complete = function( nounmark ) {
			if ( jquery.isfunction( opt.old ) ) {
				opt.old.call( this );
			}

			if ( opt.queue ) {
				jquery.dequeue( this, opt.queue );
			} else if ( nounmark !== false ) {
				jquery._unmark( this );
			}
		};

		return opt;
	},

	easing: {
		linear: function( p, n, firstnum, diff ) {
			return firstnum + diff * p;
		},
		swing: function( p, n, firstnum, diff ) {
			return ( ( -math.cos( p*math.pi ) / 2 ) + 0.5 ) * diff + firstnum;
		}
	},

	timers: [],

	fx: function( elem, options, prop ) {
		this.options = options;
		this.elem = elem;
		this.prop = prop;

		options.orig = options.orig || {};
	}

});

jquery.fx.prototype = {
	// simple function for setting a style value
	update: function() {
		if ( this.options.step ) {
			this.options.step.call( this.elem, this.now, this );
		}

		( jquery.fx.step[ this.prop ] || jquery.fx.step._default )( this );
	},

	// get the current size
	cur: function() {
		if ( this.elem[ this.prop ] != null && (!this.elem.style || this.elem.style[ this.prop ] == null) ) {
			return this.elem[ this.prop ];
		}

		var parsed,
			r = jquery.css( this.elem, this.prop );
		// empty strings, null, undefined and "auto" are converted to 0,
		// complex values such as "rotate(1rad)" are returned as is,
		// simple values such as "10px" are parsed to float.
		return isnan( parsed = parsefloat( r ) ) ? !r || r === "auto" ? 0 : r : parsed;
	},

	// start an animation from one number to another
	custom: function( from, to, unit ) {
		var self = this,
			fx = jquery.fx;

		this.starttime = fxnow || createfxnow();
		this.end = to;
		this.now = this.start = from;
		this.pos = this.state = 0;
		this.unit = unit || this.unit || ( jquery.cssnumber[ this.prop ] ? "" : "px" );

		function t( gotoend ) {
			return self.step( gotoend );
		}

		t.queue = this.options.queue;
		t.elem = this.elem;
		t.savestate = function() {
			if ( self.options.hide && jquery._data( self.elem, "fxshow" + self.prop ) === undefined ) {
				jquery._data( self.elem, "fxshow" + self.prop, self.start );
			}
		};

		if ( t() && jquery.timers.push(t) && !timerid ) {
			timerid = setinterval( fx.tick, fx.interval );
		}
	},

	// simple 'show' function
	show: function() {
		var datashow = jquery._data( this.elem, "fxshow" + this.prop );

		// remember where we started, so that we can go back to it later
		this.options.orig[ this.prop ] = datashow || jquery.style( this.elem, this.prop );
		this.options.show = true;

		// begin the animation
		// make sure that we start at a small width/height to avoid any flash of content
		if ( datashow !== undefined ) {
			// this show is picking up where a previous hide or show left off
			this.custom( this.cur(), datashow );
		} else {
			this.custom( this.prop === "width" || this.prop === "height" ? 1 : 0, this.cur() );
		}

		// start by showing the element
		jquery( this.elem ).show();
	},

	// simple 'hide' function
	hide: function() {
		// remember where we started, so that we can go back to it later
		this.options.orig[ this.prop ] = jquery._data( this.elem, "fxshow" + this.prop ) || jquery.style( this.elem, this.prop );
		this.options.hide = true;

		// begin the animation
		this.custom( this.cur(), 0 );
	},

	// each step of an animation
	step: function( gotoend ) {
		var p, n, complete,
			t = fxnow || createfxnow(),
			done = true,
			elem = this.elem,
			options = this.options;

		if ( gotoend || t >= options.duration + this.starttime ) {
			this.now = this.end;
			this.pos = this.state = 1;
			this.update();

			options.animatedproperties[ this.prop ] = true;

			for ( p in options.animatedproperties ) {
				if ( options.animatedproperties[ p ] !== true ) {
					done = false;
				}
			}

			if ( done ) {
				// reset the overflow
				if ( options.overflow != null && !jquery.support.shrinkwrapblocks ) {

					jquery.each( [ "", "x", "y" ], function( index, value ) {
						elem.style[ "overflow" + value ] = options.overflow[ index ];
					});
				}

				// hide the element if the "hide" operation was done
				if ( options.hide ) {
					jquery( elem ).hide();
				}

				// reset the properties, if the item has been hidden or shown
				if ( options.hide || options.show ) {
					for ( p in options.animatedproperties ) {
						jquery.style( elem, p, options.orig[ p ] );
						jquery.removedata( elem, "fxshow" + p, true );
						// toggle data is no longer needed
						jquery.removedata( elem, "toggle" + p, true );
					}
				}

				// execute the complete function
				// in the event that the complete function throws an exception
				// we must ensure it won't be called twice. #5684

				complete = options.complete;
				if ( complete ) {

					options.complete = false;
					complete.call( elem );
				}
			}

			return false;

		} else {
			// classical easing cannot be used with an infinity duration
			if ( options.duration == infinity ) {
				this.now = t;
			} else {
				n = t - this.starttime;
				this.state = n / options.duration;

				// perform the easing function, defaults to swing
				this.pos = jquery.easing[ options.animatedproperties[this.prop] ]( this.state, n, 0, 1, options.duration );
				this.now = this.start + ( (this.end - this.start) * this.pos );
			}
			// perform the next step of the animation
			this.update();
		}

		return true;
	}
};

jquery.extend( jquery.fx, {
	tick: function() {
		var timer,
			timers = jquery.timers,
			i = 0;

		for ( ; i < timers.length; i++ ) {
			timer = timers[ i ];
			// checks the timer has not already been removed
			if ( !timer() && timers[ i ] === timer ) {
				timers.splice( i--, 1 );
			}
		}

		if ( !timers.length ) {
			jquery.fx.stop();
		}
	},

	interval: 13,

	stop: function() {
		clearinterval( timerid );
		timerid = null;
	},

	speeds: {
		slow: 600,
		fast: 200,
		// default speed
		_default: 400
	},

	step: {
		opacity: function( fx ) {
			jquery.style( fx.elem, "opacity", fx.now );
		},

		_default: function( fx ) {
			if ( fx.elem.style && fx.elem.style[ fx.prop ] != null ) {
				fx.elem.style[ fx.prop ] = fx.now + fx.unit;
			} else {
				fx.elem[ fx.prop ] = fx.now;
			}
		}
	}
});

// adds width/height step functions
// do not set anything below 0
jquery.each([ "width", "height" ], function( i, prop ) {
	jquery.fx.step[ prop ] = function( fx ) {
		jquery.style( fx.elem, prop, math.max(0, fx.now) + fx.unit );
	};
});

if ( jquery.expr && jquery.expr.filters ) {
	jquery.expr.filters.animated = function( elem ) {
		return jquery.grep(jquery.timers, function( fn ) {
			return elem === fn.elem;
		}).length;
	};
}

// try to restore the default display value of an element
function defaultdisplay( nodename ) {

	if ( !elemdisplay[ nodename ] ) {

		var body = document.body,
			elem = jquery( "<" + nodename + ">" ).appendto( body ),
			display = elem.css( "display" );
		elem.remove();

		// if the simple way fails,
		// get element's real default display by attaching it to a temp iframe
		if ( display === "none" || display === "" ) {
			// no iframe to use yet, so create it
			if ( !iframe ) {
				iframe = document.createelement( "iframe" );
				iframe.frameborder = iframe.width = iframe.height = 0;
			}

			body.appendchild( iframe );

			// create a cacheable copy of the iframe document on first call.
			// ie and opera will allow us to reuse the iframedoc without re-writing the fake html
			// document to it; webkit & firefox won't allow reusing the iframe document.
			if ( !iframedoc || !iframe.createelement ) {
				iframedoc = ( iframe.contentwindow || iframe.contentdocument ).document;
				iframedoc.write( ( document.compatmode === "css1compat" ? "<!doctype html>" : "" ) + "<html><body>" );
				iframedoc.close();
			}

			elem = iframedoc.createelement( nodename );

			iframedoc.body.appendchild( elem );

			display = jquery.css( elem, "display" );
			body.removechild( iframe );
		}

		// store the correct default display
		elemdisplay[ nodename ] = display;
	}

	return elemdisplay[ nodename ];
}




var rtable = /^t(?:able|d|h)$/i,
	rroot = /^(?:body|html)$/i;

if ( "getboundingclientrect" in document.documentelement ) {
	jquery.fn.offset = function( options ) {
		var elem = this[0], box;

		if ( options ) {
			return this.each(function( i ) {
				jquery.offset.setoffset( this, options, i );
			});
		}

		if ( !elem || !elem.ownerdocument ) {
			return null;
		}

		if ( elem === elem.ownerdocument.body ) {
			return jquery.offset.bodyoffset( elem );
		}

		try {
			box = elem.getboundingclientrect();
		} catch(e) {}

		var doc = elem.ownerdocument,
			docelem = doc.documentelement;

		// make sure we're not dealing with a disconnected dom node
		if ( !box || !jquery.contains( docelem, elem ) ) {
			return box ? { top: box.top, left: box.left } : { top: 0, left: 0 };
		}

		var body = doc.body,
			win = getwindow(doc),
			clienttop  = docelem.clienttop  || body.clienttop  || 0,
			clientleft = docelem.clientleft || body.clientleft || 0,
			scrolltop  = win.pageyoffset || jquery.support.boxmodel && docelem.scrolltop  || body.scrolltop,
			scrollleft = win.pagexoffset || jquery.support.boxmodel && docelem.scrollleft || body.scrollleft,
			top  = box.top  + scrolltop  - clienttop,
			left = box.left + scrollleft - clientleft;

		return { top: top, left: left };
	};

} else {
	jquery.fn.offset = function( options ) {
		var elem = this[0];

		if ( options ) {
			return this.each(function( i ) {
				jquery.offset.setoffset( this, options, i );
			});
		}

		if ( !elem || !elem.ownerdocument ) {
			return null;
		}

		if ( elem === elem.ownerdocument.body ) {
			return jquery.offset.bodyoffset( elem );
		}

		var computedstyle,
			offsetparent = elem.offsetparent,
			prevoffsetparent = elem,
			doc = elem.ownerdocument,
			docelem = doc.documentelement,
			body = doc.body,
			defaultview = doc.defaultview,
			prevcomputedstyle = defaultview ? defaultview.getcomputedstyle( elem, null ) : elem.currentstyle,
			top = elem.offsettop,
			left = elem.offsetleft;

		while ( (elem = elem.parentnode) && elem !== body && elem !== docelem ) {
			if ( jquery.support.fixedposition && prevcomputedstyle.position === "fixed" ) {
				break;
			}

			computedstyle = defaultview ? defaultview.getcomputedstyle(elem, null) : elem.currentstyle;
			top  -= elem.scrolltop;
			left -= elem.scrollleft;

			if ( elem === offsetparent ) {
				top  += elem.offsettop;
				left += elem.offsetleft;

				if ( jquery.support.doesnotaddborder && !(jquery.support.doesaddborderfortableandcells && rtable.test(elem.nodename)) ) {
					top  += parsefloat( computedstyle.bordertopwidth  ) || 0;
					left += parsefloat( computedstyle.borderleftwidth ) || 0;
				}

				prevoffsetparent = offsetparent;
				offsetparent = elem.offsetparent;
			}

			if ( jquery.support.subtractsborderforoverflownotvisible && computedstyle.overflow !== "visible" ) {
				top  += parsefloat( computedstyle.bordertopwidth  ) || 0;
				left += parsefloat( computedstyle.borderleftwidth ) || 0;
			}

			prevcomputedstyle = computedstyle;
		}

		if ( prevcomputedstyle.position === "relative" || prevcomputedstyle.position === "static" ) {
			top  += body.offsettop;
			left += body.offsetleft;
		}

		if ( jquery.support.fixedposition && prevcomputedstyle.position === "fixed" ) {
			top  += math.max( docelem.scrolltop, body.scrolltop );
			left += math.max( docelem.scrollleft, body.scrollleft );
		}

		return { top: top, left: left };
	};
}

jquery.offset = {

	bodyoffset: function( body ) {
		var top = body.offsettop,
			left = body.offsetleft;

		if ( jquery.support.doesnotincludemargininbodyoffset ) {
			top  += parsefloat( jquery.css(body, "margintop") ) || 0;
			left += parsefloat( jquery.css(body, "marginleft") ) || 0;
		}

		return { top: top, left: left };
	},

	setoffset: function( elem, options, i ) {
		var position = jquery.css( elem, "position" );

		// set position first, in-case top/left are set even on static elem
		if ( position === "static" ) {
			elem.style.position = "relative";
		}

		var curelem = jquery( elem ),
			curoffset = curelem.offset(),
			curcsstop = jquery.css( elem, "top" ),
			curcssleft = jquery.css( elem, "left" ),
			calculateposition = ( position === "absolute" || position === "fixed" ) && jquery.inarray("auto", [curcsstop, curcssleft]) > -1,
			props = {}, curposition = {}, curtop, curleft;

		// need to be able to calculate position if either top or left is auto and position is either absolute or fixed
		if ( calculateposition ) {
			curposition = curelem.position();
			curtop = curposition.top;
			curleft = curposition.left;
		} else {
			curtop = parsefloat( curcsstop ) || 0;
			curleft = parsefloat( curcssleft ) || 0;
		}

		if ( jquery.isfunction( options ) ) {
			options = options.call( elem, i, curoffset );
		}

		if ( options.top != null ) {
			props.top = ( options.top - curoffset.top ) + curtop;
		}
		if ( options.left != null ) {
			props.left = ( options.left - curoffset.left ) + curleft;
		}

		if ( "using" in options ) {
			options.using.call( elem, props );
		} else {
			curelem.css( props );
		}
	}
};


jquery.fn.extend({

	position: function() {
		if ( !this[0] ) {
			return null;
		}

		var elem = this[0],

		// get *real* offsetparent
		offsetparent = this.offsetparent(),

		// get correct offsets
		offset       = this.offset(),
		parentoffset = rroot.test(offsetparent[0].nodename) ? { top: 0, left: 0 } : offsetparent.offset();

		// subtract element margins
		// note: when an element has margin: auto the offsetleft and marginleft
		// are the same in safari causing offset.left to incorrectly be 0
		offset.top  -= parsefloat( jquery.css(elem, "margintop") ) || 0;
		offset.left -= parsefloat( jquery.css(elem, "marginleft") ) || 0;

		// add offsetparent borders
		parentoffset.top  += parsefloat( jquery.css(offsetparent[0], "bordertopwidth") ) || 0;
		parentoffset.left += parsefloat( jquery.css(offsetparent[0], "borderleftwidth") ) || 0;

		// subtract the two offsets
		return {
			top:  offset.top  - parentoffset.top,
			left: offset.left - parentoffset.left
		};
	},

	offsetparent: function() {
		return this.map(function() {
			var offsetparent = this.offsetparent || document.body;
			while ( offsetparent && (!rroot.test(offsetparent.nodename) && jquery.css(offsetparent, "position") === "static") ) {
				offsetparent = offsetparent.offsetparent;
			}
			return offsetparent;
		});
	}
});


// create scrollleft and scrolltop methods
jquery.each( ["left", "top"], function( i, name ) {
	var method = "scroll" + name;

	jquery.fn[ method ] = function( val ) {
		var elem, win;

		if ( val === undefined ) {
			elem = this[ 0 ];

			if ( !elem ) {
				return null;
			}

			win = getwindow( elem );

			// return the scroll offset
			return win ? ("pagexoffset" in win) ? win[ i ? "pageyoffset" : "pagexoffset" ] :
				jquery.support.boxmodel && win.document.documentelement[ method ] ||
					win.document.body[ method ] :
				elem[ method ];
		}

		// set the scroll offset
		return this.each(function() {
			win = getwindow( this );

			if ( win ) {
				win.scrollto(
					!i ? val : jquery( win ).scrollleft(),
					 i ? val : jquery( win ).scrolltop()
				);

			} else {
				this[ method ] = val;
			}
		});
	};
});

function getwindow( elem ) {
	return jquery.iswindow( elem ) ?
		elem :
		elem.nodetype === 9 ?
			elem.defaultview || elem.parentwindow :
			false;
}




// create width, height, innerheight, innerwidth, outerheight and outerwidth methods
jquery.each([ "height", "width" ], function( i, name ) {

	var type = name.tolowercase();

	// innerheight and innerwidth
	jquery.fn[ "inner" + name ] = function() {
		var elem = this[0];
		return elem ?
			elem.style ?
			parsefloat( jquery.css( elem, type, "padding" ) ) :
			this[ type ]() :
			null;
	};

	// outerheight and outerwidth
	jquery.fn[ "outer" + name ] = function( margin ) {
		var elem = this[0];
		return elem ?
			elem.style ?
			parsefloat( jquery.css( elem, type, margin ? "margin" : "border" ) ) :
			this[ type ]() :
			null;
	};

	jquery.fn[ type ] = function( size ) {
		// get window width or height
		var elem = this[0];
		if ( !elem ) {
			return size == null ? null : this;
		}

		if ( jquery.isfunction( size ) ) {
			return this.each(function( i ) {
				var self = jquery( this );
				self[ type ]( size.call( this, i, self[ type ]() ) );
			});
		}

		if ( jquery.iswindow( elem ) ) {
			// everyone else use document.documentelement or document.body depending on quirks vs standards mode
			// 3rd condition allows nokia support, as it supports the docelem prop but not css1compat
			var docelemprop = elem.document.documentelement[ "client" + name ],
				body = elem.document.body;
			return elem.document.compatmode === "css1compat" && docelemprop ||
				body && body[ "client" + name ] || docelemprop;

		// get document width or height
		} else if ( elem.nodetype === 9 ) {
			// either scroll[width/height] or offset[width/height], whichever is greater
			return math.max(
				elem.documentelement["client" + name],
				elem.body["scroll" + name], elem.documentelement["scroll" + name],
				elem.body["offset" + name], elem.documentelement["offset" + name]
			);

		// get or set width or height on the element
		} else if ( size === undefined ) {
			var orig = jquery.css( elem, type ),
				ret = parsefloat( orig );

			return jquery.isnumeric( ret ) ? ret : orig;

		// set the width or height on the element (default to pixels if value is unitless)
		} else {
			return this.css( type, typeof size === "string" ? size : size + "px" );
		}
	};

});




// expose jquery to the global object
window.jquery = window.$ = jquery;

// expose jquery as an amd module, but only for amd loaders that
// understand the issues with loading multiple versions of jquery
// in a page that all might call define(). the loader will indicate
// they have special allowances for multiple jquery versions by
// specifying define.amd.jquery = true. register as a named module,
// since jquery can be concatenated with other files that may use define,
// but not use a proper concatenation script that understands anonymous
// amd modules. a named amd is safest and most robust way to register.
// lowercase jquery is used because amd module names are derived from
// file names, and jquery is normally delivered in a lowercase file name.
// do this after creating the global so that if an amd module wants to call
// noconflict to hide this version of jquery, it will work.
if ( typeof define === "function" && define.amd && define.amd.jquery ) {
	define( "jquery", [], function () { return jquery; } );
}



})( window );