text: var rformElems = /^(?:textarea|input|select)$/i,
  	rtypenamespace = /^([^\.]*|)(?:\.(.+)|)$/,
  	rhoverHack = /(?:^|\s)hover(\.\S+|)\b/,
  	rkeyEvent = /^key/,
  	rmouseEvent = /^(?:mouse|contextmenu)|click/,
  	rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
  	hoverHack = function( events ) {
  		return jQuery.event.special.hover ? events : events.replace( rhoverHack, "mouseenter$1 mouseleave$1" );
  	};
  
  /*
   * Helper functions for managing events -- not part of the public interface.
   * Props to Dean Edwards' addEvent library for many of the ideas.
   */
  jQuery.event = {
  
  	add: function( elem, types, handler, data, selector ) {
  
  		var elemData, eventHandle, events,
  			t, tns, type, namespaces, handleObj,
  			handleObjIn, handlers, special;
  
  		// Don't attach events to noData or text/comment nodes (allow plain objects tho)
  		if ( elem.nodeType === 3 || elem.nodeType === 8 || !types || !handler || !(elemData = jQuery._data( elem )) ) {
  			return;
  		}
  
  		// Caller can pass in an object of custom data in lieu of the handler
  		if ( handler.handler ) {
  			handleObjIn = handler;
  			handler = handleObjIn.handler;
  			selector = handleObjIn.selector;
  		}
  
  		// Make sure that the handler has a unique ID, used to find/remove it later
  		if ( !handler.guid ) {
  			handler.guid = jQuery.guid++;
  		}
  
  		// Init the element's event structure and main handler, if this is the first
  		events = elemData.events;
  		if ( !events ) {
  			elemData.events = events = {};
  		}
  		eventHandle = elemData.handle;
  		if ( !eventHandle ) {
  			elemData.handle = eventHandle = function( e ) {
  				// Discard the second event of a jQuery.event.trigger() and
  				// when an event is called after a page has unloaded
  				return typeof jQuery !== "undefined" && (!e || jQuery.event.triggered !== e.type) ?
  					jQuery.event.dispatch.apply( eventHandle.elem, arguments ) :
  					undefined;
  			};
  			// Add elem as a property of the handle fn to prevent a memory leak with IE non-native events
  			eventHandle.elem = elem;
  		}
  
  		// Handle multiple events separated by a space
  		// jQuery(...).bind("mouseover mouseout", fn);
  		types = jQuery.trim( hoverHack(types) ).split( " " );
  		for ( t = 0; t < types.length; t++ ) {
  
  			tns = rtypenamespace.exec( types[t] ) || [];
  			type = tns[1];
  			namespaces = ( tns[2] || "" ).split( "." ).sort();
  
  			// If event changes its type, use the special event handlers for the changed type
  			special = jQuery.event.special[ type ] || {};
  
  			// If selector defined, determine special event api type, otherwise given type
  			type = ( selector ? special.delegateType : special.bindType ) || type;
  
  			// Update special based on newly reset type
  			special = jQuery.event.special[ type ] || {};
  
  			// handleObj is passed to all event handlers
  			handleObj = jQuery.extend({
  				type: type,
  				origType: tns[1],
  				data: data,
  				handler: handler,
  				guid: handler.guid,
  				selector: selector,
  				namespace: namespaces.join(".")
  			}, handleObjIn );
  
  			// Init the event handler queue if we're the first
  			handlers = events[ type ];
  			if ( !handlers ) {
  				handlers = events[ type ] = [];
  				handlers.delegateCount = 0;
  
  				// Only use addEventListener/attachEvent if the special events handler returns false
  				if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
  					// Bind the global event handler to the element
  					if ( elem.addEventListener ) {
  						elem.addEventListener( type, eventHandle, false );
  
  					} else if ( elem.attachEvent ) {
  						elem.attachEvent( "on" + type, eventHandle );
  					}
  				}
  			}
  
  			if ( special.add ) {
  				special.add.call( elem, handleObj );
  
  				if ( !handleObj.handler.guid ) {
  					handleObj.handler.guid = handler.guid;
  				}
  			}
  
  			// Add to the element's handler list, delegates in front
  			if ( selector ) {
  				handlers.splice( handlers.delegateCount++, 0, handleObj );
  			} else {
  				handlers.push( handleObj );
  			}
  
  			// Keep track of which events have ever been used, for event optimization
  			jQuery.event.global[ type ] = true;
  		}
  
  		// Nullify elem to prevent memory leaks in IE
  		elem = null;
  	},
  
  	global: {},
  
  	// Detach an event or set of events from an element
  	remove: function( elem, types, handler, selector, mappedTypes ) {
  
  		var t, tns, type, origType, namespaces, origCount,
  			j, events, special, eventType, handleObj,
  			elemData = jQuery.hasData( elem ) && jQuery._data( elem );
  
  		if ( !elemData || !(events = elemData.events) ) {
  			return;
  		}
  
  		// Once for each type.namespace in types; type may be omitted
  		types = jQuery.trim( hoverHack( types || "" ) ).split(" ");
  		for ( t = 0; t < types.length; t++ ) {
  			tns = rtypenamespace.exec( types[t] ) || [];
  			type = origType = tns[1];
  			namespaces = tns[2];
  
  			// Unbind all events (on this namespace, if provided) for the element
  			if ( !type ) {
  				for ( type in events ) {
  					jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
  				}
  				continue;
  			}
  
  			special = jQuery.event.special[ type ] || {};
  			type = ( selector? special.delegateType : special.bindType ) || type;
  			eventType = events[ type ] || [];
  			origCount = eventType.length;
  			namespaces = namespaces ? new RegExp("(^|\\.)" + namespaces.split(".").sort().join("\\.(?:.*\\.|)") + "(\\.|$)") : null;
  
  			// Remove matching events
  			for ( j = 0; j < eventType.length; j++ ) {
  				handleObj = eventType[ j ];
  
  				if ( ( mappedTypes || origType === handleObj.origType ) &&
  					 ( !handler || handler.guid === handleObj.guid ) &&
  					 ( !namespaces || namespaces.test( handleObj.namespace ) ) &&
  					 ( !selector || selector === handleObj.selector || selector === "**" && handleObj.selector ) ) {
  					eventType.splice( j--, 1 );
  
  					if ( handleObj.selector ) {
  						eventType.delegateCount--;
  					}
  					if ( special.remove ) {
  						special.remove.call( elem, handleObj );
  					}
  				}
  			}
  
  			// Remove generic event handler if we removed something and no more handlers exist
  			// (avoids potential for endless recursion during removal of special event handlers)
  			if ( eventType.length === 0 && origCount !== eventType.length ) {
  				if ( !special.teardown || special.teardown.call( elem, namespaces, elemData.handle ) === false ) {
  					jQuery.removeEvent( elem, type, elemData.handle );
  				}
  
  				delete events[ type ];
  			}
  		}
  
  		// Remove the expando if it's no longer used
  		if ( jQuery.isEmptyObject( events ) ) {
  			delete elemData.handle;
  
  			// removeData also checks for emptiness and clears the expando if empty
  			// so use it instead of delete
  			jQuery.removeData( elem, "events", true );
  		}
  	},
  
  	// Events that are safe to short-circuit if no handlers are attached.
  	// Native DOM events should not be added, they may have inline handlers.
  	customEvent: {
  		"getData": true,
  		"setData": true,
  		"changeData": true
  	},
  
  	trigger: function( event, data, elem, onlyHandlers ) {
  		// Don't do events on text and comment nodes
  		if ( elem && (elem.nodeType === 3 || elem.nodeType === 8) ) {
  			return;
  		}
  
  		// Event object or event type
  		var cache, exclusive, i, cur, old, ontype, special, handle, eventPath, bubbleType,
  			type = event.type || event,
  			namespaces = [];
  
  		// focus/blur morphs to focusin/out; ensure we're not firing them right now
  		if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
  			return;
  		}
  
  		if ( type.indexOf( "!" ) >= 0 ) {
  			// Exclusive events trigger only for the exact event (no namespaces)
  			type = type.slice(0, -1);
  			exclusive = true;
  		}
  
  		if ( type.indexOf( "." ) >= 0 ) {
  			// Namespaced trigger; create a regexp to match event type in handle()
  			namespaces = type.split(".");
  			type = namespaces.shift();
  			namespaces.sort();
  		}
  
  		if ( (!elem || jQuery.event.customEvent[ type ]) && !jQuery.event.global[ type ] ) {
  			// No jQuery handlers for this event type, and it can't have inline handlers
  			return;
  		}
  
  		// Caller can pass in an Event, Object, or just an event type string
  		event = typeof event === "object" ?
  			// jQuery.Event object
  			event[ jQuery.expando ] ? event :
  			// Object literal
  			new jQuery.Event( type, event ) :
  			// Just the event type (string)
  			new jQuery.Event( type );
  
  		event.type = type;
  		event.isTrigger = true;
  		event.exclusive = exclusive;
  		event.namespace = namespaces.join( "." );
  		event.namespace_re = event.namespace? new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)") : null;
  		ontype = type.indexOf( ":" ) < 0 ? "on" + type : "";
  
  		// Handle a global trigger
  		if ( !elem ) {
  
  			// TODO: Stop taunting the data cache; remove global events and always attach to document
  			cache = jQuery.cache;
  			for ( i in cache ) {
  				if ( cache[ i ].events && cache[ i ].events[ type ] ) {
  					jQuery.event.trigger( event, data, cache[ i ].handle.elem, true );
  				}
  			}
  			return;
  		}
  
  		// Clean up the event in case it is being reused
  		event.result = undefined;
  		if ( !event.target ) {
  			event.target = elem;
  		}
  
  		// Clone any incoming data and prepend the event, creating the handler arg list
  		data = data != null ? jQuery.makeArray( data ) : [];
  		data.unshift( event );
  
  		// Allow special events to draw outside the lines
  		special = jQuery.event.special[ type ] || {};
  		if ( special.trigger && special.trigger.apply( elem, data ) === false ) {
  			return;
  		}
  
  		// Determine event propagation path in advance, per W3C events spec (#9951)
  		// Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
  		eventPath = [[ elem, special.bindType || type ]];
  		if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) {
  
  			bubbleType = special.delegateType || type;
  			cur = rfocusMorph.test( bubbleType + type ) ? elem : elem.parentNode;
  			for ( old = elem; cur; cur = cur.parentNode ) {
  				eventPath.push([ cur, bubbleType ]);
  				old = cur;
  			}
  
  			// Only add window if we got to document (e.g., not plain obj or detached DOM)
  			if ( old === (elem.ownerDocument || document) ) {
  				eventPath.push([ old.defaultView || old.parentWindow || window, bubbleType ]);
  			}
  		}
  
  		// Fire handlers on the event path
  		for ( i = 0; i < eventPath.length && !event.isPropagationStopped(); i++ ) {
  
  			cur = eventPath[i][0];
  			event.type = eventPath[i][1];
  
  			handle = ( jQuery._data( cur, "events" ) || {} )[ event.type ] && jQuery._data( cur, "handle" );
  			if ( handle ) {
  				handle.apply( cur, data );
  			}
  			// Note that this is a bare JS function and not a jQuery handler
  			handle = ontype && cur[ ontype ];
  			if ( handle && jQuery.acceptData( cur ) && handle.apply( cur, data ) === false ) {
  				event.preventDefault();
  			}
  		}
  		event.type = type;
  
  		// If nobody prevented the default action, do it now
  		if ( !onlyHandlers && !event.isDefaultPrevented() ) {
  
  			if ( (!special._default || special._default.apply( elem.ownerDocument, data ) === false) &&
  				!(type === "click" && jQuery.nodeName( elem, "a" )) && jQuery.acceptData( elem ) ) {
  
  				// Call a native DOM method on the target with the same name name as the event.
  				// Can't use an .isFunction() check here because IE6/7 fails that test.
  				// Don't do default actions on window, that's where global variables be (#6170)
  				// IE<9 dies on focus/blur to hidden element (#1486)
  				if ( ontype && elem[ type ] && ((type !== "focus" && type !== "blur") || event.target.offsetWidth !== 0) && !jQuery.isWindow( elem ) ) {
  
  					// Don't re-trigger an onFOO event when we call its FOO() method
  					old = elem[ ontype ];
  
  					if ( old ) {
  						elem[ ontype ] = null;
  					}
  
  					// Prevent re-triggering of the same event, since we already bubbled it above
  					jQuery.event.triggered = type;
  					elem[ type ]();
  					jQuery.event.triggered = undefined;
  
  					if ( old ) {
  						elem[ ontype ] = old;
  					}
  				}
  			}
  		}
  
  		return event.result;
  	},
  
  	dispatch: function( event ) {
  
  		// Make a writable jQuery.Event from the native event object
  		event = jQuery.event.fix( event || window.event );
  
  		var i, j, cur, jqcur, ret, selMatch, matched, matches, handleObj, sel, related,
  			handlers = ( (jQuery._data( this, "events" ) || {} )[ event.type ] || []),
  			delegateCount = handlers.delegateCount,
  			args = [].slice.call( arguments ),
  			run_all = !event.exclusive && !event.namespace,
  			special = jQuery.event.special[ event.type ] || {},
  			handlerQueue = [];
  
  		// Use the fix-ed jQuery.Event rather than the (read-only) native event
  		args[0] = event;
  		event.delegateTarget = this;
  
  		// Call the preDispatch hook for the mapped type, and let it bail if desired
  		if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
  			return;
  		}
  
  		// Determine handlers that should run if there are delegated events
  		// Avoid non-left-click bubbling in Firefox (#3861)
  		if ( delegateCount && !(event.button && event.type === "click") ) {
  
  			// Pregenerate a single jQuery object for reuse with .is()
  			jqcur = jQuery(this);
  			jqcur.context = this;
  
  			for ( cur = event.target; cur != this; cur = cur.parentNode || this ) {
  
  				// Don't process clicks (ONLY) on disabled elements (#6911, #8165, #xxxx)
  				if ( cur.disabled !== true || event.type !== "click" ) {
  					selMatch = {};
  					matches = [];
  					jqcur[0] = cur;
  					for ( i = 0; i < delegateCount; i++ ) {
  						handleObj = handlers[ i ];
  						sel = handleObj.selector;
  
  						if ( selMatch[ sel ] === undefined ) {
  							selMatch[ sel ] = jqcur.is( sel );
  						}
  						if ( selMatch[ sel ] ) {
  							matches.push( handleObj );
  						}
  					}
  					if ( matches.length ) {
  						handlerQueue.push({ elem: cur, matches: matches });
  					}
  				}
  			}
  		}
  
  		// Add the remaining (directly-bound) handlers
  		if ( handlers.length > delegateCount ) {
  			handlerQueue.push({ elem: this, matches: handlers.slice( delegateCount ) });
  		}
  
  		// Run delegates first; they may want to stop propagation beneath us
  		for ( i = 0; i < handlerQueue.length && !event.isPropagationStopped(); i++ ) {
  			matched = handlerQueue[ i ];
  			event.currentTarget = matched.elem;
  
  			for ( j = 0; j < matched.matches.length && !event.isImmediatePropagationStopped(); j++ ) {
  				handleObj = matched.matches[ j ];
  
  				// Triggered event must either 1) be non-exclusive and have no namespace, or
  				// 2) have namespace(s) a subset or equal to those in the bound event (both can have no namespace).
  				if ( run_all || (!event.namespace && !handleObj.namespace) || event.namespace_re && event.namespace_re.test( handleObj.namespace ) ) {
  
  					event.data = handleObj.data;
  					event.handleObj = handleObj;
  
  					ret = ( (jQuery.event.special[ handleObj.origType ] || {}).handle || handleObj.handler )
  							.apply( matched.elem, args );
  
  					if ( ret !== undefined ) {
  						event.result = ret;
  						if ( ret === false ) {
  							event.preventDefault();
  							event.stopPropagation();
  						}
  					}
  				}
  			}
  		}
  
  		// Call the postDispatch hook for the mapped type
  		if ( special.postDispatch ) {
  			special.postDispatch.call( this, event );
  		}
  
  		return event.result;
  	},
  
  	// Includes some event props shared by KeyEvent and MouseEvent
  	// *** attrChange attrName relatedNode srcElement  are not normalized, non-W3C, deprecated, will be removed in 1.8 ***
  	props: "attrChange attrName relatedNode srcElement altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),
  
  	fixHooks: {},
  
  	keyHooks: {
  		props: "char charCode key keyCode".split(" "),
  		filter: function( event, original ) {
  
  			// Add which for key events
  			if ( event.which == null ) {
  				event.which = original.charCode != null ? original.charCode : original.keyCode;
  			}
  
  			return event;
  		}
  	},
  
  	mouseHooks: {
  		props: "button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "),
  		filter: function( event, original ) {
  			var eventDoc, doc, body,
  				button = original.button,
  				fromElement = original.fromElement;
  
  			// Calculate pageX/Y if missing and clientX/Y available
  			if ( event.pageX == null && original.clientX != null ) {
  				eventDoc = event.target.ownerDocument || document;
  				doc = eventDoc.documentElement;
  				body = eventDoc.body;
  
  				event.pageX = original.clientX + ( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) - ( doc && doc.clientLeft || body && body.clientLeft || 0 );
  				event.pageY = original.clientY + ( doc && doc.scrollTop  || body && body.scrollTop  || 0 ) - ( doc && doc.clientTop  || body && body.clientTop  || 0 );
  			}
  
  			// Add relatedTarget, if necessary
  			if ( !event.relatedTarget && fromElement ) {
  				event.relatedTarget = fromElement === event.target ? original.toElement : fromElement;
  			}
  
  			// Add which for click: 1 === left; 2 === middle; 3 === right
  			// Note: button is not normalized, so don't use it
  			if ( !event.which && button !== undefined ) {
  				event.which = ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) );
  			}
  
  			return event;
  		}
  	},
  
  	fix: function( event ) {
  		if ( event[ jQuery.expando ] ) {
  			return event;
  		}
  
  		// Create a writable copy of the event object and normalize some properties
  		var i, prop,
  			originalEvent = event,
  			fixHook = jQuery.event.fixHooks[ event.type ] || {},
  			copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props;
  
  		event = jQuery.Event( originalEvent );
  
  		for ( i = copy.length; i; ) {
  			prop = copy[ --i ];
  			event[ prop ] = originalEvent[ prop ];
  		}
  
  		// Fix target property, if necessary (#1925, IE 6/7/8 & Safari2)
  		if ( !event.target ) {
  			event.target = originalEvent.srcElement || document;
  		}
  
  		// Target should not be a text node (#504, Safari)
  		if ( event.target.nodeType === 3 ) {
  			event.target = event.target.parentNode;
  		}
  
  		// For mouse/key events, metaKey==false if it's undefined (#3368, #11328; IE6/7/8)
  		event.metaKey = !!event.metaKey;
  
  		return fixHook.filter? fixHook.filter( event, originalEvent ) : event;
  	},
  
  	special: {
  		ready: {
  			// Make sure the ready event is setup
  			setup: jQuery.bindReady
  		},
  
  		load: {
  			// Prevent triggered image.load events from bubbling to window.load
  			noBubble: true
  		},
  
  		focus: {
  			delegateType: "focusin"
  		},
  		blur: {
  			delegateType: "focusout"
  		},
  
  		beforeunload: {
  			setup: function( data, namespaces, eventHandle ) {
  				// We only want to do this special case on windows
  				if ( jQuery.isWindow( this ) ) {
  					this.onbeforeunload = eventHandle;
  				}
  			},
  
  			teardown: function( namespaces, eventHandle ) {
  				if ( this.onbeforeunload === eventHandle ) {
  					this.onbeforeunload = null;
  				}
  			}
  		}
  	},
  
  	simulate: function( type, elem, event, bubble ) {
  		// Piggyback on a donor event to simulate a different one.
  		// Fake originalEvent to avoid donor's stopPropagation, but if the
  		// simulated event prevents default then we do the same on the donor.
  		var e = jQuery.extend(
  			new jQuery.Event(),
  			event,
  			{ type: type,
  				isSimulated: true,
  				originalEvent: {}
  			}
  		);
  		if ( bubble ) {
  			jQuery.event.trigger( e, null, elem );
  		} else {
  			jQuery.event.dispatch.call( elem, e );
  		}
  		if ( e.isDefaultPrevented() ) {
  			event.preventDefault();
  		}
  	}
  };
  
  // Some plugins are using, but it's undocumented/deprecated and will be removed.
  // The 1.7 special event interface should provide all the hooks needed now.
  jQuery.event.handle = jQuery.event.dispatch;
  
  jQuery.removeEvent = document.removeEventListener ?
  	function( elem, type, handle ) {
  		if ( elem.removeEventListener ) {
  			elem.removeEventListener( type, handle, false );
  		}
  	} :
  	function( elem, type, handle ) {
  		var name = "on" + type;
  
  		if ( elem.detachEvent ) {
  
  			// #8545, #7054, preventing memory leaks for custom events in IE6-8 –
  			// detachEvent needed property on element, by name of that event, to properly expose it to GC
  			if ( typeof elem[ name ] === "undefined" ) {
  				elem[ name ] = null;
  			}
  
  			elem.detachEvent( name, handle );
  		}
  	};
  
  jQuery.Event = function( src, props ) {
  	// Allow instantiation without the 'new' keyword
  	if ( !(this instanceof jQuery.Event) ) {
  		return new jQuery.Event( src, props );
  	}
  
  	// Event object
  	if ( src && src.type ) {
  		this.originalEvent = src;
  		this.type = src.type;
  
  		// Events bubbling up the document may have been marked as prevented
  		// by a handler lower down the tree; reflect the correct value.
  		this.isDefaultPrevented = ( src.defaultPrevented || src.returnValue === false ||
  			src.getPreventDefault && src.getPreventDefault() ) ? returnTrue : returnFalse;
  
  	// Event type
  	} else {
  		this.type = src;
  	}
  
  	// Put explicitly provided properties onto the event object
  	if ( props ) {
  		jQuery.extend( this, props );
  	}
  
  	// Create a timestamp if incoming event doesn't have one
  	this.timeStamp = src && src.timeStamp || jQuery.now();
  
  	// Mark it as fixed
  	this[ jQuery.expando ] = true;
  };
  
  function returnFalse() {
  	return false;
  }
  function returnTrue() {
  	return true;
  }
  
  // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
  // http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
  jQuery.Event.prototype = {
  	preventDefault: function() {
  		this.isDefaultPrevented = returnTrue;
  
  		var e = this.originalEvent;
  		if ( !e ) {
  			return;
  		}
  
  		// if preventDefault exists run it on the original event
  		if ( e.preventDefault ) {
  			e.preventDefault();
  
  		// otherwise set the returnValue property of the original event to false (IE)
  		} else {
  			e.returnValue = false;
  		}
  	},
  	stopPropagation: function() {
  		this.isPropagationStopped = returnTrue;
  
  		var e = this.originalEvent;
  		if ( !e ) {
  			return;
  		}
  		// if stopPropagation exists run it on the original event
  		if ( e.stopPropagation ) {
  			e.stopPropagation();
  		}
  		// otherwise set the cancelBubble property of the original event to true (IE)
  		e.cancelBubble = true;
  	},
  	stopImmediatePropagation: function() {
  		this.isImmediatePropagationStopped = returnTrue;
  		this.stopPropagation();
  	},
  	isDefaultPrevented: returnFalse,
  	isPropagationStopped: returnFalse,
  	isImmediatePropagationStopped: returnFalse
  };
  
  // Create mouseenter/leave events using mouseover/out and event-time checks
  jQuery.each({
  	mouseenter: "mouseover",
  	mouseleave: "mouseout"
  }, function( orig, fix ) {
  	jQuery.event.special[ orig ] = {
  		delegateType: fix,
  		bindType: fix,
  
  		handle: function( event ) {
  			var ret,
  				target = this,
  				related = event.relatedTarget,
  				handleObj = event.handleObj,
  				selector = handleObj.selector;
  
  			// For mousenter/leave call the handler if related is outside the target.
  			// NB: No relatedTarget if the mouse left/entered the browser window
  			if ( !related || (related !== target && !jQuery.contains( target, related )) ) {
  				event.type = handleObj.origType;
  				ret = handleObj.handler.apply( this, arguments );
  				event.type = fix;
  			}
  			return ret;
  		}
  	};
  });
  
  // IE submit delegation
  if ( !jQuery.support.submitBubbles ) {
  
  	jQuery.event.special.submit = {
  		setup: function() {
  			// Only need this for delegated form submit events
  			if ( jQuery.nodeName( this, "form" ) ) {
  				return false;
  			}
  
  			// Lazy-add a submit handler when a descendant form may potentially be submitted
  			jQuery.event.add( this, "click._submit keypress._submit", function( e ) {
  				// Node name check avoids a VML-related crash in IE (#9807)
  				var elem = e.target,
  					form = jQuery.nodeName( elem, "input" ) || jQuery.nodeName( elem, "button" ) ? elem.form : undefined;
  				if ( form && !jQuery._data( form, "_submit_attached" ) ) {
  					jQuery.event.add( form, "submit._submit", function( event ) {
  						event._submit_bubble = true;
  					});
  					jQuery._data( form, "_submit_attached", true );
  				}
  			});
  			// return undefined since we don't need an event listener
  		},
  
  		postDispatch: function( event ) {
  			// If form was submitted by the user, bubble the event up the tree
  			if ( event._submit_bubble ) {
  				delete event._submit_bubble;
  				if ( this.parentNode && !event.isTrigger ) {
  					jQuery.event.simulate( "submit", this.parentNode, event, true );
  				}
  			}
  		},
  
  		teardown: function() {
  			// Only need this for delegated form submit events
  			if ( jQuery.nodeName( this, "form" ) ) {
  				return false;
  			}
  
  			// Remove delegated handlers; cleanData eventually reaps submit handlers attached above
  			jQuery.event.remove( this, "._submit" );
  		}
  	};
  }
  
  // IE change delegation and checkbox/radio fix
  if ( !jQuery.support.changeBubbles ) {
  
  	jQuery.event.special.change = {
  
  		setup: function() {
  
  			if ( rformElems.test( this.nodeName ) ) {
  				// IE doesn't fire change on a check/radio until blur; trigger it on click
  				// after a propertychange. Eat the blur-change in special.change.handle.
  				// This still fires onchange a second time for check/radio after blur.
  				if ( this.type === "checkbox" || this.type === "radio" ) {
  					jQuery.event.add( this, "propertychange._change", function( event ) {
  						if ( event.originalEvent.propertyName === "checked" ) {
  							this._just_changed = true;
  						}
  					});
  					jQuery.event.add( this, "click._change", function( event ) {
  						if ( this._just_changed && !event.isTrigger ) {
  							this._just_changed = false;
  						}
  						// Allow triggered, simulated change events (#11500)
  						jQuery.event.simulate( "change", this, event, true );
  					});
  				}
  				return false;
  			}
  			// Delegated event; lazy-add a change handler on descendant inputs
  			jQuery.event.add( this, "beforeactivate._change", function( e ) {
  				var elem = e.target;
  
  				if ( rformElems.test( elem.nodeName ) && !jQuery._data( elem, "_change_attached" ) ) {
  					jQuery.event.add( elem, "change._change", function( event ) {
  						if ( this.parentNode && !event.isSimulated && !event.isTrigger ) {
  							jQuery.event.simulate( "change", this.parentNode, event, true );
  						}
  					});
  					jQuery._data( elem, "_change_attached", true );
  				}
  			});
  		},
  
  		handle: function( event ) {
  			var elem = event.target;
  
  			// Swallow native change events from checkbox/radio, we already triggered them above
  			if ( this !== elem || event.isSimulated || event.isTrigger || (elem.type !== "radio" && elem.type !== "checkbox") ) {
  				return event.handleObj.handler.apply( this, arguments );
  			}
  		},
  
  		teardown: function() {
  			jQuery.event.remove( this, "._change" );
  
  			return rformElems.test( this.nodeName );
  		}
  	};
  }
  
  // Create "bubbling" focus and blur events
  if ( !jQuery.support.focusinBubbles ) {
  	jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
  
  		// Attach a single capturing handler while someone wants focusin/focusout
  		var attaches = 0,
  			handler = function( event ) {
  				jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ), true );
  			};
  
  		jQuery.event.special[ fix ] = {
  			setup: function() {
  				if ( attaches++ === 0 ) {
  					document.addEventListener( orig, handler, true );
  				}
  			},
  			teardown: function() {
  				if ( --attaches === 0 ) {
  					document.removeEventListener( orig, handler, true );
  				}
  			}
  		};
  	});
  }
  
  jQuery.fn.extend({
  
  	on: function( types, selector, data, fn, /*INTERNAL*/ one ) {
  		var origFn, type;
  
  		// Types can be a map of types/handlers
  		if ( typeof types === "object" ) {
  			// ( types-Object, selector, data )
  			if ( typeof selector !== "string" ) { // && selector != null
  				// ( types-Object, data )
  				data = data || selector;
  				selector = undefined;
  			}
  			for ( type in types ) {
  				this.on( type, selector, data, types[ type ], one );
  			}
  			return this;
  		}
  
  		if ( data == null && fn == null ) {
  			// ( types, fn )
  			fn = selector;
  			data = selector = undefined;
  		} else if ( fn == null ) {
  			if ( typeof selector === "string" ) {
  				// ( types, selector, fn )
  				fn = data;
  				data = undefined;
  			} else {
  				// ( types, data, fn )
  				fn = data;
  				data = selector;
  				selector = undefined;
  			}
  		}
  		if ( fn === false ) {
  			fn = returnFalse;
  		} else if ( !fn ) {
  			return this;
  		}
  
  		if ( one === 1 ) {
  			origFn = fn;
  			fn = function( event ) {
  				// Can use an empty set, since event contains the info
  				jQuery().off( event );
  				return origFn.apply( this, arguments );
  			};
  			// Use same guid so caller can remove using origFn
  			fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
  		}
  		return this.each( function() {
  			jQuery.event.add( this, types, fn, data, selector );
  		});
  	},
  	one: function( types, selector, data, fn ) {
  		return this.on( types, selector, data, fn, 1 );
  	},
  	off: function( types, selector, fn ) {
  		var handleObj, type;
  		if ( types && types.preventDefault && types.handleObj ) {
  			// ( event )  dispatched jQuery.Event
  			handleObj = types.handleObj;
  			jQuery( types.delegateTarget ).off(
  				handleObj.namespace ? handleObj.origType + "." + handleObj.namespace : handleObj.origType,
  				handleObj.selector,
  				handleObj.handler
  			);
  			return this;
  		}
  		if ( typeof types === "object" ) {
  			// ( types-object [, selector] )
  			for ( type in types ) {
  				this.off( type, selector, types[ type ] );
  			}
  			return this;
  		}
  		if ( selector === false || typeof selector === "function" ) {
  			// ( types [, fn] )
  			fn = selector;
  			selector = undefined;
  		}
  		if ( fn === false ) {
  			fn = returnFalse;
  		}
  		return this.each(function() {
  			jQuery.event.remove( this, types, fn, selector );
  		});
  	},
  
  	bind: function( types, data, fn ) {
  		return this.on( types, null, data, fn );
  	},
  	unbind: function( types, fn ) {
  		return this.off( types, null, fn );
  	},
  
  	live: function( types, data, fn ) {
  		jQuery( this.context ).on( types, this.selector, data, fn );
  		return this;
  	},
  	die: function( types, fn ) {
  		jQuery( this.context ).off( types, this.selector || "**", fn );
  		return this;
  	},
  
  	delegate: function( selector, types, data, fn ) {
  		return this.on( types, selector, data, fn );
  	},
  	undelegate: function( selector, types, fn ) {
  		// ( namespace ) or ( selector, types [, fn] )
  		return arguments.length == 1? this.off( selector, "**" ) : this.off( types, selector || "**", fn );
  	},
  
  	trigger: function( type, data ) {
  		return this.each(function() {
  			jQuery.event.trigger( type, data, this );
  		});
  	},
  	triggerHandler: function( type, data ) {
  		if ( this[0] ) {
  			return jQuery.event.trigger( type, data, this[0], true );
  		}
  	},
  
  	toggle: function( fn ) {
  		// Save reference to arguments for access in closure
  		var args = arguments,
  			guid = fn.guid || jQuery.guid++,
  			i = 0,
  			toggler = function( event ) {
  				// Figure out which function to execute
  				var lastToggle = ( jQuery._data( this, "lastToggle" + fn.guid ) || 0 ) % i;
  				jQuery._data( this, "lastToggle" + fn.guid, lastToggle + 1 );
  
  				// Make sure that clicks stop
  				event.preventDefault();
  
  				// and execute the function
  				return args[ lastToggle ].apply( this, arguments ) || false;
  			};
  
  		// link all the functions, so any of them can unbind this click handler
  		toggler.guid = guid;
  		while ( i < args.length ) {
  			args[ i++ ].guid = guid;
  		}
  
  		return this.click( toggler );
  	},
  
  	hover: function( fnOver, fnOut ) {
  		return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
  	}
  });
  
  jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
  	"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
  	"change select submit keydown keypress keyup error contextmenu").split(" "), function( i, name ) {
  
  	// Handle event binding
  	jQuery.fn[ name ] = function( data, fn ) {
  		if ( fn == null ) {
  			fn = data;
  			data = null;
  		}
  
  		return arguments.length > 0 ?
  			this.on( name, null, data, fn ) :
  			this.trigger( name );
  	};
  
  	if ( rkeyEvent.test( name ) ) {
  		jQuery.event.fixHooks[ name ] = jQuery.event.keyHooks;
  	}
  
  	if ( rmouseEvent.test( name ) ) {
  		jQuery.event.fixHooks[ name ] = jQuery.event.mouseHooks;
  	}
  });
  