text: (function( jQuery ) {
  
  var rinlinejQuery = / jQuery\d+="(?:\d+|null)"/g,
  	rleadingWhitespace = /^\s+/,
  	rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig,
  	rtagName = /<([\w:]+)/,
  	rtbody = /<tbody/i,
  	rhtml = /<|&#?\w+;/,
  	rnocache = /<(?:script|object|embed|option|style)/i,
  	// checked="checked" or checked
  	rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
  	rscriptType = /\/(java|ecma)script/i,
  	rcleanScript = /^\s*<!(?:\[CDATA\[|\-\-)/,
  	wrapMap = {
  		option: [ 1, "<select multiple='multiple'>", "</select>" ],
  		legend: [ 1, "<fieldset>", "</fieldset>" ],
  		thead: [ 1, "<table>", "</table>" ],
  		tr: [ 2, "<table><tbody>", "</tbody></table>" ],
  		td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
  		col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ],
  		area: [ 1, "<map>", "</map>" ],
  		_default: [ 0, "", "" ]
  	};
  
  wrapMap.optgroup = wrapMap.option;
  wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
  wrapMap.th = wrapMap.td;
  
  // IE can't serialize <link> and <script> tags normally
  if ( !jQuery.support.htmlSerialize ) {
  	wrapMap._default = [ 1, "div<div>", "</div>" ];
  }
  
  jQuery.fn.extend({
  	text: function( text ) {
  		if ( jQuery.isFunction(text) ) {
  			return this.each(function(i) {
  				var self = jQuery( this );
  
  				self.text( text.call(this, i, self.text()) );
  			});
  		}
  
  		if ( typeof text !== "object" && text !== undefined ) {
  			return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );
  		}
  
  		return jQuery.text( this );
  	},
  
  	wrapAll: function( html ) {
  		if ( jQuery.isFunction( html ) ) {
  			return this.each(function(i) {
  				jQuery(this).wrapAll( html.call(this, i) );
  			});
  		}
  
  		if ( this[0] ) {
  			// The elements to wrap the target around
  			var wrap = jQuery( html, this[0].ownerDocument ).eq(0).clone(true);
  
  			if ( this[0].parentNode ) {
  				wrap.insertBefore( this[0] );
  			}
  
  			wrap.map(function() {
  				var elem = this;
  
  				while ( elem.firstChild && elem.firstChild.nodeType === 1 ) {
  					elem = elem.firstChild;
  				}
  
  				return elem;
  			}).append( this );
  		}
  
  		return this;
  	},
  
  	wrapInner: function( html ) {
  		if ( jQuery.isFunction( html ) ) {
  			return this.each(function(i) {
  				jQuery(this).wrapInner( html.call(this, i) );
  			});
  		}
  
  		return this.each(function() {
  			var self = jQuery( this ),
  				contents = self.contents();
  
  			if ( contents.length ) {
  				contents.wrapAll( html );
  
  			} else {
  				self.append( html );
  			}
  		});
  	},
  
  	wrap: function( html ) {
  		return this.each(function() {
  			jQuery( this ).wrapAll( html );
  		});
  	},
  
  	unwrap: function() {
  		return this.parent().each(function() {
  			if ( !jQuery.nodeName( this, "body" ) ) {
  				jQuery( this ).replaceWith( this.childNodes );
  			}
  		}).end();
  	},
  
  	append: function() {
  		return this.domManip(arguments, true, function( elem ) {
  			if ( this.nodeType === 1 ) {
  				this.appendChild( elem );
  			}
  		});
  	},
  
  	prepend: function() {
  		return this.domManip(arguments, true, function( elem ) {
  			if ( this.nodeType === 1 ) {
  				this.insertBefore( elem, this.firstChild );
  			}
  		});
  	},
  
  	before: function() {
  		if ( this[0] && this[0].parentNode ) {
  			return this.domManip(arguments, false, function( elem ) {
  				this.parentNode.insertBefore( elem, this );
  			});
  		} else if ( arguments.length ) {
  			var set = jQuery(arguments[0]);
  			set.push.apply( set, this.toArray() );
  			return this.pushStack( set, "before", arguments );
  		}
  	},
  
  	after: function() {
  		if ( this[0] && this[0].parentNode ) {
  			return this.domManip(arguments, false, function( elem ) {
  				this.parentNode.insertBefore( elem, this.nextSibling );
  			});
  		} else if ( arguments.length ) {
  			var set = this.pushStack( this, "after", arguments );
  			set.push.apply( set, jQuery(arguments[0]).toArray() );
  			return set;
  		}
  	},
  
  	// keepData is for internal use only--do not document
  	remove: function( selector, keepData ) {
  		for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
  			if ( !selector || jQuery.filter( selector, [ elem ] ).length ) {
  				if ( !keepData && elem.nodeType === 1 ) {
  					jQuery.cleanData( elem.getElementsByTagName("*") );
  					jQuery.cleanData( [ elem ] );
  				}
  
  				if ( elem.parentNode ) {
  					elem.parentNode.removeChild( elem );
  				}
  			}
  		}
  
  		return this;
  	},
  
  	empty: function() {
  		for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
  			// Remove element nodes and prevent memory leaks
  			if ( elem.nodeType === 1 ) {
  				jQuery.cleanData( elem.getElementsByTagName("*") );
  			}
  
  			// Remove any remaining nodes
  			while ( elem.firstChild ) {
  				elem.removeChild( elem.firstChild );
  			}
  		}
  
  		return this;
  	},
  
  	clone: function( dataAndEvents, deepDataAndEvents ) {
  		dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
  		deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
  
  		return this.map( function () {
  			return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
  		});
  	},
  
  	html: function( value ) {
  		if ( value === undefined ) {
  			return this[0] && this[0].nodeType === 1 ?
  				this[0].innerHTML.replace(rinlinejQuery, "") :
  				null;
  
  		// See if we can take a shortcut and just use innerHTML
  		} else if ( typeof value === "string" && !rnocache.test( value ) &&
  			(jQuery.support.leadingWhitespace || !rleadingWhitespace.test( value )) &&
  			!wrapMap[ (rtagName.exec( value ) || ["", ""])[1].toLowerCase() ] ) {
  
  			value = value.replace(rxhtmlTag, "<$1></$2>");
  
  			try {
  				for ( var i = 0, l = this.length; i < l; i++ ) {
  					// Remove element nodes and prevent memory leaks
  					if ( this[i].nodeType === 1 ) {
  						jQuery.cleanData( this[i].getElementsByTagName("*") );
  						this[i].innerHTML = value;
  					}
  				}
  
  			// If using innerHTML throws an exception, use the fallback method
  			} catch(e) {
  				this.empty().append( value );
  			}
  
  		} else if ( jQuery.isFunction( value ) ) {
  			this.each(function(i){
  				var self = jQuery( this );
  
  				self.html( value.call(this, i, self.html()) );
  			});
  
  		} else {
  			this.empty().append( value );
  		}
  
  		return this;
  	},
  
  	replaceWith: function( value ) {
  		if ( this[0] && this[0].parentNode ) {
  			// Make sure that the elements are removed from the DOM before they are inserted
  			// this can help fix replacing a parent with child elements
  			if ( jQuery.isFunction( value ) ) {
  				return this.each(function(i) {
  					var self = jQuery(this), old = self.html();
  					self.replaceWith( value.call( this, i, old ) );
  				});
  			}
  
  			if ( typeof value !== "string" ) {
  				value = jQuery( value ).detach();
  			}
  
  			return this.each(function() {
  				var next = this.nextSibling,
  					parent = this.parentNode;
  
  				jQuery( this ).remove();
  
  				if ( next ) {
  					jQuery(next).before( value );
  				} else {
  					jQuery(parent).append( value );
  				}
  			});
  		} else {
  			return this.length ?
  				this.pushStack( jQuery(jQuery.isFunction(value) ? value() : value), "replaceWith", value ) :
  				this;
  		}
  	},
  
  	detach: function( selector ) {
  		return this.remove( selector, true );
  	},
  
  	domManip: function( args, table, callback ) {
  		var results, first, fragment, parent,
  			value = args[0],
  			scripts = [];
  
  		// We can't cloneNode fragments that contain checked, in WebKit
  		if ( !jQuery.support.checkClone && arguments.length === 3 && typeof value === "string" && rchecked.test( value ) ) {
  			return this.each(function() {
  				jQuery(this).domManip( args, table, callback, true );
  			});
  		}
  
  		if ( jQuery.isFunction(value) ) {
  			return this.each(function(i) {
  				var self = jQuery(this);
  				args[0] = value.call(this, i, table ? self.html() : undefined);
  				self.domManip( args, table, callback );
  			});
  		}
  
  		if ( this[0] ) {
  			parent = value && value.parentNode;
  
  			// If we're in a fragment, just use that instead of building a new one
  			if ( jQuery.support.parentNode && parent && parent.nodeType === 11 && parent.childNodes.length === this.length ) {
  				results = { fragment: parent };
  
  			} else {
  				results = jQuery.buildFragment( args, this, scripts );
  			}
  
  			fragment = results.fragment;
  
  			if ( fragment.childNodes.length === 1 ) {
  				first = fragment = fragment.firstChild;
  			} else {
  				first = fragment.firstChild;
  			}
  
  			if ( first ) {
  				table = table && jQuery.nodeName( first, "tr" );
  
  				for ( var i = 0, l = this.length, lastIndex = l - 1; i < l; i++ ) {
  					callback.call(
  						table ?
  							root(this[i], first) :
  							this[i],
  						// Make sure that we do not leak memory by inadvertently discarding
  						// the original fragment (which might have attached data) instead of
  						// using it; in addition, use the original fragment object for the last
  						// item instead of first because it can end up being emptied incorrectly
  						// in certain situations (Bug #8070).
  						// Fragments from the fragment cache must always be cloned and never used
  						// in place.
  						results.cacheable || (l > 1 && i < lastIndex) ?
  							jQuery.clone( fragment, true, true ) :
  							fragment
  					);
  				}
  			}
  
  			if ( scripts.length ) {
  				jQuery.each( scripts, evalScript );
  			}
  		}
  
  		return this;
  	}
  });
  
  function root( elem, cur ) {
  	return jQuery.nodeName(elem, "table") ?
  		(elem.getElementsByTagName("tbody")[0] ||
  		elem.appendChild(elem.ownerDocument.createElement("tbody"))) :
  		elem;
  }
  
  function cloneCopyEvent( src, dest ) {
  
  	if ( dest.nodeType !== 1 || !jQuery.hasData( src ) ) {
  		return;
  	}
  
  	var internalKey = jQuery.expando,
  		oldData = jQuery.data( src ),
  		curData = jQuery.data( dest, oldData );
  
  	// Switch to use the internal data object, if it exists, for the next
  	// stage of data copying
  	if ( (oldData = oldData[ internalKey ]) ) {
  		var events = oldData.events;
  				curData = curData[ internalKey ] = jQuery.extend({}, oldData);
  
  		if ( events ) {
  			delete curData.handle;
  			curData.events = {};
  
  			for ( var type in events ) {
  				for ( var i = 0, l = events[ type ].length; i < l; i++ ) {
  					jQuery.event.add( dest, type + ( events[ type ][ i ].namespace ? "." : "" ) + events[ type ][ i ].namespace, events[ type ][ i ], events[ type ][ i ].data );
  				}
  			}
  		}
  	}
  }
  
  function cloneFixAttributes( src, dest ) {
  	var nodeName;
  
  	// We do not need to do anything for non-Elements
  	if ( dest.nodeType !== 1 ) {
  		return;
  	}
  
  	// clearAttributes removes the attributes, which we don't want,
  	// but also removes the attachEvent events, which we *do* want
  	if ( dest.clearAttributes ) {
  		dest.clearAttributes();
  	}
  
  	// mergeAttributes, in contrast, only merges back on the
  	// original attributes, not the events
  	if ( dest.mergeAttributes ) {
  		dest.mergeAttributes( src );
  	}
  
  	nodeName = dest.nodeName.toLowerCase();
  
  	// IE6-8 fail to clone children inside object elements that use
  	// the proprietary classid attribute value (rather than the type
  	// attribute) to identify the type of content to display
  	if ( nodeName === "object" ) {
  		dest.outerHTML = src.outerHTML;
  
  	} else if ( nodeName === "input" && (src.type === "checkbox" || src.type === "radio") ) {
  		// IE6-8 fails to persist the checked state of a cloned checkbox
  		// or radio button. Worse, IE6-7 fail to give the cloned element
  		// a checked appearance if the defaultChecked value isn't also set
  		if ( src.checked ) {
  			dest.defaultChecked = dest.checked = src.checked;
  		}
  
  		// IE6-7 get confused and end up setting the value of a cloned
  		// checkbox/radio button to an empty string instead of "on"
  		if ( dest.value !== src.value ) {
  			dest.value = src.value;
  		}
  
  	// IE6-8 fails to return the selected option to the default selected
  	// state when cloning options
  	} else if ( nodeName === "option" ) {
  		dest.selected = src.defaultSelected;
  
  	// IE6-8 fails to set the defaultValue to the correct value when
  	// cloning other types of input fields
  	} else if ( nodeName === "input" || nodeName === "textarea" ) {
  		dest.defaultValue = src.defaultValue;
  	}
  
  	// Event data gets referenced instead of copied if the expando
  	// gets copied too
  	dest.removeAttribute( jQuery.expando );
  }
  
  jQuery.buildFragment = function( args, nodes, scripts ) {
  	var fragment, cacheable, cacheresults, doc;
  
    // nodes may contain either an explicit document object,
    // a jQuery collection or context object.
    // If nodes[0] contains a valid object to assign to doc
    if ( nodes && nodes[0] ) {
      doc = nodes[0].ownerDocument || nodes[0];
    }
  
    // Ensure that an attr object doesn't incorrectly stand in as a document object
  	// Chrome and Firefox seem to allow this to occur and will throw exception
  	// Fixes #8950
  	if ( !doc.createDocumentFragment ) {
  		doc = document;
  	}
  
  	// Only cache "small" (1/2 KB) HTML strings that are associated with the main document
  	// Cloning options loses the selected state, so don't cache them
  	// IE 6 doesn't like it when you put <object> or <embed> elements in a fragment
  	// Also, WebKit does not clone 'checked' attributes on cloneNode, so don't cache
  	if ( args.length === 1 && typeof args[0] === "string" && args[0].length < 512 && doc === document &&
  		args[0].charAt(0) === "<" && !rnocache.test( args[0] ) && (jQuery.support.checkClone || !rchecked.test( args[0] )) ) {
  
  		cacheable = true;
  
  		cacheresults = jQuery.fragments[ args[0] ];
  		if ( cacheresults && cacheresults !== 1 ) {
  			fragment = cacheresults;
  		}
  	}
  
  	if ( !fragment ) {
  		fragment = doc.createDocumentFragment();
  		jQuery.clean( args, doc, fragment, scripts );
  	}
  
  	if ( cacheable ) {
  		jQuery.fragments[ args[0] ] = cacheresults ? fragment : 1;
  	}
  
  	return { fragment: fragment, cacheable: cacheable };
  };
  
  jQuery.fragments = {};
  
  jQuery.each({
  	appendTo: "append",
  	prependTo: "prepend",
  	insertBefore: "before",
  	insertAfter: "after",
  	replaceAll: "replaceWith"
  }, function( name, original ) {
  	jQuery.fn[ name ] = function( selector ) {
  		var ret = [],
  			insert = jQuery( selector ),
  			parent = this.length === 1 && this[0].parentNode;
  
  		if ( parent && parent.nodeType === 11 && parent.childNodes.length === 1 && insert.length === 1 ) {
  			insert[ original ]( this[0] );
  			return this;
  
  		} else {
  			for ( var i = 0, l = insert.length; i < l; i++ ) {
  				var elems = (i > 0 ? this.clone(true) : this).get();
  				jQuery( insert[i] )[ original ]( elems );
  				ret = ret.concat( elems );
  			}
  
  			return this.pushStack( ret, name, insert.selector );
  		}
  	};
  });
  
  function getAll( elem ) {
  	if ( "getElementsByTagName" in elem ) {
  		return elem.getElementsByTagName( "*" );
  
  	} else if ( "querySelectorAll" in elem ) {
  		return elem.querySelectorAll( "*" );
  
  	} else {
  		return [];
  	}
  }
  
  // Used in clean, fixes the defaultChecked property
  function fixDefaultChecked( elem ) {
  	if ( elem.type === "checkbox" || elem.type === "radio" ) {
  		elem.defaultChecked = elem.checked;
  	}
  }
  // Finds all inputs and passes them to fixDefaultChecked
  function findInputs( elem ) {
  	if ( jQuery.nodeName( elem, "input" ) ) {
  		fixDefaultChecked( elem );
  	} else if ( "getElementsByTagName" in elem ) {
  		jQuery.grep( elem.getElementsByTagName("input"), fixDefaultChecked );
  	}
  }
  
  jQuery.extend({
  	clone: function( elem, dataAndEvents, deepDataAndEvents ) {
  		var clone = elem.cloneNode(true),
  				srcElements,
  				destElements,
  				i;
  
  		if ( (!jQuery.support.noCloneEvent || !jQuery.support.noCloneChecked) &&
  				(elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem) ) {
  			// IE copies events bound via attachEvent when using cloneNode.
  			// Calling detachEvent on the clone will also remove the events
  			// from the original. In order to get around this, we use some
  			// proprietary methods to clear the events. Thanks to MooTools
  			// guys for this hotness.
  
  			cloneFixAttributes( elem, clone );
  
  			// Using Sizzle here is crazy slow, so we use getElementsByTagName
  			// instead
  			srcElements = getAll( elem );
  			destElements = getAll( clone );
  
  			// Weird iteration because IE will replace the length property
  			// with an element if you are cloning the body and one of the
  			// elements on the page has a name or id of "length"
  			for ( i = 0; srcElements[i]; ++i ) {
  				// Ensure that the destination node is not null; Fixes #9587
  				if ( destElements[i] ) {
  					cloneFixAttributes( srcElements[i], destElements[i] );
  				}
  			}
  		}
  
  		// Copy the events from the original to the clone
  		if ( dataAndEvents ) {
  			cloneCopyEvent( elem, clone );
  
  			if ( deepDataAndEvents ) {
  				srcElements = getAll( elem );
  				destElements = getAll( clone );
  
  				for ( i = 0; srcElements[i]; ++i ) {
  					cloneCopyEvent( srcElements[i], destElements[i] );
  				}
  			}
  		}
  
  		srcElements = destElements = null;
  
  		// Return the cloned set
  		return clone;
  	},
  
  	clean: function( elems, context, fragment, scripts ) {
  		var checkScriptType;
  
  		context = context || document;
  
  		// !context.createElement fails in IE with an error but returns typeof 'object'
  		if ( typeof context.createElement === "undefined" ) {
  			context = context.ownerDocument || context[0] && context[0].ownerDocument || document;
  		}
  
  		var ret = [], j;
  
  		for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
  			if ( typeof elem === "number" ) {
  				elem += "";
  			}
  
  			if ( !elem ) {
  				continue;
  			}
  
  			// Convert html string into DOM nodes
  			if ( typeof elem === "string" ) {
  				if ( !rhtml.test( elem ) ) {
  					elem = context.createTextNode( elem );
  				} else {
  					// Fix "XHTML"-style tags in all browsers
  					elem = elem.replace(rxhtmlTag, "<$1></$2>");
  
  					// Trim whitespace, otherwise indexOf won't work as expected
  					var tag = (rtagName.exec( elem ) || ["", ""])[1].toLowerCase(),
  						wrap = wrapMap[ tag ] || wrapMap._default,
  						depth = wrap[0],
  						div = context.createElement("div");
  
  					// Go to html and back, then peel off extra wrappers
  					div.innerHTML = wrap[1] + elem + wrap[2];
  
  					// Move to the right depth
  					while ( depth-- ) {
  						div = div.lastChild;
  					}
  
  					// Remove IE's autoinserted <tbody> from table fragments
  					if ( !jQuery.support.tbody ) {
  
  						// String was a <table>, *may* have spurious <tbody>
  						var hasBody = rtbody.test(elem),
  							tbody = tag === "table" && !hasBody ?
  								div.firstChild && div.firstChild.childNodes :
  
  								// String was a bare <thead> or <tfoot>
  								wrap[1] === "<table>" && !hasBody ?
  									div.childNodes :
  									[];
  
  						for ( j = tbody.length - 1; j >= 0 ; --j ) {
  							if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length ) {
  								tbody[ j ].parentNode.removeChild( tbody[ j ] );
  							}
  						}
  					}
  
  					// IE completely kills leading whitespace when innerHTML is used
  					if ( !jQuery.support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {
  						div.insertBefore( context.createTextNode( rleadingWhitespace.exec(elem)[0] ), div.firstChild );
  					}
  
  					elem = div.childNodes;
  				}
  			}
  
  			// Resets defaultChecked for any radios and checkboxes
  			// about to be appended to the DOM in IE 6/7 (#8060)
  			var len;
  			if ( !jQuery.support.appendChecked ) {
  				if ( elem[0] && typeof (len = elem.length) === "number" ) {
  					for ( j = 0; j < len; j++ ) {
  						findInputs( elem[j] );
  					}
  				} else {
  					findInputs( elem );
  				}
  			}
  
  			if ( elem.nodeType ) {
  				ret.push( elem );
  			} else {
  				ret = jQuery.merge( ret, elem );
  			}
  		}
  
  		if ( fragment ) {
  			checkScriptType = function( elem ) {
  				return !elem.type || rscriptType.test( elem.type );
  			};
  			for ( i = 0; ret[i]; i++ ) {
  				if ( scripts && jQuery.nodeName( ret[i], "script" ) && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript") ) {
  					scripts.push( ret[i].parentNode ? ret[i].parentNode.removeChild( ret[i] ) : ret[i] );
  
  				} else {
  					if ( ret[i].nodeType === 1 ) {
  						var jsTags = jQuery.grep( ret[i].getElementsByTagName( "script" ), checkScriptType );
  
  						ret.splice.apply( ret, [i + 1, 0].concat( jsTags ) );
  					}
  					fragment.appendChild( ret[i] );
  				}
  			}
  		}
  
  		return ret;
  	},
  
  	cleanData: function( elems ) {
  		var data, id, cache = jQuery.cache, internalKey = jQuery.expando, special = jQuery.event.special,
  			deleteExpando = jQuery.support.deleteExpando;
  
  		for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
  			if ( elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()] ) {
  				continue;
  			}
  
  			id = elem[ jQuery.expando ];
  
  			if ( id ) {
  				data = cache[ id ] && cache[ id ][ internalKey ];
  
  				if ( data && data.events ) {
  					for ( var type in data.events ) {
  						if ( special[ type ] ) {
  							jQuery.event.remove( elem, type );
  
  						// This is a shortcut to avoid jQuery.event.remove's overhead
  						} else {
  							jQuery.removeEvent( elem, type, data.handle );
  						}
  					}
  
  					// Null the DOM reference to avoid IE6/7/8 leak (#7054)
  					if ( data.handle ) {
  						data.handle.elem = null;
  					}
  				}
  
  				if ( deleteExpando ) {
  					delete elem[ jQuery.expando ];
  
  				} else if ( elem.removeAttribute ) {
  					elem.removeAttribute( jQuery.expando );
  				}
  
  				delete cache[ id ];
  			}
  		}
  	}
  });
  
  function evalScript( i, elem ) {
  	if ( elem.src ) {
  		jQuery.ajax({
  			url: elem.src,
  			async: false,
  			dataType: "script"
  		});
  	} else {
  		jQuery.globalEval( ( elem.text || elem.textContent || elem.innerHTML || "" ).replace( rcleanScript, "/*$0*/" ) );
  	}
  
  	if ( elem.parentNode ) {
  		elem.parentNode.removeChild( elem );
  	}
  }
  
  })( jQuery );
  