text: jQuery.fn.extend({
  	show: function(speed,callback){
  		return speed ?
  			this.animate({
  				height: "show", width: "show", opacity: "show"
  			}, speed, callback) :
  			
  			this.filter(":hidden").each(function(){
  				this.style.display = this.oldblock ? this.oldblock : "";
  				if ( jQuery.css(this,"display") == "none" )
  					this.style.display = "block";
  			}).end();
  	},
  	
  	hide: function(speed,callback){
  		return speed ?
  			this.animate({
  				height: "hide", width: "hide", opacity: "hide"
  			}, speed, callback) :
  			
  			this.filter(":visible").each(function(){
  				this.oldblock = this.oldblock || jQuery.css(this,"display");
  				if ( this.oldblock == "none" )
  					this.oldblock = "block";
  				this.style.display = "none";
  			}).end();
  	},
  
  	// Save the old toggle function
  	_toggle: jQuery.fn.toggle,
  	
  	toggle: function( fn, fn2 ){
  		return jQuery.isFunction(fn) && jQuery.isFunction(fn2) ?
  			this._toggle( fn, fn2 ) :
  			fn ?
  				this.animate({
  					height: "toggle", width: "toggle", opacity: "toggle"
  				}, fn, fn2) :
  				this.each(function(){
  					jQuery(this)[ jQuery(this).is(":hidden") ? "show" : "hide" ]();
  				});
  	},
  	
  	slideDown: function(speed,callback){
  		return this.animate({height: "show"}, speed, callback);
  	},
  	
  	slideUp: function(speed,callback){
  		return this.animate({height: "hide"}, speed, callback);
  	},
  
  	slideToggle: function(speed, callback){
  		return this.animate({height: "toggle"}, speed, callback);
  	},
  	
  	fadeIn: function(speed, callback){
  		return this.animate({opacity: "show"}, speed, callback);
  	},
  	
  	fadeOut: function(speed, callback){
  		return this.animate({opacity: "hide"}, speed, callback);
  	},
  	
  	fadeTo: function(speed,to,callback){
  		return this.animate({opacity: to}, speed, callback);
  	},
  	
  	animate: function( prop, speed, easing, callback ) {
  		var opt = jQuery.speed(speed, easing, callback);
  
  		return this[ opt.queue === false ? "each" : "queue" ](function(){
  			opt = jQuery.extend({}, opt);
  			var hidden = jQuery(this).is(":hidden"), self = this;
  			
  			for ( var p in prop ) {
  				if ( prop[p] == "hide" && hidden || prop[p] == "show" && !hidden )
  					return jQuery.isFunction(opt.complete) && opt.complete.apply(this);
  
  				if ( p == "height" || p == "width" ) {
  					// Store display property
  					opt.display = jQuery.css(this, "display");
  
  					// Make sure that nothing sneaks out
  					opt.overflow = this.style.overflow;
  				}
  			}
  
  			if ( opt.overflow != null )
  				this.style.overflow = "hidden";
  
  			opt.curAnim = jQuery.extend({}, prop);
  			
  			jQuery.each( prop, function(name, val){
  				var e = new jQuery.fx( self, opt, name );
  
  				if ( /toggle|show|hide/.test(val) )
  					e[ val == "toggle" ? hidden ? "show" : "hide" : val ]( prop );
  				else {
  					var parts = val.toString().match(/^([+-]?)([\d.]+)(.*)$/),
  						start = e.cur(true) || 0;
  
  					if ( parts ) {
  						end = parseFloat(parts[2]),
  						unit = parts[3] || "px";
  
  						// We need to compute starting value
  						if ( unit != "px" ) {
  							self.style[ name ] = end + unit;
  							start = (end / e.cur(true)) * start;
  							self.style[ name ] = 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;
  		});
  	},
  	
  	queue: function(type, fn){
  		if ( !fn ) {
  			fn = type;
  			type = "fx";
  		}
  
  		if ( !arguments.length )
  			return queue( this[0], type );
  
  		return this.each(function(){
  			if ( fn.constructor == Array )
  				queue(this, type, fn);
  			else {
  				queue(this, type).push( fn );
  			
  				if ( queue(this, type).length == 1 )
  					fn.apply(this);
  			}
  		});
  	},
  
  	dequeue: function(type){
  		type = type || "fx";
  
  		return this.each(function(){
  			var q = queue(this, type);
  
  			q.shift();
  
  			if ( q.length )
  				q[0].apply( this );
  		});
  	},
  
  	stop: function(){
  		var timers = jQuery.timers;
  
  		return this.each(function(){
  			for ( var i = 0; i < timers.length; i++ )
  				if ( timers[i].elem == this )
  					timers.splice(i--, 1);
  		}).dequeue();
  	}
  
  });
  
  function queue( elem, type, array ) {
  	if ( !elem )
  		return;
  
  	var queue = jQuery.data( elem, type + "queue" );
  
  	if ( !queue || array )
  		queue = jQuery.data( elem, type + "queue", 
  			array ? jQuery.makeArray(array) : [] );
  
  	return queue;
  }
  
  jQuery.extend({
  	
  	speed: function(speed, easing, fn) {
  		var opt = speed && speed.constructor == Object ? speed : {
  			complete: fn || !fn && easing || 
  				jQuery.isFunction( speed ) && speed,
  			duration: speed,
  			easing: fn && easing || easing && easing.constructor != Function && easing
  		};
  
  		opt.duration = (opt.duration && opt.duration.constructor == Number ? 
  			opt.duration : 
  			{ slow: 600, fast: 200 }[opt.duration]) || 400;
  	
  		// Queueing
  		opt.old = opt.complete;
  		opt.complete = function(){
  			jQuery(this).dequeue();
  			if ( jQuery.isFunction( opt.old ) )
  				opt.old.apply( 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;
  
  		if ( !options.orig )
  			options.orig = {};
  	}
  
  });
  
  jQuery.fx.prototype = {
  
  	// Simple function for setting a style value
  	update: function(){
  		if ( this.options.step )
  			this.options.step.apply( this.elem, [ this.now, this ] );
  
  		(jQuery.fx.step[this.prop] || jQuery.fx.step._default)( this );
  
  		// Set display property to block for height/width animations
  		if ( this.prop == "height" || this.prop == "width" )
  			this.elem.style.display = "block";
  	},
  
  	// Get the current size
  	cur: function(force){
  		if ( this.elem[this.prop] != null && this.elem.style[this.prop] == null )
  			return this.elem[ this.prop ];
  
  		var r = parseFloat(jQuery.curCSS(this.elem, this.prop, force));
  		return r && r > -10000 ? r : parseFloat(jQuery.css(this.elem, this.prop)) || 0;
  	},
  
  	// Start an animation from one number to another
  	custom: function(from, to, unit){
  		this.startTime = (new Date()).getTime();
  		this.start = from;
  		this.end = to;
  		this.unit = unit || this.unit || "px";
  		this.now = this.start;
  		this.pos = this.state = 0;
  		this.update();
  
  		var self = this;
  		function t(){
  			return self.step();
  		}
  
  		t.elem = this.elem;
  
  		jQuery.timers.push(t);
  
  		if ( jQuery.timers.length == 1 ) {
  			var timer = setInterval(function(){
  				var timers = jQuery.timers;
  				
  				for ( var i = 0; i < timers.length; i++ )
  					if ( !timers[i]() )
  						timers.splice(i--, 1);
  
  				if ( !timers.length )
  					clearInterval( timer );
  			}, 13);
  		}
  	},
  
  	// Simple 'show' function
  	show: function(){
  		// Remember where we started, so that we can go back to it later
  		this.options.orig[this.prop] = jQuery.attr( this.elem.style, this.prop );
  		this.options.show = true;
  
  		// Begin the animation
  		this.custom(0, this.cur());
  
  		// Make sure that we start at a small width/height to avoid any
  		// flash of content
  		if ( this.prop == "width" || this.prop == "height" )
  			this.elem.style[this.prop] = "1px";
  		
  		// 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.attr( this.elem.style, this.prop );
  		this.options.hide = true;
  
  		// Begin the animation
  		this.custom(this.cur(), 0);
  	},
  
  	// Each step of an animation
  	step: function(){
  		var t = (new Date()).getTime();
  
  		if ( t > this.options.duration + this.startTime ) {
  			this.now = this.end;
  			this.pos = this.state = 1;
  			this.update();
  
  			this.options.curAnim[ this.prop ] = true;
  
  			var done = true;
  			for ( var i in this.options.curAnim )
  				if ( this.options.curAnim[i] !== true )
  					done = false;
  
  			if ( done ) {
  				if ( this.options.display != null ) {
  					// Reset the overflow
  					this.elem.style.overflow = this.options.overflow;
  				
  					// Reset the display
  					this.elem.style.display = this.options.display;
  					if ( jQuery.css(this.elem, "display") == "none" )
  						this.elem.style.display = "block";
  				}
  
  				// Hide the element if the "hide" operation was done
  				if ( this.options.hide )
  					this.elem.style.display = "none";
  
  				// Reset the properties, if the item has been hidden or shown
  				if ( this.options.hide || this.options.show )
  					for ( var p in this.options.curAnim )
  						jQuery.attr(this.elem.style, p, this.options.orig[p]);
  			}
  
  			// If a callback was provided, execute it
  			if ( done && jQuery.isFunction( this.options.complete ) )
  				// Execute the complete function
  				this.options.complete.apply( this.elem );
  
  			return false;
  		} else {
  			var n = t - this.startTime;
  			this.state = n / this.options.duration;
  
  			// Perform the easing function, defaults to swing
  			this.pos = jQuery.easing[this.options.easing || (jQuery.easing.swing ? "swing" : "linear")](this.state, n, 0, 1, this.options.duration);
  			this.now = this.start + ((this.end - this.start) * this.pos);
  
  			// Perform the next step of the animation
  			this.update();
  		}
  
  		return true;
  	}
  
  };
  
  jQuery.fx.step = {
  	scrollLeft: function(fx){
  		fx.elem.scrollLeft = fx.now;
  	},
  
  	scrollTop: function(fx){
  		fx.elem.scrollTop = fx.now;
  	},
  
  	opacity: function(fx){
  		jQuery.attr(fx.elem.style, "opacity", fx.now);
  	},
  
  	_default: function(fx){
  		fx.elem.style[ fx.prop ] = fx.now + fx.unit;
  	}
  };
  