1 /*!
  2  * jQuery JavaScript Library v1.4.2
  3  * http://jquery.com/
  4  *
  5  * Copyright 2010, John Resig
  6  * Dual licensed under the MIT or GPL Version 2 licenses.
  7  * http://jquery.org/license
  8  *
  9  * Includes Sizzle.js
 10  * http://sizzlejs.com/
 11  * Copyright 2010, The Dojo Foundation
 12  * Released under the MIT, BSD, and GPL Licenses.
 13  *
 14  * Date: Sat Feb 13 22:33:48 2010 -0500
 15  */
 16 (function( window, undefined ) {
 17 
 18 // Define a local copy of jQuery
 19 var jQuery = function( selector, context ) {
 20 		// The jQuery object is actually just the init constructor 'enhanced'
 21 		return new jQuery.fn.init( selector, context );
 22 	},
 23 
 24 	// Map over jQuery in case of overwrite
 25 	_jQuery = window.jQuery,
 26 
 27 	// Map over the $ in case of overwrite
 28 	_$ = window.$,
 29 
 30 	// Use the correct document accordingly with window argument (sandbox)
 31 	document = window.document,
 32 
 33 	// A central reference to the root jQuery(document)
 34 	rootjQuery,
 35 
 36 	// A simple way to check for HTML strings or ID strings
 37 	// (both of which we optimize for)
 38 	quickExpr = /^[^<]*(<[\w\W]+>)[^>]*$|^#([\w-]+)$/,
 39 
 40 	// Is it a simple selector
 41 	isSimple = /^.[^:#\[\.,]*$/,
 42 
 43 	// Check if a string has a non-whitespace character in it
 44 	rnotwhite = /\S/,
 45 
 46 	// Used for trimming whitespace
 47 	rtrim = /^(\s|\u00A0)+|(\s|\u00A0)+$/g,
 48 
 49 	// Match a standalone tag
 50 	rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/,
 51 
 52 	// Keep a UserAgent string for use with jQuery.browser
 53 	userAgent = navigator.userAgent,
 54 
 55 	// For matching the engine and version of the browser
 56 	browserMatch,
 57 	
 58 	// Has the ready events already been bound?
 59 	readyBound = false,
 60 	
 61 	// The functions to execute on DOM ready
 62 	readyList = [],
 63 
 64 	// The ready event handler
 65 	DOMContentLoaded,
 66 
 67 	// Save a reference to some core methods
 68 	toString = Object.prototype.toString,
 69 	hasOwnProperty = Object.prototype.hasOwnProperty,
 70 	push = Array.prototype.push,
 71 	slice = Array.prototype.slice,
 72 	indexOf = Array.prototype.indexOf;
 73 
 74 jQuery.fn = jQuery.prototype = {
 75 	init: function( selector, context ) {
 76 		var match, elem, ret, doc;
 77 
 78 		// Handle $(""), $(null), or $(undefined)
 79 		if ( !selector ) {
 80 			return this;
 81 		}
 82 
 83 		// Handle $(DOMElement)
 84 		if ( selector.nodeType ) {
 85 			this.context = this[0] = selector;
 86 			this.length = 1;
 87 			return this;
 88 		}
 89 		
 90 		// The body element only exists once, optimize finding it
 91 		if ( selector === "body" && !context ) {
 92 			this.context = document;
 93 			this[0] = document.body;
 94 			this.selector = "body";
 95 			this.length = 1;
 96 			return this;
 97 		}
 98 
 99 		// Handle HTML strings
100 		if ( typeof selector === "string" ) {
101 			// Are we dealing with HTML string or an ID?
102 			match = quickExpr.exec( selector );
103 
104 			// Verify a match, and that no context was specified for #id
105 			if ( match && (match[1] || !context) ) {
106 
107 				// HANDLE: $(html) -> $(array)
108 				if ( match[1] ) {
109 					doc = (context ? context.ownerDocument || context : document);
110 
111 					// If a single string is passed in and it's a single tag
112 					// just do a createElement and skip the rest
113 					ret = rsingleTag.exec( selector );
114 
115 					if ( ret ) {
116 						if ( jQuery.isPlainObject( context ) ) {
117 							selector = [ document.createElement( ret[1] ) ];
118 							jQuery.fn.attr.call( selector, context, true );
119 
120 						} else {
121 							selector = [ doc.createElement( ret[1] ) ];
122 						}
123 
124 					} else {
125 						ret = buildFragment( [ match[1] ], [ doc ] );
126 						selector = (ret.cacheable ? ret.fragment.cloneNode(true) : ret.fragment).childNodes;
127 					}
128 					
129 					return jQuery.merge( this, selector );
130 					
131 				// HANDLE: $("#id")
132 				} else {
133 					elem = document.getElementById( match[2] );
134 
135 					if ( elem ) {
136 						// Handle the case where IE and Opera return items
137 						// by name instead of ID
138 						if ( elem.id !== match[2] ) {
139 							return rootjQuery.find( selector );
140 						}
141 
142 						// Otherwise, we inject the element directly into the jQuery object
143 						this.length = 1;
144 						this[0] = elem;
145 					}
146 
147 					this.context = document;
148 					this.selector = selector;
149 					return this;
150 				}
151 
152 			// HANDLE: $("TAG")
153 			} else if ( !context && /^\w+$/.test( selector ) ) {
154 				this.selector = selector;
155 				this.context = document;
156 				selector = document.getElementsByTagName( selector );
157 				return jQuery.merge( this, selector );
158 
159 			// HANDLE: $(expr, $(...))
160 			} else if ( !context || context.jquery ) {
161 				return (context || rootjQuery).find( selector );
162 
163 			// HANDLE: $(expr, context)
164 			// (which is just equivalent to: $(context).find(expr)
165 			} else {
166 				return jQuery( context ).find( selector );
167 			}
168 
169 		// HANDLE: $(function)
170 		// Shortcut for document ready
171 		} else if ( jQuery.isFunction( selector ) ) {
172 			return rootjQuery.ready( selector );
173 		}
174 
175 		if (selector.selector !== undefined) {
176 			this.selector = selector.selector;
177 			this.context = selector.context;
178 		}
179 
180 		return jQuery.makeArray( selector, this );
181 	},
182 
183 	// Start with an empty selector
184 	selector: "",
185 
186 	// The current version of jQuery being used
187 	jquery: "1.4.2",
188 
189 	// The default length of a jQuery object is 0
190 	length: 0,
191 
192 	// The number of elements contained in the matched element set
193 	size: function() {
194 		return this.length;
195 	},
196 
197 	toArray: function() {
198 		return slice.call( this, 0 );
199 	},
200 
201 	// Get the Nth element in the matched element set OR
202 	// Get the whole matched element set as a clean array
203 	get: function( num ) {
204 		return num == null ?
205 
206 			// Return a 'clean' array
207 			this.toArray() :
208 
209 			// Return just the object
210 			( num < 0 ? this.slice(num)[ 0 ] : this[ num ] );
211 	},
212 
213 	// Take an array of elements and push it onto the stack
214 	// (returning the new matched element set)
215 	pushStack: function( elems, name, selector ) {
216 		// Build a new jQuery matched element set
217 		var ret = jQuery();
218 
219 		if ( jQuery.isArray( elems ) ) {
220 			push.apply( ret, elems );
221 		
222 		} else {
223 			jQuery.merge( ret, elems );
224 		}
225 
226 		// Add the old object onto the stack (as a reference)
227 		ret.prevObject = this;
228 
229 		ret.context = this.context;
230 
231 		if ( name === "find" ) {
232 			ret.selector = this.selector + (this.selector ? " " : "") + selector;
233 		} else if ( name ) {
234 			ret.selector = this.selector + "." + name + "(" + selector + ")";
235 		}
236 
237 		// Return the newly-formed element set
238 		return ret;
239 	},
240 
241 	// Execute a callback for every element in the matched set.
242 	// (You can seed the arguments with an array of args, but this is
243 	// only used internally.)
244 	each: function( callback, args ) {
245 		return jQuery.each( this, callback, args );
246 	},
247 	
248 	ready: function( fn ) {
249 		// Attach the listeners
250 		jQuery.bindReady();
251 
252 		// If the DOM is already ready
253 		if ( jQuery.isReady ) {
254 			// Execute the function immediately
255 			fn.call( document, jQuery );
256 
257 		// Otherwise, remember the function for later
258 		} else if ( readyList ) {
259 			// Add the function to the wait list
260 			readyList.push( fn );
261 		}
262 
263 		return this;
264 	},
265 	
266 	eq: function( i ) {
267 		return i === -1 ?
268 			this.slice( i ) :
269 			this.slice( i, +i + 1 );
270 	},
271 
272 	first: function() {
273 		return this.eq( 0 );
274 	},
275 
276 	last: function() {
277 		return this.eq( -1 );
278 	},
279 
280 	slice: function() {
281 		return this.pushStack( slice.apply( this, arguments ),
282 			"slice", slice.call(arguments).join(",") );
283 	},
284 
285 	map: function( callback ) {
286 		return this.pushStack( jQuery.map(this, function( elem, i ) {
287 			return callback.call( elem, i, elem );
288 		}));
289 	},
290 	
291 	end: function() {
292 		return this.prevObject || jQuery(null);
293 	},
294 
295 	// For internal use only.
296 	// Behaves like an Array's method, not like a jQuery method.
297 	push: push,
298 	sort: [].sort,
299 	splice: [].splice
300 };
301 
302 // Give the init function the jQuery prototype for later instantiation
303 jQuery.fn.init.prototype = jQuery.fn;
304 
305 jQuery.extend = jQuery.fn.extend = function() {
306 	// copy reference to target object
307 	var target = arguments[0] || {}, i = 1, length = arguments.length, deep = false, options, name, src, copy;
308 
309 	// Handle a deep copy situation
310 	if ( typeof target === "boolean" ) {
311 		deep = target;
312 		target = arguments[1] || {};
313 		// skip the boolean and the target
314 		i = 2;
315 	}
316 
317 	// Handle case when target is a string or something (possible in deep copy)
318 	if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
319 		target = {};
320 	}
321 
322 	// extend jQuery itself if only one argument is passed
323 	if ( length === i ) {
324 		target = this;
325 		--i;
326 	}
327 
328 	for ( ; i < length; i++ ) {
329 		// Only deal with non-null/undefined values
330 		if ( (options = arguments[ i ]) != null ) {
331 			// Extend the base object
332 			for ( name in options ) {
333 				src = target[ name ];
334 				copy = options[ name ];
335 
336 				// Prevent never-ending loop
337 				if ( target === copy ) {
338 					continue;
339 				}
340 
341 				// Recurse if we're merging object literal values or arrays
342 				if ( deep && copy && ( jQuery.isPlainObject(copy) || jQuery.isArray(copy) ) ) {
343 					var clone = src && ( jQuery.isPlainObject(src) || jQuery.isArray(src) ) ? src
344 						: jQuery.isArray(copy) ? [] : {};
345 
346 					// Never move original objects, clone them
347 					target[ name ] = jQuery.extend( deep, clone, copy );
348 
349 				// Don't bring in undefined values
350 				} else if ( copy !== undefined ) {
351 					target[ name ] = copy;
352 				}
353 			}
354 		}
355 	}
356 
357 	// Return the modified object
358 	return target;
359 };
360 
361 jQuery.extend({
362 	noConflict: function( deep ) {
363 		window.$ = _$;
364 
365 		if ( deep ) {
366 			window.jQuery = _jQuery;
367 		}
368 
369 		return jQuery;
370 	},
371 	
372 	// Is the DOM ready to be used? Set to true once it occurs.
373 	isReady: false,
374 	
375 	// Handle when the DOM is ready
376 	ready: function() {
377 		// Make sure that the DOM is not already loaded
378 		if ( !jQuery.isReady ) {
379 			// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
380 			if ( !document.body ) {
381 				return setTimeout( jQuery.ready, 13 );
382 			}
383 
384 			// Remember that the DOM is ready
385 			jQuery.isReady = true;
386 
387 			// If there are functions bound, to execute
388 			if ( readyList ) {
389 				// Execute all of them
390 				var fn, i = 0;
391 				while ( (fn = readyList[ i++ ]) ) {
392 					fn.call( document, jQuery );
393 				}
394 
395 				// Reset the list of functions
396 				readyList = null;
397 			}
398 
399 			// Trigger any bound ready events
400 			if ( jQuery.fn.triggerHandler ) {
401 				jQuery( document ).triggerHandler( "ready" );
402 			}
403 		}
404 	},
405 	
406 	bindReady: function() {
407 		if ( readyBound ) {
408 			return;
409 		}
410 
411 		readyBound = true;
412 
413 		// Catch cases where $(document).ready() is called after the
414 		// browser event has already occurred.
415 		if ( document.readyState === "complete" ) {
416 			return jQuery.ready();
417 		}
418 
419 		// Mozilla, Opera and webkit nightlies currently support this event
420 		if ( document.addEventListener ) {
421 			// Use the handy event callback
422 			document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
423 			
424 			// A fallback to window.onload, that will always work
425 			window.addEventListener( "load", jQuery.ready, false );
426 
427 		// If IE event model is used
428 		} else if ( document.attachEvent ) {
429 			// ensure firing before onload,
430 			// maybe late but safe also for iframes
431 			document.attachEvent("onreadystatechange", DOMContentLoaded);
432 			
433 			// A fallback to window.onload, that will always work
434 			window.attachEvent( "onload", jQuery.ready );
435 
436 			// If IE and not a frame
437 			// continually check to see if the document is ready
438 			var toplevel = false;
439 
440 			try {
441 				toplevel = window.frameElement == null;
442 			} catch(e) {}
443 
444 			if ( document.documentElement.doScroll && toplevel ) {
445 				doScrollCheck();
446 			}
447 		}
448 	},
449 
450 	// See test/unit/core.js for details concerning isFunction.
451 	// Since version 1.3, DOM methods and functions like alert
452 	// aren't supported. They return false on IE (#2968).
453 	isFunction: function( obj ) {
454 		return toString.call(obj) === "[object Function]";
455 	},
456 
457 	isArray: function( obj ) {
458 		return toString.call(obj) === "[object Array]";
459 	},
460 
461 	isPlainObject: function( obj ) {
462 		// Must be an Object.
463 		// Because of IE, we also have to check the presence of the constructor property.
464 		// Make sure that DOM nodes and window objects don't pass through, as well
465 		if ( !obj || toString.call(obj) !== "[object Object]" || obj.nodeType || obj.setInterval ) {
466 			return false;
467 		}
468 		
469 		// Not own constructor property must be Object
470 		if ( obj.constructor
471 			&& !hasOwnProperty.call(obj, "constructor")
472 			&& !hasOwnProperty.call(obj.constructor.prototype, "isPrototypeOf") ) {
473 			return false;
474 		}
475 		
476 		// Own properties are enumerated firstly, so to speed up,
477 		// if last one is own, then all properties are own.
478 	
479 		var key;
480 		for ( key in obj ) {}
481 		
482 		return key === undefined || hasOwnProperty.call( obj, key );
483 	},
484 
485 	isEmptyObject: function( obj ) {
486 		for ( var name in obj ) {
487 			return false;
488 		}
489 		return true;
490 	},
491 	
492 	error: function( msg ) {
493 		throw msg;
494 	},
495 	
496 	parseJSON: function( data ) {
497 		if ( typeof data !== "string" || !data ) {
498 			return null;
499 		}
500 
501 		// Make sure leading/trailing whitespace is removed (IE can't handle it)
502 		data = jQuery.trim( data );
503 		
504 		// Make sure the incoming data is actual JSON
505 		// Logic borrowed from http://json.org/json2.js
506 		if ( /^[\],:{}\s]*$/.test(data.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, "@")
507 			.replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, "]")
508 			.replace(/(?:^|:|,)(?:\s*\[)+/g, "")) ) {
509 
510 			// Try to use the native JSON parser first
511 			return window.JSON && window.JSON.parse ?
512 				window.JSON.parse( data ) :
513 				(new Function("return " + data))();
514 
515 		} else {
516 			jQuery.error( "Invalid JSON: " + data );
517 		}
518 	},
519 
520 	noop: function() {},
521 
522 	// Evalulates a script in a global context
523 	globalEval: function( data ) {
524 		if ( data && rnotwhite.test(data) ) {
525 			// Inspired by code by Andrea Giammarchi
526 			// http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html
527 			var head = document.getElementsByTagName("head")[0] || document.documentElement,
528 				script = document.createElement("script");
529 
530 			script.type = "text/javascript";
531 
532 			if ( jQuery.support.scriptEval ) {
533 				script.appendChild( document.createTextNode( data ) );
534 			} else {
535 				script.text = data;
536 			}
537 
538 			// Use insertBefore instead of appendChild to circumvent an IE6 bug.
539 			// This arises when a base node is used (#2709).
540 			head.insertBefore( script, head.firstChild );
541 			head.removeChild( script );
542 		}
543 	},
544 
545 	nodeName: function( elem, name ) {
546 		return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();
547 	},
548 
549 	// args is for internal usage only
550 	each: function( object, callback, args ) {
551 		var name, i = 0,
552 			length = object.length,
553 			isObj = length === undefined || jQuery.isFunction(object);
554 
555 		if ( args ) {
556 			if ( isObj ) {
557 				for ( name in object ) {
558 					if ( callback.apply( object[ name ], args ) === false ) {
559 						break;
560 					}
561 				}
562 			} else {
563 				for ( ; i < length; ) {
564 					if ( callback.apply( object[ i++ ], args ) === false ) {
565 						break;
566 					}
567 				}
568 			}
569 
570 		// A special, fast, case for the most common use of each
571 		} else {
572 			if ( isObj ) {
573 				for ( name in object ) {
574 					if ( callback.call( object[ name ], name, object[ name ] ) === false ) {
575 						break;
576 					}
577 				}
578 			} else {
579 				for ( var value = object[0];
580 					i < length && callback.call( value, i, value ) !== false; value = object[++i] ) {}
581 			}
582 		}
583 
584 		return object;
585 	},
586 
587 	trim: function( text ) {
588 		return (text || "").replace( rtrim, "" );
589 	},
590 
591 	// results is for internal usage only
592 	makeArray: function( array, results ) {
593 		var ret = results || [];
594 
595 		if ( array != null ) {
596 			// The window, strings (and functions) also have 'length'
597 			// The extra typeof function check is to prevent crashes
598 			// in Safari 2 (See: #3039)
599 			if ( array.length == null || typeof array === "string" || jQuery.isFunction(array) || (typeof array !== "function" && array.setInterval) ) {
600 				push.call( ret, array );
601 			} else {
602 				jQuery.merge( ret, array );
603 			}
604 		}
605 
606 		return ret;
607 	},
608 
609 	inArray: function( elem, array ) {
610 		if ( array.indexOf ) {
611 			return array.indexOf( elem );
612 		}
613 
614 		for ( var i = 0, length = array.length; i < length; i++ ) {
615 			if ( array[ i ] === elem ) {
616 				return i;
617 			}
618 		}
619 
620 		return -1;
621 	},
622 
623 	merge: function( first, second ) {
624 		var i = first.length, j = 0;
625 
626 		if ( typeof second.length === "number" ) {
627 			for ( var l = second.length; j < l; j++ ) {
628 				first[ i++ ] = second[ j ];
629 			}
630 		
631 		} else {
632 			while ( second[j] !== undefined ) {
633 				first[ i++ ] = second[ j++ ];
634 			}
635 		}
636 
637 		first.length = i;
638 
639 		return first;
640 	},
641 
642 	grep: function( elems, callback, inv ) {
643 		var ret = [];
644 
645 		// Go through the array, only saving the items
646 		// that pass the validator function
647 		for ( var i = 0, length = elems.length; i < length; i++ ) {
648 			if ( !inv !== !callback( elems[ i ], i ) ) {
649 				ret.push( elems[ i ] );
650 			}
651 		}
652 
653 		return ret;
654 	},
655 
656 	// arg is for internal usage only
657 	map: function( elems, callback, arg ) {
658 		var ret = [], value;
659 
660 		// Go through the array, translating each of the items to their
661 		// new value (or values).
662 		for ( var i = 0, length = elems.length; i < length; i++ ) {
663 			value = callback( elems[ i ], i, arg );
664 
665 			if ( value != null ) {
666 				ret[ ret.length ] = value;
667 			}
668 		}
669 
670 		return ret.concat.apply( [], ret );
671 	},
672 
673 	// A global GUID counter for objects
674 	guid: 1,
675 
676 	proxy: function( fn, proxy, thisObject ) {
677 		if ( arguments.length === 2 ) {
678 			if ( typeof proxy === "string" ) {
679 				thisObject = fn;
680 				fn = thisObject[ proxy ];
681 				proxy = undefined;
682 
683 			} else if ( proxy && !jQuery.isFunction( proxy ) ) {
684 				thisObject = proxy;
685 				proxy = undefined;
686 			}
687 		}
688 
689 		if ( !proxy && fn ) {
690 			proxy = function() {
691 				return fn.apply( thisObject || this, arguments );
692 			};
693 		}
694 
695 		// Set the guid of unique handler to the same of original handler, so it can be removed
696 		if ( fn ) {
697 			proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++;
698 		}
699 
700 		// So proxy can be declared as an argument
701 		return proxy;
702 	},
703 
704 	// Use of jQuery.browser is frowned upon.
705 	// More details: http://docs.jquery.com/Utilities/jQuery.browser
706 	uaMatch: function( ua ) {
707 		ua = ua.toLowerCase();
708 
709 		var match = /(webkit)[ \/]([\w.]+)/.exec( ua ) ||
710 			/(opera)(?:.*version)?[ \/]([\w.]+)/.exec( ua ) ||
711 			/(msie) ([\w.]+)/.exec( ua ) ||
712 			!/compatible/.test( ua ) && /(mozilla)(?:.*? rv:([\w.]+))?/.exec( ua ) ||
713 		  	[];
714 
715 		return { browser: match[1] || "", version: match[2] || "0" };
716 	},
717 
718 	browser: {}
719 });
720 
721 browserMatch = jQuery.uaMatch( userAgent );
722 if ( browserMatch.browser ) {
723 	jQuery.browser[ browserMatch.browser ] = true;
724 	jQuery.browser.version = browserMatch.version;
725 }
726 
727 // Deprecated, use jQuery.browser.webkit instead
728 if ( jQuery.browser.webkit ) {
729 	jQuery.browser.safari = true;
730 }
731 
732 if ( indexOf ) {
733 	jQuery.inArray = function( elem, array ) {
734 		return indexOf.call( array, elem );
735 	};
736 }
737 
738 // All jQuery objects should point back to these
739 rootjQuery = jQuery(document);
740 
741 // Cleanup functions for the document ready method
742 if ( document.addEventListener ) {
743 	DOMContentLoaded = function() {
744 		document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );
745 		jQuery.ready();
746 	};
747 
748 } else if ( document.attachEvent ) {
749 	DOMContentLoaded = function() {
750 		// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
751 		if ( document.readyState === "complete" ) {
752 			document.detachEvent( "onreadystatechange", DOMContentLoaded );
753 			jQuery.ready();
754 		}
755 	};
756 }
757 
758 // The DOM ready check for Internet Explorer
759 function doScrollCheck() {
760 	if ( jQuery.isReady ) {
761 		return;
762 	}
763 
764 	try {
765 		// If IE is used, use the trick by Diego Perini
766 		// http://javascript.nwbox.com/IEContentLoaded/
767 		document.documentElement.doScroll("left");
768 	} catch( error ) {
769 		setTimeout( doScrollCheck, 1 );
770 		return;
771 	}
772 
773 	// and execute any waiting functions
774 	jQuery.ready();
775 }
776 
777 function evalScript( i, elem ) {
778 	if ( elem.src ) {
779 		jQuery.ajax({
780 			url: elem.src,
781 			async: false,
782 			dataType: "script"
783 		});
784 	} else {
785 		jQuery.globalEval( elem.text || elem.textContent || elem.innerHTML || "" );
786 	}
787 
788 	if ( elem.parentNode ) {
789 		elem.parentNode.removeChild( elem );
790 	}
791 }
792 
793 // Mutifunctional method to get and set values to a collection
794 // The value/s can be optionally by executed if its a function
795 function access( elems, key, value, exec, fn, pass ) {
796 	var length = elems.length;
797 	
798 	// Setting many attributes
799 	if ( typeof key === "object" ) {
800 		for ( var k in key ) {
801 			access( elems, k, key[k], exec, fn, value );
802 		}
803 		return elems;
804 	}
805 	
806 	// Setting one attribute
807 	if ( value !== undefined ) {
808 		// Optionally, function values get executed if exec is true
809 		exec = !pass && exec && jQuery.isFunction(value);
810 		
811 		for ( var i = 0; i < length; i++ ) {
812 			fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
813 		}
814 		
815 		return elems;
816 	}
817 	
818 	// Getting an attribute
819 	return length ? fn( elems[0], key ) : undefined;
820 }
821 
822 function now() {
823 	return (new Date).getTime();
824 }
825 (function() {
826 
827 	jQuery.support = {};
828 
829 	var root = document.documentElement,
830 		script = document.createElement("script"),
831 		div = document.createElement("div"),
832 		id = "script" + now();
833 
834 	div.style.display = "none";
835 	div.innerHTML = "   <link/><table></table><a href='/a' style='color:red;float:left;opacity:.55;'>a</a><input type='checkbox'/>";
836 
837 	var all = div.getElementsByTagName("*"),
838 		a = div.getElementsByTagName("a")[0];
839 
840 	// Can't get basic test support
841 	if ( !all || !all.length || !a ) {
842 		return;
843 	}
844 
845 	jQuery.support = {
846 		// IE strips leading whitespace when .innerHTML is used
847 		leadingWhitespace: div.firstChild.nodeType === 3,
848 
849 		// Make sure that tbody elements aren't automatically inserted
850 		// IE will insert them into empty tables
851 		tbody: !div.getElementsByTagName("tbody").length,
852 
853 		// Make sure that link elements get serialized correctly by innerHTML
854 		// This requires a wrapper element in IE
855 		htmlSerialize: !!div.getElementsByTagName("link").length,
856 
857 		// Get the style information from getAttribute
858 		// (IE uses .cssText insted)
859 		style: /red/.test( a.getAttribute("style") ),
860 
861 		// Make sure that URLs aren't manipulated
862 		// (IE normalizes it by default)
863 		hrefNormalized: a.getAttribute("href") === "/a",
864 
865 		// Make sure that element opacity exists
866 		// (IE uses filter instead)
867 		// Use a regex to work around a WebKit issue. See #5145
868 		opacity: /^0.55$/.test( a.style.opacity ),
869 
870 		// Verify style float existence
871 		// (IE uses styleFloat instead of cssFloat)
872 		cssFloat: !!a.style.cssFloat,
873 
874 		// Make sure that if no value is specified for a checkbox
875 		// that it defaults to "on".
876 		// (WebKit defaults to "" instead)
877 		checkOn: div.getElementsByTagName("input")[0].value === "on",
878 
879 		// Make sure that a selected-by-default option has a working selected property.
880 		// (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
881 		optSelected: document.createElement("select").appendChild( document.createElement("option") ).selected,
882 
883 		parentNode: div.removeChild( div.appendChild( document.createElement("div") ) ).parentNode === null,
884 
885 		// Will be defined later
886 		deleteExpando: true,
887 		checkClone: false,
888 		scriptEval: false,
889 		noCloneEvent: true,
890 		boxModel: null
891 	};
892 
893 	script.type = "text/javascript";
894 	try {
895 		script.appendChild( document.createTextNode( "window." + id + "=1;" ) );
896 	} catch(e) {}
897 
898 	root.insertBefore( script, root.firstChild );
899 
900 	// Make sure that the execution of code works by injecting a script
901 	// tag with appendChild/createTextNode
902 	// (IE doesn't support this, fails, and uses .text instead)
903 	if ( window[ id ] ) {
904 		jQuery.support.scriptEval = true;
905 		delete window[ id ];
906 	}
907 
908 	// Test to see if it's possible to delete an expando from an element
909 	// Fails in Internet Explorer
910 	try {
911 		delete script.test;
912 	
913 	} catch(e) {
914 		jQuery.support.deleteExpando = false;
915 	}
916 
917 	root.removeChild( script );
918 
919 	if ( div.attachEvent && div.fireEvent ) {
920 		div.attachEvent("onclick", function click() {
921 			// Cloning a node shouldn't copy over any
922 			// bound event handlers (IE does this)
923 			jQuery.support.noCloneEvent = false;
924 			div.detachEvent("onclick", click);
925 		});
926 		div.cloneNode(true).fireEvent("onclick");
927 	}
928 
929 	div = document.createElement("div");
930 	div.innerHTML = "<input type='radio' name='radiotest' checked='checked'/>";
931 
932 	var fragment = document.createDocumentFragment();
933 	fragment.appendChild( div.firstChild );
934 
935 	// WebKit doesn't clone checked state correctly in fragments
936 	jQuery.support.checkClone = fragment.cloneNode(true).cloneNode(true).lastChild.checked;
937 
938 	// Figure out if the W3C box model works as expected
939 	// document.body must exist before we can do this
940 	jQuery(function() {
941 		var div = document.createElement("div");
942 		div.style.width = div.style.paddingLeft = "1px";
943 
944 		document.body.appendChild( div );
945 		jQuery.boxModel = jQuery.support.boxModel = div.offsetWidth === 2;
946 		document.body.removeChild( div ).style.display = 'none';
947 
948 		div = null;
949 	});
950 
951 	// Technique from Juriy Zaytsev
952 	// http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/
953 	var eventSupported = function( eventName ) { 
954 		var el = document.createElement("div"); 
955 		eventName = "on" + eventName; 
956 
957 		var isSupported = (eventName in el); 
958 		if ( !isSupported ) { 
959 			el.setAttribute(eventName, "return;"); 
960 			isSupported = typeof el[eventName] === "function"; 
961 		} 
962 		el = null; 
963 
964 		return isSupported; 
965 	};
966 	
967 	jQuery.support.submitBubbles = eventSupported("submit");
968 	jQuery.support.changeBubbles = eventSupported("change");
969 
970 	// release memory in IE
971 	root = script = div = all = a = null;
972 })();
973 
974 jQuery.props = {
975 	"for": "htmlFor",
976 	"class": "className",
977 	readonly: "readOnly",
978 	maxlength: "maxLength",
979 	cellspacing: "cellSpacing",
980 	rowspan: "rowSpan",
981 	colspan: "colSpan",
982 	tabindex: "tabIndex",
983 	usemap: "useMap",
984 	frameborder: "frameBorder"
985 };
986 var expando = "jQuery" + now(), uuid = 0, windowData = {};
987 
988 jQuery.extend({
989 	cache: {},
990 	
991 	expando:expando,
992 
993 	// The following elements throw uncatchable exceptions if you
994 	// attempt to add expando properties to them.
995 	noData: {
996 		"embed": true,
997 		"object": true,
998 		"applet": true
999 	},
1000 
1001 	data: function( elem, name, data ) {
1002 		if ( elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()] ) {
1003 			return;
1004 		}
1005 
1006 		elem = elem == window ?
1007 			windowData :
1008 			elem;
1009 
1010 		var id = elem[ expando ], cache = jQuery.cache, thisCache;
1011 
1012 		if ( !id && typeof name === "string" && data === undefined ) {
1013 			return null;
1014 		}
1015 
1016 		// Compute a unique ID for the element
1017 		if ( !id ) { 
1018 			id = ++uuid;
1019 		}
1020 
1021 		// Avoid generating a new cache unless none exists and we
1022 		// want to manipulate it.
1023 		if ( typeof name === "object" ) {
1024 			elem[ expando ] = id;
1025 			thisCache = cache[ id ] = jQuery.extend(true, {}, name);
1026 
1027 		} else if ( !cache[ id ] ) {
1028 			elem[ expando ] = id;
1029 			cache[ id ] = {};
1030 		}
1031 
1032 		thisCache = cache[ id ];
1033 
1034 		// Prevent overriding the named cache with undefined values
1035 		if ( data !== undefined ) {
1036 			thisCache[ name ] = data;
1037 		}
1038 
1039 		return typeof name === "string" ? thisCache[ name ] : thisCache;
1040 	},
1041 
1042 	removeData: function( elem, name ) {
1043 		if ( elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()] ) {
1044 			return;
1045 		}
1046 
1047 		elem = elem == window ?
1048 			windowData :
1049 			elem;
1050 
1051 		var id = elem[ expando ], cache = jQuery.cache, thisCache = cache[ id ];
1052 
1053 		// If we want to remove a specific section of the element's data
1054 		if ( name ) {
1055 			if ( thisCache ) {
1056 				// Remove the section of cache data
1057 				delete thisCache[ name ];
1058 
1059 				// If we've removed all the data, remove the element's cache
1060 				if ( jQuery.isEmptyObject(thisCache) ) {
1061 					jQuery.removeData( elem );
1062 				}
1063 			}
1064 
1065 		// Otherwise, we want to remove all of the element's data
1066 		} else {
1067 			if ( jQuery.support.deleteExpando ) {
1068 				delete elem[ jQuery.expando ];
1069 
1070 			} else if ( elem.removeAttribute ) {
1071 				elem.removeAttribute( jQuery.expando );
1072 			}
1073 
1074 			// Completely remove the data cache
1075 			delete cache[ id ];
1076 		}
1077 	}
1078 });
1079 
1080 jQuery.fn.extend({
1081 	data: function( key, value ) {
1082 		if ( typeof key === "undefined" && this.length ) {
1083 			return jQuery.data( this[0] );
1084 
1085 		} else if ( typeof key === "object" ) {
1086 			return this.each(function() {
1087 				jQuery.data( this, key );
1088 			});
1089 		}
1090 
1091 		var parts = key.split(".");
1092 		parts[1] = parts[1] ? "." + parts[1] : "";
1093 
1094 		if ( value === undefined ) {
1095 			var data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
1096 
1097 			if ( data === undefined && this.length ) {
1098 				data = jQuery.data( this[0], key );
1099 			}
1100 			return data === undefined && parts[1] ?
1101 				this.data( parts[0] ) :
1102 				data;
1103 		} else {
1104 			return this.trigger("setData" + parts[1] + "!", [parts[0], value]).each(function() {
1105 				jQuery.data( this, key, value );
1106 			});
1107 		}
1108 	},
1109 
1110 	removeData: function( key ) {
1111 		return this.each(function() {
1112 			jQuery.removeData( this, key );
1113 		});
1114 	}
1115 });
1116 jQuery.extend({
1117 	queue: function( elem, type, data ) {
1118 		if ( !elem ) {
1119 			return;
1120 		}
1121 
1122 		type = (type || "fx") + "queue";
1123 		var q = jQuery.data( elem, type );
1124 
1125 		// Speed up dequeue by getting out quickly if this is just a lookup
1126 		if ( !data ) {
1127 			return q || [];
1128 		}
1129 
1130 		if ( !q || jQuery.isArray(data) ) {
1131 			q = jQuery.data( elem, type, jQuery.makeArray(data) );
1132 
1133 		} else {
1134 			q.push( data );
1135 		}
1136 
1137 		return q;
1138 	},
1139 
1140 	dequeue: function( elem, type ) {
1141 		type = type || "fx";
1142 
1143 		var queue = jQuery.queue( elem, type ), fn = queue.shift();
1144 
1145 		// If the fx queue is dequeued, always remove the progress sentinel
1146 		if ( fn === "inprogress" ) {
1147 			fn = queue.shift();
1148 		}
1149 
1150 		if ( fn ) {
1151 			// Add a progress sentinel to prevent the fx queue from being
1152 			// automatically dequeued
1153 			if ( type === "fx" ) {
1154 				queue.unshift("inprogress");
1155 			}
1156 
1157 			fn.call(elem, function() {
1158 				jQuery.dequeue(elem, type);
1159 			});
1160 		}
1161 	}
1162 });
1163 
1164 jQuery.fn.extend({
1165 	queue: function( type, data ) {
1166 		if ( typeof type !== "string" ) {
1167 			data = type;
1168 			type = "fx";
1169 		}
1170 
1171 		if ( data === undefined ) {
1172 			return jQuery.queue( this[0], type );
1173 		}
1174 		return this.each(function( i, elem ) {
1175 			var queue = jQuery.queue( this, type, data );
1176 
1177 			if ( type === "fx" && queue[0] !== "inprogress" ) {
1178 				jQuery.dequeue( this, type );
1179 			}
1180 		});
1181 	},
1182 	dequeue: function( type ) {
1183 		return this.each(function() {
1184 			jQuery.dequeue( this, type );
1185 		});
1186 	},
1187 
1188 	// Based off of the plugin by Clint Helfers, with permission.
1189 	// http://blindsignals.com/index.php/2009/07/jquery-delay/
1190 	delay: function( time, type ) {
1191 		time = jQuery.fx ? jQuery.fx.speeds[time] || time : time;
1192 		type = type || "fx";
1193 
1194 		return this.queue( type, function() {
1195 			var elem = this;
1196 			setTimeout(function() {
1197 				jQuery.dequeue( elem, type );
1198 			}, time );
1199 		});
1200 	},
1201 
1202 	clearQueue: function( type ) {
1203 		return this.queue( type || "fx", [] );
1204 	}
1205 });
1206 var rclass = /[\n\t]/g,
1207 	rspace = /\s+/,
1208 	rreturn = /\r/g,
1209 	rspecialurl = /href|src|style/,
1210 	rtype = /(button|input)/i,
1211 	rfocusable = /(button|input|object|select|textarea)/i,
1212 	rclickable = /^(a|area)$/i,
1213 	rradiocheck = /radio|checkbox/;
1214 
1215 jQuery.fn.extend({
1216 	attr: function( name, value ) {
1217 		return access( this, name, value, true, jQuery.attr );
1218 	},
1219 
1220 	removeAttr: function( name, fn ) {
1221 		return this.each(function(){
1222 			jQuery.attr( this, name, "" );
1223 			if ( this.nodeType === 1 ) {
1224 				this.removeAttribute( name );
1225 			}
1226 		});
1227 	},
1228 
1229 	addClass: function( value ) {
1230 		if ( jQuery.isFunction(value) ) {
1231 			return this.each(function(i) {
1232 				var self = jQuery(this);
1233 				self.addClass( value.call(this, i, self.attr("class")) );
1234 			});
1235 		}
1236 
1237 		if ( value && typeof value === "string" ) {
1238 			var classNames = (value || "").split( rspace );
1239 
1240 			for ( var i = 0, l = this.length; i < l; i++ ) {
1241 				var elem = this[i];
1242 
1243 				if ( elem.nodeType === 1 ) {
1244 					if ( !elem.className ) {
1245 						elem.className = value;
1246 
1247 					} else {
1248 						var className = " " + elem.className + " ", setClass = elem.className;
1249 						for ( var c = 0, cl = classNames.length; c < cl; c++ ) {
1250 							if ( className.indexOf( " " + classNames[c] + " " ) < 0 ) {
1251 								setClass += " " + classNames[c];
1252 							}
1253 						}
1254 						elem.className = jQuery.trim( setClass );
1255 					}
1256 				}
1257 			}
1258 		}
1259 
1260 		return this;
1261 	},
1262 
1263 	removeClass: function( value ) {
1264 		if ( jQuery.isFunction(value) ) {
1265 			return this.each(function(i) {
1266 				var self = jQuery(this);
1267 				self.removeClass( value.call(this, i, self.attr("class")) );
1268 			});
1269 		}
1270 
1271 		if ( (value && typeof value === "string") || value === undefined ) {
1272 			var classNames = (value || "").split(rspace);
1273 
1274 			for ( var i = 0, l = this.length; i < l; i++ ) {
1275 				var elem = this[i];
1276 
1277 				if ( elem.nodeType === 1 && elem.className ) {
1278 					if ( value ) {
1279 						var className = (" " + elem.className + " ").replace(rclass, " ");
1280 						for ( var c = 0, cl = classNames.length; c < cl; c++ ) {
1281 							className = className.replace(" " + classNames[c] + " ", " ");
1282 						}
1283 						elem.className = jQuery.trim( className );
1284 
1285 					} else {
1286 						elem.className = "";
1287 					}
1288 				}
1289 			}
1290 		}
1291 
1292 		return this;
1293 	},
1294 
1295 	toggleClass: function( value, stateVal ) {
1296 		var type = typeof value, isBool = typeof stateVal === "boolean";
1297 
1298 		if ( jQuery.isFunction( value ) ) {
1299 			return this.each(function(i) {
1300 				var self = jQuery(this);
1301 				self.toggleClass( value.call(this, i, self.attr("class"), stateVal), stateVal );
1302 			});
1303 		}
1304 
1305 		return this.each(function() {
1306 			if ( type === "string" ) {
1307 				// toggle individual class names
1308 				var className, i = 0, self = jQuery(this),
1309 					state = stateVal,
1310 					classNames = value.split( rspace );
1311 
1312 				while ( (className = classNames[ i++ ]) ) {
1313 					// check each className given, space seperated list
1314 					state = isBool ? state : !self.hasClass( className );
1315 					self[ state ? "addClass" : "removeClass" ]( className );
1316 				}
1317 
1318 			} else if ( type === "undefined" || type === "boolean" ) {
1319 				if ( this.className ) {
1320 					// store className if set
1321 					jQuery.data( this, "__className__", this.className );
1322 				}
1323 
1324 				// toggle whole className
1325 				this.className = this.className || value === false ? "" : jQuery.data( this, "__className__" ) || "";
1326 			}
1327 		});
1328 	},
1329 
1330 	hasClass: function( selector ) {
1331 		var className = " " + selector + " ";
1332 		for ( var i = 0, l = this.length; i < l; i++ ) {
1333 			if ( (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) {
1334 				return true;
1335 			}
1336 		}
1337 
1338 		return false;
1339 	},
1340 
1341 	val: function( value ) {
1342 		if ( value === undefined ) {
1343 			var elem = this[0];
1344 
1345 			if ( elem ) {
1346 				if ( jQuery.nodeName( elem, "option" ) ) {
1347 					return (elem.attributes.value || {}).specified ? elem.value : elem.text;
1348 				}
1349 
1350 				// We need to handle select boxes special
1351 				if ( jQuery.nodeName( elem, "select" ) ) {
1352 					var index = elem.selectedIndex,
1353 						values = [],
1354 						options = elem.options,
1355 						one = elem.type === "select-one";
1356 
1357 					// Nothing was selected
1358 					if ( index < 0 ) {
1359 						return null;
1360 					}
1361 
1362 					// Loop through all the selected options
1363 					for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {
1364 						var option = options[ i ];
1365 
1366 						if ( option.selected ) {
1367 							// Get the specifc value for the option
1368 							value = jQuery(option).val();
1369 
1370 							// We don't need an array for one selects
1371 							if ( one ) {
1372 								return value;
1373 							}
1374 
1375 							// Multi-Selects return an array
1376 							values.push( value );
1377 						}
1378 					}
1379 
1380 					return values;
1381 				}
1382 
1383 				// Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
1384 				if ( rradiocheck.test( elem.type ) && !jQuery.support.checkOn ) {
1385 					return elem.getAttribute("value") === null ? "on" : elem.value;
1386 				}
1387 				
1388 
1389 				// Everything else, we just grab the value
1390 				return (elem.value || "").replace(rreturn, "");
1391 
1392 			}
1393 
1394 			return undefined;
1395 		}
1396 
1397 		var isFunction = jQuery.isFunction(value);
1398 
1399 		return this.each(function(i) {
1400 			var self = jQuery(this), val = value;
1401 
1402 			if ( this.nodeType !== 1 ) {
1403 				return;
1404 			}
1405 
1406 			if ( isFunction ) {
1407 				val = value.call(this, i, self.val());
1408 			}
1409 
1410 			// Typecast each time if the value is a Function and the appended
1411 			// value is therefore different each time.
1412 			if ( typeof val === "number" ) {
1413 				val += "";
1414 			}
1415 
1416 			if ( jQuery.isArray(val) && rradiocheck.test( this.type ) ) {
1417 				this.checked = jQuery.inArray( self.val(), val ) >= 0;
1418 
1419 			} else if ( jQuery.nodeName( this, "select" ) ) {
1420 				var values = jQuery.makeArray(val);
1421 
1422 				jQuery( "option", this ).each(function() {
1423 					this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
1424 				});
1425 
1426 				if ( !values.length ) {
1427 					this.selectedIndex = -1;
1428 				}
1429 
1430 			} else {
1431 				this.value = val;
1432 			}
1433 		});
1434 	}
1435 });
1436 
1437 jQuery.extend({
1438 	attrFn: {
1439 		val: true,
1440 		css: true,
1441 		html: true,
1442 		text: true,
1443 		data: true,
1444 		width: true,
1445 		height: true,
1446 		offset: true
1447 	},
1448 		
1449 	attr: function( elem, name, value, pass ) {
1450 		// don't set attributes on text and comment nodes
1451 		if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 ) {
1452 			return undefined;
1453 		}
1454 
1455 		if ( pass && name in jQuery.attrFn ) {
1456 			return jQuery(elem)[name](value);
1457 		}
1458 
1459 		var notxml = elem.nodeType !== 1 || !jQuery.isXMLDoc( elem ),
1460 			// Whether we are setting (or getting)
1461 			set = value !== undefined;
1462 
1463 		// Try to normalize/fix the name
1464 		name = notxml && jQuery.props[ name ] || name;
1465 
1466 		// Only do all the following if this is a node (faster for style)
1467 		if ( elem.nodeType === 1 ) {
1468 			// These attributes require special treatment
1469 			var special = rspecialurl.test( name );
1470 
1471 			// Safari mis-reports the default selected property of an option
1472 			// Accessing the parent's selectedIndex property fixes it
1473 			if ( name === "selected" && !jQuery.support.optSelected ) {
1474 				var parent = elem.parentNode;
1475 				if ( parent ) {
1476 					parent.selectedIndex;
1477 	
1478 					// Make sure that it also works with optgroups, see #5701
1479 					if ( parent.parentNode ) {
1480 						parent.parentNode.selectedIndex;
1481 					}
1482 				}
1483 			}
1484 
1485 			// If applicable, access the attribute via the DOM 0 way
1486 			if ( name in elem && notxml && !special ) {
1487 				if ( set ) {
1488 					// We can't allow the type property to be changed (since it causes problems in IE)
1489 					if ( name === "type" && rtype.test( elem.nodeName ) && elem.parentNode ) {
1490 						jQuery.error( "type property can't be changed" );
1491 					}
1492 
1493 					elem[ name ] = value;
1494 				}
1495 
1496 				// browsers index elements by id/name on forms, give priority to attributes.
1497 				if ( jQuery.nodeName( elem, "form" ) && elem.getAttributeNode(name) ) {
1498 					return elem.getAttributeNode( name ).nodeValue;
1499 				}
1500 
1501 				// elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
1502 				// http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
1503 				if ( name === "tabIndex" ) {
1504 					var attributeNode = elem.getAttributeNode( "tabIndex" );
1505 
1506 					return attributeNode && attributeNode.specified ?
1507 						attributeNode.value :
1508 						rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
1509 							0 :
1510 							undefined;
1511 				}
1512 
1513 				return elem[ name ];
1514 			}
1515 
1516 			if ( !jQuery.support.style && notxml && name === "style" ) {
1517 				if ( set ) {
1518 					elem.style.cssText = "" + value;
1519 				}
1520 
1521 				return elem.style.cssText;
1522 			}
1523 
1524 			if ( set ) {
1525 				// convert the value to a string (all browsers do this but IE) see #1070
1526 				elem.setAttribute( name, "" + value );
1527 			}
1528 
1529 			var attr = !jQuery.support.hrefNormalized && notxml && special ?
1530 					// Some attributes require a special call on IE
1531 					elem.getAttribute( name, 2 ) :
1532 					elem.getAttribute( name );
1533 
1534 			// Non-existent attributes return null, we normalize to undefined
1535 			return attr === null ? undefined : attr;
1536 		}
1537 
1538 		// elem is actually elem.style ... set the style
1539 		// Using attr for specific style information is now deprecated. Use style instead.
1540 		return jQuery.style( elem, name, value );
1541 	}
1542 });
1543 var rnamespaces = /\.(.*)$/,
1544 	fcleanup = function( nm ) {
1545 		return nm.replace(/[^\w\s\.\|`]/g, function( ch ) {
1546 			return "\\" + ch;
1547 		});
1548 	};
1549 
1550 /*
1551  * A number of helper functions used for managing events.
1552  * Many of the ideas behind this code originated from
1553  * Dean Edwards' addEvent library.
1554  */
1555 jQuery.event = {
1556 
1557 	// Bind an event to an element
1558 	// Original by Dean Edwards
1559 	add: function( elem, types, handler, data ) {
1560 		if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
1561 			return;
1562 		}
1563 
1564 		// For whatever reason, IE has trouble passing the window object
1565 		// around, causing it to be cloned in the process
1566 		if ( elem.setInterval && ( elem !== window && !elem.frameElement ) ) {
1567 			elem = window;
1568 		}
1569 
1570 		var handleObjIn, handleObj;
1571 
1572 		if ( handler.handler ) {
1573 			handleObjIn = handler;
1574 			handler = handleObjIn.handler;
1575 		}
1576 
1577 		// Make sure that the function being executed has a unique ID
1578 		if ( !handler.guid ) {
1579 			handler.guid = jQuery.guid++;
1580 		}
1581 
1582 		// Init the element's event structure
1583 		var elemData = jQuery.data( elem );
1584 
1585 		// If no elemData is found then we must be trying to bind to one of the
1586 		// banned noData elements
1587 		if ( !elemData ) {
1588 			return;
1589 		}
1590 
1591 		var events = elemData.events = elemData.events || {},
1592 			eventHandle = elemData.handle, eventHandle;
1593 
1594 		if ( !eventHandle ) {
1595 			elemData.handle = eventHandle = function() {
1596 				// Handle the second event of a trigger and when
1597 				// an event is called after a page has unloaded
1598 				return typeof jQuery !== "undefined" && !jQuery.event.triggered ?
1599 					jQuery.event.handle.apply( eventHandle.elem, arguments ) :
1600 					undefined;
1601 			};
1602 		}
1603 
1604 		// Add elem as a property of the handle function
1605 		// This is to prevent a memory leak with non-native events in IE.
1606 		eventHandle.elem = elem;
1607 
1608 		// Handle multiple events separated by a space
1609 		// jQuery(...).bind("mouseover mouseout", fn);
1610 		types = types.split(" ");
1611 
1612 		var type, i = 0, namespaces;
1613 
1614 		while ( (type = types[ i++ ]) ) {
1615 			handleObj = handleObjIn ?
1616 				jQuery.extend({}, handleObjIn) :
1617 				{ handler: handler, data: data };
1618 
1619 			// Namespaced event handlers
1620 			if ( type.indexOf(".") > -1 ) {
1621 				namespaces = type.split(".");
1622 				type = namespaces.shift();
1623 				handleObj.namespace = namespaces.slice(0).sort().join(".");
1624 
1625 			} else {
1626 				namespaces = [];
1627 				handleObj.namespace = "";
1628 			}
1629 
1630 			handleObj.type = type;
1631 			handleObj.guid = handler.guid;
1632 
1633 			// Get the current list of functions bound to this event
1634 			var handlers = events[ type ],
1635 				special = jQuery.event.special[ type ] || {};
1636 
1637 			// Init the event handler queue
1638 			if ( !handlers ) {
1639 				handlers = events[ type ] = [];
1640 
1641 				// Check for a special event handler
1642 				// Only use addEventListener/attachEvent if the special
1643 				// events handler returns false
1644 				if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
1645 					// Bind the global event handler to the element
1646 					if ( elem.addEventListener ) {
1647 						elem.addEventListener( type, eventHandle, false );
1648 
1649 					} else if ( elem.attachEvent ) {
1650 						elem.attachEvent( "on" + type, eventHandle );
1651 					}
1652 				}
1653 			}
1654 			
1655 			if ( special.add ) { 
1656 				special.add.call( elem, handleObj ); 
1657 
1658 				if ( !handleObj.handler.guid ) {
1659 					handleObj.handler.guid = handler.guid;
1660 				}
1661 			}
1662 
1663 			// Add the function to the element's handler list
1664 			handlers.push( handleObj );
1665 
1666 			// Keep track of which events have been used, for global triggering
1667 			jQuery.event.global[ type ] = true;
1668 		}
1669 
1670 		// Nullify elem to prevent memory leaks in IE
1671 		elem = null;
1672 	},
1673 
1674 	global: {},
1675 
1676 	// Detach an event or set of events from an element
1677 	remove: function( elem, types, handler, pos ) {
1678 		// don't do events on text and comment nodes
1679 		if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
1680 			return;
1681 		}
1682 
1683 		var ret, type, fn, i = 0, all, namespaces, namespace, special, eventType, handleObj, origType,
1684 			elemData = jQuery.data( elem ),
1685 			events = elemData && elemData.events;
1686 
1687 		if ( !elemData || !events ) {
1688 			return;
1689 		}
1690 
1691 		// types is actually an event object here
1692 		if ( types && types.type ) {
1693 			handler = types.handler;
1694 			types = types.type;
1695 		}
1696 
1697 		// Unbind all events for the element
1698 		if ( !types || typeof types === "string" && types.charAt(0) === "." ) {
1699 			types = types || "";
1700 
1701 			for ( type in events ) {
1702 				jQuery.event.remove( elem, type + types );
1703 			}
1704 
1705 			return;
1706 		}
1707 
1708 		// Handle multiple events separated by a space
1709 		// jQuery(...).unbind("mouseover mouseout", fn);
1710 		types = types.split(" ");
1711 
1712 		while ( (type = types[ i++ ]) ) {
1713 			origType = type;
1714 			handleObj = null;
1715 			all = type.indexOf(".") < 0;
1716 			namespaces = [];
1717 
1718 			if ( !all ) {
1719 				// Namespaced event handlers
1720 				namespaces = type.split(".");
1721 				type = namespaces.shift();
1722 
1723 				namespace = new RegExp("(^|\\.)" + 
1724 					jQuery.map( namespaces.slice(0).sort(), fcleanup ).join("\\.(?:.*\\.)?") + "(\\.|$)")
1725 			}
1726 
1727 			eventType = events[ type ];
1728 
1729 			if ( !eventType ) {
1730 				continue;
1731 			}
1732 
1733 			if ( !handler ) {
1734 				for ( var j = 0; j < eventType.length; j++ ) {
1735 					handleObj = eventType[ j ];
1736 
1737 					if ( all || namespace.test( handleObj.namespace ) ) {
1738 						jQuery.event.remove( elem, origType, handleObj.handler, j );
1739 						eventType.splice( j--, 1 );
1740 					}
1741 				}
1742 
1743 				continue;
1744 			}
1745 
1746 			special = jQuery.event.special[ type ] || {};
1747 
1748 			for ( var j = pos || 0; j < eventType.length; j++ ) {
1749 				handleObj = eventType[ j ];
1750 
1751 				if ( handler.guid === handleObj.guid ) {
1752 					// remove the given handler for the given type
1753 					if ( all || namespace.test( handleObj.namespace ) ) {
1754 						if ( pos == null ) {
1755 							eventType.splice( j--, 1 );
1756 						}
1757 
1758 						if ( special.remove ) {
1759 							special.remove.call( elem, handleObj );
1760 						}
1761 					}
1762 
1763 					if ( pos != null ) {
1764 						break;
1765 					}
1766 				}
1767 			}
1768 
1769 			// remove generic event handler if no more handlers exist
1770 			if ( eventType.length === 0 || pos != null && eventType.length === 1 ) {
1771 				if ( !special.teardown || special.teardown.call( elem, namespaces ) === false ) {
1772 					removeEvent( elem, type, elemData.handle );
1773 				}
1774 
1775 				ret = null;
1776 				delete events[ type ];
1777 			}
1778 		}
1779 
1780 		// Remove the expando if it's no longer used
1781 		if ( jQuery.isEmptyObject( events ) ) {
1782 			var handle = elemData.handle;
1783 			if ( handle ) {
1784 				handle.elem = null;
1785 			}
1786 
1787 			delete elemData.events;
1788 			delete elemData.handle;
1789 
1790 			if ( jQuery.isEmptyObject( elemData ) ) {
1791 				jQuery.removeData( elem );
1792 			}
1793 		}
1794 	},
1795 
1796 	// bubbling is internal
1797 	trigger: function( event, data, elem /*, bubbling */ ) {
1798 		// Event object or event type
1799 		var type = event.type || event,
1800 			bubbling = arguments[3];
1801 
1802 		if ( !bubbling ) {
1803 			event = typeof event === "object" ?
1804 				// jQuery.Event object
1805 				event[expando] ? event :
1806 				// Object literal
1807 				jQuery.extend( jQuery.Event(type), event ) :
1808 				// Just the event type (string)
1809 				jQuery.Event(type);
1810 
1811 			if ( type.indexOf("!") >= 0 ) {
1812 				event.type = type = type.slice(0, -1);
1813 				event.exclusive = true;
1814 			}
1815 
1816 			// Handle a global trigger
1817 			if ( !elem ) {
1818 				// Don't bubble custom events when global (to avoid too much overhead)
1819 				event.stopPropagation();
1820 
1821 				// Only trigger if we've ever bound an event for it
1822 				if ( jQuery.event.global[ type ] ) {
1823 					jQuery.each( jQuery.cache, function() {
1824 						if ( this.events && this.events[type] ) {
1825 							jQuery.event.trigger( event, data, this.handle.elem );
1826 						}
1827 					});
1828 				}
1829 			}
1830 
1831 			// Handle triggering a single element
1832 
1833 			// don't do events on text and comment nodes
1834 			if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 ) {
1835 				return undefined;
1836 			}
1837 
1838 			// Clean up in case it is reused
1839 			event.result = undefined;
1840 			event.target = elem;
1841 
1842 			// Clone the incoming data, if any
1843 			data = jQuery.makeArray( data );
1844 			data.unshift( event );
1845 		}
1846 
1847 		event.currentTarget = elem;
1848 
1849 		// Trigger the event, it is assumed that "handle" is a function
1850 		var handle = jQuery.data( elem, "handle" );
1851 		if ( handle ) {
1852 			handle.apply( elem, data );
1853 		}
1854 
1855 		var parent = elem.parentNode || elem.ownerDocument;
1856 
1857 		// Trigger an inline bound script
1858 		try {
1859 			if ( !(elem && elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()]) ) {
1860 				if ( elem[ "on" + type ] && elem[ "on" + type ].apply( elem, data ) === false ) {
1861 					event.result = false;
1862 				}
1863 			}
1864 
1865 		// prevent IE from throwing an error for some elements with some event types, see #3533
1866 		} catch (e) {}
1867 
1868 		if ( !event.isPropagationStopped() && parent ) {
1869 			jQuery.event.trigger( event, data, parent, true );
1870 
1871 		} else if ( !event.isDefaultPrevented() ) {
1872 			var target = event.target, old,
1873 				isClick = jQuery.nodeName(target, "a") && type === "click",
1874 				special = jQuery.event.special[ type ] || {};
1875 
1876 			if ( (!special._default || special._default.call( elem, event ) === false) && 
1877 				!isClick && !(target && target.nodeName && jQuery.noData[target.nodeName.toLowerCase()]) ) {
1878 
1879 				try {
1880 					if ( target[ type ] ) {
1881 						// Make sure that we don't accidentally re-trigger the onFOO events
1882 						old = target[ "on" + type ];
1883 
1884 						if ( old ) {
1885 							target[ "on" + type ] = null;
1886 						}
1887 
1888 						jQuery.event.triggered = true;
1889 						target[ type ]();
1890 					}
1891 
1892 				// prevent IE from throwing an error for some elements with some event types, see #3533
1893 				} catch (e) {}
1894 
1895 				if ( old ) {
1896 					target[ "on" + type ] = old;
1897 				}
1898 
1899 				jQuery.event.triggered = false;
1900 			}
1901 		}
1902 	},
1903 
1904 	handle: function( event ) {
1905 		var all, handlers, namespaces, namespace, events;
1906 
1907 		event = arguments[0] = jQuery.event.fix( event || window.event );
1908 		event.currentTarget = this;
1909 
1910 		// Namespaced event handlers
1911 		all = event.type.indexOf(".") < 0 && !event.exclusive;
1912 
1913 		if ( !all ) {
1914 			namespaces = event.type.split(".");
1915 			event.type = namespaces.shift();
1916 			namespace = new RegExp("(^|\\.)" + namespaces.slice(0).sort().join("\\.(?:.*\\.)?") + "(\\.|$)");
1917 		}
1918 
1919 		var events = jQuery.data(this, "events"), handlers = events[ event.type ];
1920 
1921 		if ( events && handlers ) {
1922 			// Clone the handlers to prevent manipulation
1923 			handlers = handlers.slice(0);
1924 
1925 			for ( var j = 0, l = handlers.length; j < l; j++ ) {
1926 				var handleObj = handlers[ j ];
1927 
1928 				// Filter the functions by class
1929 				if ( all || namespace.test( handleObj.namespace ) ) {
1930 					// Pass in a reference to the handler function itself
1931 					// So that we can later remove it
1932 					event.handler = handleObj.handler;
1933 					event.data = handleObj.data;
1934 					event.handleObj = handleObj;
1935 	
1936 					var ret = handleObj.handler.apply( this, arguments );
1937 
1938 					if ( ret !== undefined ) {
1939 						event.result = ret;
1940 						if ( ret === false ) {
1941 							event.preventDefault();
1942 							event.stopPropagation();
1943 						}
1944 					}
1945 
1946 					if ( event.isImmediatePropagationStopped() ) {
1947 						break;
1948 					}
1949 				}
1950 			}
1951 		}
1952 
1953 		return event.result;
1954 	},
1955 
1956 	props: "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode layerX layerY metaKey newValue offsetX offsetY originalTarget pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "),
1957 
1958 	fix: function( event ) {
1959 		if ( event[ expando ] ) {
1960 			return event;
1961 		}
1962 
1963 		// store a copy of the original event object
1964 		// and "clone" to set read-only properties
1965 		var originalEvent = event;
1966 		event = jQuery.Event( originalEvent );
1967 
1968 		for ( var i = this.props.length, prop; i; ) {
1969 			prop = this.props[ --i ];
1970 			event[ prop ] = originalEvent[ prop ];
1971 		}
1972 
1973 		// Fix target property, if necessary
1974 		if ( !event.target ) {
1975 			event.target = event.srcElement || document; // Fixes #1925 where srcElement might not be defined either
1976 		}
1977 
1978 		// check if target is a textnode (safari)
1979 		if ( event.target.nodeType === 3 ) {
1980 			event.target = event.target.parentNode;
1981 		}
1982 
1983 		// Add relatedTarget, if necessary
1984 		if ( !event.relatedTarget && event.fromElement ) {
1985 			event.relatedTarget = event.fromElement === event.target ? event.toElement : event.fromElement;
1986 		}
1987 
1988 		// Calculate pageX/Y if missing and clientX/Y available
1989 		if ( event.pageX == null && event.clientX != null ) {
1990 			var doc = document.documentElement, body = document.body;
1991 			event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
1992 			event.pageY = event.clientY + (doc && doc.scrollTop  || body && body.scrollTop  || 0) - (doc && doc.clientTop  || body && body.clientTop  || 0);
1993 		}
1994 
1995 		// Add which for key events
1996 		if ( !event.which && ((event.charCode || event.charCode === 0) ? event.charCode : event.keyCode) ) {
1997 			event.which = event.charCode || event.keyCode;
1998 		}
1999 
2000 		// Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
2001 		if ( !event.metaKey && event.ctrlKey ) {
2002 			event.metaKey = event.ctrlKey;
2003 		}
2004 
2005 		// Add which for click: 1 === left; 2 === middle; 3 === right
2006 		// Note: button is not normalized, so don't use it
2007 		if ( !event.which && event.button !== undefined ) {
2008 			event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
2009 		}
2010 
2011 		return event;
2012 	},
2013 
2014 	// Deprecated, use jQuery.guid instead
2015 	guid: 1E8,
2016 
2017 	// Deprecated, use jQuery.proxy instead
2018 	proxy: jQuery.proxy,
2019 
2020 	special: {
2021 		ready: {
2022 			// Make sure the ready event is setup
2023 			setup: jQuery.bindReady,
2024 			teardown: jQuery.noop
2025 		},
2026 
2027 		live: {
2028 			add: function( handleObj ) {
2029 				jQuery.event.add( this, handleObj.origType, jQuery.extend({}, handleObj, {handler: liveHandler}) ); 
2030 			},
2031 
2032 			remove: function( handleObj ) {
2033 				var remove = true,
2034 					type = handleObj.origType.replace(rnamespaces, "");
2035 				
2036 				jQuery.each( jQuery.data(this, "events").live || [], function() {
2037 					if ( type === this.origType.replace(rnamespaces, "") ) {
2038 						remove = false;
2039 						return false;
2040 					}
2041 				});
2042 
2043 				if ( remove ) {
2044 					jQuery.event.remove( this, handleObj.origType, liveHandler );
2045 				}
2046 			}
2047 
2048 		},
2049 
2050 		beforeunload: {
2051 			setup: function( data, namespaces, eventHandle ) {
2052 				// We only want to do this special case on windows
2053 				if ( this.setInterval ) {
2054 					this.onbeforeunload = eventHandle;
2055 				}
2056 
2057 				return false;
2058 			},
2059 			teardown: function( namespaces, eventHandle ) {
2060 				if ( this.onbeforeunload === eventHandle ) {
2061 					this.onbeforeunload = null;
2062 				}
2063 			}
2064 		}
2065 	}
2066 };
2067 
2068 var removeEvent = document.removeEventListener ?
2069 	function( elem, type, handle ) {
2070 		elem.removeEventListener( type, handle, false );
2071 	} : 
2072 	function( elem, type, handle ) {
2073 		elem.detachEvent( "on" + type, handle );
2074 	};
2075 
2076 jQuery.Event = function( src ) {
2077 	// Allow instantiation without the 'new' keyword
2078 	if ( !this.preventDefault ) {
2079 		return new jQuery.Event( src );
2080 	}
2081 
2082 	// Event object
2083 	if ( src && src.type ) {
2084 		this.originalEvent = src;
2085 		this.type = src.type;
2086 	// Event type
2087 	} else {
2088 		this.type = src;
2089 	}
2090 
2091 	// timeStamp is buggy for some events on Firefox(#3843)
2092 	// So we won't rely on the native value
2093 	this.timeStamp = now();
2094 
2095 	// Mark it as fixed
2096 	this[ expando ] = true;
2097 };
2098 
2099 function returnFalse() {
2100 	return false;
2101 }
2102 function returnTrue() {
2103 	return true;
2104 }
2105 
2106 // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
2107 // http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
2108 jQuery.Event.prototype = {
2109 	preventDefault: function() {
2110 		this.isDefaultPrevented = returnTrue;
2111 
2112 		var e = this.originalEvent;
2113 		if ( !e ) {
2114 			return;
2115 		}
2116 		
2117 		// if preventDefault exists run it on the original event
2118 		if ( e.preventDefault ) {
2119 			e.preventDefault();
2120 		}
2121 		// otherwise set the returnValue property of the original event to false (IE)
2122 		e.returnValue = false;
2123 	},
2124 	stopPropagation: function() {
2125 		this.isPropagationStopped = returnTrue;
2126 
2127 		var e = this.originalEvent;
2128 		if ( !e ) {
2129 			return;
2130 		}
2131 		// if stopPropagation exists run it on the original event
2132 		if ( e.stopPropagation ) {
2133 			e.stopPropagation();
2134 		}
2135 		// otherwise set the cancelBubble property of the original event to true (IE)
2136 		e.cancelBubble = true;
2137 	},
2138 	stopImmediatePropagation: function() {
2139 		this.isImmediatePropagationStopped = returnTrue;
2140 		this.stopPropagation();
2141 	},
2142 	isDefaultPrevented: returnFalse,
2143 	isPropagationStopped: returnFalse,
2144 	isImmediatePropagationStopped: returnFalse
2145 };
2146 
2147 // Checks if an event happened on an element within another element
2148 // Used in jQuery.event.special.mouseenter and mouseleave handlers
2149 var withinElement = function( event ) {
2150 	// Check if mouse(over|out) are still within the same parent element
2151 	var parent = event.relatedTarget;
2152 
2153 	// Firefox sometimes assigns relatedTarget a XUL element
2154 	// which we cannot access the parentNode property of
2155 	try {
2156 		// Traverse up the tree
2157 		while ( parent && parent !== this ) {
2158 			parent = parent.parentNode;
2159 		}
2160 
2161 		if ( parent !== this ) {
2162 			// set the correct event type
2163 			event.type = event.data;
2164 
2165 			// handle event if we actually just moused on to a non sub-element
2166 			jQuery.event.handle.apply( this, arguments );
2167 		}
2168 
2169 	// assuming we've left the element since we most likely mousedover a xul element
2170 	} catch(e) { }
2171 },
2172 
2173 // In case of event delegation, we only need to rename the event.type,
2174 // liveHandler will take care of the rest.
2175 delegate = function( event ) {
2176 	event.type = event.data;
2177 	jQuery.event.handle.apply( this, arguments );
2178 };
2179 
2180 // Create mouseenter and mouseleave events
2181 jQuery.each({
2182 	mouseenter: "mouseover",
2183 	mouseleave: "mouseout"
2184 }, function( orig, fix ) {
2185 	jQuery.event.special[ orig ] = {
2186 		setup: function( data ) {
2187 			jQuery.event.add( this, fix, data && data.selector ? delegate : withinElement, orig );
2188 		},
2189 		teardown: function( data ) {
2190 			jQuery.event.remove( this, fix, data && data.selector ? delegate : withinElement );
2191 		}
2192 	};
2193 });
2194 
2195 // submit delegation
2196 if ( !jQuery.support.submitBubbles ) {
2197 
2198 	jQuery.event.special.submit = {
2199 		setup: function( data, namespaces ) {
2200 			if ( this.nodeName.toLowerCase() !== "form" ) {
2201 				jQuery.event.add(this, "click.specialSubmit", function( e ) {
2202 					var elem = e.target, type = elem.type;
2203 
2204 					if ( (type === "submit" || type === "image") && jQuery( elem ).closest("form").length ) {
2205 						return trigger( "submit", this, arguments );
2206 					}
2207 				});
2208 	 
2209 				jQuery.event.add(this, "keypress.specialSubmit", function( e ) {
2210 					var elem = e.target, type = elem.type;
2211 
2212 					if ( (type === "text" || type === "password") && jQuery( elem ).closest("form").length && e.keyCode === 13 ) {
2213 						return trigger( "submit", this, arguments );
2214 					}
2215 				});
2216 
2217 			} else {
2218 				return false;
2219 			}
2220 		},
2221 
2222 		teardown: function( namespaces ) {
2223 			jQuery.event.remove( this, ".specialSubmit" );
2224 		}
2225 	};
2226 
2227 }
2228 
2229 // change delegation, happens here so we have bind.
2230 if ( !jQuery.support.changeBubbles ) {
2231 
2232 	var formElems = /textarea|input|select/i,
2233 
2234 	changeFilters,
2235 
2236 	getVal = function( elem ) {
2237 		var type = elem.type, val = elem.value;
2238 
2239 		if ( type === "radio" || type === "checkbox" ) {
2240 			val = elem.checked;
2241 
2242 		} else if ( type === "select-multiple" ) {
2243 			val = elem.selectedIndex > -1 ?
2244 				jQuery.map( elem.options, function( elem ) {
2245 					return elem.selected;
2246 				}).join("-") :
2247 				"";
2248 
2249 		} else if ( elem.nodeName.toLowerCase() === "select" ) {
2250 			val = elem.selectedIndex;
2251 		}
2252 
2253 		return val;
2254 	},
2255 
2256 	testChange = function testChange( e ) {
2257 		var elem = e.target, data, val;
2258 
2259 		if ( !formElems.test( elem.nodeName ) || elem.readOnly ) {
2260 			return;
2261 		}
2262 
2263 		data = jQuery.data( elem, "_change_data" );
2264 		val = getVal(elem);
2265 
2266 		// the current data will be also retrieved by beforeactivate
2267 		if ( e.type !== "focusout" || elem.type !== "radio" ) {
2268 			jQuery.data( elem, "_change_data", val );
2269 		}
2270 		
2271 		if ( data === undefined || val === data ) {
2272 			return;
2273 		}
2274 
2275 		if ( data != null || val ) {
2276 			e.type = "change";
2277 			return jQuery.event.trigger( e, arguments[1], elem );
2278 		}
2279 	};
2280 
2281 	jQuery.event.special.change = {
2282 		filters: {
2283 			focusout: testChange, 
2284 
2285 			click: function( e ) {
2286 				var elem = e.target, type = elem.type;
2287 
2288 				if ( type === "radio" || type === "checkbox" || elem.nodeName.toLowerCase() === "select" ) {
2289 					return testChange.call( this, e );
2290 				}
2291 			},
2292 
2293 			// Change has to be called before submit
2294 			// Keydown will be called before keypress, which is used in submit-event delegation
2295 			keydown: function( e ) {
2296 				var elem = e.target, type = elem.type;
2297 
2298 				if ( (e.keyCode === 13 && elem.nodeName.toLowerCase() !== "textarea") ||
2299 					(e.keyCode === 32 && (type === "checkbox" || type === "radio")) ||
2300 					type === "select-multiple" ) {
2301 					return testChange.call( this, e );
2302 				}
2303 			},
2304 
2305 			// Beforeactivate happens also before the previous element is blurred
2306 			// with this event you can't trigger a change event, but you can store
2307 			// information/focus[in] is not needed anymore
2308 			beforeactivate: function( e ) {
2309 				var elem = e.target;
2310 				jQuery.data( elem, "_change_data", getVal(elem) );
2311 			}
2312 		},
2313 
2314 		setup: function( data, namespaces ) {
2315 			if ( this.type === "file" ) {
2316 				return false;
2317 			}
2318 
2319 			for ( var type in changeFilters ) {
2320 				jQuery.event.add( this, type + ".specialChange", changeFilters[type] );
2321 			}
2322 
2323 			return formElems.test( this.nodeName );
2324 		},
2325 
2326 		teardown: function( namespaces ) {
2327 			jQuery.event.remove( this, ".specialChange" );
2328 
2329 			return formElems.test( this.nodeName );
2330 		}
2331 	};
2332 
2333 	changeFilters = jQuery.event.special.change.filters;
2334 }
2335 
2336 function trigger( type, elem, args ) {
2337 	args[0].type = type;
2338 	return jQuery.event.handle.apply( elem, args );
2339 }
2340 
2341 // Create "bubbling" focus and blur events
2342 if ( document.addEventListener ) {
2343 	jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
2344 		jQuery.event.special[ fix ] = {
2345 			setup: function() {
2346 				this.addEventListener( orig, handler, true );
2347 			}, 
2348 			teardown: function() { 
2349 				this.removeEventListener( orig, handler, true );
2350 			}
2351 		};
2352 
2353 		function handler( e ) { 
2354 			e = jQuery.event.fix( e );
2355 			e.type = fix;
2356 			return jQuery.event.handle.call( this, e );
2357 		}
2358 	});
2359 }
2360 
2361 jQuery.each(["bind", "one"], function( i, name ) {
2362 	jQuery.fn[ name ] = function( type, data, fn ) {
2363 		// Handle object literals
2364 		if ( typeof type === "object" ) {
2365 			for ( var key in type ) {
2366 				this[ name ](key, data, type[key], fn);
2367 			}
2368 			return this;
2369 		}
2370 		
2371 		if ( jQuery.isFunction( data ) ) {
2372 			fn = data;
2373 			data = undefined;
2374 		}
2375 
2376 		var handler = name === "one" ? jQuery.proxy( fn, function( event ) {
2377 			jQuery( this ).unbind( event, handler );
2378 			return fn.apply( this, arguments );
2379 		}) : fn;
2380 
2381 		if ( type === "unload" && name !== "one" ) {
2382 			this.one( type, data, fn );
2383 
2384 		} else {
2385 			for ( var i = 0, l = this.length; i < l; i++ ) {
2386 				jQuery.event.add( this[i], type, handler, data );
2387 			}
2388 		}
2389 
2390 		return this;
2391 	};
2392 });
2393 
2394 jQuery.fn.extend({
2395 	unbind: function( type, fn ) {
2396 		// Handle object literals
2397 		if ( typeof type === "object" && !type.preventDefault ) {
2398 			for ( var key in type ) {
2399 				this.unbind(key, type[key]);
2400 			}
2401 
2402 		} else {
2403 			for ( var i = 0, l = this.length; i < l; i++ ) {
2404 				jQuery.event.remove( this[i], type, fn );
2405 			}
2406 		}
2407 
2408 		return this;
2409 	},
2410 	
2411 	delegate: function( selector, types, data, fn ) {
2412 		return this.live( types, data, fn, selector );
2413 	},
2414 	
2415 	undelegate: function( selector, types, fn ) {
2416 		if ( arguments.length === 0 ) {
2417 				return this.unbind( "live" );
2418 		
2419 		} else {
2420 			return this.die( types, null, fn, selector );
2421 		}
2422 	},
2423 	
2424 	trigger: function( type, data ) {
2425 		return this.each(function() {
2426 			jQuery.event.trigger( type, data, this );
2427 		});
2428 	},
2429 
2430 	triggerHandler: function( type, data ) {
2431 		if ( this[0] ) {
2432 			var event = jQuery.Event( type );
2433 			event.preventDefault();
2434 			event.stopPropagation();
2435 			jQuery.event.trigger( event, data, this[0] );
2436 			return event.result;
2437 		}
2438 	},
2439 
2440 	toggle: function( fn ) {
2441 		// Save reference to arguments for access in closure
2442 		var args = arguments, i = 1;
2443 
2444 		// link all the functions, so any of them can unbind this click handler
2445 		while ( i < args.length ) {
2446 			jQuery.proxy( fn, args[ i++ ] );
2447 		}
2448 
2449 		return this.click( jQuery.proxy( fn, function( event ) {
2450 			// Figure out which function to execute
2451 			var lastToggle = ( jQuery.data( this, "lastToggle" + fn.guid ) || 0 ) % i;
2452 			jQuery.data( this, "lastToggle" + fn.guid, lastToggle + 1 );
2453 
2454 			// Make sure that clicks stop
2455 			event.preventDefault();
2456 
2457 			// and execute the function
2458 			return args[ lastToggle ].apply( this, arguments ) || false;
2459 		}));
2460 	},
2461 
2462 	hover: function( fnOver, fnOut ) {
2463 		return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
2464 	}
2465 });
2466 
2467 var liveMap = {
2468 	focus: "focusin",
2469 	blur: "focusout",
2470 	mouseenter: "mouseover",
2471 	mouseleave: "mouseout"
2472 };
2473 
2474 jQuery.each(["live", "die"], function( i, name ) {
2475 	jQuery.fn[ name ] = function( types, data, fn, origSelector /* Internal Use Only */ ) {
2476 		var type, i = 0, match, namespaces, preType,
2477 			selector = origSelector || this.selector,
2478 			context = origSelector ? this : jQuery( this.context );
2479 
2480 		if ( jQuery.isFunction( data ) ) {
2481 			fn = data;
2482 			data = undefined;
2483 		}
2484 
2485 		types = (types || "").split(" ");
2486 
2487 		while ( (type = types[ i++ ]) != null ) {
2488 			match = rnamespaces.exec( type );
2489 			namespaces = "";
2490 
2491 			if ( match )  {
2492 				namespaces = match[0];
2493 				type = type.replace( rnamespaces, "" );
2494 			}
2495 
2496 			if ( type === "hover" ) {
2497 				types.push( "mouseenter" + namespaces, "mouseleave" + namespaces );
2498 				continue;
2499 			}
2500 
2501 			preType = type;
2502 
2503 			if ( type === "focus" || type === "blur" ) {
2504 				types.push( liveMap[ type ] + namespaces );
2505 				type = type + namespaces;
2506 
2507 			} else {
2508 				type = (liveMap[ type ] || type) + namespaces;
2509 			}
2510 
2511 			if ( name === "live" ) {
2512 				// bind live handler
2513 				context.each(function(){
2514 					jQuery.event.add( this, liveConvert( type, selector ),
2515 						{ data: data, selector: selector, handler: fn, origType: type, origHandler: fn, preType: preType } );
2516 				});
2517 
2518 			} else {
2519 				// unbind live handler
2520 				context.unbind( liveConvert( type, selector ), fn );
2521 			}
2522 		}
2523 		
2524 		return this;
2525 	}
2526 });
2527 
2528 function liveHandler( event ) {
2529 	var stop, elems = [], selectors = [], args = arguments,
2530 		related, match, handleObj, elem, j, i, l, data,
2531 		events = jQuery.data( this, "events" );
2532 
2533 	// Make sure we avoid non-left-click bubbling in Firefox (#3861)
2534 	if ( event.liveFired === this || !events || !events.live || event.button && event.type === "click" ) {
2535 		return;
2536 	}
2537 
2538 	event.liveFired = this;
2539 
2540 	var live = events.live.slice(0);
2541 
2542 	for ( j = 0; j < live.length; j++ ) {
2543 		handleObj = live[j];
2544 
2545 		if ( handleObj.origType.replace( rnamespaces, "" ) === event.type ) {
2546 			selectors.push( handleObj.selector );
2547 
2548 		} else {
2549 			live.splice( j--, 1 );
2550 		}
2551 	}
2552 
2553 	match = jQuery( event.target ).closest( selectors, event.currentTarget );
2554 
2555 	for ( i = 0, l = match.length; i < l; i++ ) {
2556 		for ( j = 0; j < live.length; j++ ) {
2557 			handleObj = live[j];
2558 
2559 			if ( match[i].selector === handleObj.selector ) {
2560 				elem = match[i].elem;
2561 				related = null;
2562 
2563 				// Those two events require additional checking
2564 				if ( handleObj.preType === "mouseenter" || handleObj.preType === "mouseleave" ) {
2565 					related = jQuery( event.relatedTarget ).closest( handleObj.selector )[0];
2566 				}
2567 
2568 				if ( !related || related !== elem ) {
2569 					elems.push({ elem: elem, handleObj: handleObj });
2570 				}
2571 			}
2572 		}
2573 	}
2574 
2575 	for ( i = 0, l = elems.length; i < l; i++ ) {
2576 		match = elems[i];
2577 		event.currentTarget = match.elem;
2578 		event.data = match.handleObj.data;
2579 		event.handleObj = match.handleObj;
2580 
2581 		if ( match.handleObj.origHandler.apply( match.elem, args ) === false ) {
2582 			stop = false;
2583 			break;
2584 		}
2585 	}
2586 
2587 	return stop;
2588 }
2589 
2590 function liveConvert( type, selector ) {
2591 	return "live." + (type && type !== "*" ? type + "." : "") + selector.replace(/\./g, "`").replace(/ /g, "&");
2592 }
2593 
2594 jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
2595 	"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
2596 	"change select submit keydown keypress keyup error").split(" "), function( i, name ) {
2597 
2598 	// Handle event binding
2599 	jQuery.fn[ name ] = function( fn ) {
2600 		return fn ? this.bind( name, fn ) : this.trigger( name );
2601 	};
2602 
2603 	if ( jQuery.attrFn ) {
2604 		jQuery.attrFn[ name ] = true;
2605 	}
2606 });
2607 
2608 // Prevent memory leaks in IE
2609 // Window isn't included so as not to unbind existing unload events
2610 // More info:
2611 //  - http://isaacschlueter.com/2006/10/msie-memory-leaks/
2612 if ( window.attachEvent && !window.addEventListener ) {
2613 	window.attachEvent("onunload", function() {
2614 		for ( var id in jQuery.cache ) {
2615 			if ( jQuery.cache[ id ].handle ) {
2616 				// Try/Catch is to handle iframes being unloaded, see #4280
2617 				try {
2618 					jQuery.event.remove( jQuery.cache[ id ].handle.elem );
2619 				} catch(e) {}
2620 			}
2621 		}
2622 	});
2623 }
2624 /*!
2625  * Sizzle CSS Selector Engine - v1.0
2626  *  Copyright 2009, The Dojo Foundation
2627  *  Released under the MIT, BSD, and GPL Licenses.
2628  *  More information: http://sizzlejs.com/
2629  */
2630 (function(){
2631 
2632 var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^[\]]*\]|['"][^'"]*['"]|[^[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,
2633 	done = 0,
2634 	toString = Object.prototype.toString,
2635 	hasDuplicate = false,
2636 	baseHasDuplicate = true;
2637 
2638 // Here we check if the JavaScript engine is using some sort of
2639 // optimization where it does not always call our comparision
2640 // function. If that is the case, discard the hasDuplicate value.
2641 //   Thus far that includes Google Chrome.
2642 [0, 0].sort(function(){
2643 	baseHasDuplicate = false;
2644 	return 0;
2645 });
2646 
2647 var Sizzle = function(selector, context, results, seed) {
2648 	results = results || [];
2649 	var origContext = context = context || document;
2650 
2651 	if ( context.nodeType !== 1 && context.nodeType !== 9 ) {
2652 		return [];
2653 	}
2654 	
2655 	if ( !selector || typeof selector !== "string" ) {
2656 		return results;
2657 	}
2658 
2659 	var parts = [], m, set, checkSet, extra, prune = true, contextXML = isXML(context),
2660 		soFar = selector;
2661 	
2662 	// Reset the position of the chunker regexp (start from head)
2663 	while ( (chunker.exec(""), m = chunker.exec(soFar)) !== null ) {
2664 		soFar = m[3];
2665 		
2666 		parts.push( m[1] );
2667 		
2668 		if ( m[2] ) {
2669 			extra = m[3];
2670 			break;
2671 		}
2672 	}
2673 
2674 	if ( parts.length > 1 && origPOS.exec( selector ) ) {
2675 		if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
2676 			set = posProcess( parts[0] + parts[1], context );
2677 		} else {
2678 			set = Expr.relative[ parts[0] ] ?
2679 				[ context ] :
2680 				Sizzle( parts.shift(), context );
2681 
2682 			while ( parts.length ) {
2683 				selector = parts.shift();
2684 
2685 				if ( Expr.relative[ selector ] ) {
2686 					selector += parts.shift();
2687 				}
2688 				
2689 				set = posProcess( selector, set );
2690 			}
2691 		}
2692 	} else {
2693 		// Take a shortcut and set the context if the root selector is an ID
2694 		// (but not if it'll be faster if the inner selector is an ID)
2695 		if ( !seed && parts.length > 1 && context.nodeType === 9 && !contextXML &&
2696 				Expr.match.ID.test(parts[0]) && !Expr.match.ID.test(parts[parts.length - 1]) ) {
2697 			var ret = Sizzle.find( parts.shift(), context, contextXML );
2698 			context = ret.expr ? Sizzle.filter( ret.expr, ret.set )[0] : ret.set[0];
2699 		}
2700 
2701 		if ( context ) {
2702 			var ret = seed ?
2703 				{ expr: parts.pop(), set: makeArray(seed) } :
2704 				Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" || parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML );
2705 			set = ret.expr ? Sizzle.filter( ret.expr, ret.set ) : ret.set;
2706 
2707 			if ( parts.length > 0 ) {
2708 				checkSet = makeArray(set);
2709 			} else {
2710 				prune = false;
2711 			}
2712 
2713 			while ( parts.length ) {
2714 				var cur = parts.pop(), pop = cur;
2715 
2716 				if ( !Expr.relative[ cur ] ) {
2717 					cur = "";
2718 				} else {
2719 					pop = parts.pop();
2720 				}
2721 
2722 				if ( pop == null ) {
2723 					pop = context;
2724 				}
2725 
2726 				Expr.relative[ cur ]( checkSet, pop, contextXML );
2727 			}
2728 		} else {
2729 			checkSet = parts = [];
2730 		}
2731 	}
2732 
2733 	if ( !checkSet ) {
2734 		checkSet = set;
2735 	}
2736 
2737 	if ( !checkSet ) {
2738 		Sizzle.error( cur || selector );
2739 	}
2740 
2741 	if ( toString.call(checkSet) === "[object Array]" ) {
2742 		if ( !prune ) {
2743 			results.push.apply( results, checkSet );
2744 		} else if ( context && context.nodeType === 1 ) {
2745 			for ( var i = 0; checkSet[i] != null; i++ ) {
2746 				if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && contains(context, checkSet[i])) ) {
2747 					results.push( set[i] );
2748 				}
2749 			}
2750 		} else {
2751 			for ( var i = 0; checkSet[i] != null; i++ ) {
2752 				if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
2753 					results.push( set[i] );
2754 				}
2755 			}
2756 		}
2757 	} else {
2758 		makeArray( checkSet, results );
2759 	}
2760 
2761 	if ( extra ) {
2762 		Sizzle( extra, origContext, results, seed );
2763 		Sizzle.uniqueSort( results );
2764 	}
2765 
2766 	return results;
2767 };
2768 
2769 Sizzle.uniqueSort = function(results){
2770 	if ( sortOrder ) {
2771 		hasDuplicate = baseHasDuplicate;
2772 		results.sort(sortOrder);
2773 
2774 		if ( hasDuplicate ) {
2775 			for ( var i = 1; i < results.length; i++ ) {
2776 				if ( results[i] === results[i-1] ) {
2777 					results.splice(i--, 1);
2778 				}
2779 			}
2780 		}
2781 	}
2782 
2783 	return results;
2784 };
2785 
2786 Sizzle.matches = function(expr, set){
2787 	return Sizzle(expr, null, null, set);
2788 };
2789 
2790 Sizzle.find = function(expr, context, isXML){
2791 	var set, match;
2792 
2793 	if ( !expr ) {
2794 		return [];
2795 	}
2796 
2797 	for ( var i = 0, l = Expr.order.length; i < l; i++ ) {
2798 		var type = Expr.order[i], match;
2799 		
2800 		if ( (match = Expr.leftMatch[ type ].exec( expr )) ) {
2801 			var left = match[1];
2802 			match.splice(1,1);
2803 
2804 			if ( left.substr( left.length - 1 ) !== "\\" ) {
2805 				match[1] = (match[1] || "").replace(/\\/g, "");
2806 				set = Expr.find[ type ]( match, context, isXML );
2807 				if ( set != null ) {
2808 					expr = expr.replace( Expr.match[ type ], "" );
2809 					break;
2810 				}
2811 			}
2812 		}
2813 	}
2814 
2815 	if ( !set ) {
2816 		set = context.getElementsByTagName("*");
2817 	}
2818 
2819 	return {set: set, expr: expr};
2820 };
2821 
2822 Sizzle.filter = function(expr, set, inplace, not){
2823 	var old = expr, result = [], curLoop = set, match, anyFound,
2824 		isXMLFilter = set && set[0] && isXML(set[0]);
2825 
2826 	while ( expr && set.length ) {
2827 		for ( var type in Expr.filter ) {
2828 			if ( (match = Expr.leftMatch[ type ].exec( expr )) != null && match[2] ) {
2829 				var filter = Expr.filter[ type ], found, item, left = match[1];
2830 				anyFound = false;
2831 
2832 				match.splice(1,1);
2833 
2834 				if ( left.substr( left.length - 1 ) === "\\" ) {
2835 					continue;
2836 				}
2837 
2838 				if ( curLoop === result ) {
2839 					result = [];
2840 				}
2841 
2842 				if ( Expr.preFilter[ type ] ) {
2843 					match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter );
2844 
2845 					if ( !match ) {
2846 						anyFound = found = true;
2847 					} else if ( match === true ) {
2848 						continue;
2849 					}
2850 				}
2851 
2852 				if ( match ) {
2853 					for ( var i = 0; (item = curLoop[i]) != null; i++ ) {
2854 						if ( item ) {
2855 							found = filter( item, match, i, curLoop );
2856 							var pass = not ^ !!found;
2857 
2858 							if ( inplace && found != null ) {
2859 								if ( pass ) {
2860 									anyFound = true;
2861 								} else {
2862 									curLoop[i] = false;
2863 								}
2864 							} else if ( pass ) {
2865 								result.push( item );
2866 								anyFound = true;
2867 							}
2868 						}
2869 					}
2870 				}
2871 
2872 				if ( found !== undefined ) {
2873 					if ( !inplace ) {
2874 						curLoop = result;
2875 					}
2876 
2877 					expr = expr.replace( Expr.match[ type ], "" );
2878 
2879 					if ( !anyFound ) {
2880 						return [];
2881 					}
2882 
2883 					break;
2884 				}
2885 			}
2886 		}
2887 
2888 		// Improper expression
2889 		if ( expr === old ) {
2890 			if ( anyFound == null ) {
2891 				Sizzle.error( expr );
2892 			} else {
2893 				break;
2894 			}
2895 		}
2896 
2897 		old = expr;
2898 	}
2899 
2900 	return curLoop;
2901 };
2902 
2903 Sizzle.error = function( msg ) {
2904 	throw "Syntax error, unrecognized expression: " + msg;
2905 };
2906 
2907 var Expr = Sizzle.selectors = {
2908 	order: [ "ID", "NAME", "TAG" ],
2909 	match: {
2910 		ID: /#((?:[\w\u00c0-\uFFFF-]|\\.)+)/,
2911 		CLASS: /\.((?:[\w\u00c0-\uFFFF-]|\\.)+)/,
2912 		NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF-]|\\.)+)['"]*\]/,
2913 		ATTR: /\[\s*((?:[\w\u00c0-\uFFFF-]|\\.)+)\s*(?:(\S?=)\s*(['"]*)(.*?)\3|)\s*\]/,
2914 		TAG: /^((?:[\w\u00c0-\uFFFF\*-]|\\.)+)/,
2915 		CHILD: /:(only|nth|last|first)-child(?:\((even|odd|[\dn+-]*)\))?/,
2916 		POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^-]|$)/,
2917 		PSEUDO: /:((?:[\w\u00c0-\uFFFF-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/
2918 	},
2919 	leftMatch: {},
2920 	attrMap: {
2921 		"class": "className",
2922 		"for": "htmlFor"
2923 	},
2924 	attrHandle: {
2925 		href: function(elem){
2926 			return elem.getAttribute("href");
2927 		}
2928 	},
2929 	relative: {
2930 		"+": function(checkSet, part){
2931 			var isPartStr = typeof part === "string",
2932 				isTag = isPartStr && !/\W/.test(part),
2933 				isPartStrNotTag = isPartStr && !isTag;
2934 
2935 			if ( isTag ) {
2936 				part = part.toLowerCase();
2937 			}
2938 
2939 			for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) {
2940 				if ( (elem = checkSet[i]) ) {
2941 					while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {}
2942 
2943 					checkSet[i] = isPartStrNotTag || elem && elem.nodeName.toLowerCase() === part ?
2944 						elem || false :
2945 						elem === part;
2946 				}
2947 			}
2948 
2949 			if ( isPartStrNotTag ) {
2950 				Sizzle.filter( part, checkSet, true );
2951 			}
2952 		},
2953 		">": function(checkSet, part){
2954 			var isPartStr = typeof part === "string";
2955 
2956 			if ( isPartStr && !/\W/.test(part) ) {
2957 				part = part.toLowerCase();
2958 
2959 				for ( var i = 0, l = checkSet.length; i < l; i++ ) {
2960 					var elem = checkSet[i];
2961 					if ( elem ) {
2962 						var parent = elem.parentNode;
2963 						checkSet[i] = parent.nodeName.toLowerCase() === part ? parent : false;
2964 					}
2965 				}
2966 			} else {
2967 				for ( var i = 0, l = checkSet.length; i < l; i++ ) {
2968 					var elem = checkSet[i];
2969 					if ( elem ) {
2970 						checkSet[i] = isPartStr ?
2971 							elem.parentNode :
2972 							elem.parentNode === part;
2973 					}
2974 				}
2975 
2976 				if ( isPartStr ) {
2977 					Sizzle.filter( part, checkSet, true );
2978 				}
2979 			}
2980 		},
2981 		"": function(checkSet, part, isXML){
2982 			var doneName = done++, checkFn = dirCheck;
2983 
2984 			if ( typeof part === "string" && !/\W/.test(part) ) {
2985 				var nodeCheck = part = part.toLowerCase();
2986 				checkFn = dirNodeCheck;
2987 			}
2988 
2989 			checkFn("parentNode", part, doneName, checkSet, nodeCheck, isXML);
2990 		},
2991 		"~": function(checkSet, part, isXML){
2992 			var doneName = done++, checkFn = dirCheck;
2993 
2994 			if ( typeof part === "string" && !/\W/.test(part) ) {
2995 				var nodeCheck = part = part.toLowerCase();
2996 				checkFn = dirNodeCheck;
2997 			}
2998 
2999 			checkFn("previousSibling", part, doneName, checkSet, nodeCheck, isXML);
3000 		}
3001 	},
3002 	find: {
3003 		ID: function(match, context, isXML){
3004 			if ( typeof context.getElementById !== "undefined" && !isXML ) {
3005 				var m = context.getElementById(match[1]);
3006 				return m ? [m] : [];
3007 			}
3008 		},
3009 		NAME: function(match, context){
3010 			if ( typeof context.getElementsByName !== "undefined" ) {
3011 				var ret = [], results = context.getElementsByName(match[1]);
3012 
3013 				for ( var i = 0, l = results.length; i < l; i++ ) {
3014 					if ( results[i].getAttribute("name") === match[1] ) {
3015 						ret.push( results[i] );
3016 					}
3017 				}
3018 
3019 				return ret.length === 0 ? null : ret;
3020 			}
3021 		},
3022 		TAG: function(match, context){
3023 			return context.getElementsByTagName(match[1]);
3024 		}
3025 	},
3026 	preFilter: {
3027 		CLASS: function(match, curLoop, inplace, result, not, isXML){
3028 			match = " " + match[1].replace(/\\/g, "") + " ";
3029 
3030 			if ( isXML ) {
3031 				return match;
3032 			}
3033 
3034 			for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) {
3035 				if ( elem ) {
3036 					if ( not ^ (elem.className && (" " + elem.className + " ").replace(/[\t\n]/g, " ").indexOf(match) >= 0) ) {
3037 						if ( !inplace ) {
3038 							result.push( elem );
3039 						}
3040 					} else if ( inplace ) {
3041 						curLoop[i] = false;
3042 					}
3043 				}
3044 			}
3045 
3046 			return false;
3047 		},
3048 		ID: function(match){
3049 			return match[1].replace(/\\/g, "");
3050 		},
3051 		TAG: function(match, curLoop){
3052 			return match[1].toLowerCase();
3053 		},
3054 		CHILD: function(match){
3055 			if ( match[1] === "nth" ) {
3056 				// parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
3057 				var test = /(-?)(\d*)n((?:\+|-)?\d*)/.exec(
3058 					match[2] === "even" && "2n" || match[2] === "odd" && "2n+1" ||
3059 					!/\D/.test( match[2] ) && "0n+" + match[2] || match[2]);
3060 
3061 				// calculate the numbers (first)n+(last) including if they are negative
3062 				match[2] = (test[1] + (test[2] || 1)) - 0;
3063 				match[3] = test[3] - 0;
3064 			}
3065 
3066 			// TODO: Move to normal caching system
3067 			match[0] = done++;
3068 
3069 			return match;
3070 		},
3071 		ATTR: function(match, curLoop, inplace, result, not, isXML){
3072 			var name = match[1].replace(/\\/g, "");
3073 			
3074 			if ( !isXML && Expr.attrMap[name] ) {
3075 				match[1] = Expr.attrMap[name];
3076 			}
3077 
3078 			if ( match[2] === "~=" ) {
3079 				match[4] = " " + match[4] + " ";
3080 			}
3081 
3082 			return match;
3083 		},
3084 		PSEUDO: function(match, curLoop, inplace, result, not){
3085 			if ( match[1] === "not" ) {
3086 				// If we're dealing with a complex expression, or a simple one
3087 				if ( ( chunker.exec(match[3]) || "" ).length > 1 || /^\w/.test(match[3]) ) {
3088 					match[3] = Sizzle(match[3], null, null, curLoop);
3089 				} else {
3090 					var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not);
3091 					if ( !inplace ) {
3092 						result.push.apply( result, ret );
3093 					}
3094 					return false;
3095 				}
3096 			} else if ( Expr.match.POS.test( match[0] ) || Expr.match.CHILD.test( match[0] ) ) {
3097 				return true;
3098 			}
3099 			
3100 			return match;
3101 		},
3102 		POS: function(match){
3103 			match.unshift( true );
3104 			return match;
3105 		}
3106 	},
3107 	filters: {
3108 		enabled: function(elem){
3109 			return elem.disabled === false && elem.type !== "hidden";
3110 		},
3111 		disabled: function(elem){
3112 			return elem.disabled === true;
3113 		},
3114 		checked: function(elem){
3115 			return elem.checked === true;
3116 		},
3117 		selected: function(elem){
3118 			// Accessing this property makes selected-by-default
3119 			// options in Safari work properly
3120 			elem.parentNode.selectedIndex;
3121 			return elem.selected === true;
3122 		},
3123 		parent: function(elem){
3124 			return !!elem.firstChild;
3125 		},
3126 		empty: function(elem){
3127 			return !elem.firstChild;
3128 		},
3129 		has: function(elem, i, match){
3130 			return !!Sizzle( match[3], elem ).length;
3131 		},
3132 		header: function(elem){
3133 			return /h\d/i.test( elem.nodeName );
3134 		},
3135 		text: function(elem){
3136 			return "text" === elem.type;
3137 		},
3138 		radio: function(elem){
3139 			return "radio" === elem.type;
3140 		},
3141 		checkbox: function(elem){
3142 			return "checkbox" === elem.type;
3143 		},
3144 		file: function(elem){
3145 			return "file" === elem.type;
3146 		},
3147 		password: function(elem){
3148 			return "password" === elem.type;
3149 		},
3150 		submit: function(elem){
3151 			return "submit" === elem.type;
3152 		},
3153 		image: function(elem){
3154 			return "image" === elem.type;
3155 		},
3156 		reset: function(elem){
3157 			return "reset" === elem.type;
3158 		},
3159 		button: function(elem){
3160 			return "button" === elem.type || elem.nodeName.toLowerCase() === "button";
3161 		},
3162 		input: function(elem){
3163 			return /input|select|textarea|button/i.test(elem.nodeName);
3164 		}
3165 	},
3166 	setFilters: {
3167 		first: function(elem, i){
3168 			return i === 0;
3169 		},
3170 		last: function(elem, i, match, array){
3171 			return i === array.length - 1;
3172 		},
3173 		even: function(elem, i){
3174 			return i % 2 === 0;
3175 		},
3176 		odd: function(elem, i){
3177 			return i % 2 === 1;
3178 		},
3179 		lt: function(elem, i, match){
3180 			return i < match[3] - 0;
3181 		},
3182 		gt: function(elem, i, match){
3183 			return i > match[3] - 0;
3184 		},
3185 		nth: function(elem, i, match){
3186 			return match[3] - 0 === i;
3187 		},
3188 		eq: function(elem, i, match){
3189 			return match[3] - 0 === i;
3190 		}
3191 	},
3192 	filter: {
3193 		PSEUDO: function(elem, match, i, array){
3194 			var name = match[1], filter = Expr.filters[ name ];
3195 
3196 			if ( filter ) {
3197 				return filter( elem, i, match, array );
3198 			} else if ( name === "contains" ) {
3199 				return (elem.textContent || elem.innerText || getText([ elem ]) || "").indexOf(match[3]) >= 0;
3200 			} else if ( name === "not" ) {
3201 				var not = match[3];
3202 
3203 				for ( var i = 0, l = not.length; i < l; i++ ) {
3204 					if ( not[i] === elem ) {
3205 						return false;
3206 					}
3207 				}
3208 
3209 				return true;
3210 			} else {
3211 				Sizzle.error( "Syntax error, unrecognized expression: " + name );
3212 			}
3213 		},
3214 		CHILD: function(elem, match){
3215 			var type = match[1], node = elem;
3216 			switch (type) {
3217 				case 'only':
3218 				case 'first':
3219 					while ( (node = node.previousSibling) )	 {
3220 						if ( node.nodeType === 1 ) { 
3221 							return false; 
3222 						}
3223 					}
3224 					if ( type === "first" ) { 
3225 						return true; 
3226 					}
3227 					node = elem;
3228 				case 'last':
3229 					while ( (node = node.nextSibling) )	 {
3230 						if ( node.nodeType === 1 ) { 
3231 							return false; 
3232 						}
3233 					}
3234 					return true;
3235 				case 'nth':
3236 					var first = match[2], last = match[3];
3237 
3238 					if ( first === 1 && last === 0 ) {
3239 						return true;
3240 					}
3241 					
3242 					var doneName = match[0],
3243 						parent = elem.parentNode;
3244 	
3245 					if ( parent && (parent.sizcache !== doneName || !elem.nodeIndex) ) {
3246 						var count = 0;
3247 						for ( node = parent.firstChild; node; node = node.nextSibling ) {
3248 							if ( node.nodeType === 1 ) {
3249 								node.nodeIndex = ++count;
3250 							}
3251 						} 
3252 						parent.sizcache = doneName;
3253 					}
3254 					
3255 					var diff = elem.nodeIndex - last;
3256 					if ( first === 0 ) {
3257 						return diff === 0;
3258 					} else {
3259 						return ( diff % first === 0 && diff / first >= 0 );
3260 					}
3261 			}
3262 		},
3263 		ID: function(elem, match){
3264 			return elem.nodeType === 1 && elem.getAttribute("id") === match;
3265 		},
3266 		TAG: function(elem, match){
3267 			return (match === "*" && elem.nodeType === 1) || elem.nodeName.toLowerCase() === match;
3268 		},
3269 		CLASS: function(elem, match){
3270 			return (" " + (elem.className || elem.getAttribute("class")) + " ")
3271 				.indexOf( match ) > -1;
3272 		},
3273 		ATTR: function(elem, match){
3274 			var name = match[1],
3275 				result = Expr.attrHandle[ name ] ?
3276 					Expr.attrHandle[ name ]( elem ) :
3277 					elem[ name ] != null ?
3278 						elem[ name ] :
3279 						elem.getAttribute( name ),
3280 				value = result + "",
3281 				type = match[2],
3282 				check = match[4];
3283 
3284 			return result == null ?
3285 				type === "!=" :
3286 				type === "=" ?
3287 				value === check :
3288 				type === "*=" ?
3289 				value.indexOf(check) >= 0 :
3290 				type === "~=" ?
3291 				(" " + value + " ").indexOf(check) >= 0 :
3292 				!check ?
3293 				value && result !== false :
3294 				type === "!=" ?
3295 				value !== check :
3296 				type === "^=" ?
3297 				value.indexOf(check) === 0 :
3298 				type === "$=" ?
3299 				value.substr(value.length - check.length) === check :
3300 				type === "|=" ?
3301 				value === check || value.substr(0, check.length + 1) === check + "-" :
3302 				false;
3303 		},
3304 		POS: function(elem, match, i, array){
3305 			var name = match[2], filter = Expr.setFilters[ name ];
3306 
3307 			if ( filter ) {
3308 				return filter( elem, i, match, array );
3309 			}
3310 		}
3311 	}
3312 };
3313 
3314 var origPOS = Expr.match.POS;
3315 
3316 for ( var type in Expr.match ) {
3317 	Expr.match[ type ] = new RegExp( Expr.match[ type ].source + /(?![^\[]*\])(?![^\(]*\))/.source );
3318 	Expr.leftMatch[ type ] = new RegExp( /(^(?:.|\r|\n)*?)/.source + Expr.match[ type ].source.replace(/\\(\d+)/g, function(all, num){
3319 		return "\\" + (num - 0 + 1);
3320 	}));
3321 }
3322 
3323 var makeArray = function(array, results) {
3324 	array = Array.prototype.slice.call( array, 0 );
3325 
3326 	if ( results ) {
3327 		results.push.apply( results, array );
3328 		return results;
3329 	}
3330 	
3331 	return array;
3332 };
3333 
3334 // Perform a simple check to determine if the browser is capable of
3335 // converting a NodeList to an array using builtin methods.
3336 // Also verifies that the returned array holds DOM nodes
3337 // (which is not the case in the Blackberry browser)
3338 try {
3339 	Array.prototype.slice.call( document.documentElement.childNodes, 0 )[0].nodeType;
3340 
3341 // Provide a fallback method if it does not work
3342 } catch(e){
3343 	makeArray = function(array, results) {
3344 		var ret = results || [];
3345 
3346 		if ( toString.call(array) === "[object Array]" ) {
3347 			Array.prototype.push.apply( ret, array );
3348 		} else {
3349 			if ( typeof array.length === "number" ) {
3350 				for ( var i = 0, l = array.length; i < l; i++ ) {
3351 					ret.push( array[i] );
3352 				}
3353 			} else {
3354 				for ( var i = 0; array[i]; i++ ) {
3355 					ret.push( array[i] );
3356 				}
3357 			}
3358 		}
3359 
3360 		return ret;
3361 	};
3362 }
3363 
3364 var sortOrder;
3365 
3366 if ( document.documentElement.compareDocumentPosition ) {
3367 	sortOrder = function( a, b ) {
3368 		if ( !a.compareDocumentPosition || !b.compareDocumentPosition ) {
3369 			if ( a == b ) {
3370 				hasDuplicate = true;
3371 			}
3372 			return a.compareDocumentPosition ? -1 : 1;
3373 		}
3374 
3375 		var ret = a.compareDocumentPosition(b) & 4 ? -1 : a === b ? 0 : 1;
3376 		if ( ret === 0 ) {
3377 			hasDuplicate = true;
3378 		}
3379 		return ret;
3380 	};
3381 } else if ( "sourceIndex" in document.documentElement ) {
3382 	sortOrder = function( a, b ) {
3383 		if ( !a.sourceIndex || !b.sourceIndex ) {
3384 			if ( a == b ) {
3385 				hasDuplicate = true;
3386 			}
3387 			return a.sourceIndex ? -1 : 1;
3388 		}
3389 
3390 		var ret = a.sourceIndex - b.sourceIndex;
3391 		if ( ret === 0 ) {
3392 			hasDuplicate = true;
3393 		}
3394 		return ret;
3395 	};
3396 } else if ( document.createRange ) {
3397 	sortOrder = function( a, b ) {
3398 		if ( !a.ownerDocument || !b.ownerDocument ) {
3399 			if ( a == b ) {
3400 				hasDuplicate = true;
3401 			}
3402 			return a.ownerDocument ? -1 : 1;
3403 		}
3404 
3405 		var aRange = a.ownerDocument.createRange(), bRange = b.ownerDocument.createRange();
3406 		aRange.setStart(a, 0);
3407 		aRange.setEnd(a, 0);
3408 		bRange.setStart(b, 0);
3409 		bRange.setEnd(b, 0);
3410 		var ret = aRange.compareBoundaryPoints(Range.START_TO_END, bRange);
3411 		if ( ret === 0 ) {
3412 			hasDuplicate = true;
3413 		}
3414 		return ret;
3415 	};
3416 }
3417 
3418 // Utility function for retreiving the text value of an array of DOM nodes
3419 function getText( elems ) {
3420 	var ret = "", elem;
3421 
3422 	for ( var i = 0; elems[i]; i++ ) {
3423 		elem = elems[i];
3424 
3425 		// Get the text from text nodes and CDATA nodes
3426 		if ( elem.nodeType === 3 || elem.nodeType === 4 ) {
3427 			ret += elem.nodeValue;
3428 
3429 		// Traverse everything else, except comment nodes
3430 		} else if ( elem.nodeType !== 8 ) {
3431 			ret += getText( elem.childNodes );
3432 		}
3433 	}
3434 
3435 	return ret;
3436 }
3437 
3438 // Check to see if the browser returns elements by name when
3439 // querying by getElementById (and provide a workaround)
3440 (function(){
3441 	// We're going to inject a fake input element with a specified name
3442 	var form = document.createElement("div"),
3443 		id = "script" + (new Date).getTime();
3444 	form.innerHTML = "<a name='" + id + "'/>";
3445 
3446 	// Inject it into the root element, check its status, and remove it quickly
3447 	var root = document.documentElement;
3448 	root.insertBefore( form, root.firstChild );
3449 
3450 	// The workaround has to do additional checks after a getElementById
3451 	// Which slows things down for other browsers (hence the branching)
3452 	if ( document.getElementById( id ) ) {
3453 		Expr.find.ID = function(match, context, isXML){
3454 			if ( typeof context.getElementById !== "undefined" && !isXML ) {
3455 				var m = context.getElementById(match[1]);
3456 				return m ? m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ? [m] : undefined : [];
3457 			}
3458 		};
3459 
3460 		Expr.filter.ID = function(elem, match){
3461 			var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
3462 			return elem.nodeType === 1 && node && node.nodeValue === match;
3463 		};
3464 	}
3465 
3466 	root.removeChild( form );
3467 	root = form = null; // release memory in IE
3468 })();
3469 
3470 (function(){
3471 	// Check to see if the browser returns only elements
3472 	// when doing getElementsByTagName("*")
3473 
3474 	// Create a fake element
3475 	var div = document.createElement("div");
3476 	div.appendChild( document.createComment("") );
3477 
3478 	// Make sure no comments are found
3479 	if ( div.getElementsByTagName("*").length > 0 ) {
3480 		Expr.find.TAG = function(match, context){
3481 			var results = context.getElementsByTagName(match[1]);
3482 
3483 			// Filter out possible comments
3484 			if ( match[1] === "*" ) {
3485 				var tmp = [];
3486 
3487 				for ( var i = 0; results[i]; i++ ) {
3488 					if ( results[i].nodeType === 1 ) {
3489 						tmp.push( results[i] );
3490 					}
3491 				}
3492 
3493 				results = tmp;
3494 			}
3495 
3496 			return results;
3497 		};
3498 	}
3499 
3500 	// Check to see if an attribute returns normalized href attributes
3501 	div.innerHTML = "<a href='#'></a>";
3502 	if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined" &&
3503 			div.firstChild.getAttribute("href") !== "#" ) {
3504 		Expr.attrHandle.href = function(elem){
3505 			return elem.getAttribute("href", 2);
3506 		};
3507 	}
3508 
3509 	div = null; // release memory in IE
3510 })();
3511 
3512 if ( document.querySelectorAll ) {
3513 	(function(){
3514 		var oldSizzle = Sizzle, div = document.createElement("div");
3515 		div.innerHTML = "<p class='TEST'></p>";
3516 
3517 		// Safari can't handle uppercase or unicode characters when
3518 		// in quirks mode.
3519 		if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) {
3520 			return;
3521 		}
3522 	
3523 		Sizzle = function(query, context, extra, seed){
3524 			context = context || document;
3525 
3526 			// Only use querySelectorAll on non-XML documents
3527 			// (ID selectors don't work in non-HTML documents)
3528 			if ( !seed && context.nodeType === 9 && !isXML(context) ) {
3529 				try {
3530 					return makeArray( context.querySelectorAll(query), extra );
3531 				} catch(e){}
3532 			}
3533 		
3534 			return oldSizzle(query, context, extra, seed);
3535 		};
3536 
3537 		for ( var prop in oldSizzle ) {
3538 			Sizzle[ prop ] = oldSizzle[ prop ];
3539 		}
3540 
3541 		div = null; // release memory in IE
3542 	})();
3543 }
3544 
3545 (function(){
3546 	var div = document.createElement("div");
3547 
3548 	div.innerHTML = "<div class='test e'></div><div class='test'></div>";
3549 
3550 	// Opera can't find a second classname (in 9.6)
3551 	// Also, make sure that getElementsByClassName actually exists
3552 	if ( !div.getElementsByClassName || div.getElementsByClassName("e").length === 0 ) {
3553 		return;
3554 	}
3555 
3556 	// Safari caches class attributes, doesn't catch changes (in 3.2)
3557 	div.lastChild.className = "e";
3558 
3559 	if ( div.getElementsByClassName("e").length === 1 ) {
3560 		return;
3561 	}
3562 	
3563 	Expr.order.splice(1, 0, "CLASS");
3564 	Expr.find.CLASS = function(match, context, isXML) {
3565 		if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) {
3566 			return context.getElementsByClassName(match[1]);
3567 		}
3568 	};
3569 
3570 	div = null; // release memory in IE
3571 })();
3572 
3573 function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
3574 	for ( var i = 0, l = checkSet.length; i < l; i++ ) {
3575 		var elem = checkSet[i];
3576 		if ( elem ) {
3577 			elem = elem[dir];
3578 			var match = false;
3579 
3580 			while ( elem ) {
3581 				if ( elem.sizcache === doneName ) {
3582 					match = checkSet[elem.sizset];
3583 					break;
3584 				}
3585 
3586 				if ( elem.nodeType === 1 && !isXML ){
3587 					elem.sizcache = doneName;
3588 					elem.sizset = i;
3589 				}
3590 
3591 				if ( elem.nodeName.toLowerCase() === cur ) {
3592 					match = elem;
3593 					break;
3594 				}
3595 
3596 				elem = elem[dir];
3597 			}
3598 
3599 			checkSet[i] = match;
3600 		}
3601 	}
3602 }
3603 
3604 function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
3605 	for ( var i = 0, l = checkSet.length; i < l; i++ ) {
3606 		var elem = checkSet[i];
3607 		if ( elem ) {
3608 			elem = elem[dir];
3609 			var match = false;
3610 
3611 			while ( elem ) {
3612 				if ( elem.sizcache === doneName ) {
3613 					match = checkSet[elem.sizset];
3614 					break;
3615 				}
3616 
3617 				if ( elem.nodeType === 1 ) {
3618 					if ( !isXML ) {
3619 						elem.sizcache = doneName;
3620 						elem.sizset = i;
3621 					}
3622 					if ( typeof cur !== "string" ) {
3623 						if ( elem === cur ) {
3624 							match = true;
3625 							break;
3626 						}
3627 
3628 					} else if ( Sizzle.filter( cur, [elem] ).length > 0 ) {
3629 						match = elem;
3630 						break;
3631 					}
3632 				}
3633 
3634 				elem = elem[dir];
3635 			}
3636 
3637 			checkSet[i] = match;
3638 		}
3639 	}
3640 }
3641 
3642 var contains = document.compareDocumentPosition ? function(a, b){
3643 	return !!(a.compareDocumentPosition(b) & 16);
3644 } : function(a, b){
3645 	return a !== b && (a.contains ? a.contains(b) : true);
3646 };
3647 
3648 var isXML = function(elem){
3649 	// documentElement is verified for cases where it doesn't yet exist
3650 	// (such as loading iframes in IE - #4833) 
3651 	var documentElement = (elem ? elem.ownerDocument || elem : 0).documentElement;
3652 	return documentElement ? documentElement.nodeName !== "HTML" : false;
3653 };
3654 
3655 var posProcess = function(selector, context){
3656 	var tmpSet = [], later = "", match,
3657 		root = context.nodeType ? [context] : context;
3658 
3659 	// Position selectors must be done after the filter
3660 	// And so must :not(positional) so we move all PSEUDOs to the end
3661 	while ( (match = Expr.match.PSEUDO.exec( selector )) ) {
3662 		later += match[0];
3663 		selector = selector.replace( Expr.match.PSEUDO, "" );
3664 	}
3665 
3666 	selector = Expr.relative[selector] ? selector + "*" : selector;
3667 
3668 	for ( var i = 0, l = root.length; i < l; i++ ) {
3669 		Sizzle( selector, root[i], tmpSet );
3670 	}
3671 
3672 	return Sizzle.filter( later, tmpSet );
3673 };
3674 
3675 // EXPOSE
3676 jQuery.find = Sizzle;
3677 jQuery.expr = Sizzle.selectors;
3678 jQuery.expr[":"] = jQuery.expr.filters;
3679 jQuery.unique = Sizzle.uniqueSort;
3680 jQuery.text = getText;
3681 jQuery.isXMLDoc = isXML;
3682 jQuery.contains = contains;
3683 
3684 return;
3685 
3686 window.Sizzle = Sizzle;
3687 
3688 })();
3689 var runtil = /Until$/,
3690 	rparentsprev = /^(?:parents|prevUntil|prevAll)/,
3691 	// Note: This RegExp should be improved, or likely pulled from Sizzle
3692 	rmultiselector = /,/,
3693 	slice = Array.prototype.slice;
3694 
3695 // Implement the identical functionality for filter and not
3696 var winnow = function( elements, qualifier, keep ) {
3697 	if ( jQuery.isFunction( qualifier ) ) {
3698 		return jQuery.grep(elements, function( elem, i ) {
3699 			return !!qualifier.call( elem, i, elem ) === keep;
3700 		});
3701 
3702 	} else if ( qualifier.nodeType ) {
3703 		return jQuery.grep(elements, function( elem, i ) {
3704 			return (elem === qualifier) === keep;
3705 		});
3706 
3707 	} else if ( typeof qualifier === "string" ) {
3708 		var filtered = jQuery.grep(elements, function( elem ) {
3709 			return elem.nodeType === 1;
3710 		});
3711 
3712 		if ( isSimple.test( qualifier ) ) {
3713 			return jQuery.filter(qualifier, filtered, !keep);
3714 		} else {
3715 			qualifier = jQuery.filter( qualifier, filtered );
3716 		}
3717 	}
3718 
3719 	return jQuery.grep(elements, function( elem, i ) {
3720 		return (jQuery.inArray( elem, qualifier ) >= 0) === keep;
3721 	});
3722 };
3723 
3724 jQuery.fn.extend({
3725 	find: function( selector ) {
3726 		var ret = this.pushStack( "", "find", selector ), length = 0;
3727 
3728 		for ( var i = 0, l = this.length; i < l; i++ ) {
3729 			length = ret.length;
3730 			jQuery.find( selector, this[i], ret );
3731 
3732 			if ( i > 0 ) {
3733 				// Make sure that the results are unique
3734 				for ( var n = length; n < ret.length; n++ ) {
3735 					for ( var r = 0; r < length; r++ ) {
3736 						if ( ret[r] === ret[n] ) {
3737 							ret.splice(n--, 1);
3738 							break;
3739 						}
3740 					}
3741 				}
3742 			}
3743 		}
3744 
3745 		return ret;
3746 	},
3747 
3748 	has: function( target ) {
3749 		var targets = jQuery( target );
3750 		return this.filter(function() {
3751 			for ( var i = 0, l = targets.length; i < l; i++ ) {
3752 				if ( jQuery.contains( this, targets[i] ) ) {
3753 					return true;
3754 				}
3755 			}
3756 		});
3757 	},
3758 
3759 	not: function( selector ) {
3760 		return this.pushStack( winnow(this, selector, false), "not", selector);
3761 	},
3762 
3763 	filter: function( selector ) {
3764 		return this.pushStack( winnow(this, selector, true), "filter", selector );
3765 	},
3766 	
3767 	is: function( selector ) {
3768 		return !!selector && jQuery.filter( selector, this ).length > 0;
3769 	},
3770 
3771 	closest: function( selectors, context ) {
3772 		if ( jQuery.isArray( selectors ) ) {
3773 			var ret = [], cur = this[0], match, matches = {}, selector;
3774 
3775 			if ( cur && selectors.length ) {
3776 				for ( var i = 0, l = selectors.length; i < l; i++ ) {
3777 					selector = selectors[i];
3778 
3779 					if ( !matches[selector] ) {
3780 						matches[selector] = jQuery.expr.match.POS.test( selector ) ? 
3781 							jQuery( selector, context || this.context ) :
3782 							selector;
3783 					}
3784 				}
3785 
3786 				while ( cur && cur.ownerDocument && cur !== context ) {
3787 					for ( selector in matches ) {
3788 						match = matches[selector];
3789 
3790 						if ( match.jquery ? match.index(cur) > -1 : jQuery(cur).is(match) ) {
3791 							ret.push({ selector: selector, elem: cur });
3792 							delete matches[selector];
3793 						}
3794 					}
3795 					cur = cur.parentNode;
3796 				}
3797 			}
3798 
3799 			return ret;
3800 		}
3801 
3802 		var pos = jQuery.expr.match.POS.test( selectors ) ? 
3803 			jQuery( selectors, context || this.context ) : null;
3804 
3805 		return this.map(function( i, cur ) {
3806 			while ( cur && cur.ownerDocument && cur !== context ) {
3807 				if ( pos ? pos.index(cur) > -1 : jQuery(cur).is(selectors) ) {
3808 					return cur;
3809 				}
3810 				cur = cur.parentNode;
3811 			}
3812 			return null;
3813 		});
3814 	},
3815 	
3816 	// Determine the position of an element within
3817 	// the matched set of elements
3818 	index: function( elem ) {
3819 		if ( !elem || typeof elem === "string" ) {
3820 			return jQuery.inArray( this[0],
3821 				// If it receives a string, the selector is used
3822 				// If it receives nothing, the siblings are used
3823 				elem ? jQuery( elem ) : this.parent().children() );
3824 		}
3825 		// Locate the position of the desired element
3826 		return jQuery.inArray(
3827 			// If it receives a jQuery object, the first element is used
3828 			elem.jquery ? elem[0] : elem, this );
3829 	},
3830 
3831 	add: function( selector, context ) {
3832 		var set = typeof selector === "string" ?
3833 				jQuery( selector, context || this.context ) :
3834 				jQuery.makeArray( selector ),
3835 			all = jQuery.merge( this.get(), set );
3836 
3837 		return this.pushStack( isDisconnected( set[0] ) || isDisconnected( all[0] ) ?
3838 			all :
3839 			jQuery.unique( all ) );
3840 	},
3841 
3842 	andSelf: function() {
3843 		return this.add( this.prevObject );
3844 	}
3845 });
3846 
3847 // A painfully simple check to see if an element is disconnected
3848 // from a document (should be improved, where feasible).
3849 function isDisconnected( node ) {
3850 	return !node || !node.parentNode || node.parentNode.nodeType === 11;
3851 }
3852 
3853 jQuery.each({
3854 	parent: function( elem ) {
3855 		var parent = elem.parentNode;
3856 		return parent && parent.nodeType !== 11 ? parent : null;
3857 	},
3858 	parents: function( elem ) {
3859 		return jQuery.dir( elem, "parentNode" );
3860 	},
3861 	parentsUntil: function( elem, i, until ) {
3862 		return jQuery.dir( elem, "parentNode", until );
3863 	},
3864 	next: function( elem ) {
3865 		return jQuery.nth( elem, 2, "nextSibling" );
3866 	},
3867 	prev: function( elem ) {
3868 		return jQuery.nth( elem, 2, "previousSibling" );
3869 	},
3870 	nextAll: function( elem ) {
3871 		return jQuery.dir( elem, "nextSibling" );
3872 	},
3873 	prevAll: function( elem ) {
3874 		return jQuery.dir( elem, "previousSibling" );
3875 	},
3876 	nextUntil: function( elem, i, until ) {
3877 		return jQuery.dir( elem, "nextSibling", until );
3878 	},
3879 	prevUntil: function( elem, i, until ) {
3880 		return jQuery.dir( elem, "previousSibling", until );
3881 	},
3882 	siblings: function( elem ) {
3883 		return jQuery.sibling( elem.parentNode.firstChild, elem );
3884 	},
3885 	children: function( elem ) {
3886 		return jQuery.sibling( elem.firstChild );
3887 	},
3888 	contents: function( elem ) {
3889 		return jQuery.nodeName( elem, "iframe" ) ?
3890 			elem.contentDocument || elem.contentWindow.document :
3891 			jQuery.makeArray( elem.childNodes );
3892 	}
3893 }, function( name, fn ) {
3894 	jQuery.fn[ name ] = function( until, selector ) {
3895 		var ret = jQuery.map( this, fn, until );
3896 		
3897 		if ( !runtil.test( name ) ) {
3898 			selector = until;
3899 		}
3900 
3901 		if ( selector && typeof selector === "string" ) {
3902 			ret = jQuery.filter( selector, ret );
3903 		}
3904 
3905 		ret = this.length > 1 ? jQuery.unique( ret ) : ret;
3906 
3907 		if ( (this.length > 1 || rmultiselector.test( selector )) && rparentsprev.test( name ) ) {
3908 			ret = ret.reverse();
3909 		}
3910 
3911 		return this.pushStack( ret, name, slice.call(arguments).join(",") );
3912 	};
3913 });
3914 
3915 jQuery.extend({
3916 	filter: function( expr, elems, not ) {
3917 		if ( not ) {
3918 			expr = ":not(" + expr + ")";
3919 		}
3920 
3921 		return jQuery.find.matches(expr, elems);
3922 	},
3923 	
3924 	dir: function( elem, dir, until ) {
3925 		var matched = [], cur = elem[dir];
3926 		while ( cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery( cur ).is( until )) ) {
3927 			if ( cur.nodeType === 1 ) {
3928 				matched.push( cur );
3929 			}
3930 			cur = cur[dir];
3931 		}
3932 		return matched;
3933 	},
3934 
3935 	nth: function( cur, result, dir, elem ) {
3936 		result = result || 1;
3937 		var num = 0;
3938 
3939 		for ( ; cur; cur = cur[dir] ) {
3940 			if ( cur.nodeType === 1 && ++num === result ) {
3941 				break;
3942 			}
3943 		}
3944 
3945 		return cur;
3946 	},
3947 
3948 	sibling: function( n, elem ) {
3949 		var r = [];
3950 
3951 		for ( ; n; n = n.nextSibling ) {
3952 			if ( n.nodeType === 1 && n !== elem ) {
3953 				r.push( n );
3954 			}
3955 		}
3956 
3957 		return r;
3958 	}
3959 });
3960 var rinlinejQuery = / jQuery\d+="(?:\d+|null)"/g,
3961 	rleadingWhitespace = /^\s+/,
3962 	rxhtmlTag = /(<([\w:]+)[^>]*?)\/>/g,
3963 	rselfClosing = /^(?:area|br|col|embed|hr|img|input|link|meta|param)$/i,
3964 	rtagName = /<([\w:]+)/,
3965 	rtbody = /<tbody/i,
3966 	rhtml = /<|&#?\w+;/,
3967 	rnocache = /<script|<object|<embed|<option|<style/i,
3968 	rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,  // checked="checked" or checked (html5)
3969 	fcloseTag = function( all, front, tag ) {
3970 		return rselfClosing.test( tag ) ?
3971 			all :
3972 			front + "></" + tag + ">";
3973 	},
3974 	wrapMap = {
3975 		option: [ 1, "<select multiple='multiple'>", "</select>" ],
3976 		legend: [ 1, "<fieldset>", "</fieldset>" ],
3977 		thead: [ 1, "<table>", "</table>" ],
3978 		tr: [ 2, "<table><tbody>", "</tbody></table>" ],
3979 		td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
3980 		col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ],
3981 		area: [ 1, "<map>", "</map>" ],
3982 		_default: [ 0, "", "" ]
3983 	};
3984 
3985 wrapMap.optgroup = wrapMap.option;
3986 wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
3987 wrapMap.th = wrapMap.td;
3988 
3989 // IE can't serialize <link> and <script> tags normally
3990 if ( !jQuery.support.htmlSerialize ) {
3991 	wrapMap._default = [ 1, "div<div>", "</div>" ];
3992 }
3993 
3994 jQuery.fn.extend({
3995 	text: function( text ) {
3996 		if ( jQuery.isFunction(text) ) {
3997 			return this.each(function(i) {
3998 				var self = jQuery(this);
3999 				self.text( text.call(this, i, self.text()) );
4000 			});
4001 		}
4002 
4003 		if ( typeof text !== "object" && text !== undefined ) {
4004 			return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );
4005 		}
4006 
4007 		return jQuery.text( this );
4008 	},
4009 
4010 	wrapAll: function( html ) {
4011 		if ( jQuery.isFunction( html ) ) {
4012 			return this.each(function(i) {
4013 				jQuery(this).wrapAll( html.call(this, i) );
4014 			});
4015 		}
4016 
4017 		if ( this[0] ) {
4018 			// The elements to wrap the target around
4019 			var wrap = jQuery( html, this[0].ownerDocument ).eq(0).clone(true);
4020 
4021 			if ( this[0].parentNode ) {
4022 				wrap.insertBefore( this[0] );
4023 			}
4024 
4025 			wrap.map(function() {
4026 				var elem = this;
4027 
4028 				while ( elem.firstChild && elem.firstChild.nodeType === 1 ) {
4029 					elem = elem.firstChild;
4030 				}
4031 
4032 				return elem;
4033 			}).append(this);
4034 		}
4035 
4036 		return this;
4037 	},
4038 
4039 	wrapInner: function( html ) {
4040 		if ( jQuery.isFunction( html ) ) {
4041 			return this.each(function(i) {
4042 				jQuery(this).wrapInner( html.call(this, i) );
4043 			});
4044 		}
4045 
4046 		return this.each(function() {
4047 			var self = jQuery( this ), contents = self.contents();
4048 
4049 			if ( contents.length ) {
4050 				contents.wrapAll( html );
4051 
4052 			} else {
4053 				self.append( html );
4054 			}
4055 		});
4056 	},
4057 
4058 	wrap: function( html ) {
4059 		return this.each(function() {
4060 			jQuery( this ).wrapAll( html );
4061 		});
4062 	},
4063 
4064 	unwrap: function() {
4065 		return this.parent().each(function() {
4066 			if ( !jQuery.nodeName( this, "body" ) ) {
4067 				jQuery( this ).replaceWith( this.childNodes );
4068 			}
4069 		}).end();
4070 	},
4071 
4072 	append: function() {
4073 		return this.domManip(arguments, true, function( elem ) {
4074 			if ( this.nodeType === 1 ) {
4075 				this.appendChild( elem );
4076 			}
4077 		});
4078 	},
4079 
4080 	prepend: function() {
4081 		return this.domManip(arguments, true, function( elem ) {
4082 			if ( this.nodeType === 1 ) {
4083 				this.insertBefore( elem, this.firstChild );
4084 			}
4085 		});
4086 	},
4087 
4088 	before: function() {
4089 		if ( this[0] && this[0].parentNode ) {
4090 			return this.domManip(arguments, false, function( elem ) {
4091 				this.parentNode.insertBefore( elem, this );
4092 			});
4093 		} else if ( arguments.length ) {
4094 			var set = jQuery(arguments[0]);
4095 			set.push.apply( set, this.toArray() );
4096 			return this.pushStack( set, "before", arguments );
4097 		}
4098 	},
4099 
4100 	after: function() {
4101 		if ( this[0] && this[0].parentNode ) {
4102 			return this.domManip(arguments, false, function( elem ) {
4103 				this.parentNode.insertBefore( elem, this.nextSibling );
4104 			});
4105 		} else if ( arguments.length ) {
4106 			var set = this.pushStack( this, "after", arguments );
4107 			set.push.apply( set, jQuery(arguments[0]).toArray() );
4108 			return set;
4109 		}
4110 	},
4111 	
4112 	// keepData is for internal use only--do not document
4113 	remove: function( selector, keepData ) {
4114 		for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
4115 			if ( !selector || jQuery.filter( selector, [ elem ] ).length ) {
4116 				if ( !keepData && elem.nodeType === 1 ) {
4117 					jQuery.cleanData( elem.getElementsByTagName("*") );
4118 					jQuery.cleanData( [ elem ] );
4119 				}
4120 
4121 				if ( elem.parentNode ) {
4122 					 elem.parentNode.removeChild( elem );
4123 				}
4124 			}
4125 		}
4126 		
4127 		return this;
4128 	},
4129 
4130 	empty: function() {
4131 		for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
4132 			// Remove element nodes and prevent memory leaks
4133 			if ( elem.nodeType === 1 ) {
4134 				jQuery.cleanData( elem.getElementsByTagName("*") );
4135 			}
4136 
4137 			// Remove any remaining nodes
4138 			while ( elem.firstChild ) {
4139 				elem.removeChild( elem.firstChild );
4140 			}
4141 		}
4142 		
4143 		return this;
4144 	},
4145 
4146 	clone: function( events ) {
4147 		// Do the clone
4148 		var ret = this.map(function() {
4149 			if ( !jQuery.support.noCloneEvent && !jQuery.isXMLDoc(this) ) {
4150 				// IE copies events bound via attachEvent when
4151 				// using cloneNode. Calling detachEvent on the
4152 				// clone will also remove the events from the orignal
4153 				// In order to get around this, we use innerHTML.
4154 				// Unfortunately, this means some modifications to
4155 				// attributes in IE that are actually only stored
4156 				// as properties will not be copied (such as the
4157 				// the name attribute on an input).
4158 				var html = this.outerHTML, ownerDocument = this.ownerDocument;
4159 				if ( !html ) {
4160 					var div = ownerDocument.createElement("div");
4161 					div.appendChild( this.cloneNode(true) );
4162 					html = div.innerHTML;
4163 				}
4164 
4165 				return jQuery.clean([html.replace(rinlinejQuery, "")
4166 					// Handle the case in IE 8 where action=/test/> self-closes a tag
4167 					.replace(/=([^="'>\s]+\/)>/g, '="$1">')
4168 					.replace(rleadingWhitespace, "")], ownerDocument)[0];
4169 			} else {
4170 				return this.cloneNode(true);
4171 			}
4172 		});
4173 
4174 		// Copy the events from the original to the clone
4175 		if ( events === true ) {
4176 			cloneCopyEvent( this, ret );
4177 			cloneCopyEvent( this.find("*"), ret.find("*") );
4178 		}
4179 
4180 		// Return the cloned set
4181 		return ret;
4182 	},
4183 
4184 	html: function( value ) {
4185 		if ( value === undefined ) {
4186 			return this[0] && this[0].nodeType === 1 ?
4187 				this[0].innerHTML.replace(rinlinejQuery, "") :
4188 				null;
4189 
4190 		// See if we can take a shortcut and just use innerHTML
4191 		} else if ( typeof value === "string" && !rnocache.test( value ) &&
4192 			(jQuery.support.leadingWhitespace || !rleadingWhitespace.test( value )) &&
4193 			!wrapMap[ (rtagName.exec( value ) || ["", ""])[1].toLowerCase() ] ) {
4194 
4195 			value = value.replace(rxhtmlTag, fcloseTag);
4196 
4197 			try {
4198 				for ( var i = 0, l = this.length; i < l; i++ ) {
4199 					// Remove element nodes and prevent memory leaks
4200 					if ( this[i].nodeType === 1 ) {
4201 						jQuery.cleanData( this[i].getElementsByTagName("*") );
4202 						this[i].innerHTML = value;
4203 					}
4204 				}
4205 
4206 			// If using innerHTML throws an exception, use the fallback method
4207 			} catch(e) {
4208 				this.empty().append( value );
4209 			}
4210 
4211 		} else if ( jQuery.isFunction( value ) ) {
4212 			this.each(function(i){
4213 				var self = jQuery(this), old = self.html();
4214 				self.empty().append(function(){
4215 					return value.call( this, i, old );
4216 				});
4217 			});
4218 
4219 		} else {
4220 			this.empty().append( value );
4221 		}
4222 
4223 		return this;
4224 	},
4225 
4226 	replaceWith: function( value ) {
4227 		if ( this[0] && this[0].parentNode ) {
4228 			// Make sure that the elements are removed from the DOM before they are inserted
4229 			// this can help fix replacing a parent with child elements
4230 			if ( jQuery.isFunction( value ) ) {
4231 				return this.each(function(i) {
4232 					var self = jQuery(this), old = self.html();
4233 					self.replaceWith( value.call( this, i, old ) );
4234 				});
4235 			}
4236 
4237 			if ( typeof value !== "string" ) {
4238 				value = jQuery(value).detach();
4239 			}
4240 
4241 			return this.each(function() {
4242 				var next = this.nextSibling, parent = this.parentNode;
4243 
4244 				jQuery(this).remove();
4245 
4246 				if ( next ) {
4247 					jQuery(next).before( value );
4248 				} else {
4249 					jQuery(parent).append( value );
4250 				}
4251 			});
4252 		} else {
4253 			return this.pushStack( jQuery(jQuery.isFunction(value) ? value() : value), "replaceWith", value );
4254 		}
4255 	},
4256 
4257 	detach: function( selector ) {
4258 		return this.remove( selector, true );
4259 	},
4260 
4261 	domManip: function( args, table, callback ) {
4262 		var results, first, value = args[0], scripts = [], fragment, parent;
4263 
4264 		// We can't cloneNode fragments that contain checked, in WebKit
4265 		if ( !jQuery.support.checkClone && arguments.length === 3 && typeof value === "string" && rchecked.test( value ) ) {
4266 			return this.each(function() {
4267 				jQuery(this).domManip( args, table, callback, true );
4268 			});
4269 		}
4270 
4271 		if ( jQuery.isFunction(value) ) {
4272 			return this.each(function(i) {
4273 				var self = jQuery(this);
4274 				args[0] = value.call(this, i, table ? self.html() : undefined);
4275 				self.domManip( args, table, callback );
4276 			});
4277 		}
4278 
4279 		if ( this[0] ) {
4280 			parent = value && value.parentNode;
4281 
4282 			// If we're in a fragment, just use that instead of building a new one
4283 			if ( jQuery.support.parentNode && parent && parent.nodeType === 11 && parent.childNodes.length === this.length ) {
4284 				results = { fragment: parent };
4285 
4286 			} else {
4287 				results = buildFragment( args, this, scripts );
4288 			}
4289 			
4290 			fragment = results.fragment;
4291 			
4292 			if ( fragment.childNodes.length === 1 ) {
4293 				first = fragment = fragment.firstChild;
4294 			} else {
4295 				first = fragment.firstChild;
4296 			}
4297 
4298 			if ( first ) {
4299 				table = table && jQuery.nodeName( first, "tr" );
4300 
4301 				for ( var i = 0, l = this.length; i < l; i++ ) {
4302 					callback.call(
4303 						table ?
4304 							root(this[i], first) :
4305 							this[i],
4306 						i > 0 || results.cacheable || this.length > 1  ?
4307 							fragment.cloneNode(true) :
4308 							fragment
4309 					);
4310 				}
4311 			}
4312 
4313 			if ( scripts.length ) {
4314 				jQuery.each( scripts, evalScript );
4315 			}
4316 		}
4317 
4318 		return this;
4319 
4320 		function root( elem, cur ) {
4321 			return jQuery.nodeName(elem, "table") ?
4322 				(elem.getElementsByTagName("tbody")[0] ||
4323 				elem.appendChild(elem.ownerDocument.createElement("tbody"))) :
4324 				elem;
4325 		}
4326 	}
4327 });
4328 
4329 function cloneCopyEvent(orig, ret) {
4330 	var i = 0;
4331 
4332 	ret.each(function() {
4333 		if ( this.nodeName !== (orig[i] && orig[i].nodeName) ) {
4334 			return;
4335 		}
4336 
4337 		var oldData = jQuery.data( orig[i++] ), curData = jQuery.data( this, oldData ), events = oldData && oldData.events;
4338 
4339 		if ( events ) {
4340 			delete curData.handle;
4341 			curData.events = {};
4342 
4343 			for ( var type in events ) {
4344 				for ( var handler in events[ type ] ) {
4345 					jQuery.event.add( this, type, events[ type ][ handler ], events[ type ][ handler ].data );
4346 				}
4347 			}
4348 		}
4349 	});
4350 }
4351 
4352 function buildFragment( args, nodes, scripts ) {
4353 	var fragment, cacheable, cacheresults,
4354 		doc = (nodes && nodes[0] ? nodes[0].ownerDocument || nodes[0] : document);
4355 
4356 	// Only cache "small" (1/2 KB) strings that are associated with the main document
4357 	// Cloning options loses the selected state, so don't cache them
4358 	// IE 6 doesn't like it when you put <object> or <embed> elements in a fragment
4359 	// Also, WebKit does not clone 'checked' attributes on cloneNode, so don't cache
4360 	if ( args.length === 1 && typeof args[0] === "string" && args[0].length < 512 && doc === document &&
4361 		!rnocache.test( args[0] ) && (jQuery.support.checkClone || !rchecked.test( args[0] )) ) {
4362 
4363 		cacheable = true;
4364 		cacheresults = jQuery.fragments[ args[0] ];
4365 		if ( cacheresults ) {
4366 			if ( cacheresults !== 1 ) {
4367 				fragment = cacheresults;
4368 			}
4369 		}
4370 	}
4371 
4372 	if ( !fragment ) {
4373 		fragment = doc.createDocumentFragment();
4374 		jQuery.clean( args, doc, fragment, scripts );
4375 	}
4376 
4377 	if ( cacheable ) {
4378 		jQuery.fragments[ args[0] ] = cacheresults ? fragment : 1;
4379 	}
4380 
4381 	return { fragment: fragment, cacheable: cacheable };
4382 }
4383 
4384 jQuery.fragments = {};
4385 
4386 jQuery.each({
4387 	appendTo: "append",
4388 	prependTo: "prepend",
4389 	insertBefore: "before",
4390 	insertAfter: "after",
4391 	replaceAll: "replaceWith"
4392 }, function( name, original ) {
4393 	jQuery.fn[ name ] = function( selector ) {
4394 		var ret = [], insert = jQuery( selector ),
4395 			parent = this.length === 1 && this[0].parentNode;
4396 		
4397 		if ( parent && parent.nodeType === 11 && parent.childNodes.length === 1 && insert.length === 1 ) {
4398 			insert[ original ]( this[0] );
4399 			return this;
4400 			
4401 		} else {
4402 			for ( var i = 0, l = insert.length; i < l; i++ ) {
4403 				var elems = (i > 0 ? this.clone(true) : this).get();
4404 				jQuery.fn[ original ].apply( jQuery(insert[i]), elems );
4405 				ret = ret.concat( elems );
4406 			}
4407 		
4408 			return this.pushStack( ret, name, insert.selector );
4409 		}
4410 	};
4411 });
4412 
4413 jQuery.extend({
4414 	clean: function( elems, context, fragment, scripts ) {
4415 		context = context || document;
4416 
4417 		// !context.createElement fails in IE with an error but returns typeof 'object'
4418 		if ( typeof context.createElement === "undefined" ) {
4419 			context = context.ownerDocument || context[0] && context[0].ownerDocument || document;
4420 		}
4421 
4422 		var ret = [];
4423 
4424 		for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
4425 			if ( typeof elem === "number" ) {
4426 				elem += "";
4427 			}
4428 
4429 			if ( !elem ) {
4430 				continue;
4431 			}
4432 
4433 			// Convert html string into DOM nodes
4434 			if ( typeof elem === "string" && !rhtml.test( elem ) ) {
4435 				elem = context.createTextNode( elem );
4436 
4437 			} else if ( typeof elem === "string" ) {
4438 				// Fix "XHTML"-style tags in all browsers
4439 				elem = elem.replace(rxhtmlTag, fcloseTag);
4440 
4441 				// Trim whitespace, otherwise indexOf won't work as expected
4442 				var tag = (rtagName.exec( elem ) || ["", ""])[1].toLowerCase(),
4443 					wrap = wrapMap[ tag ] || wrapMap._default,
4444 					depth = wrap[0],
4445 					div = context.createElement("div");
4446 
4447 				// Go to html and back, then peel off extra wrappers
4448 				div.innerHTML = wrap[1] + elem + wrap[2];
4449 
4450 				// Move to the right depth
4451 				while ( depth-- ) {
4452 					div = div.lastChild;
4453 				}
4454 
4455 				// Remove IE's autoinserted <tbody> from table fragments
4456 				if ( !jQuery.support.tbody ) {
4457 
4458 					// String was a <table>, *may* have spurious <tbody>
4459 					var hasBody = rtbody.test(elem),
4460 						tbody = tag === "table" && !hasBody ?
4461 							div.firstChild && div.firstChild.childNodes :
4462 
4463 							// String was a bare <thead> or <tfoot>
4464 							wrap[1] === "<table>" && !hasBody ?
4465 								div.childNodes :
4466 								[];
4467 
4468 					for ( var j = tbody.length - 1; j >= 0 ; --j ) {
4469 						if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length ) {
4470 							tbody[ j ].parentNode.removeChild( tbody[ j ] );
4471 						}
4472 					}
4473 
4474 				}
4475 
4476 				// IE completely kills leading whitespace when innerHTML is used
4477 				if ( !jQuery.support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {
4478 					div.insertBefore( context.createTextNode( rleadingWhitespace.exec(elem)[0] ), div.firstChild );
4479 				}
4480 
4481 				elem = div.childNodes;
4482 			}
4483 
4484 			if ( elem.nodeType ) {
4485 				ret.push( elem );
4486 			} else {
4487 				ret = jQuery.merge( ret, elem );
4488 			}
4489 		}
4490 
4491 		if ( fragment ) {
4492 			for ( var i = 0; ret[i]; i++ ) {
4493 				if ( scripts && jQuery.nodeName( ret[i], "script" ) && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript") ) {
4494 					scripts.push( ret[i].parentNode ? ret[i].parentNode.removeChild( ret[i] ) : ret[i] );
4495 				
4496 				} else {
4497 					if ( ret[i].nodeType === 1 ) {
4498 						ret.splice.apply( ret, [i + 1, 0].concat(jQuery.makeArray(ret[i].getElementsByTagName("script"))) );
4499 					}
4500 					fragment.appendChild( ret[i] );
4501 				}
4502 			}
4503 		}
4504 
4505 		return ret;
4506 	},
4507 	
4508 	cleanData: function( elems ) {
4509 		var data, id, cache = jQuery.cache,
4510 			special = jQuery.event.special,
4511 			deleteExpando = jQuery.support.deleteExpando;
4512 		
4513 		for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
4514 			id = elem[ jQuery.expando ];
4515 			
4516 			if ( id ) {
4517 				data = cache[ id ];
4518 				
4519 				if ( data.events ) {
4520 					for ( var type in data.events ) {
4521 						if ( special[ type ] ) {
4522 							jQuery.event.remove( elem, type );
4523 
4524 						} else {
4525 							removeEvent( elem, type, data.handle );
4526 						}
4527 					}
4528 				}
4529 				
4530 				if ( deleteExpando ) {
4531 					delete elem[ jQuery.expando ];
4532 
4533 				} else if ( elem.removeAttribute ) {
4534 					elem.removeAttribute( jQuery.expando );
4535 				}
4536 				
4537 				delete cache[ id ];
4538 			}
4539 		}
4540 	}
4541 });
4542 // exclude the following css properties to add px
4543 var rexclude = /z-?index|font-?weight|opacity|zoom|line-?height/i,
4544 	ralpha = /alpha\([^)]*\)/,
4545 	ropacity = /opacity=([^)]*)/,
4546 	rfloat = /float/i,
4547 	rdashAlpha = /-([a-z])/ig,
4548 	rupper = /([A-Z])/g,
4549 	rnumpx = /^-?\d+(?:px)?$/i,
4550 	rnum = /^-?\d/,
4551 
4552 	cssShow = { position: "absolute", visibility: "hidden", display:"block" },
4553 	cssWidth = [ "Left", "Right" ],
4554 	cssHeight = [ "Top", "Bottom" ],
4555 
4556 	// cache check for defaultView.getComputedStyle
4557 	getComputedStyle = document.defaultView && document.defaultView.getComputedStyle,
4558 	// normalize float css property
4559 	styleFloat = jQuery.support.cssFloat ? "cssFloat" : "styleFloat",
4560 	fcamelCase = function( all, letter ) {
4561 		return letter.toUpperCase();
4562 	};
4563 
4564 jQuery.fn.css = function( name, value ) {
4565 	return access( this, name, value, true, function( elem, name, value ) {
4566 		if ( value === undefined ) {
4567 			return jQuery.curCSS( elem, name );
4568 		}
4569 		
4570 		if ( typeof value === "number" && !rexclude.test(name) ) {
4571 			value += "px";
4572 		}
4573 
4574 		jQuery.style( elem, name, value );
4575 	});
4576 };
4577 
4578 jQuery.extend({
4579 	style: function( elem, name, value ) {
4580 		// don't set styles on text and comment nodes
4581 		if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 ) {
4582 			return undefined;
4583 		}
4584 
4585 		// ignore negative width and height values #1599
4586 		if ( (name === "width" || name === "height") && parseFloat(value) < 0 ) {
4587 			value = undefined;
4588 		}
4589 
4590 		var style = elem.style || elem, set = value !== undefined;
4591 
4592 		// IE uses filters for opacity
4593 		if ( !jQuery.support.opacity && name === "opacity" ) {
4594 			if ( set ) {
4595 				// IE has trouble with opacity if it does not have layout
4596 				// Force it by setting the zoom level
4597 				style.zoom = 1;
4598 
4599 				// Set the alpha filter to set the opacity
4600 				var opacity = parseInt( value, 10 ) + "" === "NaN" ? "" : "alpha(opacity=" + value * 100 + ")";
4601 				var filter = style.filter || jQuery.curCSS( elem, "filter" ) || "";
4602 				style.filter = ralpha.test(filter) ? filter.replace(ralpha, opacity) : opacity;
4603 			}
4604 
4605 			return style.filter && style.filter.indexOf("opacity=") >= 0 ?
4606 				(parseFloat( ropacity.exec(style.filter)[1] ) / 100) + "":
4607 				"";
4608 		}
4609 
4610 		// Make sure we're using the right name for getting the float value
4611 		if ( rfloat.test( name ) ) {
4612 			name = styleFloat;
4613 		}
4614 
4615 		name = name.replace(rdashAlpha, fcamelCase);
4616 
4617 		if ( set ) {
4618 			style[ name ] = value;
4619 		}
4620 
4621 		return style[ name ];
4622 	},
4623 
4624 	css: function( elem, name, force, extra ) {
4625 		if ( name === "width" || name === "height" ) {
4626 			var val, props = cssShow, which = name === "width" ? cssWidth : cssHeight;
4627 
4628 			function getWH() {
4629 				val = name === "width" ? elem.offsetWidth : elem.offsetHeight;
4630 
4631 				if ( extra === "border" ) {
4632 					return;
4633 				}
4634 
4635 				jQuery.each( which, function() {
4636 					if ( !extra ) {
4637 						val -= parseFloat(jQuery.curCSS( elem, "padding" + this, true)) || 0;
4638 					}
4639 
4640 					if ( extra === "margin" ) {
4641 						val += parseFloat(jQuery.curCSS( elem, "margin" + this, true)) || 0;
4642 					} else {
4643 						val -= parseFloat(jQuery.curCSS( elem, "border" + this + "Width", true)) || 0;
4644 					}
4645 				});
4646 			}
4647 
4648 			if ( elem.offsetWidth !== 0 ) {
4649 				getWH();
4650 			} else {
4651 				jQuery.swap( elem, props, getWH );
4652 			}
4653 
4654 			return Math.max(0, Math.round(val));
4655 		}
4656 
4657 		return jQuery.curCSS( elem, name, force );
4658 	},
4659 
4660 	curCSS: function( elem, name, force ) {
4661 		var ret, style = elem.style, filter;
4662 
4663 		// IE uses filters for opacity
4664 		if ( !jQuery.support.opacity && name === "opacity" && elem.currentStyle ) {
4665 			ret = ropacity.test(elem.currentStyle.filter || "") ?
4666 				(parseFloat(RegExp.$1) / 100) + "" :
4667 				"";
4668 
4669 			return ret === "" ?
4670 				"1" :
4671 				ret;
4672 		}
4673 
4674 		// Make sure we're using the right name for getting the float value
4675 		if ( rfloat.test( name ) ) {
4676 			name = styleFloat;
4677 		}
4678 
4679 		if ( !force && style && style[ name ] ) {
4680 			ret = style[ name ];
4681 
4682 		} else if ( getComputedStyle ) {
4683 
4684 			// Only "float" is needed here
4685 			if ( rfloat.test( name ) ) {
4686 				name = "float";
4687 			}
4688 
4689 			name = name.replace( rupper, "-$1" ).toLowerCase();
4690 
4691 			var defaultView = elem.ownerDocument.defaultView;
4692 
4693 			if ( !defaultView ) {
4694 				return null;
4695 			}
4696 
4697 			var computedStyle = defaultView.getComputedStyle( elem, null );
4698 
4699 			if ( computedStyle ) {
4700 				ret = computedStyle.getPropertyValue( name );
4701 			}
4702 
4703 			// We should always get a number back from opacity
4704 			if ( name === "opacity" && ret === "" ) {
4705 				ret = "1";
4706 			}
4707 
4708 		} else if ( elem.currentStyle ) {
4709 			var camelCase = name.replace(rdashAlpha, fcamelCase);
4710 
4711 			ret = elem.currentStyle[ name ] || elem.currentStyle[ camelCase ];
4712 
4713 			// From the awesome hack by Dean Edwards
4714 			// http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
4715 
4716 			// If we're not dealing with a regular pixel number
4717 			// but a number that has a weird ending, we need to convert it to pixels
4718 			if ( !rnumpx.test( ret ) && rnum.test( ret ) ) {
4719 				// Remember the original values
4720 				var left = style.left, rsLeft = elem.runtimeStyle.left;
4721 
4722 				// Put in the new values to get a computed value out
4723 				elem.runtimeStyle.left = elem.currentStyle.left;
4724 				style.left = camelCase === "fontSize" ? "1em" : (ret || 0);
4725 				ret = style.pixelLeft + "px";
4726 
4727 				// Revert the changed values
4728 				style.left = left;
4729 				elem.runtimeStyle.left = rsLeft;
4730 			}
4731 		}
4732 
4733 		return ret;
4734 	},
4735 
4736 	// A method for quickly swapping in/out CSS properties to get correct calculations
4737 	swap: function( elem, options, callback ) {
4738 		var old = {};
4739 
4740 		// Remember the old values, and insert the new ones
4741 		for ( var name in options ) {
4742 			old[ name ] = elem.style[ name ];
4743 			elem.style[ name ] = options[ name ];
4744 		}
4745 
4746 		callback.call( elem );
4747 
4748 		// Revert the old values
4749 		for ( var name in options ) {
4750 			elem.style[ name ] = old[ name ];
4751 		}
4752 	}
4753 });
4754 
4755 if ( jQuery.expr && jQuery.expr.filters ) {
4756 	jQuery.expr.filters.hidden = function( elem ) {
4757 		var width = elem.offsetWidth, height = elem.offsetHeight,
4758 			skip = elem.nodeName.toLowerCase() === "tr";
4759 
4760 		return width === 0 && height === 0 && !skip ?
4761 			true :
4762 			width > 0 && height > 0 && !skip ?
4763 				false :
4764 				jQuery.curCSS(elem, "display") === "none";
4765 	};
4766 
4767 	jQuery.expr.filters.visible = function( elem ) {
4768 		return !jQuery.expr.filters.hidden( elem );
4769 	};
4770 }
4771 var jsc = now(),
4772 	rscript = /<script(.|\s)*?\/script>/gi,
4773 	rselectTextarea = /select|textarea/i,
4774 	rinput = /color|date|datetime|email|hidden|month|number|password|range|search|tel|text|time|url|week/i,
4775 	jsre = /=\?(&|$)/,
4776 	rquery = /\?/,
4777 	rts = /(\?|&)_=.*?(&|$)/,
4778 	rurl = /^(\w+:)?\/\/([^\/?#]+)/,
4779 	r20 = /%20/g,
4780 
4781 	// Keep a copy of the old load method
4782 	_load = jQuery.fn.load;
4783 
4784 jQuery.fn.extend({
4785 	load: function( url, params, callback ) {
4786 		if ( typeof url !== "string" ) {
4787 			return _load.call( this, url );
4788 
4789 		// Don't do a request if no elements are being requested
4790 		} else if ( !this.length ) {
4791 			return this;
4792 		}
4793 
4794 		var off = url.indexOf(" ");
4795 		if ( off >= 0 ) {
4796 			var selector = url.slice(off, url.length);
4797 			url = url.slice(0, off);
4798 		}
4799 
4800 		// Default to a GET request
4801 		var type = "GET";
4802 
4803 		// If the second parameter was provided
4804 		if ( params ) {
4805 			// If it's a function
4806 			if ( jQuery.isFunction( params ) ) {
4807 				// We assume that it's the callback
4808 				callback = params;
4809 				params = null;
4810 
4811 			// Otherwise, build a param string
4812 			} else if ( typeof params === "object" ) {
4813 				params = jQuery.param( params, jQuery.ajaxSettings.traditional );
4814 				type = "POST";
4815 			}
4816 		}
4817 
4818 		var self = this;
4819 
4820 		// Request the remote document
4821 		jQuery.ajax({
4822 			url: url,
4823 			type: type,
4824 			dataType: "html",
4825 			data: params,
4826 			complete: function( res, status ) {
4827 				// If successful, inject the HTML into all the matched elements
4828 				if ( status === "success" || status === "notmodified" ) {
4829 					// See if a selector was specified
4830 					self.html( selector ?
4831 						// Create a dummy div to hold the results
4832 						jQuery("<div />")
4833 							// inject the contents of the document in, removing the scripts
4834 							// to avoid any 'Permission Denied' errors in IE
4835 							.append(res.responseText.replace(rscript, ""))
4836 
4837 							// Locate the specified elements
4838 							.find(selector) :
4839 
4840 						// If not, just inject the full result
4841 						res.responseText );
4842 				}
4843 
4844 				if ( callback ) {
4845 					self.each( callback, [res.responseText, status, res] );
4846 				}
4847 			}
4848 		});
4849 
4850 		return this;
4851 	},
4852 
4853 	serialize: function() {
4854 		return jQuery.param(this.serializeArray());
4855 	},
4856 	serializeArray: function() {
4857 		return this.map(function() {
4858 			return this.elements ? jQuery.makeArray(this.elements) : this;
4859 		})
4860 		.filter(function() {
4861 			return this.name && !this.disabled &&
4862 				(this.checked || rselectTextarea.test(this.nodeName) ||
4863 					rinput.test(this.type));
4864 		})
4865 		.map(function( i, elem ) {
4866 			var val = jQuery(this).val();
4867 
4868 			return val == null ?
4869 				null :
4870 				jQuery.isArray(val) ?
4871 					jQuery.map( val, function( val, i ) {
4872 						return { name: elem.name, value: val };
4873 					}) :
4874 					{ name: elem.name, value: val };
4875 		}).get();
4876 	}
4877 });
4878 
4879 // Attach a bunch of functions for handling common AJAX events
4880 jQuery.each( "ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split(" "), function( i, o ) {
4881 	jQuery.fn[o] = function( f ) {
4882 		return this.bind(o, f);
4883 	};
4884 });
4885 
4886 jQuery.extend({
4887 
4888 	get: function( url, data, callback, type ) {
4889 		// shift arguments if data argument was omited
4890 		if ( jQuery.isFunction( data ) ) {
4891 			type = type || callback;
4892 			callback = data;
4893 			data = null;
4894 		}
4895 
4896 		return jQuery.ajax({
4897 			type: "GET",
4898 			url: url,
4899 			data: data,
4900 			success: callback,
4901 			dataType: type
4902 		});
4903 	},
4904 
4905 	getScript: function( url, callback ) {
4906 		return jQuery.get(url, null, callback, "script");
4907 	},
4908 
4909 	getJSON: function( url, data, callback ) {
4910 		return jQuery.get(url, data, callback, "json");
4911 	},
4912 
4913 	post: function( url, data, callback, type ) {
4914 		// shift arguments if data argument was omited
4915 		if ( jQuery.isFunction( data ) ) {
4916 			type = type || callback;
4917 			callback = data;
4918 			data = {};
4919 		}
4920 
4921 		return jQuery.ajax({
4922 			type: "POST",
4923 			url: url,
4924 			data: data,
4925 			success: callback,
4926 			dataType: type
4927 		});
4928 	},
4929 
4930 	ajaxSetup: function( settings ) {
4931 		jQuery.extend( jQuery.ajaxSettings, settings );
4932 	},
4933 
4934 	ajaxSettings: {
4935 		url: location.href,
4936 		global: true,
4937 		type: "GET",
4938 		contentType: "application/x-www-form-urlencoded",
4939 		processData: true,
4940 		async: true,
4941 		/*
4942 		timeout: 0,
4943 		data: null,
4944 		username: null,
4945 		password: null,
4946 		traditional: false,
4947 		*/
4948 		// Create the request object; Microsoft failed to properly
4949 		// implement the XMLHttpRequest in IE7 (can't request local files),
4950 		// so we use the ActiveXObject when it is available
4951 		// This function can be overriden by calling jQuery.ajaxSetup
4952 		xhr: window.XMLHttpRequest && (window.location.protocol !== "file:" || !window.ActiveXObject) ?
4953 			function() {
4954 				return new window.XMLHttpRequest();
4955 			} :
4956 			function() {
4957 				try {
4958 					return new window.ActiveXObject("Microsoft.XMLHTTP");
4959 				} catch(e) {}
4960 			},
4961 		accepts: {
4962 			xml: "application/xml, text/xml",
4963 			html: "text/html",
4964 			script: "text/javascript, application/javascript",
4965 			json: "application/json, text/javascript",
4966 			text: "text/plain",
4967 			_default: "*/*"
4968 		}
4969 	},
4970 
4971 	// Last-Modified header cache for next request
4972 	lastModified: {},
4973 	etag: {},
4974 
4975 	ajax: function( origSettings ) {
4976 		var s = jQuery.extend(true, {}, jQuery.ajaxSettings, origSettings);
4977 		
4978 		var jsonp, status, data,
4979 			callbackContext = origSettings && origSettings.context || s,
4980 			type = s.type.toUpperCase();
4981 
4982 		// convert data if not already a string
4983 		if ( s.data && s.processData && typeof s.data !== "string" ) {
4984 			s.data = jQuery.param( s.data, s.traditional );
4985 		}
4986 
4987 		// Handle JSONP Parameter Callbacks
4988 		if ( s.dataType === "jsonp" ) {
4989 			if ( type === "GET" ) {
4990 				if ( !jsre.test( s.url ) ) {
4991 					s.url += (rquery.test( s.url ) ? "&" : "?") + (s.jsonp || "callback") + "=?";
4992 				}
4993 			} else if ( !s.data || !jsre.test(s.data) ) {
4994 				s.data = (s.data ? s.data + "&" : "") + (s.jsonp || "callback") + "=?";
4995 			}
4996 			s.dataType = "json";
4997 		}
4998 
4999 		// Build temporary JSONP function
5000 		if ( s.dataType === "json" && (s.data && jsre.test(s.data) || jsre.test(s.url)) ) {
5001 			jsonp = s.jsonpCallback || ("jsonp" + jsc++);
5002 
5003 			// Replace the =? sequence both in the query string and the data
5004 			if ( s.data ) {
5005 				s.data = (s.data + "").replace(jsre, "=" + jsonp + "$1");
5006 			}
5007 
5008 			s.url = s.url.replace(jsre, "=" + jsonp + "$1");
5009 
5010 			// We need to make sure
5011 			// that a JSONP style response is executed properly
5012 			s.dataType = "script";
5013 
5014 			// Handle JSONP-style loading
5015 			window[ jsonp ] = window[ jsonp ] || function( tmp ) {
5016 				data = tmp;
5017 				success();
5018 				complete();
5019 				// Garbage collect
5020 				window[ jsonp ] = undefined;
5021 
5022 				try {
5023 					delete window[ jsonp ];
5024 				} catch(e) {}
5025 
5026 				if ( head ) {
5027 					head.removeChild( script );
5028 				}
5029 			};
5030 		}
5031 
5032 		if ( s.dataType === "script" && s.cache === null ) {
5033 			s.cache = false;
5034 		}
5035 
5036 		if ( s.cache === false && type === "GET" ) {
5037 			var ts = now();
5038 
5039 			// try replacing _= if it is there
5040 			var ret = s.url.replace(rts, "$1_=" + ts + "$2");
5041 
5042 			// if nothing was replaced, add timestamp to the end
5043 			s.url = ret + ((ret === s.url) ? (rquery.test(s.url) ? "&" : "?") + "_=" + ts : "");
5044 		}
5045 
5046 		// If data is available, append data to url for get requests
5047 		if ( s.data && type === "GET" ) {
5048 			s.url += (rquery.test(s.url) ? "&" : "?") + s.data;
5049 		}
5050 
5051 		// Watch for a new set of requests
5052 		if ( s.global && ! jQuery.active++ ) {
5053 			jQuery.event.trigger( "ajaxStart" );
5054 		}
5055 
5056 		// Matches an absolute URL, and saves the domain
5057 		var parts = rurl.exec( s.url ),
5058 			remote = parts && (parts[1] && parts[1] !== location.protocol || parts[2] !== location.host);
5059 
5060 		// If we're requesting a remote document
5061 		// and trying to load JSON or Script with a GET
5062 		if ( s.dataType === "script" && type === "GET" && remote ) {
5063 			var head = document.getElementsByTagName("head")[0] || document.documentElement;
5064 			var script = document.createElement("script");
5065 			script.src = s.url;
5066 			if ( s.scriptCharset ) {
5067 				script.charset = s.scriptCharset;
5068 			}
5069 
5070 			// Handle Script loading
5071 			if ( !jsonp ) {
5072 				var done = false;
5073 
5074 				// Attach handlers for all browsers
5075 				script.onload = script.onreadystatechange = function() {
5076 					if ( !done && (!this.readyState ||
5077 							this.readyState === "loaded" || this.readyState === "complete") ) {
5078 						done = true;
5079 						success();
5080 						complete();
5081 
5082 						// Handle memory leak in IE
5083 						script.onload = script.onreadystatechange = null;
5084 						if ( head && script.parentNode ) {
5085 							head.removeChild( script );
5086 						}
5087 					}
5088 				};
5089 			}
5090 
5091 			// Use insertBefore instead of appendChild  to circumvent an IE6 bug.
5092 			// This arises when a base node is used (#2709 and #4378).
5093 			head.insertBefore( script, head.firstChild );
5094 
5095 			// We handle everything using the script element injection
5096 			return undefined;
5097 		}
5098 
5099 		var requestDone = false;
5100 
5101 		// Create the request object
5102 		var xhr = s.xhr();
5103 
5104 		if ( !xhr ) {
5105 			return;
5106 		}
5107 
5108 		// Open the socket
5109 		// Passing null username, generates a login popup on Opera (#2865)
5110 		if ( s.username ) {
5111 			xhr.open(type, s.url, s.async, s.username, s.password);
5112 		} else {
5113 			xhr.open(type, s.url, s.async);
5114 		}
5115 
5116 		// Need an extra try/catch for cross domain requests in Firefox 3
5117 		try {
5118 			// Set the correct header, if data is being sent
5119 			if ( s.data || origSettings && origSettings.contentType ) {
5120 				xhr.setRequestHeader("Content-Type", s.contentType);
5121 			}
5122 
5123 			// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
5124 			if ( s.ifModified ) {
5125 				if ( jQuery.lastModified[s.url] ) {
5126 					xhr.setRequestHeader("If-Modified-Since", jQuery.lastModified[s.url]);
5127 				}
5128 
5129 				if ( jQuery.etag[s.url] ) {
5130 					xhr.setRequestHeader("If-None-Match", jQuery.etag[s.url]);
5131 				}
5132 			}
5133 
5134 			// Set header so the called script knows that it's an XMLHttpRequest
5135 			// Only send the header if it's not a remote XHR
5136 			if ( !remote ) {
5137 				xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
5138 			}
5139 
5140 			// Set the Accepts header for the server, depending on the dataType
5141 			xhr.setRequestHeader("Accept", s.dataType && s.accepts[ s.dataType ] ?
5142 				s.accepts[ s.dataType ] + ", */*" :
5143 				s.accepts._default );
5144 		} catch(e) {}
5145 
5146 		// Allow custom headers/mimetypes and early abort
5147 		if ( s.beforeSend && s.beforeSend.call(callbackContext, xhr, s) === false ) {
5148 			// Handle the global AJAX counter
5149 			if ( s.global && ! --jQuery.active ) {
5150 				jQuery.event.trigger( "ajaxStop" );
5151 			}
5152 
5153 			// close opended socket
5154 			xhr.abort();
5155 			return false;
5156 		}
5157 
5158 		if ( s.global ) {
5159 			trigger("ajaxSend", [xhr, s]);
5160 		}
5161 
5162 		// Wait for a response to come back
5163 		var onreadystatechange = xhr.onreadystatechange = function( isTimeout ) {
5164 			// The request was aborted
5165 			if ( !xhr || xhr.readyState === 0 || isTimeout === "abort" ) {
5166 				// Opera doesn't call onreadystatechange before this point
5167 				// so we simulate the call
5168 				if ( !requestDone ) {
5169 					complete();
5170 				}
5171 
5172 				requestDone = true;
5173 				if ( xhr ) {
5174 					xhr.onreadystatechange = jQuery.noop;
5175 				}
5176 
5177 			// The transfer is complete and the data is available, or the request timed out
5178 			} else if ( !requestDone && xhr && (xhr.readyState === 4 || isTimeout === "timeout") ) {
5179 				requestDone = true;
5180 				xhr.onreadystatechange = jQuery.noop;
5181 
5182 				status = isTimeout === "timeout" ?
5183 					"timeout" :
5184 					!jQuery.httpSuccess( xhr ) ?
5185 						"error" :
5186 						s.ifModified && jQuery.httpNotModified( xhr, s.url ) ?
5187 							"notmodified" :
5188 							"success";
5189 
5190 				var errMsg;
5191 
5192 				if ( status === "success" ) {
5193 					// Watch for, and catch, XML document parse errors
5194 					try {
5195 						// process the data (runs the xml through httpData regardless of callback)
5196 						data = jQuery.httpData( xhr, s.dataType, s );
5197 					} catch(err) {
5198 						status = "parsererror";
5199 						errMsg = err;
5200 					}
5201 				}
5202 
5203 				// Make sure that the request was successful or notmodified
5204 				if ( status === "success" || status === "notmodified" ) {
5205 					// JSONP handles its own success callback
5206 					if ( !jsonp ) {
5207 						success();
5208 					}
5209 				} else {
5210 					jQuery.handleError(s, xhr, status, errMsg);
5211 				}
5212 
5213 				// Fire the complete handlers
5214 				complete();
5215 
5216 				if ( isTimeout === "timeout" ) {
5217 					xhr.abort();
5218 				}
5219 
5220 				// Stop memory leaks
5221 				if ( s.async ) {
5222 					xhr = null;
5223 				}
5224 			}
5225 		};
5226 
5227 		// Override the abort handler, if we can (IE doesn't allow it, but that's OK)
5228 		// Opera doesn't fire onreadystatechange at all on abort
5229 		try {
5230 			var oldAbort = xhr.abort;
5231 			xhr.abort = function() {
5232 				if ( xhr ) {
5233 					oldAbort.call( xhr );
5234 				}
5235 
5236 				onreadystatechange( "abort" );
5237 			};
5238 		} catch(e) { }
5239 
5240 		// Timeout checker
5241 		if ( s.async && s.timeout > 0 ) {
5242 			setTimeout(function() {
5243 				// Check to see if the request is still happening
5244 				if ( xhr && !requestDone ) {
5245 					onreadystatechange( "timeout" );
5246 				}
5247 			}, s.timeout);
5248 		}
5249 
5250 		// Send the data
5251 		try {
5252 			xhr.send( type === "POST" || type === "PUT" || type === "DELETE" ? s.data : null );
5253 		} catch(e) {
5254 			jQuery.handleError(s, xhr, null, e);
5255 			// Fire the complete handlers
5256 			complete();
5257 		}
5258 
5259 		// firefox 1.5 doesn't fire statechange for sync requests
5260 		if ( !s.async ) {
5261 			onreadystatechange();
5262 		}
5263 
5264 		function success() {
5265 			// If a local callback was specified, fire it and pass it the data
5266 			if ( s.success ) {
5267 				s.success.call( callbackContext, data, status, xhr );
5268 			}
5269 
5270 			// Fire the global callback
5271 			if ( s.global ) {
5272 				trigger( "ajaxSuccess", [xhr, s] );
5273 			}
5274 		}
5275 
5276 		function complete() {
5277 			// Process result
5278 			if ( s.complete ) {
5279 				s.complete.call( callbackContext, xhr, status);
5280 			}
5281 
5282 			// The request was completed
5283 			if ( s.global ) {
5284 				trigger( "ajaxComplete", [xhr, s] );
5285 			}
5286 
5287 			// Handle the global AJAX counter
5288 			if ( s.global && ! --jQuery.active ) {
5289 				jQuery.event.trigger( "ajaxStop" );
5290 			}
5291 		}
5292 		
5293 		function trigger(type, args) {
5294 			(s.context ? jQuery(s.context) : jQuery.event).trigger(type, args);
5295 		}
5296 
5297 		// return XMLHttpRequest to allow aborting the request etc.
5298 		return xhr;
5299 	},
5300 
5301 	handleError: function( s, xhr, status, e ) {
5302 		// If a local callback was specified, fire it
5303 		if ( s.error ) {
5304 			s.error.call( s.context || s, xhr, status, e );
5305 		}
5306 
5307 		// Fire the global callback
5308 		if ( s.global ) {
5309 			(s.context ? jQuery(s.context) : jQuery.event).trigger( "ajaxError", [xhr, s, e] );
5310 		}
5311 	},
5312 
5313 	// Counter for holding the number of active queries
5314 	active: 0,
5315 
5316 	// Determines if an XMLHttpRequest was successful or not
5317 	httpSuccess: function( xhr ) {
5318 		try {
5319 			// IE error sometimes returns 1223 when it should be 204 so treat it as success, see #1450
5320 			return !xhr.status && location.protocol === "file:" ||
5321 				// Opera returns 0 when status is 304
5322 				( xhr.status >= 200 && xhr.status < 300 ) ||
5323 				xhr.status === 304 || xhr.status === 1223 || xhr.status === 0;
5324 		} catch(e) {}
5325 
5326 		return false;
5327 	},
5328 
5329 	// Determines if an XMLHttpRequest returns NotModified
5330 	httpNotModified: function( xhr, url ) {
5331 		var lastModified = xhr.getResponseHeader("Last-Modified"),
5332 			etag = xhr.getResponseHeader("Etag");
5333 
5334 		if ( lastModified ) {
5335 			jQuery.lastModified[url] = lastModified;
5336 		}
5337 
5338 		if ( etag ) {
5339 			jQuery.etag[url] = etag;
5340 		}
5341 
5342 		// Opera returns 0 when status is 304
5343 		return xhr.status === 304 || xhr.status === 0;
5344 	},
5345 
5346 	httpData: function( xhr, type, s ) {
5347 		var ct = xhr.getResponseHeader("content-type") || "",
5348 			xml = type === "xml" || !type && ct.indexOf("xml") >= 0,
5349 			data = xml ? xhr.responseXML : xhr.responseText;
5350 
5351 		if ( xml && data.documentElement.nodeName === "parsererror" ) {
5352 			jQuery.error( "parsererror" );
5353 		}
5354 
5355 		// Allow a pre-filtering function to sanitize the response
5356 		// s is checked to keep backwards compatibility
5357 		if ( s && s.dataFilter ) {
5358 			data = s.dataFilter( data, type );
5359 		}
5360 
5361 		// The filter can actually parse the response
5362 		if ( typeof data === "string" ) {
5363 			// Get the JavaScript object, if JSON is used.
5364 			if ( type === "json" || !type && ct.indexOf("json") >= 0 ) {
5365 				data = jQuery.parseJSON( data );
5366 
5367 			// If the type is "script", eval it in global context
5368 			} else if ( type === "script" || !type && ct.indexOf("javascript") >= 0 ) {
5369 				jQuery.globalEval( data );
5370 			}
5371 		}
5372 
5373 		return data;
5374 	},
5375 
5376 	// Serialize an array of form elements or a set of
5377 	// key/values into a query string
5378 	param: function( a, traditional ) {
5379 		var s = [];
5380 		
5381 		// Set traditional to true for jQuery <= 1.3.2 behavior.
5382 		if ( traditional === undefined ) {
5383 			traditional = jQuery.ajaxSettings.traditional;
5384 		}
5385 		
5386 		// If an array was passed in, assume that it is an array of form elements.
5387 		if ( jQuery.isArray(a) || a.jquery ) {
5388 			// Serialize the form elements
5389 			jQuery.each( a, function() {
5390 				add( this.name, this.value );
5391 			});
5392 			
5393 		} else {
5394 			// If traditional, encode the "old" way (the way 1.3.2 or older
5395 			// did it), otherwise encode params recursively.
5396 			for ( var prefix in a ) {
5397 				buildParams( prefix, a[prefix] );
5398 			}
5399 		}
5400 
5401 		// Return the resulting serialization
5402 		return s.join("&").replace(r20, "+");
5403 
5404 		function buildParams( prefix, obj ) {
5405 			if ( jQuery.isArray(obj) ) {
5406 				// Serialize array item.
5407 				jQuery.each( obj, function( i, v ) {
5408 					if ( traditional || /\[\]$/.test( prefix ) ) {
5409 						// Treat each array item as a scalar.
5410 						add( prefix, v );
5411 					} else {
5412 						// If array item is non-scalar (array or object), encode its
5413 						// numeric index to resolve deserialization ambiguity issues.
5414 						// Note that rack (as of 1.0.0) can't currently deserialize
5415 						// nested arrays properly, and attempting to do so may cause
5416 						// a server error. Possible fixes are to modify rack's
5417 						// deserialization algorithm or to provide an option or flag
5418 						// to force array serialization to be shallow.
5419 						buildParams( prefix + "[" + ( typeof v === "object" || jQuery.isArray(v) ? i : "" ) + "]", v );
5420 					}
5421 				});
5422 					
5423 			} else if ( !traditional && obj != null && typeof obj === "object" ) {
5424 				// Serialize object item.
5425 				jQuery.each( obj, function( k, v ) {
5426 					buildParams( prefix + "[" + k + "]", v );
5427 				});
5428 					
5429 			} else {
5430 				// Serialize scalar item.
5431 				add( prefix, obj );
5432 			}
5433 		}
5434 
5435 		function add( key, value ) {
5436 			// If value is a function, invoke it and return its value
5437 			value = jQuery.isFunction(value) ? value() : value;
5438 			s[ s.length ] = encodeURIComponent(key) + "=" + encodeURIComponent(value);
5439 		}
5440 	}
5441 });
5442 var elemdisplay = {},
5443 	rfxtypes = /toggle|show|hide/,
5444 	rfxnum = /^([+-]=)?([\d+-.]+)(.*)$/,
5445 	timerId,
5446 	fxAttrs = [
5447 		// height animations
5448 		[ "height", "marginTop", "marginBottom", "paddingTop", "paddingBottom" ],
5449 		// width animations
5450 		[ "width", "marginLeft", "marginRight", "paddingLeft", "paddingRight" ],
5451 		// opacity animations
5452 		[ "opacity" ]
5453 	];
5454 
5455 jQuery.fn.extend({
5456 	show: function( speed, callback ) {
5457 		if ( speed || speed === 0) {
5458 			return this.animate( genFx("show", 3), speed, callback);
5459 
5460 		} else {
5461 			for ( var i = 0, l = this.length; i < l; i++ ) {
5462 				var old = jQuery.data(this[i], "olddisplay");
5463 
5464 				this[i].style.display = old || "";
5465 
5466 				if ( jQuery.css(this[i], "display") === "none" ) {
5467 					var nodeName = this[i].nodeName, display;
5468 
5469 					if ( elemdisplay[ nodeName ] ) {
5470 						display = elemdisplay[ nodeName ];
5471 
5472 					} else {
5473 						var elem = jQuery("<" + nodeName + " />").appendTo("body");
5474 
5475 						display = elem.css("display");
5476 
5477 						if ( display === "none" ) {
5478 							display = "block";
5479 						}
5480 
5481 						elem.remove();
5482 
5483 						elemdisplay[ nodeName ] = display;
5484 					}
5485 
5486 					jQuery.data(this[i], "olddisplay", display);
5487 				}
5488 			}
5489 
5490 			// Set the display of the elements in a second loop
5491 			// to avoid the constant reflow
5492 			for ( var j = 0, k = this.length; j < k; j++ ) {
5493 				this[j].style.display = jQuery.data(this[j], "olddisplay") || "";
5494 			}
5495 
5496 			return this;
5497 		}
5498 	},
5499 
5500 	hide: function( speed, callback ) {
5501 		if ( speed || speed === 0 ) {
5502 			return this.animate( genFx("hide", 3), speed, callback);
5503 
5504 		} else {
5505 			for ( var i = 0, l = this.length; i < l; i++ ) {
5506 				var old = jQuery.data(this[i], "olddisplay");
5507 				if ( !old && old !== "none" ) {
5508 					jQuery.data(this[i], "olddisplay", jQuery.css(this[i], "display"));
5509 				}
5510 			}
5511 
5512 			// Set the display of the elements in a second loop
5513 			// to avoid the constant reflow
5514 			for ( var j = 0, k = this.length; j < k; j++ ) {
5515 				this[j].style.display = "none";
5516 			}
5517 
5518 			return this;
5519 		}
5520 	},
5521 
5522 	// Save the old toggle function
5523 	_toggle: jQuery.fn.toggle,
5524 
5525 	toggle: function( fn, fn2 ) {
5526 		var bool = typeof fn === "boolean";
5527 
5528 		if ( jQuery.isFunction(fn) && jQuery.isFunction(fn2) ) {
5529 			this._toggle.apply( this, arguments );
5530 
5531 		} else if ( fn == null || bool ) {
5532 			this.each(function() {
5533 				var state = bool ? fn : jQuery(this).is(":hidden");
5534 				jQuery(this)[ state ? "show" : "hide" ]();
5535 			});
5536 
5537 		} else {
5538 			this.animate(genFx("toggle", 3), fn, fn2);
5539 		}
5540 
5541 		return this;
5542 	},
5543 
5544 	fadeTo: function( speed, to, callback ) {
5545 		return this.filter(":hidden").css("opacity", 0).show().end()
5546 					.animate({opacity: to}, speed, callback);
5547 	},
5548 
5549 	animate: function( prop, speed, easing, callback ) {
5550 		var optall = jQuery.speed(speed, easing, callback);
5551 
5552 		if ( jQuery.isEmptyObject( prop ) ) {
5553 			return this.each( optall.complete );
5554 		}
5555 
5556 		return this[ optall.queue === false ? "each" : "queue" ](function() {
5557 			var opt = jQuery.extend({}, optall), p,
5558 				hidden = this.nodeType === 1 && jQuery(this).is(":hidden"),
5559 				self = this;
5560 
5561 			for ( p in prop ) {
5562 				var name = p.replace(rdashAlpha, fcamelCase);
5563 
5564 				if ( p !== name ) {
5565 					prop[ name ] = prop[ p ];
5566 					delete prop[ p ];
5567 					p = name;
5568 				}
5569 
5570 				if ( prop[p] === "hide" && hidden || prop[p] === "show" && !hidden ) {
5571 					return opt.complete.call(this);
5572 				}
5573 
5574 				if ( ( p === "height" || p === "width" ) && this.style ) {
5575 					// Store display property
5576 					opt.display = jQuery.css(this, "display");
5577 
5578 					// Make sure that nothing sneaks out
5579 					opt.overflow = this.style.overflow;
5580 				}
5581 
5582 				if ( jQuery.isArray( prop[p] ) ) {
5583 					// Create (if needed) and add to specialEasing
5584 					(opt.specialEasing = opt.specialEasing || {})[p] = prop[p][1];
5585 					prop[p] = prop[p][0];
5586 				}
5587 			}
5588 
5589 			if ( opt.overflow != null ) {
5590 				this.style.overflow = "hidden";
5591 			}
5592 
5593 			opt.curAnim = jQuery.extend({}, prop);
5594 
5595 			jQuery.each( prop, function( name, val ) {
5596 				var e = new jQuery.fx( self, opt, name );
5597 
5598 				if ( rfxtypes.test(val) ) {
5599 					e[ val === "toggle" ? hidden ? "show" : "hide" : val ]( prop );
5600 
5601 				} else {
5602 					var parts = rfxnum.exec(val),
5603 						start = e.cur(true) || 0;
5604 
5605 					if ( parts ) {
5606 						var end = parseFloat( parts[2] ),
5607 							unit = parts[3] || "px";
5608 
5609 						// We need to compute starting value
5610 						if ( unit !== "px" ) {
5611 							self.style[ name ] = (end || 1) + unit;
5612 							start = ((end || 1) / e.cur(true)) * start;
5613 							self.style[ name ] = start + unit;
5614 						}
5615 
5616 						// If a +=/-= token was provided, we're doing a relative animation
5617 						if ( parts[1] ) {
5618 							end = ((parts[1] === "-=" ? -1 : 1) * end) + start;
5619 						}
5620 
5621 						e.custom( start, end, unit );
5622 
5623 					} else {
5624 						e.custom( start, val, "" );
5625 					}
5626 				}
5627 			});
5628 
5629 			// For JS strict compliance
5630 			return true;
5631 		});
5632 	},
5633 
5634 	stop: function( clearQueue, gotoEnd ) {
5635 		var timers = jQuery.timers;
5636 
5637 		if ( clearQueue ) {
5638 			this.queue([]);
5639 		}
5640 
5641 		this.each(function() {
5642 			// go in reverse order so anything added to the queue during the loop is ignored
5643 			for ( var i = timers.length - 1; i >= 0; i-- ) {
5644 				if ( timers[i].elem === this ) {
5645 					if (gotoEnd) {
5646 						// force the next step to be the last
5647 						timers[i](true);
5648 					}
5649 
5650 					timers.splice(i, 1);
5651 				}
5652 			}
5653 		});
5654 
5655 		// start the next in the queue if the last step wasn't forced
5656 		if ( !gotoEnd ) {
5657 			this.dequeue();
5658 		}
5659 
5660 		return this;
5661 	}
5662 
5663 });
5664 
5665 // Generate shortcuts for custom animations
5666 jQuery.each({
5667 	slideDown: genFx("show", 1),
5668 	slideUp: genFx("hide", 1),
5669 	slideToggle: genFx("toggle", 1),
5670 	fadeIn: { opacity: "show" },
5671 	fadeOut: { opacity: "hide" }
5672 }, function( name, props ) {
5673 	jQuery.fn[ name ] = function( speed, callback ) {
5674 		return this.animate( props, speed, callback );
5675 	};
5676 });
5677 
5678 jQuery.extend({
5679 	speed: function( speed, easing, fn ) {
5680 		var opt = speed && typeof speed === "object" ? speed : {
5681 			complete: fn || !fn && easing ||
5682 				jQuery.isFunction( speed ) && speed,
5683 			duration: speed,
5684 			easing: fn && easing || easing && !jQuery.isFunction(easing) && easing
5685 		};
5686 
5687 		opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
5688 			jQuery.fx.speeds[opt.duration] || jQuery.fx.speeds._default;
5689 
5690 		// Queueing
5691 		opt.old = opt.complete;
5692 		opt.complete = function() {
5693 			if ( opt.queue !== false ) {
5694 				jQuery(this).dequeue();
5695 			}
5696 			if ( jQuery.isFunction( opt.old ) ) {
5697 				opt.old.call( this );
5698 			}
5699 		};
5700 
5701 		return opt;
5702 	},
5703 
5704 	easing: {
5705 		linear: function( p, n, firstNum, diff ) {
5706 			return firstNum + diff * p;
5707 		},
5708 		swing: function( p, n, firstNum, diff ) {
5709 			return ((-Math.cos(p*Math.PI)/2) + 0.5) * diff + firstNum;
5710 		}
5711 	},
5712 
5713 	timers: [],
5714 
5715 	fx: function( elem, options, prop ) {
5716 		this.options = options;
5717 		this.elem = elem;
5718 		this.prop = prop;
5719 
5720 		if ( !options.orig ) {
5721 			options.orig = {};
5722 		}
5723 	}
5724 
5725 });
5726 
5727 jQuery.fx.prototype = {
5728 	// Simple function for setting a style value
5729 	update: function() {
5730 		if ( this.options.step ) {
5731 			this.options.step.call( this.elem, this.now, this );
5732 		}
5733 
5734 		(jQuery.fx.step[this.prop] || jQuery.fx.step._default)( this );
5735 
5736 		// Set display property to block for height/width animations
5737 		if ( ( this.prop === "height" || this.prop === "width" ) && this.elem.style ) {
5738 			this.elem.style.display = "block";
5739 		}
5740 	},
5741 
5742 	// Get the current size
5743 	cur: function( force ) {
5744 		if ( this.elem[this.prop] != null && (!this.elem.style || this.elem.style[this.prop] == null) ) {
5745 			return this.elem[ this.prop ];
5746 		}
5747 
5748 		var r = parseFloat(jQuery.css(this.elem, this.prop, force));
5749 		return r && r > -10000 ? r : parseFloat(jQuery.curCSS(this.elem, this.prop)) || 0;
5750 	},
5751 
5752 	// Start an animation from one number to another
5753 	custom: function( from, to, unit ) {
5754 		this.startTime = now();
5755 		this.start = from;
5756 		this.end = to;
5757 		this.unit = unit || this.unit || "px";
5758 		this.now = this.start;
5759 		this.pos = this.state = 0;
5760 
5761 		var self = this;
5762 		function t( gotoEnd ) {
5763 			return self.step(gotoEnd);
5764 		}
5765 
5766 		t.elem = this.elem;
5767 
5768 		if ( t() && jQuery.timers.push(t) && !timerId ) {
5769 			timerId = setInterval(jQuery.fx.tick, 13);
5770 		}
5771 	},
5772 
5773 	// Simple 'show' function
5774 	show: function() {
5775 		// Remember where we started, so that we can go back to it later
5776 		this.options.orig[this.prop] = jQuery.style( this.elem, this.prop );
5777 		this.options.show = true;
5778 
5779 		// Begin the animation
5780 		// Make sure that we start at a small width/height to avoid any
5781 		// flash of content
5782 		this.custom(this.prop === "width" || this.prop === "height" ? 1 : 0, this.cur());
5783 
5784 		// Start by showing the element
5785 		jQuery( this.elem ).show();
5786 	},
5787 
5788 	// Simple 'hide' function
5789 	hide: function() {
5790 		// Remember where we started, so that we can go back to it later
5791 		this.options.orig[this.prop] = jQuery.style( this.elem, this.prop );
5792 		this.options.hide = true;
5793 
5794 		// Begin the animation
5795 		this.custom(this.cur(), 0);
5796 	},
5797 
5798 	// Each step of an animation
5799 	step: function( gotoEnd ) {
5800 		var t = now(), done = true;
5801 
5802 		if ( gotoEnd || t >= this.options.duration + this.startTime ) {
5803 			this.now = this.end;
5804 			this.pos = this.state = 1;
5805 			this.update();
5806 
5807 			this.options.curAnim[ this.prop ] = true;
5808 
5809 			for ( var i in this.options.curAnim ) {
5810 				if ( this.options.curAnim[i] !== true ) {
5811 					done = false;
5812 				}
5813 			}
5814 
5815 			if ( done ) {
5816 				if ( this.options.display != null ) {
5817 					// Reset the overflow
5818 					this.elem.style.overflow = this.options.overflow;
5819 
5820 					// Reset the display
5821 					var old = jQuery.data(this.elem, "olddisplay");
5822 					this.elem.style.display = old ? old : this.options.display;
5823 
5824 					if ( jQuery.css(this.elem, "display") === "none" ) {
5825 						this.elem.style.display = "block";
5826 					}
5827 				}
5828 
5829 				// Hide the element if the "hide" operation was done
5830 				if ( this.options.hide ) {
5831 					jQuery(this.elem).hide();
5832 				}
5833 
5834 				// Reset the properties, if the item has been hidden or shown
5835 				if ( this.options.hide || this.options.show ) {
5836 					for ( var p in this.options.curAnim ) {
5837 						jQuery.style(this.elem, p, this.options.orig[p]);
5838 					}
5839 				}
5840 
5841 				// Execute the complete function
5842 				this.options.complete.call( this.elem );
5843 			}
5844 
5845 			return false;
5846 
5847 		} else {
5848 			var n = t - this.startTime;
5849 			this.state = n / this.options.duration;
5850 
5851 			// Perform the easing function, defaults to swing
5852 			var specialEasing = this.options.specialEasing && this.options.specialEasing[this.prop];
5853 			var defaultEasing = this.options.easing || (jQuery.easing.swing ? "swing" : "linear");
5854 			this.pos = jQuery.easing[specialEasing || defaultEasing](this.state, n, 0, 1, this.options.duration);
5855 			this.now = this.start + ((this.end - this.start) * this.pos);
5856 
5857 			// Perform the next step of the animation
5858 			this.update();
5859 		}
5860 
5861 		return true;
5862 	}
5863 };
5864 
5865 jQuery.extend( jQuery.fx, {
5866 	tick: function() {
5867 		var timers = jQuery.timers;
5868 
5869 		for ( var i = 0; i < timers.length; i++ ) {
5870 			if ( !timers[i]() ) {
5871 				timers.splice(i--, 1);
5872 			}
5873 		}
5874 
5875 		if ( !timers.length ) {
5876 			jQuery.fx.stop();
5877 		}
5878 	},
5879 		
5880 	stop: function() {
5881 		clearInterval( timerId );
5882 		timerId = null;
5883 	},
5884 	
5885 	speeds: {
5886 		slow: 600,
5887  		fast: 200,
5888  		// Default speed
5889  		_default: 400
5890 	},
5891 
5892 	step: {
5893 		opacity: function( fx ) {
5894 			jQuery.style(fx.elem, "opacity", fx.now);
5895 		},
5896 
5897 		_default: function( fx ) {
5898 			if ( fx.elem.style && fx.elem.style[ fx.prop ] != null ) {
5899 				fx.elem.style[ fx.prop ] = (fx.prop === "width" || fx.prop === "height" ? Math.max(0, fx.now) : fx.now) + fx.unit;
5900 			} else {
5901 				fx.elem[ fx.prop ] = fx.now;
5902 			}
5903 		}
5904 	}
5905 });
5906 
5907 if ( jQuery.expr && jQuery.expr.filters ) {
5908 	jQuery.expr.filters.animated = function( elem ) {
5909 		return jQuery.grep(jQuery.timers, function( fn ) {
5910 			return elem === fn.elem;
5911 		}).length;
5912 	};
5913 }
5914 
5915 function genFx( type, num ) {
5916 	var obj = {};
5917 
5918 	jQuery.each( fxAttrs.concat.apply([], fxAttrs.slice(0,num)), function() {
5919 		obj[ this ] = type;
5920 	});
5921 
5922 	return obj;
5923 }
5924 if ( "getBoundingClientRect" in document.documentElement ) {
5925 	jQuery.fn.offset = function( options ) {
5926 		var elem = this[0];
5927 
5928 		if ( options ) { 
5929 			return this.each(function( i ) {
5930 				jQuery.offset.setOffset( this, options, i );
5931 			});
5932 		}
5933 
5934 		if ( !elem || !elem.ownerDocument ) {
5935 			return null;
5936 		}
5937 
5938 		if ( elem === elem.ownerDocument.body ) {
5939 			return jQuery.offset.bodyOffset( elem );
5940 		}
5941 
5942 		var box = elem.getBoundingClientRect(), doc = elem.ownerDocument, body = doc.body, docElem = doc.documentElement,
5943 			clientTop = docElem.clientTop || body.clientTop || 0, clientLeft = docElem.clientLeft || body.clientLeft || 0,
5944 			top  = box.top  + (self.pageYOffset || jQuery.support.boxModel && docElem.scrollTop  || body.scrollTop ) - clientTop,
5945 			left = box.left + (self.pageXOffset || jQuery.support.boxModel && docElem.scrollLeft || body.scrollLeft) - clientLeft;
5946 
5947 		return { top: top, left: left };
5948 	};
5949 
5950 } else {
5951 	jQuery.fn.offset = function( options ) {
5952 		var elem = this[0];
5953 
5954 		if ( options ) { 
5955 			return this.each(function( i ) {
5956 				jQuery.offset.setOffset( this, options, i );
5957 			});
5958 		}
5959 
5960 		if ( !elem || !elem.ownerDocument ) {
5961 			return null;
5962 		}
5963 
5964 		if ( elem === elem.ownerDocument.body ) {
5965 			return jQuery.offset.bodyOffset( elem );
5966 		}
5967 
5968 		jQuery.offset.initialize();
5969 
5970 		var offsetParent = elem.offsetParent, prevOffsetParent = elem,
5971 			doc = elem.ownerDocument, computedStyle, docElem = doc.documentElement,
5972 			body = doc.body, defaultView = doc.defaultView,
5973 			prevComputedStyle = defaultView ? defaultView.getComputedStyle( elem, null ) : elem.currentStyle,
5974 			top = elem.offsetTop, left = elem.offsetLeft;
5975 
5976 		while ( (elem = elem.parentNode) && elem !== body && elem !== docElem ) {
5977 			if ( jQuery.offset.supportsFixedPosition && prevComputedStyle.position === "fixed" ) {
5978 				break;
5979 			}
5980 
5981 			computedStyle = defaultView ? defaultView.getComputedStyle(elem, null) : elem.currentStyle;
5982 			top  -= elem.scrollTop;
5983 			left -= elem.scrollLeft;
5984 
5985 			if ( elem === offsetParent ) {
5986 				top  += elem.offsetTop;
5987 				left += elem.offsetLeft;
5988 
5989 				if ( jQuery.offset.doesNotAddBorder && !(jQuery.offset.doesAddBorderForTableAndCells && /^t(able|d|h)$/i.test(elem.nodeName)) ) {
5990 					top  += parseFloat( computedStyle.borderTopWidth  ) || 0;
5991 					left += parseFloat( computedStyle.borderLeftWidth ) || 0;
5992 				}
5993 
5994 				prevOffsetParent = offsetParent, offsetParent = elem.offsetParent;
5995 			}
5996 
5997 			if ( jQuery.offset.subtractsBorderForOverflowNotVisible && computedStyle.overflow !== "visible" ) {
5998 				top  += parseFloat( computedStyle.borderTopWidth  ) || 0;
5999 				left += parseFloat( computedStyle.borderLeftWidth ) || 0;
6000 			}
6001 
6002 			prevComputedStyle = computedStyle;
6003 		}
6004 
6005 		if ( prevComputedStyle.position === "relative" || prevComputedStyle.position === "static" ) {
6006 			top  += body.offsetTop;
6007 			left += body.offsetLeft;
6008 		}
6009 
6010 		if ( jQuery.offset.supportsFixedPosition && prevComputedStyle.position === "fixed" ) {
6011 			top  += Math.max( docElem.scrollTop, body.scrollTop );
6012 			left += Math.max( docElem.scrollLeft, body.scrollLeft );
6013 		}
6014 
6015 		return { top: top, left: left };
6016 	};
6017 }
6018 
6019 jQuery.offset = {
6020 	initialize: function() {
6021 		var body = document.body, container = document.createElement("div"), innerDiv, checkDiv, table, td, bodyMarginTop = parseFloat( jQuery.curCSS(body, "marginTop", true) ) || 0,
6022 			html = "<div style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;'><div></div></div><table style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;' cellpadding='0' cellspacing='0'><tr><td></td></tr></table>";
6023 
6024 		jQuery.extend( container.style, { position: "absolute", top: 0, left: 0, margin: 0, border: 0, width: "1px", height: "1px", visibility: "hidden" } );
6025 
6026 		container.innerHTML = html;
6027 		body.insertBefore( container, body.firstChild );
6028 		innerDiv = container.firstChild;
6029 		checkDiv = innerDiv.firstChild;
6030 		td = innerDiv.nextSibling.firstChild.firstChild;
6031 
6032 		this.doesNotAddBorder = (checkDiv.offsetTop !== 5);
6033 		this.doesAddBorderForTableAndCells = (td.offsetTop === 5);
6034 
6035 		checkDiv.style.position = "fixed", checkDiv.style.top = "20px";
6036 		// safari subtracts parent border width here which is 5px
6037 		this.supportsFixedPosition = (checkDiv.offsetTop === 20 || checkDiv.offsetTop === 15);
6038 		checkDiv.style.position = checkDiv.style.top = "";
6039 
6040 		innerDiv.style.overflow = "hidden", innerDiv.style.position = "relative";
6041 		this.subtractsBorderForOverflowNotVisible = (checkDiv.offsetTop === -5);
6042 
6043 		this.doesNotIncludeMarginInBodyOffset = (body.offsetTop !== bodyMarginTop);
6044 
6045 		body.removeChild( container );
6046 		body = container = innerDiv = checkDiv = table = td = null;
6047 		jQuery.offset.initialize = jQuery.noop;
6048 	},
6049 
6050 	bodyOffset: function( body ) {
6051 		var top = body.offsetTop, left = body.offsetLeft;
6052 
6053 		jQuery.offset.initialize();
6054 
6055 		if ( jQuery.offset.doesNotIncludeMarginInBodyOffset ) {
6056 			top  += parseFloat( jQuery.curCSS(body, "marginTop",  true) ) || 0;
6057 			left += parseFloat( jQuery.curCSS(body, "marginLeft", true) ) || 0;
6058 		}
6059 
6060 		return { top: top, left: left };
6061 	},
6062 	
6063 	setOffset: function( elem, options, i ) {
6064 		// set position first, in-case top/left are set even on static elem
6065 		if ( /static/.test( jQuery.curCSS( elem, "position" ) ) ) {
6066 			elem.style.position = "relative";
6067 		}
6068 		var curElem   = jQuery( elem ),
6069 			curOffset = curElem.offset(),
6070 			curTop    = parseInt( jQuery.curCSS( elem, "top",  true ), 10 ) || 0,
6071 			curLeft   = parseInt( jQuery.curCSS( elem, "left", true ), 10 ) || 0;
6072 
6073 		if ( jQuery.isFunction( options ) ) {
6074 			options = options.call( elem, i, curOffset );
6075 		}
6076 
6077 		var props = {
6078 			top:  (options.top  - curOffset.top)  + curTop,
6079 			left: (options.left - curOffset.left) + curLeft
6080 		};
6081 		
6082 		if ( "using" in options ) {
6083 			options.using.call( elem, props );
6084 		} else {
6085 			curElem.css( props );
6086 		}
6087 	}
6088 };
6089 
6090 
6091 jQuery.fn.extend({
6092 	position: function() {
6093 		if ( !this[0] ) {
6094 			return null;
6095 		}
6096 
6097 		var elem = this[0],
6098 
6099 		// Get *real* offsetParent
6100 		offsetParent = this.offsetParent(),
6101 
6102 		// Get correct offsets
6103 		offset       = this.offset(),
6104 		parentOffset = /^body|html$/i.test(offsetParent[0].nodeName) ? { top: 0, left: 0 } : offsetParent.offset();
6105 
6106 		// Subtract element margins
6107 		// note: when an element has margin: auto the offsetLeft and marginLeft
6108 		// are the same in Safari causing offset.left to incorrectly be 0
6109 		offset.top  -= parseFloat( jQuery.curCSS(elem, "marginTop",  true) ) || 0;
6110 		offset.left -= parseFloat( jQuery.curCSS(elem, "marginLeft", true) ) || 0;
6111 
6112 		// Add offsetParent borders
6113 		parentOffset.top  += parseFloat( jQuery.curCSS(offsetParent[0], "borderTopWidth",  true) ) || 0;
6114 		parentOffset.left += parseFloat( jQuery.curCSS(offsetParent[0], "borderLeftWidth", true) ) || 0;
6115 
6116 		// Subtract the two offsets
6117 		return {
6118 			top:  offset.top  - parentOffset.top,
6119 			left: offset.left - parentOffset.left
6120 		};
6121 	},
6122 
6123 	offsetParent: function() {
6124 		return this.map(function() {
6125 			var offsetParent = this.offsetParent || document.body;
6126 			while ( offsetParent && (!/^body|html$/i.test(offsetParent.nodeName) && jQuery.css(offsetParent, "position") === "static") ) {
6127 				offsetParent = offsetParent.offsetParent;
6128 			}
6129 			return offsetParent;
6130 		});
6131 	}
6132 });
6133 
6134 
6135 // Create scrollLeft and scrollTop methods
6136 jQuery.each( ["Left", "Top"], function( i, name ) {
6137 	var method = "scroll" + name;
6138 
6139 	jQuery.fn[ method ] = function(val) {
6140 		var elem = this[0], win;
6141 		
6142 		if ( !elem ) {
6143 			return null;
6144 		}
6145 
6146 		if ( val !== undefined ) {
6147 			// Set the scroll offset
6148 			return this.each(function() {
6149 				win = getWindow( this );
6150 
6151 				if ( win ) {
6152 					win.scrollTo(
6153 						!i ? val : jQuery(win).scrollLeft(),
6154 						 i ? val : jQuery(win).scrollTop()
6155 					);
6156 
6157 				} else {
6158 					this[ method ] = val;
6159 				}
6160 			});
6161 		} else {
6162 			win = getWindow( elem );
6163 
6164 			// Return the scroll offset
6165 			return win ? ("pageXOffset" in win) ? win[ i ? "pageYOffset" : "pageXOffset" ] :
6166 				jQuery.support.boxModel && win.document.documentElement[ method ] ||
6167 					win.document.body[ method ] :
6168 				elem[ method ];
6169 		}
6170 	};
6171 });
6172 
6173 function getWindow( elem ) {
6174 	return ("scrollTo" in elem && elem.document) ?
6175 		elem :
6176 		elem.nodeType === 9 ?
6177 			elem.defaultView || elem.parentWindow :
6178 			false;
6179 }
6180 // Create innerHeight, innerWidth, outerHeight and outerWidth methods
6181 jQuery.each([ "Height", "Width" ], function( i, name ) {
6182 
6183 	var type = name.toLowerCase();
6184 
6185 	// innerHeight and innerWidth
6186 	jQuery.fn["inner" + name] = function() {
6187 		return this[0] ?
6188 			jQuery.css( this[0], type, false, "padding" ) :
6189 			null;
6190 	};
6191 
6192 	// outerHeight and outerWidth
6193 	jQuery.fn["outer" + name] = function( margin ) {
6194 		return this[0] ?
6195 			jQuery.css( this[0], type, false, margin ? "margin" : "border" ) :
6196 			null;
6197 	};
6198 
6199 	jQuery.fn[ type ] = function( size ) {
6200 		// Get window width or height
6201 		var elem = this[0];
6202 		if ( !elem ) {
6203 			return size == null ? null : this;
6204 		}
6205 		
6206 		if ( jQuery.isFunction( size ) ) {
6207 			return this.each(function( i ) {
6208 				var self = jQuery( this );
6209 				self[ type ]( size.call( this, i, self[ type ]() ) );
6210 			});
6211 		}
6212 
6213 		return ("scrollTo" in elem && elem.document) ? // does it walk and quack like a window?
6214 			// Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
6215 			elem.document.compatMode === "CSS1Compat" && elem.document.documentElement[ "client" + name ] ||
6216 			elem.document.body[ "client" + name ] :
6217 
6218 			// Get document width or height
6219 			(elem.nodeType === 9) ? // is it a document
6220 				// Either scroll[Width/Height] or offset[Width/Height], whichever is greater
6221 				Math.max(
6222 					elem.documentElement["client" + name],
6223 					elem.body["scroll" + name], elem.documentElement["scroll" + name],
6224 					elem.body["offset" + name], elem.documentElement["offset" + name]
6225 				) :
6226 
6227 				// Get or set width or height on the element
6228 				size === undefined ?
6229 					// Get width or height on the element
6230 					jQuery.css( elem, type ) :
6231 
6232 					// Set the width or height on the element (default to pixels if value is unitless)
6233 					this.css( type, typeof size === "string" ? size : size + "px" );
6234 	};
6235 
6236 });
6237 // Expose jQuery to the global object
6238 window.jQuery = window.$ = jQuery;
6239 
6240 })(window);