Strabon

changeset 605:3e0f14b9bcd4

Added more button when displaying literals which have large length, for example geometries.
author Stella Giannakopoulou <sgian@di.uoa.gr>
date Tue Oct 02 18:35:44 2012 +0300 (2012-10-02)
parents 06a1beb9b9c3
children b060242046c2
files endpoint/WebContent/browse.jsp endpoint/WebContent/js/more_link.js endpoint/WebContent/query.jsp endpoint/WebContent/style.css resultio/src/main/java/org/openrdf/query/resultio/sparqlhtml/stSPARQLResultsHTMLWriter.java
line diff
     1.1 --- a/endpoint/WebContent/browse.jsp	Tue Oct 02 15:12:45 2012 +0300
     1.2 +++ b/endpoint/WebContent/browse.jsp	Tue Oct 02 18:35:44 2012 +0300
     1.3 @@ -13,7 +13,43 @@
     1.4  	<meta name="viewport" content="initial-scale=1.0, user-scalable=no" />
     1.5  	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
     1.6  	<link rel="stylesheet" href="style.css" type="text/css" />
     1.7 +	<script type="text/javascript" src="js/more_link.js"></script>	
     1.8  	<title>TELEIOS: Strabon Endpoint</title>
     1.9 +	<script>
    1.10 +		$(document).ready(function() {
    1.11 +		var showChar = 100;
    1.12 +		var ellipsestext = "...";
    1.13 +		var moretext = "more";
    1.14 +		var lesstext = "less";
    1.15 +		$('.more').each(function() {
    1.16 +			var content = $(this).html();
    1.17 +	
    1.18 +			if(content.length > showChar) {
    1.19 +	
    1.20 +				var c = content.substr(0, showChar);
    1.21 +				var h = content.substr(showChar-1, content.length - showChar);
    1.22 +	
    1.23 +				var html = c + '<span class="moreelipses">'+ellipsestext+'</span>&nbsp;<span class="morecontent"><span>' + h + '</span>&nbsp;&nbsp;<a href="" class="morelink">'+moretext+'</a></span>';
    1.24 +	
    1.25 +				$(this).html(html);
    1.26 +			}
    1.27 +	
    1.28 +		});
    1.29 +	
    1.30 +		$(".morelink").click(function(){
    1.31 +			if($(this).hasClass("less")) {
    1.32 +				$(this).removeClass("less");
    1.33 +				$(this).html(moretext);
    1.34 +			} else {
    1.35 +				$(this).addClass("less");
    1.36 +				$(this).html(lesstext);
    1.37 +			}
    1.38 +			$(this).parent().prev().toggle();
    1.39 +			$(this).prev().toggle();
    1.40 +			return false;
    1.41 +		});
    1.42 +	});
    1.43 +</script>
    1.44  </head>
    1.45  <body topmargin="0" leftmargin="0" link="#FFFFFF" vlink="#FFFFFF" alink="#FFFFFF">
    1.46  <TABLE width="80%" BORDER=0 CELLPADDING=0 CELLSPACING=0>  
    1.47 @@ -36,7 +72,7 @@
    1.48  	<h1>About: </h1>
    1.49  	<a href=""><%=request.getAttribute("resource")%></a>
    1.50  	<div id="response">
    1.51 -	<!-- Response -->
    1.52 +	<!-- Response -->	
    1.53  <% if (request.getAttribute("response") != null) {
    1.54  	if (Common.getHTMLFormat().equals(request.getParameter("format"))) {%>
    1.55  		<%=request.getAttribute("response")%>
    1.56 @@ -46,4 +82,5 @@
    1.57  <%}%>
    1.58  </div>
    1.59  </body>
    1.60 +
    1.61  </html>
    1.62 \ No newline at end of file
     2.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     2.2 +++ b/endpoint/WebContent/js/more_link.js	Tue Oct 02 18:35:44 2012 +0300
     2.3 @@ -0,0 +1,9440 @@
     2.4 +/*!
     2.5 + * jQuery JavaScript Library v1.8.2
     2.6 + * http://jquery.com/
     2.7 + *
     2.8 + * Includes Sizzle.js
     2.9 + * http://sizzlejs.com/
    2.10 + *
    2.11 + * Copyright 2012 jQuery Foundation and other contributors
    2.12 + * Released under the MIT license
    2.13 + * http://jquery.org/license
    2.14 + *
    2.15 + * Date: Thu Sep 20 2012 21:13:05 GMT-0400 (Eastern Daylight Time)
    2.16 + */
    2.17 +(function( window, undefined ) {
    2.18 +var
    2.19 +	// A central reference to the root jQuery(document)
    2.20 +	rootjQuery,
    2.21 +
    2.22 +	// The deferred used on DOM ready
    2.23 +	readyList,
    2.24 +
    2.25 +	// Use the correct document accordingly with window argument (sandbox)
    2.26 +	document = window.document,
    2.27 +	location = window.location,
    2.28 +	navigator = window.navigator,
    2.29 +
    2.30 +	// Map over jQuery in case of overwrite
    2.31 +	_jQuery = window.jQuery,
    2.32 +
    2.33 +	// Map over the $ in case of overwrite
    2.34 +	_$ = window.$,
    2.35 +
    2.36 +	// Save a reference to some core methods
    2.37 +	core_push = Array.prototype.push,
    2.38 +	core_slice = Array.prototype.slice,
    2.39 +	core_indexOf = Array.prototype.indexOf,
    2.40 +	core_toString = Object.prototype.toString,
    2.41 +	core_hasOwn = Object.prototype.hasOwnProperty,
    2.42 +	core_trim = String.prototype.trim,
    2.43 +
    2.44 +	// Define a local copy of jQuery
    2.45 +	jQuery = function( selector, context ) {
    2.46 +		// The jQuery object is actually just the init constructor 'enhanced'
    2.47 +		return new jQuery.fn.init( selector, context, rootjQuery );
    2.48 +	},
    2.49 +
    2.50 +	// Used for matching numbers
    2.51 +	core_pnum = /[\-+]?(?:\d*\.|)\d+(?:[eE][\-+]?\d+|)/.source,
    2.52 +
    2.53 +	// Used for detecting and trimming whitespace
    2.54 +	core_rnotwhite = /\S/,
    2.55 +	core_rspace = /\s+/,
    2.56 +
    2.57 +	// Make sure we trim BOM and NBSP (here's looking at you, Safari 5.0 and IE)
    2.58 +	rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
    2.59 +
    2.60 +	// A simple way to check for HTML strings
    2.61 +	// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
    2.62 +	rquickExpr = /^(?:[^#<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/,
    2.63 +
    2.64 +	// Match a standalone tag
    2.65 +	rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>|)$/,
    2.66 +
    2.67 +	// JSON RegExp
    2.68 +	rvalidchars = /^[\],:{}\s]*$/,
    2.69 +	rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
    2.70 +	rvalidescape = /\\(?:["\\\/bfnrt]|u[\da-fA-F]{4})/g,
    2.71 +	rvalidtokens = /"[^"\\\r\n]*"|true|false|null|-?(?:\d\d*\.|)\d+(?:[eE][\-+]?\d+|)/g,
    2.72 +
    2.73 +	// Matches dashed string for camelizing
    2.74 +	rmsPrefix = /^-ms-/,
    2.75 +	rdashAlpha = /-([\da-z])/gi,
    2.76 +
    2.77 +	// Used by jQuery.camelCase as callback to replace()
    2.78 +	fcamelCase = function( all, letter ) {
    2.79 +		return ( letter + "" ).toUpperCase();
    2.80 +	},
    2.81 +
    2.82 +	// The ready event handler and self cleanup method
    2.83 +	DOMContentLoaded = function() {
    2.84 +		if ( document.addEventListener ) {
    2.85 +			document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );
    2.86 +			jQuery.ready();
    2.87 +		} else if ( document.readyState === "complete" ) {
    2.88 +			// we're here because readyState === "complete" in oldIE
    2.89 +			// which is good enough for us to call the dom ready!
    2.90 +			document.detachEvent( "onreadystatechange", DOMContentLoaded );
    2.91 +			jQuery.ready();
    2.92 +		}
    2.93 +	},
    2.94 +
    2.95 +	// [[Class]] -> type pairs
    2.96 +	class2type = {};
    2.97 +
    2.98 +jQuery.fn = jQuery.prototype = {
    2.99 +	constructor: jQuery,
   2.100 +	init: function( selector, context, rootjQuery ) {
   2.101 +		var match, elem, ret, doc;
   2.102 +
   2.103 +		// Handle $(""), $(null), $(undefined), $(false)
   2.104 +		if ( !selector ) {
   2.105 +			return this;
   2.106 +		}
   2.107 +
   2.108 +		// Handle $(DOMElement)
   2.109 +		if ( selector.nodeType ) {
   2.110 +			this.context = this[0] = selector;
   2.111 +			this.length = 1;
   2.112 +			return this;
   2.113 +		}
   2.114 +
   2.115 +		// Handle HTML strings
   2.116 +		if ( typeof selector === "string" ) {
   2.117 +			if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
   2.118 +				// Assume that strings that start and end with <> are HTML and skip the regex check
   2.119 +				match = [ null, selector, null ];
   2.120 +
   2.121 +			} else {
   2.122 +				match = rquickExpr.exec( selector );
   2.123 +			}
   2.124 +
   2.125 +			// Match html or make sure no context is specified for #id
   2.126 +			if ( match && (match[1] || !context) ) {
   2.127 +
   2.128 +				// HANDLE: $(html) -> $(array)
   2.129 +				if ( match[1] ) {
   2.130 +					context = context instanceof jQuery ? context[0] : context;
   2.131 +					doc = ( context && context.nodeType ? context.ownerDocument || context : document );
   2.132 +
   2.133 +					// scripts is true for back-compat
   2.134 +					selector = jQuery.parseHTML( match[1], doc, true );
   2.135 +					if ( rsingleTag.test( match[1] ) && jQuery.isPlainObject( context ) ) {
   2.136 +						this.attr.call( selector, context, true );
   2.137 +					}
   2.138 +
   2.139 +					return jQuery.merge( this, selector );
   2.140 +
   2.141 +				// HANDLE: $(#id)
   2.142 +				} else {
   2.143 +					elem = document.getElementById( match[2] );
   2.144 +
   2.145 +					// Check parentNode to catch when Blackberry 4.6 returns
   2.146 +					// nodes that are no longer in the document #6963
   2.147 +					if ( elem && elem.parentNode ) {
   2.148 +						// Handle the case where IE and Opera return items
   2.149 +						// by name instead of ID
   2.150 +						if ( elem.id !== match[2] ) {
   2.151 +							return rootjQuery.find( selector );
   2.152 +						}
   2.153 +
   2.154 +						// Otherwise, we inject the element directly into the jQuery object
   2.155 +						this.length = 1;
   2.156 +						this[0] = elem;
   2.157 +					}
   2.158 +
   2.159 +					this.context = document;
   2.160 +					this.selector = selector;
   2.161 +					return this;
   2.162 +				}
   2.163 +
   2.164 +			// HANDLE: $(expr, $(...))
   2.165 +			} else if ( !context || context.jquery ) {
   2.166 +				return ( context || rootjQuery ).find( selector );
   2.167 +
   2.168 +			// HANDLE: $(expr, context)
   2.169 +			// (which is just equivalent to: $(context).find(expr)
   2.170 +			} else {
   2.171 +				return this.constructor( context ).find( selector );
   2.172 +			}
   2.173 +
   2.174 +		// HANDLE: $(function)
   2.175 +		// Shortcut for document ready
   2.176 +		} else if ( jQuery.isFunction( selector ) ) {
   2.177 +			return rootjQuery.ready( selector );
   2.178 +		}
   2.179 +
   2.180 +		if ( selector.selector !== undefined ) {
   2.181 +			this.selector = selector.selector;
   2.182 +			this.context = selector.context;
   2.183 +		}
   2.184 +
   2.185 +		return jQuery.makeArray( selector, this );
   2.186 +	},
   2.187 +
   2.188 +	// Start with an empty selector
   2.189 +	selector: "",
   2.190 +
   2.191 +	// The current version of jQuery being used
   2.192 +	jquery: "1.8.2",
   2.193 +
   2.194 +	// The default length of a jQuery object is 0
   2.195 +	length: 0,
   2.196 +
   2.197 +	// The number of elements contained in the matched element set
   2.198 +	size: function() {
   2.199 +		return this.length;
   2.200 +	},
   2.201 +
   2.202 +	toArray: function() {
   2.203 +		return core_slice.call( this );
   2.204 +	},
   2.205 +
   2.206 +	// Get the Nth element in the matched element set OR
   2.207 +	// Get the whole matched element set as a clean array
   2.208 +	get: function( num ) {
   2.209 +		return num == null ?
   2.210 +
   2.211 +			// Return a 'clean' array
   2.212 +			this.toArray() :
   2.213 +
   2.214 +			// Return just the object
   2.215 +			( num < 0 ? this[ this.length + num ] : this[ num ] );
   2.216 +	},
   2.217 +
   2.218 +	// Take an array of elements and push it onto the stack
   2.219 +	// (returning the new matched element set)
   2.220 +	pushStack: function( elems, name, selector ) {
   2.221 +
   2.222 +		// Build a new jQuery matched element set
   2.223 +		var ret = jQuery.merge( this.constructor(), elems );
   2.224 +
   2.225 +		// Add the old object onto the stack (as a reference)
   2.226 +		ret.prevObject = this;
   2.227 +
   2.228 +		ret.context = this.context;
   2.229 +
   2.230 +		if ( name === "find" ) {
   2.231 +			ret.selector = this.selector + ( this.selector ? " " : "" ) + selector;
   2.232 +		} else if ( name ) {
   2.233 +			ret.selector = this.selector + "." + name + "(" + selector + ")";
   2.234 +		}
   2.235 +
   2.236 +		// Return the newly-formed element set
   2.237 +		return ret;
   2.238 +	},
   2.239 +
   2.240 +	// Execute a callback for every element in the matched set.
   2.241 +	// (You can seed the arguments with an array of args, but this is
   2.242 +	// only used internally.)
   2.243 +	each: function( callback, args ) {
   2.244 +		return jQuery.each( this, callback, args );
   2.245 +	},
   2.246 +
   2.247 +	ready: function( fn ) {
   2.248 +		// Add the callback
   2.249 +		jQuery.ready.promise().done( fn );
   2.250 +
   2.251 +		return this;
   2.252 +	},
   2.253 +
   2.254 +	eq: function( i ) {
   2.255 +		i = +i;
   2.256 +		return i === -1 ?
   2.257 +			this.slice( i ) :
   2.258 +			this.slice( i, i + 1 );
   2.259 +	},
   2.260 +
   2.261 +	first: function() {
   2.262 +		return this.eq( 0 );
   2.263 +	},
   2.264 +
   2.265 +	last: function() {
   2.266 +		return this.eq( -1 );
   2.267 +	},
   2.268 +
   2.269 +	slice: function() {
   2.270 +		return this.pushStack( core_slice.apply( this, arguments ),
   2.271 +			"slice", core_slice.call(arguments).join(",") );
   2.272 +	},
   2.273 +
   2.274 +	map: function( callback ) {
   2.275 +		return this.pushStack( jQuery.map(this, function( elem, i ) {
   2.276 +			return callback.call( elem, i, elem );
   2.277 +		}));
   2.278 +	},
   2.279 +
   2.280 +	end: function() {
   2.281 +		return this.prevObject || this.constructor(null);
   2.282 +	},
   2.283 +
   2.284 +	// For internal use only.
   2.285 +	// Behaves like an Array's method, not like a jQuery method.
   2.286 +	push: core_push,
   2.287 +	sort: [].sort,
   2.288 +	splice: [].splice
   2.289 +};
   2.290 +
   2.291 +// Give the init function the jQuery prototype for later instantiation
   2.292 +jQuery.fn.init.prototype = jQuery.fn;
   2.293 +
   2.294 +jQuery.extend = jQuery.fn.extend = function() {
   2.295 +	var options, name, src, copy, copyIsArray, clone,
   2.296 +		target = arguments[0] || {},
   2.297 +		i = 1,
   2.298 +		length = arguments.length,
   2.299 +		deep = false;
   2.300 +
   2.301 +	// Handle a deep copy situation
   2.302 +	if ( typeof target === "boolean" ) {
   2.303 +		deep = target;
   2.304 +		target = arguments[1] || {};
   2.305 +		// skip the boolean and the target
   2.306 +		i = 2;
   2.307 +	}
   2.308 +
   2.309 +	// Handle case when target is a string or something (possible in deep copy)
   2.310 +	if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
   2.311 +		target = {};
   2.312 +	}
   2.313 +
   2.314 +	// extend jQuery itself if only one argument is passed
   2.315 +	if ( length === i ) {
   2.316 +		target = this;
   2.317 +		--i;
   2.318 +	}
   2.319 +
   2.320 +	for ( ; i < length; i++ ) {
   2.321 +		// Only deal with non-null/undefined values
   2.322 +		if ( (options = arguments[ i ]) != null ) {
   2.323 +			// Extend the base object
   2.324 +			for ( name in options ) {
   2.325 +				src = target[ name ];
   2.326 +				copy = options[ name ];
   2.327 +
   2.328 +				// Prevent never-ending loop
   2.329 +				if ( target === copy ) {
   2.330 +					continue;
   2.331 +				}
   2.332 +
   2.333 +				// Recurse if we're merging plain objects or arrays
   2.334 +				if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
   2.335 +					if ( copyIsArray ) {
   2.336 +						copyIsArray = false;
   2.337 +						clone = src && jQuery.isArray(src) ? src : [];
   2.338 +
   2.339 +					} else {
   2.340 +						clone = src && jQuery.isPlainObject(src) ? src : {};
   2.341 +					}
   2.342 +
   2.343 +					// Never move original objects, clone them
   2.344 +					target[ name ] = jQuery.extend( deep, clone, copy );
   2.345 +
   2.346 +				// Don't bring in undefined values
   2.347 +				} else if ( copy !== undefined ) {
   2.348 +					target[ name ] = copy;
   2.349 +				}
   2.350 +			}
   2.351 +		}
   2.352 +	}
   2.353 +
   2.354 +	// Return the modified object
   2.355 +	return target;
   2.356 +};
   2.357 +
   2.358 +jQuery.extend({
   2.359 +	noConflict: function( deep ) {
   2.360 +		if ( window.$ === jQuery ) {
   2.361 +			window.$ = _$;
   2.362 +		}
   2.363 +
   2.364 +		if ( deep && window.jQuery === jQuery ) {
   2.365 +			window.jQuery = _jQuery;
   2.366 +		}
   2.367 +
   2.368 +		return jQuery;
   2.369 +	},
   2.370 +
   2.371 +	// Is the DOM ready to be used? Set to true once it occurs.
   2.372 +	isReady: false,
   2.373 +
   2.374 +	// A counter to track how many items to wait for before
   2.375 +	// the ready event fires. See #6781
   2.376 +	readyWait: 1,
   2.377 +
   2.378 +	// Hold (or release) the ready event
   2.379 +	holdReady: function( hold ) {
   2.380 +		if ( hold ) {
   2.381 +			jQuery.readyWait++;
   2.382 +		} else {
   2.383 +			jQuery.ready( true );
   2.384 +		}
   2.385 +	},
   2.386 +
   2.387 +	// Handle when the DOM is ready
   2.388 +	ready: function( wait ) {
   2.389 +
   2.390 +		// Abort if there are pending holds or we're already ready
   2.391 +		if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
   2.392 +			return;
   2.393 +		}
   2.394 +
   2.395 +		// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
   2.396 +		if ( !document.body ) {
   2.397 +			return setTimeout( jQuery.ready, 1 );
   2.398 +		}
   2.399 +
   2.400 +		// Remember that the DOM is ready
   2.401 +		jQuery.isReady = true;
   2.402 +
   2.403 +		// If a normal DOM Ready event fired, decrement, and wait if need be
   2.404 +		if ( wait !== true && --jQuery.readyWait > 0 ) {
   2.405 +			return;
   2.406 +		}
   2.407 +
   2.408 +		// If there are functions bound, to execute
   2.409 +		readyList.resolveWith( document, [ jQuery ] );
   2.410 +
   2.411 +		// Trigger any bound ready events
   2.412 +		if ( jQuery.fn.trigger ) {
   2.413 +			jQuery( document ).trigger("ready").off("ready");
   2.414 +		}
   2.415 +	},
   2.416 +
   2.417 +	// See test/unit/core.js for details concerning isFunction.
   2.418 +	// Since version 1.3, DOM methods and functions like alert
   2.419 +	// aren't supported. They return false on IE (#2968).
   2.420 +	isFunction: function( obj ) {
   2.421 +		return jQuery.type(obj) === "function";
   2.422 +	},
   2.423 +
   2.424 +	isArray: Array.isArray || function( obj ) {
   2.425 +		return jQuery.type(obj) === "array";
   2.426 +	},
   2.427 +
   2.428 +	isWindow: function( obj ) {
   2.429 +		return obj != null && obj == obj.window;
   2.430 +	},
   2.431 +
   2.432 +	isNumeric: function( obj ) {
   2.433 +		return !isNaN( parseFloat(obj) ) && isFinite( obj );
   2.434 +	},
   2.435 +
   2.436 +	type: function( obj ) {
   2.437 +		return obj == null ?
   2.438 +			String( obj ) :
   2.439 +			class2type[ core_toString.call(obj) ] || "object";
   2.440 +	},
   2.441 +
   2.442 +	isPlainObject: function( obj ) {
   2.443 +		// Must be an Object.
   2.444 +		// Because of IE, we also have to check the presence of the constructor property.
   2.445 +		// Make sure that DOM nodes and window objects don't pass through, as well
   2.446 +		if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
   2.447 +			return false;
   2.448 +		}
   2.449 +
   2.450 +		try {
   2.451 +			// Not own constructor property must be Object
   2.452 +			if ( obj.constructor &&
   2.453 +				!core_hasOwn.call(obj, "constructor") &&
   2.454 +				!core_hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
   2.455 +				return false;
   2.456 +			}
   2.457 +		} catch ( e ) {
   2.458 +			// IE8,9 Will throw exceptions on certain host objects #9897
   2.459 +			return false;
   2.460 +		}
   2.461 +
   2.462 +		// Own properties are enumerated firstly, so to speed up,
   2.463 +		// if last one is own, then all properties are own.
   2.464 +
   2.465 +		var key;
   2.466 +		for ( key in obj ) {}
   2.467 +
   2.468 +		return key === undefined || core_hasOwn.call( obj, key );
   2.469 +	},
   2.470 +
   2.471 +	isEmptyObject: function( obj ) {
   2.472 +		var name;
   2.473 +		for ( name in obj ) {
   2.474 +			return false;
   2.475 +		}
   2.476 +		return true;
   2.477 +	},
   2.478 +
   2.479 +	error: function( msg ) {
   2.480 +		throw new Error( msg );
   2.481 +	},
   2.482 +
   2.483 +	// data: string of html
   2.484 +	// context (optional): If specified, the fragment will be created in this context, defaults to document
   2.485 +	// scripts (optional): If true, will include scripts passed in the html string
   2.486 +	parseHTML: function( data, context, scripts ) {
   2.487 +		var parsed;
   2.488 +		if ( !data || typeof data !== "string" ) {
   2.489 +			return null;
   2.490 +		}
   2.491 +		if ( typeof context === "boolean" ) {
   2.492 +			scripts = context;
   2.493 +			context = 0;
   2.494 +		}
   2.495 +		context = context || document;
   2.496 +
   2.497 +		// Single tag
   2.498 +		if ( (parsed = rsingleTag.exec( data )) ) {
   2.499 +			return [ context.createElement( parsed[1] ) ];
   2.500 +		}
   2.501 +
   2.502 +		parsed = jQuery.buildFragment( [ data ], context, scripts ? null : [] );
   2.503 +		return jQuery.merge( [],
   2.504 +			(parsed.cacheable ? jQuery.clone( parsed.fragment ) : parsed.fragment).childNodes );
   2.505 +	},
   2.506 +
   2.507 +	parseJSON: function( data ) {
   2.508 +		if ( !data || typeof data !== "string") {
   2.509 +			return null;
   2.510 +		}
   2.511 +
   2.512 +		// Make sure leading/trailing whitespace is removed (IE can't handle it)
   2.513 +		data = jQuery.trim( data );
   2.514 +
   2.515 +		// Attempt to parse using the native JSON parser first
   2.516 +		if ( window.JSON && window.JSON.parse ) {
   2.517 +			return window.JSON.parse( data );
   2.518 +		}
   2.519 +
   2.520 +		// Make sure the incoming data is actual JSON
   2.521 +		// Logic borrowed from http://json.org/json2.js
   2.522 +		if ( rvalidchars.test( data.replace( rvalidescape, "@" )
   2.523 +			.replace( rvalidtokens, "]" )
   2.524 +			.replace( rvalidbraces, "")) ) {
   2.525 +
   2.526 +			return ( new Function( "return " + data ) )();
   2.527 +
   2.528 +		}
   2.529 +		jQuery.error( "Invalid JSON: " + data );
   2.530 +	},
   2.531 +
   2.532 +	// Cross-browser xml parsing
   2.533 +	parseXML: function( data ) {
   2.534 +		var xml, tmp;
   2.535 +		if ( !data || typeof data !== "string" ) {
   2.536 +			return null;
   2.537 +		}
   2.538 +		try {
   2.539 +			if ( window.DOMParser ) { // Standard
   2.540 +				tmp = new DOMParser();
   2.541 +				xml = tmp.parseFromString( data , "text/xml" );
   2.542 +			} else { // IE
   2.543 +				xml = new ActiveXObject( "Microsoft.XMLDOM" );
   2.544 +				xml.async = "false";
   2.545 +				xml.loadXML( data );
   2.546 +			}
   2.547 +		} catch( e ) {
   2.548 +			xml = undefined;
   2.549 +		}
   2.550 +		if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) {
   2.551 +			jQuery.error( "Invalid XML: " + data );
   2.552 +		}
   2.553 +		return xml;
   2.554 +	},
   2.555 +
   2.556 +	noop: function() {},
   2.557 +
   2.558 +	// Evaluates a script in a global context
   2.559 +	// Workarounds based on findings by Jim Driscoll
   2.560 +	// http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
   2.561 +	globalEval: function( data ) {
   2.562 +		if ( data && core_rnotwhite.test( data ) ) {
   2.563 +			// We use execScript on Internet Explorer
   2.564 +			// We use an anonymous function so that context is window
   2.565 +			// rather than jQuery in Firefox
   2.566 +			( window.execScript || function( data ) {
   2.567 +				window[ "eval" ].call( window, data );
   2.568 +			} )( data );
   2.569 +		}
   2.570 +	},
   2.571 +
   2.572 +	// Convert dashed to camelCase; used by the css and data modules
   2.573 +	// Microsoft forgot to hump their vendor prefix (#9572)
   2.574 +	camelCase: function( string ) {
   2.575 +		return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
   2.576 +	},
   2.577 +
   2.578 +	nodeName: function( elem, name ) {
   2.579 +		return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
   2.580 +	},
   2.581 +
   2.582 +	// args is for internal usage only
   2.583 +	each: function( obj, callback, args ) {
   2.584 +		var name,
   2.585 +			i = 0,
   2.586 +			length = obj.length,
   2.587 +			isObj = length === undefined || jQuery.isFunction( obj );
   2.588 +
   2.589 +		if ( args ) {
   2.590 +			if ( isObj ) {
   2.591 +				for ( name in obj ) {
   2.592 +					if ( callback.apply( obj[ name ], args ) === false ) {
   2.593 +						break;
   2.594 +					}
   2.595 +				}
   2.596 +			} else {
   2.597 +				for ( ; i < length; ) {
   2.598 +					if ( callback.apply( obj[ i++ ], args ) === false ) {
   2.599 +						break;
   2.600 +					}
   2.601 +				}
   2.602 +			}
   2.603 +
   2.604 +		// A special, fast, case for the most common use of each
   2.605 +		} else {
   2.606 +			if ( isObj ) {
   2.607 +				for ( name in obj ) {
   2.608 +					if ( callback.call( obj[ name ], name, obj[ name ] ) === false ) {
   2.609 +						break;
   2.610 +					}
   2.611 +				}
   2.612 +			} else {
   2.613 +				for ( ; i < length; ) {
   2.614 +					if ( callback.call( obj[ i ], i, obj[ i++ ] ) === false ) {
   2.615 +						break;
   2.616 +					}
   2.617 +				}
   2.618 +			}
   2.619 +		}
   2.620 +
   2.621 +		return obj;
   2.622 +	},
   2.623 +
   2.624 +	// Use native String.trim function wherever possible
   2.625 +	trim: core_trim && !core_trim.call("\uFEFF\xA0") ?
   2.626 +		function( text ) {
   2.627 +			return text == null ?
   2.628 +				"" :
   2.629 +				core_trim.call( text );
   2.630 +		} :
   2.631 +
   2.632 +		// Otherwise use our own trimming functionality
   2.633 +		function( text ) {
   2.634 +			return text == null ?
   2.635 +				"" :
   2.636 +				( text + "" ).replace( rtrim, "" );
   2.637 +		},
   2.638 +
   2.639 +	// results is for internal usage only
   2.640 +	makeArray: function( arr, results ) {
   2.641 +		var type,
   2.642 +			ret = results || [];
   2.643 +
   2.644 +		if ( arr != null ) {
   2.645 +			// The window, strings (and functions) also have 'length'
   2.646 +			// Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
   2.647 +			type = jQuery.type( arr );
   2.648 +
   2.649 +			if ( arr.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( arr ) ) {
   2.650 +				core_push.call( ret, arr );
   2.651 +			} else {
   2.652 +				jQuery.merge( ret, arr );
   2.653 +			}
   2.654 +		}
   2.655 +
   2.656 +		return ret;
   2.657 +	},
   2.658 +
   2.659 +	inArray: function( elem, arr, i ) {
   2.660 +		var len;
   2.661 +
   2.662 +		if ( arr ) {
   2.663 +			if ( core_indexOf ) {
   2.664 +				return core_indexOf.call( arr, elem, i );
   2.665 +			}
   2.666 +
   2.667 +			len = arr.length;
   2.668 +			i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0;
   2.669 +
   2.670 +			for ( ; i < len; i++ ) {
   2.671 +				// Skip accessing in sparse arrays
   2.672 +				if ( i in arr && arr[ i ] === elem ) {
   2.673 +					return i;
   2.674 +				}
   2.675 +			}
   2.676 +		}
   2.677 +
   2.678 +		return -1;
   2.679 +	},
   2.680 +
   2.681 +	merge: function( first, second ) {
   2.682 +		var l = second.length,
   2.683 +			i = first.length,
   2.684 +			j = 0;
   2.685 +
   2.686 +		if ( typeof l === "number" ) {
   2.687 +			for ( ; j < l; j++ ) {
   2.688 +				first[ i++ ] = second[ j ];
   2.689 +			}
   2.690 +
   2.691 +		} else {
   2.692 +			while ( second[j] !== undefined ) {
   2.693 +				first[ i++ ] = second[ j++ ];
   2.694 +			}
   2.695 +		}
   2.696 +
   2.697 +		first.length = i;
   2.698 +
   2.699 +		return first;
   2.700 +	},
   2.701 +
   2.702 +	grep: function( elems, callback, inv ) {
   2.703 +		var retVal,
   2.704 +			ret = [],
   2.705 +			i = 0,
   2.706 +			length = elems.length;
   2.707 +		inv = !!inv;
   2.708 +
   2.709 +		// Go through the array, only saving the items
   2.710 +		// that pass the validator function
   2.711 +		for ( ; i < length; i++ ) {
   2.712 +			retVal = !!callback( elems[ i ], i );
   2.713 +			if ( inv !== retVal ) {
   2.714 +				ret.push( elems[ i ] );
   2.715 +			}
   2.716 +		}
   2.717 +
   2.718 +		return ret;
   2.719 +	},
   2.720 +
   2.721 +	// arg is for internal usage only
   2.722 +	map: function( elems, callback, arg ) {
   2.723 +		var value, key,
   2.724 +			ret = [],
   2.725 +			i = 0,
   2.726 +			length = elems.length,
   2.727 +			// jquery objects are treated as arrays
   2.728 +			isArray = elems instanceof jQuery || length !== undefined && typeof length === "number" && ( ( length > 0 && elems[ 0 ] && elems[ length -1 ] ) || length === 0 || jQuery.isArray( elems ) ) ;
   2.729 +
   2.730 +		// Go through the array, translating each of the items to their
   2.731 +		if ( isArray ) {
   2.732 +			for ( ; i < length; i++ ) {
   2.733 +				value = callback( elems[ i ], i, arg );
   2.734 +
   2.735 +				if ( value != null ) {
   2.736 +					ret[ ret.length ] = value;
   2.737 +				}
   2.738 +			}
   2.739 +
   2.740 +		// Go through every key on the object,
   2.741 +		} else {
   2.742 +			for ( key in elems ) {
   2.743 +				value = callback( elems[ key ], key, arg );
   2.744 +
   2.745 +				if ( value != null ) {
   2.746 +					ret[ ret.length ] = value;
   2.747 +				}
   2.748 +			}
   2.749 +		}
   2.750 +
   2.751 +		// Flatten any nested arrays
   2.752 +		return ret.concat.apply( [], ret );
   2.753 +	},
   2.754 +
   2.755 +	// A global GUID counter for objects
   2.756 +	guid: 1,
   2.757 +
   2.758 +	// Bind a function to a context, optionally partially applying any
   2.759 +	// arguments.
   2.760 +	proxy: function( fn, context ) {
   2.761 +		var tmp, args, proxy;
   2.762 +
   2.763 +		if ( typeof context === "string" ) {
   2.764 +			tmp = fn[ context ];
   2.765 +			context = fn;
   2.766 +			fn = tmp;
   2.767 +		}
   2.768 +
   2.769 +		// Quick check to determine if target is callable, in the spec
   2.770 +		// this throws a TypeError, but we will just return undefined.
   2.771 +		if ( !jQuery.isFunction( fn ) ) {
   2.772 +			return undefined;
   2.773 +		}
   2.774 +
   2.775 +		// Simulated bind
   2.776 +		args = core_slice.call( arguments, 2 );
   2.777 +		proxy = function() {
   2.778 +			return fn.apply( context, args.concat( core_slice.call( arguments ) ) );
   2.779 +		};
   2.780 +
   2.781 +		// Set the guid of unique handler to the same of original handler, so it can be removed
   2.782 +		proxy.guid = fn.guid = fn.guid || jQuery.guid++;
   2.783 +
   2.784 +		return proxy;
   2.785 +	},
   2.786 +
   2.787 +	// Multifunctional method to get and set values of a collection
   2.788 +	// The value/s can optionally be executed if it's a function
   2.789 +	access: function( elems, fn, key, value, chainable, emptyGet, pass ) {
   2.790 +		var exec,
   2.791 +			bulk = key == null,
   2.792 +			i = 0,
   2.793 +			length = elems.length;
   2.794 +
   2.795 +		// Sets many values
   2.796 +		if ( key && typeof key === "object" ) {
   2.797 +			for ( i in key ) {
   2.798 +				jQuery.access( elems, fn, i, key[i], 1, emptyGet, value );
   2.799 +			}
   2.800 +			chainable = 1;
   2.801 +
   2.802 +		// Sets one value
   2.803 +		} else if ( value !== undefined ) {
   2.804 +			// Optionally, function values get executed if exec is true
   2.805 +			exec = pass === undefined && jQuery.isFunction( value );
   2.806 +
   2.807 +			if ( bulk ) {
   2.808 +				// Bulk operations only iterate when executing function values
   2.809 +				if ( exec ) {
   2.810 +					exec = fn;
   2.811 +					fn = function( elem, key, value ) {
   2.812 +						return exec.call( jQuery( elem ), value );
   2.813 +					};
   2.814 +
   2.815 +				// Otherwise they run against the entire set
   2.816 +				} else {
   2.817 +					fn.call( elems, value );
   2.818 +					fn = null;
   2.819 +				}
   2.820 +			}
   2.821 +
   2.822 +			if ( fn ) {
   2.823 +				for (; i < length; i++ ) {
   2.824 +					fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
   2.825 +				}
   2.826 +			}
   2.827 +
   2.828 +			chainable = 1;
   2.829 +		}
   2.830 +
   2.831 +		return chainable ?
   2.832 +			elems :
   2.833 +
   2.834 +			// Gets
   2.835 +			bulk ?
   2.836 +				fn.call( elems ) :
   2.837 +				length ? fn( elems[0], key ) : emptyGet;
   2.838 +	},
   2.839 +
   2.840 +	now: function() {
   2.841 +		return ( new Date() ).getTime();
   2.842 +	}
   2.843 +});
   2.844 +
   2.845 +jQuery.ready.promise = function( obj ) {
   2.846 +	if ( !readyList ) {
   2.847 +
   2.848 +		readyList = jQuery.Deferred();
   2.849 +
   2.850 +		// Catch cases where $(document).ready() is called after the browser event has already occurred.
   2.851 +		// we once tried to use readyState "interactive" here, but it caused issues like the one
   2.852 +		// discovered by ChrisS here: http://bugs.jquery.com/ticket/12282#comment:15
   2.853 +		if ( document.readyState === "complete" ) {
   2.854 +			// Handle it asynchronously to allow scripts the opportunity to delay ready
   2.855 +			setTimeout( jQuery.ready, 1 );
   2.856 +
   2.857 +		// Standards-based browsers support DOMContentLoaded
   2.858 +		} else if ( document.addEventListener ) {
   2.859 +			// Use the handy event callback
   2.860 +			document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
   2.861 +
   2.862 +			// A fallback to window.onload, that will always work
   2.863 +			window.addEventListener( "load", jQuery.ready, false );
   2.864 +
   2.865 +		// If IE event model is used
   2.866 +		} else {
   2.867 +			// Ensure firing before onload, maybe late but safe also for iframes
   2.868 +			document.attachEvent( "onreadystatechange", DOMContentLoaded );
   2.869 +
   2.870 +			// A fallback to window.onload, that will always work
   2.871 +			window.attachEvent( "onload", jQuery.ready );
   2.872 +
   2.873 +			// If IE and not a frame
   2.874 +			// continually check to see if the document is ready
   2.875 +			var top = false;
   2.876 +
   2.877 +			try {
   2.878 +				top = window.frameElement == null && document.documentElement;
   2.879 +			} catch(e) {}
   2.880 +
   2.881 +			if ( top && top.doScroll ) {
   2.882 +				(function doScrollCheck() {
   2.883 +					if ( !jQuery.isReady ) {
   2.884 +
   2.885 +						try {
   2.886 +							// Use the trick by Diego Perini
   2.887 +							// http://javascript.nwbox.com/IEContentLoaded/
   2.888 +							top.doScroll("left");
   2.889 +						} catch(e) {
   2.890 +							return setTimeout( doScrollCheck, 50 );
   2.891 +						}
   2.892 +
   2.893 +						// and execute any waiting functions
   2.894 +						jQuery.ready();
   2.895 +					}
   2.896 +				})();
   2.897 +			}
   2.898 +		}
   2.899 +	}
   2.900 +	return readyList.promise( obj );
   2.901 +};
   2.902 +
   2.903 +// Populate the class2type map
   2.904 +jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {
   2.905 +	class2type[ "[object " + name + "]" ] = name.toLowerCase();
   2.906 +});
   2.907 +
   2.908 +// All jQuery objects should point back to these
   2.909 +rootjQuery = jQuery(document);
   2.910 +// String to Object options format cache
   2.911 +var optionsCache = {};
   2.912 +
   2.913 +// Convert String-formatted options into Object-formatted ones and store in cache
   2.914 +function createOptions( options ) {
   2.915 +	var object = optionsCache[ options ] = {};
   2.916 +	jQuery.each( options.split( core_rspace ), function( _, flag ) {
   2.917 +		object[ flag ] = true;
   2.918 +	});
   2.919 +	return object;
   2.920 +}
   2.921 +
   2.922 +/*
   2.923 + * Create a callback list using the following parameters:
   2.924 + *
   2.925 + *	options: an optional list of space-separated options that will change how
   2.926 + *			the callback list behaves or a more traditional option object
   2.927 + *
   2.928 + * By default a callback list will act like an event callback list and can be
   2.929 + * "fired" multiple times.
   2.930 + *
   2.931 + * Possible options:
   2.932 + *
   2.933 + *	once:			will ensure the callback list can only be fired once (like a Deferred)
   2.934 + *
   2.935 + *	memory:			will keep track of previous values and will call any callback added
   2.936 + *					after the list has been fired right away with the latest "memorized"
   2.937 + *					values (like a Deferred)
   2.938 + *
   2.939 + *	unique:			will ensure a callback can only be added once (no duplicate in the list)
   2.940 + *
   2.941 + *	stopOnFalse:	interrupt callings when a callback returns false
   2.942 + *
   2.943 + */
   2.944 +jQuery.Callbacks = function( options ) {
   2.945 +
   2.946 +	// Convert options from String-formatted to Object-formatted if needed
   2.947 +	// (we check in cache first)
   2.948 +	options = typeof options === "string" ?
   2.949 +		( optionsCache[ options ] || createOptions( options ) ) :
   2.950 +		jQuery.extend( {}, options );
   2.951 +
   2.952 +	var // Last fire value (for non-forgettable lists)
   2.953 +		memory,
   2.954 +		// Flag to know if list was already fired
   2.955 +		fired,
   2.956 +		// Flag to know if list is currently firing
   2.957 +		firing,
   2.958 +		// First callback to fire (used internally by add and fireWith)
   2.959 +		firingStart,
   2.960 +		// End of the loop when firing
   2.961 +		firingLength,
   2.962 +		// Index of currently firing callback (modified by remove if needed)
   2.963 +		firingIndex,
   2.964 +		// Actual callback list
   2.965 +		list = [],
   2.966 +		// Stack of fire calls for repeatable lists
   2.967 +		stack = !options.once && [],
   2.968 +		// Fire callbacks
   2.969 +		fire = function( data ) {
   2.970 +			memory = options.memory && data;
   2.971 +			fired = true;
   2.972 +			firingIndex = firingStart || 0;
   2.973 +			firingStart = 0;
   2.974 +			firingLength = list.length;
   2.975 +			firing = true;
   2.976 +			for ( ; list && firingIndex < firingLength; firingIndex++ ) {
   2.977 +				if ( list[ firingIndex ].apply( data[ 0 ], data[ 1 ] ) === false && options.stopOnFalse ) {
   2.978 +					memory = false; // To prevent further calls using add
   2.979 +					break;
   2.980 +				}
   2.981 +			}
   2.982 +			firing = false;
   2.983 +			if ( list ) {
   2.984 +				if ( stack ) {
   2.985 +					if ( stack.length ) {
   2.986 +						fire( stack.shift() );
   2.987 +					}
   2.988 +				} else if ( memory ) {
   2.989 +					list = [];
   2.990 +				} else {
   2.991 +					self.disable();
   2.992 +				}
   2.993 +			}
   2.994 +		},
   2.995 +		// Actual Callbacks object
   2.996 +		self = {
   2.997 +			// Add a callback or a collection of callbacks to the list
   2.998 +			add: function() {
   2.999 +				if ( list ) {
  2.1000 +					// First, we save the current length
  2.1001 +					var start = list.length;
  2.1002 +					(function add( args ) {
  2.1003 +						jQuery.each( args, function( _, arg ) {
  2.1004 +							var type = jQuery.type( arg );
  2.1005 +							if ( type === "function" && ( !options.unique || !self.has( arg ) ) ) {
  2.1006 +								list.push( arg );
  2.1007 +							} else if ( arg && arg.length && type !== "string" ) {
  2.1008 +								// Inspect recursively
  2.1009 +								add( arg );
  2.1010 +							}
  2.1011 +						});
  2.1012 +					})( arguments );
  2.1013 +					// Do we need to add the callbacks to the
  2.1014 +					// current firing batch?
  2.1015 +					if ( firing ) {
  2.1016 +						firingLength = list.length;
  2.1017 +					// With memory, if we're not firing then
  2.1018 +					// we should call right away
  2.1019 +					} else if ( memory ) {
  2.1020 +						firingStart = start;
  2.1021 +						fire( memory );
  2.1022 +					}
  2.1023 +				}
  2.1024 +				return this;
  2.1025 +			},
  2.1026 +			// Remove a callback from the list
  2.1027 +			remove: function() {
  2.1028 +				if ( list ) {
  2.1029 +					jQuery.each( arguments, function( _, arg ) {
  2.1030 +						var index;
  2.1031 +						while( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
  2.1032 +							list.splice( index, 1 );
  2.1033 +							// Handle firing indexes
  2.1034 +							if ( firing ) {
  2.1035 +								if ( index <= firingLength ) {
  2.1036 +									firingLength--;
  2.1037 +								}
  2.1038 +								if ( index <= firingIndex ) {
  2.1039 +									firingIndex--;
  2.1040 +								}
  2.1041 +							}
  2.1042 +						}
  2.1043 +					});
  2.1044 +				}
  2.1045 +				return this;
  2.1046 +			},
  2.1047 +			// Control if a given callback is in the list
  2.1048 +			has: function( fn ) {
  2.1049 +				return jQuery.inArray( fn, list ) > -1;
  2.1050 +			},
  2.1051 +			// Remove all callbacks from the list
  2.1052 +			empty: function() {
  2.1053 +				list = [];
  2.1054 +				return this;
  2.1055 +			},
  2.1056 +			// Have the list do nothing anymore
  2.1057 +			disable: function() {
  2.1058 +				list = stack = memory = undefined;
  2.1059 +				return this;
  2.1060 +			},
  2.1061 +			// Is it disabled?
  2.1062 +			disabled: function() {
  2.1063 +				return !list;
  2.1064 +			},
  2.1065 +			// Lock the list in its current state
  2.1066 +			lock: function() {
  2.1067 +				stack = undefined;
  2.1068 +				if ( !memory ) {
  2.1069 +					self.disable();
  2.1070 +				}
  2.1071 +				return this;
  2.1072 +			},
  2.1073 +			// Is it locked?
  2.1074 +			locked: function() {
  2.1075 +				return !stack;
  2.1076 +			},
  2.1077 +			// Call all callbacks with the given context and arguments
  2.1078 +			fireWith: function( context, args ) {
  2.1079 +				args = args || [];
  2.1080 +				args = [ context, args.slice ? args.slice() : args ];
  2.1081 +				if ( list && ( !fired || stack ) ) {
  2.1082 +					if ( firing ) {
  2.1083 +						stack.push( args );
  2.1084 +					} else {
  2.1085 +						fire( args );
  2.1086 +					}
  2.1087 +				}
  2.1088 +				return this;
  2.1089 +			},
  2.1090 +			// Call all the callbacks with the given arguments
  2.1091 +			fire: function() {
  2.1092 +				self.fireWith( this, arguments );
  2.1093 +				return this;
  2.1094 +			},
  2.1095 +			// To know if the callbacks have already been called at least once
  2.1096 +			fired: function() {
  2.1097 +				return !!fired;
  2.1098 +			}
  2.1099 +		};
  2.1100 +
  2.1101 +	return self;
  2.1102 +};
  2.1103 +jQuery.extend({
  2.1104 +
  2.1105 +	Deferred: function( func ) {
  2.1106 +		var tuples = [
  2.1107 +				// action, add listener, listener list, final state
  2.1108 +				[ "resolve", "done", jQuery.Callbacks("once memory"), "resolved" ],
  2.1109 +				[ "reject", "fail", jQuery.Callbacks("once memory"), "rejected" ],
  2.1110 +				[ "notify", "progress", jQuery.Callbacks("memory") ]
  2.1111 +			],
  2.1112 +			state = "pending",
  2.1113 +			promise = {
  2.1114 +				state: function() {
  2.1115 +					return state;
  2.1116 +				},
  2.1117 +				always: function() {
  2.1118 +					deferred.done( arguments ).fail( arguments );
  2.1119 +					return this;
  2.1120 +				},
  2.1121 +				then: function( /* fnDone, fnFail, fnProgress */ ) {
  2.1122 +					var fns = arguments;
  2.1123 +					return jQuery.Deferred(function( newDefer ) {
  2.1124 +						jQuery.each( tuples, function( i, tuple ) {
  2.1125 +							var action = tuple[ 0 ],
  2.1126 +								fn = fns[ i ];
  2.1127 +							// deferred[ done | fail | progress ] for forwarding actions to newDefer
  2.1128 +							deferred[ tuple[1] ]( jQuery.isFunction( fn ) ?
  2.1129 +								function() {
  2.1130 +									var returned = fn.apply( this, arguments );
  2.1131 +									if ( returned && jQuery.isFunction( returned.promise ) ) {
  2.1132 +										returned.promise()
  2.1133 +											.done( newDefer.resolve )
  2.1134 +											.fail( newDefer.reject )
  2.1135 +											.progress( newDefer.notify );
  2.1136 +									} else {
  2.1137 +										newDefer[ action + "With" ]( this === deferred ? newDefer : this, [ returned ] );
  2.1138 +									}
  2.1139 +								} :
  2.1140 +								newDefer[ action ]
  2.1141 +							);
  2.1142 +						});
  2.1143 +						fns = null;
  2.1144 +					}).promise();
  2.1145 +				},
  2.1146 +				// Get a promise for this deferred
  2.1147 +				// If obj is provided, the promise aspect is added to the object
  2.1148 +				promise: function( obj ) {
  2.1149 +					return obj != null ? jQuery.extend( obj, promise ) : promise;
  2.1150 +				}
  2.1151 +			},
  2.1152 +			deferred = {};
  2.1153 +
  2.1154 +		// Keep pipe for back-compat
  2.1155 +		promise.pipe = promise.then;
  2.1156 +
  2.1157 +		// Add list-specific methods
  2.1158 +		jQuery.each( tuples, function( i, tuple ) {
  2.1159 +			var list = tuple[ 2 ],
  2.1160 +				stateString = tuple[ 3 ];
  2.1161 +
  2.1162 +			// promise[ done | fail | progress ] = list.add
  2.1163 +			promise[ tuple[1] ] = list.add;
  2.1164 +
  2.1165 +			// Handle state
  2.1166 +			if ( stateString ) {
  2.1167 +				list.add(function() {
  2.1168 +					// state = [ resolved | rejected ]
  2.1169 +					state = stateString;
  2.1170 +
  2.1171 +				// [ reject_list | resolve_list ].disable; progress_list.lock
  2.1172 +				}, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock );
  2.1173 +			}
  2.1174 +
  2.1175 +			// deferred[ resolve | reject | notify ] = list.fire
  2.1176 +			deferred[ tuple[0] ] = list.fire;
  2.1177 +			deferred[ tuple[0] + "With" ] = list.fireWith;
  2.1178 +		});
  2.1179 +
  2.1180 +		// Make the deferred a promise
  2.1181 +		promise.promise( deferred );
  2.1182 +
  2.1183 +		// Call given func if any
  2.1184 +		if ( func ) {
  2.1185 +			func.call( deferred, deferred );
  2.1186 +		}
  2.1187 +
  2.1188 +		// All done!
  2.1189 +		return deferred;
  2.1190 +	},
  2.1191 +
  2.1192 +	// Deferred helper
  2.1193 +	when: function( subordinate /* , ..., subordinateN */ ) {
  2.1194 +		var i = 0,
  2.1195 +			resolveValues = core_slice.call( arguments ),
  2.1196 +			length = resolveValues.length,
  2.1197 +
  2.1198 +			// the count of uncompleted subordinates
  2.1199 +			remaining = length !== 1 || ( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0,
  2.1200 +
  2.1201 +			// the master Deferred. If resolveValues consist of only a single Deferred, just use that.
  2.1202 +			deferred = remaining === 1 ? subordinate : jQuery.Deferred(),
  2.1203 +
  2.1204 +			// Update function for both resolve and progress values
  2.1205 +			updateFunc = function( i, contexts, values ) {
  2.1206 +				return function( value ) {
  2.1207 +					contexts[ i ] = this;
  2.1208 +					values[ i ] = arguments.length > 1 ? core_slice.call( arguments ) : value;
  2.1209 +					if( values === progressValues ) {
  2.1210 +						deferred.notifyWith( contexts, values );
  2.1211 +					} else if ( !( --remaining ) ) {
  2.1212 +						deferred.resolveWith( contexts, values );
  2.1213 +					}
  2.1214 +				};
  2.1215 +			},
  2.1216 +
  2.1217 +			progressValues, progressContexts, resolveContexts;
  2.1218 +
  2.1219 +		// add listeners to Deferred subordinates; treat others as resolved
  2.1220 +		if ( length > 1 ) {
  2.1221 +			progressValues = new Array( length );
  2.1222 +			progressContexts = new Array( length );
  2.1223 +			resolveContexts = new Array( length );
  2.1224 +			for ( ; i < length; i++ ) {
  2.1225 +				if ( resolveValues[ i ] && jQuery.isFunction( resolveValues[ i ].promise ) ) {
  2.1226 +					resolveValues[ i ].promise()
  2.1227 +						.done( updateFunc( i, resolveContexts, resolveValues ) )
  2.1228 +						.fail( deferred.reject )
  2.1229 +						.progress( updateFunc( i, progressContexts, progressValues ) );
  2.1230 +				} else {
  2.1231 +					--remaining;
  2.1232 +				}
  2.1233 +			}
  2.1234 +		}
  2.1235 +
  2.1236 +		// if we're not waiting on anything, resolve the master
  2.1237 +		if ( !remaining ) {
  2.1238 +			deferred.resolveWith( resolveContexts, resolveValues );
  2.1239 +		}
  2.1240 +
  2.1241 +		return deferred.promise();
  2.1242 +	}
  2.1243 +});
  2.1244 +jQuery.support = (function() {
  2.1245 +
  2.1246 +	var support,
  2.1247 +		all,
  2.1248 +		a,
  2.1249 +		select,
  2.1250 +		opt,
  2.1251 +		input,
  2.1252 +		fragment,
  2.1253 +		eventName,
  2.1254 +		i,
  2.1255 +		isSupported,
  2.1256 +		clickFn,
  2.1257 +		div = document.createElement("div");
  2.1258 +
  2.1259 +	// Preliminary tests
  2.1260 +	div.setAttribute( "className", "t" );
  2.1261 +	div.innerHTML = "  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>";
  2.1262 +
  2.1263 +	all = div.getElementsByTagName("*");
  2.1264 +	a = div.getElementsByTagName("a")[ 0 ];
  2.1265 +	a.style.cssText = "top:1px;float:left;opacity:.5";
  2.1266 +
  2.1267 +	// Can't get basic test support
  2.1268 +	if ( !all || !all.length ) {
  2.1269 +		return {};
  2.1270 +	}
  2.1271 +
  2.1272 +	// First batch of supports tests
  2.1273 +	select = document.createElement("select");
  2.1274 +	opt = select.appendChild( document.createElement("option") );
  2.1275 +	input = div.getElementsByTagName("input")[ 0 ];
  2.1276 +
  2.1277 +	support = {
  2.1278 +		// IE strips leading whitespace when .innerHTML is used
  2.1279 +		leadingWhitespace: ( div.firstChild.nodeType === 3 ),
  2.1280 +
  2.1281 +		// Make sure that tbody elements aren't automatically inserted
  2.1282 +		// IE will insert them into empty tables
  2.1283 +		tbody: !div.getElementsByTagName("tbody").length,
  2.1284 +
  2.1285 +		// Make sure that link elements get serialized correctly by innerHTML
  2.1286 +		// This requires a wrapper element in IE
  2.1287 +		htmlSerialize: !!div.getElementsByTagName("link").length,
  2.1288 +
  2.1289 +		// Get the style information from getAttribute
  2.1290 +		// (IE uses .cssText instead)
  2.1291 +		style: /top/.test( a.getAttribute("style") ),
  2.1292 +
  2.1293 +		// Make sure that URLs aren't manipulated
  2.1294 +		// (IE normalizes it by default)
  2.1295 +		hrefNormalized: ( a.getAttribute("href") === "/a" ),
  2.1296 +
  2.1297 +		// Make sure that element opacity exists
  2.1298 +		// (IE uses filter instead)
  2.1299 +		// Use a regex to work around a WebKit issue. See #5145
  2.1300 +		opacity: /^0.5/.test( a.style.opacity ),
  2.1301 +
  2.1302 +		// Verify style float existence
  2.1303 +		// (IE uses styleFloat instead of cssFloat)
  2.1304 +		cssFloat: !!a.style.cssFloat,
  2.1305 +
  2.1306 +		// Make sure that if no value is specified for a checkbox
  2.1307 +		// that it defaults to "on".
  2.1308 +		// (WebKit defaults to "" instead)
  2.1309 +		checkOn: ( input.value === "on" ),
  2.1310 +
  2.1311 +		// Make sure that a selected-by-default option has a working selected property.
  2.1312 +		// (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
  2.1313 +		optSelected: opt.selected,
  2.1314 +
  2.1315 +		// Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
  2.1316 +		getSetAttribute: div.className !== "t",
  2.1317 +
  2.1318 +		// Tests for enctype support on a form(#6743)
  2.1319 +		enctype: !!document.createElement("form").enctype,
  2.1320 +
  2.1321 +		// Makes sure cloning an html5 element does not cause problems
  2.1322 +		// Where outerHTML is undefined, this still works
  2.1323 +		html5Clone: document.createElement("nav").cloneNode( true ).outerHTML !== "<:nav></:nav>",
  2.1324 +
  2.1325 +		// jQuery.support.boxModel DEPRECATED in 1.8 since we don't support Quirks Mode
  2.1326 +		boxModel: ( document.compatMode === "CSS1Compat" ),
  2.1327 +
  2.1328 +		// Will be defined later
  2.1329 +		submitBubbles: true,
  2.1330 +		changeBubbles: true,
  2.1331 +		focusinBubbles: false,
  2.1332 +		deleteExpando: true,
  2.1333 +		noCloneEvent: true,
  2.1334 +		inlineBlockNeedsLayout: false,
  2.1335 +		shrinkWrapBlocks: false,
  2.1336 +		reliableMarginRight: true,
  2.1337 +		boxSizingReliable: true,
  2.1338 +		pixelPosition: false
  2.1339 +	};
  2.1340 +
  2.1341 +	// Make sure checked status is properly cloned
  2.1342 +	input.checked = true;
  2.1343 +	support.noCloneChecked = input.cloneNode( true ).checked;
  2.1344 +
  2.1345 +	// Make sure that the options inside disabled selects aren't marked as disabled
  2.1346 +	// (WebKit marks them as disabled)
  2.1347 +	select.disabled = true;
  2.1348 +	support.optDisabled = !opt.disabled;
  2.1349 +
  2.1350 +	// Test to see if it's possible to delete an expando from an element
  2.1351 +	// Fails in Internet Explorer
  2.1352 +	try {
  2.1353 +		delete div.test;
  2.1354 +	} catch( e ) {
  2.1355 +		support.deleteExpando = false;
  2.1356 +	}
  2.1357 +
  2.1358 +	if ( !div.addEventListener && div.attachEvent && div.fireEvent ) {
  2.1359 +		div.attachEvent( "onclick", clickFn = function() {
  2.1360 +			// Cloning a node shouldn't copy over any
  2.1361 +			// bound event handlers (IE does this)
  2.1362 +			support.noCloneEvent = false;
  2.1363 +		});
  2.1364 +		div.cloneNode( true ).fireEvent("onclick");
  2.1365 +		div.detachEvent( "onclick", clickFn );
  2.1366 +	}
  2.1367 +
  2.1368 +	// Check if a radio maintains its value
  2.1369 +	// after being appended to the DOM
  2.1370 +	input = document.createElement("input");
  2.1371 +	input.value = "t";
  2.1372 +	input.setAttribute( "type", "radio" );
  2.1373 +	support.radioValue = input.value === "t";
  2.1374 +
  2.1375 +	input.setAttribute( "checked", "checked" );
  2.1376 +
  2.1377 +	// #11217 - WebKit loses check when the name is after the checked attribute
  2.1378 +	input.setAttribute( "name", "t" );
  2.1379 +
  2.1380 +	div.appendChild( input );
  2.1381 +	fragment = document.createDocumentFragment();
  2.1382 +	fragment.appendChild( div.lastChild );
  2.1383 +
  2.1384 +	// WebKit doesn't clone checked state correctly in fragments
  2.1385 +	support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked;
  2.1386 +
  2.1387 +	// Check if a disconnected checkbox will retain its checked
  2.1388 +	// value of true after appended to the DOM (IE6/7)
  2.1389 +	support.appendChecked = input.checked;
  2.1390 +
  2.1391 +	fragment.removeChild( input );
  2.1392 +	fragment.appendChild( div );
  2.1393 +
  2.1394 +	// Technique from Juriy Zaytsev
  2.1395 +	// http://perfectionkills.com/detecting-event-support-without-browser-sniffing/
  2.1396 +	// We only care about the case where non-standard event systems
  2.1397 +	// are used, namely in IE. Short-circuiting here helps us to
  2.1398 +	// avoid an eval call (in setAttribute) which can cause CSP
  2.1399 +	// to go haywire. See: https://developer.mozilla.org/en/Security/CSP
  2.1400 +	if ( div.attachEvent ) {
  2.1401 +		for ( i in {
  2.1402 +			submit: true,
  2.1403 +			change: true,
  2.1404 +			focusin: true
  2.1405 +		}) {
  2.1406 +			eventName = "on" + i;
  2.1407 +			isSupported = ( eventName in div );
  2.1408 +			if ( !isSupported ) {
  2.1409 +				div.setAttribute( eventName, "return;" );
  2.1410 +				isSupported = ( typeof div[ eventName ] === "function" );
  2.1411 +			}
  2.1412 +			support[ i + "Bubbles" ] = isSupported;
  2.1413 +		}
  2.1414 +	}
  2.1415 +
  2.1416 +	// Run tests that need a body at doc ready
  2.1417 +	jQuery(function() {
  2.1418 +		var container, div, tds, marginDiv,
  2.1419 +			divReset = "padding:0;margin:0;border:0;display:block;overflow:hidden;",
  2.1420 +			body = document.getElementsByTagName("body")[0];
  2.1421 +
  2.1422 +		if ( !body ) {
  2.1423 +			// Return for frameset docs that don't have a body
  2.1424 +			return;
  2.1425 +		}
  2.1426 +
  2.1427 +		container = document.createElement("div");
  2.1428 +		container.style.cssText = "visibility:hidden;border:0;width:0;height:0;position:static;top:0;margin-top:1px";
  2.1429 +		body.insertBefore( container, body.firstChild );
  2.1430 +
  2.1431 +		// Construct the test element
  2.1432 +		div = document.createElement("div");
  2.1433 +		container.appendChild( div );
  2.1434 +
  2.1435 +		// Check if table cells still have offsetWidth/Height when they are set
  2.1436 +		// to display:none and there are still other visible table cells in a
  2.1437 +		// table row; if so, offsetWidth/Height are not reliable for use when
  2.1438 +		// determining if an element has been hidden directly using
  2.1439 +		// display:none (it is still safe to use offsets if a parent element is
  2.1440 +		// hidden; don safety goggles and see bug #4512 for more information).
  2.1441 +		// (only IE 8 fails this test)
  2.1442 +		div.innerHTML = "<table><tr><td></td><td>t</td></tr></table>";
  2.1443 +		tds = div.getElementsByTagName("td");
  2.1444 +		tds[ 0 ].style.cssText = "padding:0;margin:0;border:0;display:none";
  2.1445 +		isSupported = ( tds[ 0 ].offsetHeight === 0 );
  2.1446 +
  2.1447 +		tds[ 0 ].style.display = "";
  2.1448 +		tds[ 1 ].style.display = "none";
  2.1449 +
  2.1450 +		// Check if empty table cells still have offsetWidth/Height
  2.1451 +		// (IE <= 8 fail this test)
  2.1452 +		support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 );
  2.1453 +
  2.1454 +		// Check box-sizing and margin behavior
  2.1455 +		div.innerHTML = "";
  2.1456 +		div.style.cssText = "box-sizing:border-box;-moz-box-sizing:border-box;-webkit-box-sizing:border-box;padding:1px;border:1px;display:block;width:4px;margin-top:1%;position:absolute;top:1%;";
  2.1457 +		support.boxSizing = ( div.offsetWidth === 4 );
  2.1458 +		support.doesNotIncludeMarginInBodyOffset = ( body.offsetTop !== 1 );
  2.1459 +
  2.1460 +		// NOTE: To any future maintainer, we've window.getComputedStyle
  2.1461 +		// because jsdom on node.js will break without it.
  2.1462 +		if ( window.getComputedStyle ) {
  2.1463 +			support.pixelPosition = ( window.getComputedStyle( div, null ) || {} ).top !== "1%";
  2.1464 +			support.boxSizingReliable = ( window.getComputedStyle( div, null ) || { width: "4px" } ).width === "4px";
  2.1465 +
  2.1466 +			// Check if div with explicit width and no margin-right incorrectly
  2.1467 +			// gets computed margin-right based on width of container. For more
  2.1468 +			// info see bug #3333
  2.1469 +			// Fails in WebKit before Feb 2011 nightlies
  2.1470 +			// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
  2.1471 +			marginDiv = document.createElement("div");
  2.1472 +			marginDiv.style.cssText = div.style.cssText = divReset;
  2.1473 +			marginDiv.style.marginRight = marginDiv.style.width = "0";
  2.1474 +			div.style.width = "1px";
  2.1475 +			div.appendChild( marginDiv );
  2.1476 +			support.reliableMarginRight =
  2.1477 +				!parseFloat( ( window.getComputedStyle( marginDiv, null ) || {} ).marginRight );
  2.1478 +		}
  2.1479 +
  2.1480 +		if ( typeof div.style.zoom !== "undefined" ) {
  2.1481 +			// Check if natively block-level elements act like inline-block
  2.1482 +			// elements when setting their display to 'inline' and giving
  2.1483 +			// them layout
  2.1484 +			// (IE < 8 does this)
  2.1485 +			div.innerHTML = "";
  2.1486 +			div.style.cssText = divReset + "width:1px;padding:1px;display:inline;zoom:1";
  2.1487 +			support.inlineBlockNeedsLayout = ( div.offsetWidth === 3 );
  2.1488 +
  2.1489 +			// Check if elements with layout shrink-wrap their children
  2.1490 +			// (IE 6 does this)
  2.1491 +			div.style.display = "block";
  2.1492 +			div.style.overflow = "visible";
  2.1493 +			div.innerHTML = "<div></div>";
  2.1494 +			div.firstChild.style.width = "5px";
  2.1495 +			support.shrinkWrapBlocks = ( div.offsetWidth !== 3 );
  2.1496 +
  2.1497 +			container.style.zoom = 1;
  2.1498 +		}
  2.1499 +
  2.1500 +		// Null elements to avoid leaks in IE
  2.1501 +		body.removeChild( container );
  2.1502 +		container = div = tds = marginDiv = null;
  2.1503 +	});
  2.1504 +
  2.1505 +	// Null elements to avoid leaks in IE
  2.1506 +	fragment.removeChild( div );
  2.1507 +	all = a = select = opt = input = fragment = div = null;
  2.1508 +
  2.1509 +	return support;
  2.1510 +})();
  2.1511 +var rbrace = /(?:\{[\s\S]*\}|\[[\s\S]*\])$/,
  2.1512 +	rmultiDash = /([A-Z])/g;
  2.1513 +
  2.1514 +jQuery.extend({
  2.1515 +	cache: {},
  2.1516 +
  2.1517 +	deletedIds: [],
  2.1518 +
  2.1519 +	// Remove at next major release (1.9/2.0)
  2.1520 +	uuid: 0,
  2.1521 +
  2.1522 +	// Unique for each copy of jQuery on the page
  2.1523 +	// Non-digits removed to match rinlinejQuery
  2.1524 +	expando: "jQuery" + ( jQuery.fn.jquery + Math.random() ).replace( /\D/g, "" ),
  2.1525 +
  2.1526 +	// The following elements throw uncatchable exceptions if you
  2.1527 +	// attempt to add expando properties to them.
  2.1528 +	noData: {
  2.1529 +		"embed": true,
  2.1530 +		// Ban all objects except for Flash (which handle expandos)
  2.1531 +		"object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
  2.1532 +		"applet": true
  2.1533 +	},
  2.1534 +
  2.1535 +	hasData: function( elem ) {
  2.1536 +		elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ];
  2.1537 +		return !!elem && !isEmptyDataObject( elem );
  2.1538 +	},
  2.1539 +
  2.1540 +	data: function( elem, name, data, pvt /* Internal Use Only */ ) {
  2.1541 +		if ( !jQuery.acceptData( elem ) ) {
  2.1542 +			return;
  2.1543 +		}
  2.1544 +
  2.1545 +		var thisCache, ret,
  2.1546 +			internalKey = jQuery.expando,
  2.1547 +			getByName = typeof name === "string",
  2.1548 +
  2.1549 +			// We have to handle DOM nodes and JS objects differently because IE6-7
  2.1550 +			// can't GC object references properly across the DOM-JS boundary
  2.1551 +			isNode = elem.nodeType,
  2.1552 +
  2.1553 +			// Only DOM nodes need the global jQuery cache; JS object data is
  2.1554 +			// attached directly to the object so GC can occur automatically
  2.1555 +			cache = isNode ? jQuery.cache : elem,
  2.1556 +
  2.1557 +			// Only defining an ID for JS objects if its cache already exists allows
  2.1558 +			// the code to shortcut on the same path as a DOM node with no cache
  2.1559 +			id = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey;
  2.1560 +
  2.1561 +		// Avoid doing any more work than we need to when trying to get data on an
  2.1562 +		// object that has no data at all
  2.1563 +		if ( (!id || !cache[id] || (!pvt && !cache[id].data)) && getByName && data === undefined ) {
  2.1564 +			return;
  2.1565 +		}
  2.1566 +
  2.1567 +		if ( !id ) {
  2.1568 +			// Only DOM nodes need a new unique ID for each element since their data
  2.1569 +			// ends up in the global cache
  2.1570 +			if ( isNode ) {
  2.1571 +				elem[ internalKey ] = id = jQuery.deletedIds.pop() || jQuery.guid++;
  2.1572 +			} else {
  2.1573 +				id = internalKey;
  2.1574 +			}
  2.1575 +		}
  2.1576 +
  2.1577 +		if ( !cache[ id ] ) {
  2.1578 +			cache[ id ] = {};
  2.1579 +
  2.1580 +			// Avoids exposing jQuery metadata on plain JS objects when the object
  2.1581 +			// is serialized using JSON.stringify
  2.1582 +			if ( !isNode ) {
  2.1583 +				cache[ id ].toJSON = jQuery.noop;
  2.1584 +			}
  2.1585 +		}
  2.1586 +
  2.1587 +		// An object can be passed to jQuery.data instead of a key/value pair; this gets
  2.1588 +		// shallow copied over onto the existing cache
  2.1589 +		if ( typeof name === "object" || typeof name === "function" ) {
  2.1590 +			if ( pvt ) {
  2.1591 +				cache[ id ] = jQuery.extend( cache[ id ], name );
  2.1592 +			} else {
  2.1593 +				cache[ id ].data = jQuery.extend( cache[ id ].data, name );
  2.1594 +			}
  2.1595 +		}
  2.1596 +
  2.1597 +		thisCache = cache[ id ];
  2.1598 +
  2.1599 +		// jQuery data() is stored in a separate object inside the object's internal data
  2.1600 +		// cache in order to avoid key collisions between internal data and user-defined
  2.1601 +		// data.
  2.1602 +		if ( !pvt ) {
  2.1603 +			if ( !thisCache.data ) {
  2.1604 +				thisCache.data = {};
  2.1605 +			}
  2.1606 +
  2.1607 +			thisCache = thisCache.data;
  2.1608 +		}
  2.1609 +
  2.1610 +		if ( data !== undefined ) {
  2.1611 +			thisCache[ jQuery.camelCase( name ) ] = data;
  2.1612 +		}
  2.1613 +
  2.1614 +		// Check for both converted-to-camel and non-converted data property names
  2.1615 +		// If a data property was specified
  2.1616 +		if ( getByName ) {
  2.1617 +
  2.1618 +			// First Try to find as-is property data
  2.1619 +			ret = thisCache[ name ];
  2.1620 +
  2.1621 +			// Test for null|undefined property data
  2.1622 +			if ( ret == null ) {
  2.1623 +
  2.1624 +				// Try to find the camelCased property
  2.1625 +				ret = thisCache[ jQuery.camelCase( name ) ];
  2.1626 +			}
  2.1627 +		} else {
  2.1628 +			ret = thisCache;
  2.1629 +		}
  2.1630 +
  2.1631 +		return ret;
  2.1632 +	},
  2.1633 +
  2.1634 +	removeData: function( elem, name, pvt /* Internal Use Only */ ) {
  2.1635 +		if ( !jQuery.acceptData( elem ) ) {
  2.1636 +			return;
  2.1637 +		}
  2.1638 +
  2.1639 +		var thisCache, i, l,
  2.1640 +
  2.1641 +			isNode = elem.nodeType,
  2.1642 +
  2.1643 +			// See jQuery.data for more information
  2.1644 +			cache = isNode ? jQuery.cache : elem,
  2.1645 +			id = isNode ? elem[ jQuery.expando ] : jQuery.expando;
  2.1646 +
  2.1647 +		// If there is already no cache entry for this object, there is no
  2.1648 +		// purpose in continuing
  2.1649 +		if ( !cache[ id ] ) {
  2.1650 +			return;
  2.1651 +		}
  2.1652 +
  2.1653 +		if ( name ) {
  2.1654 +
  2.1655 +			thisCache = pvt ? cache[ id ] : cache[ id ].data;
  2.1656 +
  2.1657 +			if ( thisCache ) {
  2.1658 +
  2.1659 +				// Support array or space separated string names for data keys
  2.1660 +				if ( !jQuery.isArray( name ) ) {
  2.1661 +
  2.1662 +					// try the string as a key before any manipulation
  2.1663 +					if ( name in thisCache ) {
  2.1664 +						name = [ name ];
  2.1665 +					} else {
  2.1666 +
  2.1667 +						// split the camel cased version by spaces unless a key with the spaces exists
  2.1668 +						name = jQuery.camelCase( name );
  2.1669 +						if ( name in thisCache ) {
  2.1670 +							name = [ name ];
  2.1671 +						} else {
  2.1672 +							name = name.split(" ");
  2.1673 +						}
  2.1674 +					}
  2.1675 +				}
  2.1676 +
  2.1677 +				for ( i = 0, l = name.length; i < l; i++ ) {
  2.1678 +					delete thisCache[ name[i] ];
  2.1679 +				}
  2.1680 +
  2.1681 +				// If there is no data left in the cache, we want to continue
  2.1682 +				// and let the cache object itself get destroyed
  2.1683 +				if ( !( pvt ? isEmptyDataObject : jQuery.isEmptyObject )( thisCache ) ) {
  2.1684 +					return;
  2.1685 +				}
  2.1686 +			}
  2.1687 +		}
  2.1688 +
  2.1689 +		// See jQuery.data for more information
  2.1690 +		if ( !pvt ) {
  2.1691 +			delete cache[ id ].data;
  2.1692 +
  2.1693 +			// Don't destroy the parent cache unless the internal data object
  2.1694 +			// had been the only thing left in it
  2.1695 +			if ( !isEmptyDataObject( cache[ id ] ) ) {
  2.1696 +				return;
  2.1697 +			}
  2.1698 +		}
  2.1699 +
  2.1700 +		// Destroy the cache
  2.1701 +		if ( isNode ) {
  2.1702 +			jQuery.cleanData( [ elem ], true );
  2.1703 +
  2.1704 +		// Use delete when supported for expandos or `cache` is not a window per isWindow (#10080)
  2.1705 +		} else if ( jQuery.support.deleteExpando || cache != cache.window ) {
  2.1706 +			delete cache[ id ];
  2.1707 +
  2.1708 +		// When all else fails, null
  2.1709 +		} else {
  2.1710 +			cache[ id ] = null;
  2.1711 +		}
  2.1712 +	},
  2.1713 +
  2.1714 +	// For internal use only.
  2.1715 +	_data: function( elem, name, data ) {
  2.1716 +		return jQuery.data( elem, name, data, true );
  2.1717 +	},
  2.1718 +
  2.1719 +	// A method for determining if a DOM node can handle the data expando
  2.1720 +	acceptData: function( elem ) {
  2.1721 +		var noData = elem.nodeName && jQuery.noData[ elem.nodeName.toLowerCase() ];
  2.1722 +
  2.1723 +		// nodes accept data unless otherwise specified; rejection can be conditional
  2.1724 +		return !noData || noData !== true && elem.getAttribute("classid") === noData;
  2.1725 +	}
  2.1726 +});
  2.1727 +
  2.1728 +jQuery.fn.extend({
  2.1729 +	data: function( key, value ) {
  2.1730 +		var parts, part, attr, name, l,
  2.1731 +			elem = this[0],
  2.1732 +			i = 0,
  2.1733 +			data = null;
  2.1734 +
  2.1735 +		// Gets all values
  2.1736 +		if ( key === undefined ) {
  2.1737 +			if ( this.length ) {
  2.1738 +				data = jQuery.data( elem );
  2.1739 +
  2.1740 +				if ( elem.nodeType === 1 && !jQuery._data( elem, "parsedAttrs" ) ) {
  2.1741 +					attr = elem.attributes;
  2.1742 +					for ( l = attr.length; i < l; i++ ) {
  2.1743 +						name = attr[i].name;
  2.1744 +
  2.1745 +						if ( !name.indexOf( "data-" ) ) {
  2.1746 +							name = jQuery.camelCase( name.substring(5) );
  2.1747 +
  2.1748 +							dataAttr( elem, name, data[ name ] );
  2.1749 +						}
  2.1750 +					}
  2.1751 +					jQuery._data( elem, "parsedAttrs", true );
  2.1752 +				}
  2.1753 +			}
  2.1754 +
  2.1755 +			return data;
  2.1756 +		}
  2.1757 +
  2.1758 +		// Sets multiple values
  2.1759 +		if ( typeof key === "object" ) {
  2.1760 +			return this.each(function() {
  2.1761 +				jQuery.data( this, key );
  2.1762 +			});
  2.1763 +		}
  2.1764 +
  2.1765 +		parts = key.split( ".", 2 );
  2.1766 +		parts[1] = parts[1] ? "." + parts[1] : "";
  2.1767 +		part = parts[1] + "!";
  2.1768 +
  2.1769 +		return jQuery.access( this, function( value ) {
  2.1770 +
  2.1771 +			if ( value === undefined ) {
  2.1772 +				data = this.triggerHandler( "getData" + part, [ parts[0] ] );
  2.1773 +
  2.1774 +				// Try to fetch any internally stored data first
  2.1775 +				if ( data === undefined && elem ) {
  2.1776 +					data = jQuery.data( elem, key );
  2.1777 +					data = dataAttr( elem, key, data );
  2.1778 +				}
  2.1779 +
  2.1780 +				return data === undefined && parts[1] ?
  2.1781 +					this.data( parts[0] ) :
  2.1782 +					data;
  2.1783 +			}
  2.1784 +
  2.1785 +			parts[1] = value;
  2.1786 +			this.each(function() {
  2.1787 +				var self = jQuery( this );
  2.1788 +
  2.1789 +				self.triggerHandler( "setData" + part, parts );
  2.1790 +				jQuery.data( this, key, value );
  2.1791 +				self.triggerHandler( "changeData" + part, parts );
  2.1792 +			});
  2.1793 +		}, null, value, arguments.length > 1, null, false );
  2.1794 +	},
  2.1795 +
  2.1796 +	removeData: function( key ) {
  2.1797 +		return this.each(function() {
  2.1798 +			jQuery.removeData( this, key );
  2.1799 +		});
  2.1800 +	}
  2.1801 +});
  2.1802 +
  2.1803 +function dataAttr( elem, key, data ) {
  2.1804 +	// If nothing was found internally, try to fetch any
  2.1805 +	// data from the HTML5 data-* attribute
  2.1806 +	if ( data === undefined && elem.nodeType === 1 ) {
  2.1807 +
  2.1808 +		var name = "data-" + key.replace( rmultiDash, "-$1" ).toLowerCase();
  2.1809 +
  2.1810 +		data = elem.getAttribute( name );
  2.1811 +
  2.1812 +		if ( typeof data === "string" ) {
  2.1813 +			try {
  2.1814 +				data = data === "true" ? true :
  2.1815 +				data === "false" ? false :
  2.1816 +				data === "null" ? null :
  2.1817 +				// Only convert to a number if it doesn't change the string
  2.1818 +				+data + "" === data ? +data :
  2.1819 +				rbrace.test( data ) ? jQuery.parseJSON( data ) :
  2.1820 +					data;
  2.1821 +			} catch( e ) {}
  2.1822 +
  2.1823 +			// Make sure we set the data so it isn't changed later
  2.1824 +			jQuery.data( elem, key, data );
  2.1825 +
  2.1826 +		} else {
  2.1827 +			data = undefined;
  2.1828 +		}
  2.1829 +	}
  2.1830 +
  2.1831 +	return data;
  2.1832 +}
  2.1833 +
  2.1834 +// checks a cache object for emptiness
  2.1835 +function isEmptyDataObject( obj ) {
  2.1836 +	var name;
  2.1837 +	for ( name in obj ) {
  2.1838 +
  2.1839 +		// if the public data object is empty, the private is still empty
  2.1840 +		if ( name === "data" && jQuery.isEmptyObject( obj[name] ) ) {
  2.1841 +			continue;
  2.1842 +		}
  2.1843 +		if ( name !== "toJSON" ) {
  2.1844 +			return false;
  2.1845 +		}
  2.1846 +	}
  2.1847 +
  2.1848 +	return true;
  2.1849 +}
  2.1850 +jQuery.extend({
  2.1851 +	queue: function( elem, type, data ) {
  2.1852 +		var queue;
  2.1853 +
  2.1854 +		if ( elem ) {
  2.1855 +			type = ( type || "fx" ) + "queue";
  2.1856 +			queue = jQuery._data( elem, type );
  2.1857 +
  2.1858 +			// Speed up dequeue by getting out quickly if this is just a lookup
  2.1859 +			if ( data ) {
  2.1860 +				if ( !queue || jQuery.isArray(data) ) {
  2.1861 +					queue = jQuery._data( elem, type, jQuery.makeArray(data) );
  2.1862 +				} else {
  2.1863 +					queue.push( data );
  2.1864 +				}
  2.1865 +			}
  2.1866 +			return queue || [];
  2.1867 +		}
  2.1868 +	},
  2.1869 +
  2.1870 +	dequeue: function( elem, type ) {
  2.1871 +		type = type || "fx";
  2.1872 +
  2.1873 +		var queue = jQuery.queue( elem, type ),
  2.1874 +			startLength = queue.length,
  2.1875 +			fn = queue.shift(),
  2.1876 +			hooks = jQuery._queueHooks( elem, type ),
  2.1877 +			next = function() {
  2.1878 +				jQuery.dequeue( elem, type );
  2.1879 +			};
  2.1880 +
  2.1881 +		// If the fx queue is dequeued, always remove the progress sentinel
  2.1882 +		if ( fn === "inprogress" ) {
  2.1883 +			fn = queue.shift();
  2.1884 +			startLength--;
  2.1885 +		}
  2.1886 +
  2.1887 +		if ( fn ) {
  2.1888 +
  2.1889 +			// Add a progress sentinel to prevent the fx queue from being
  2.1890 +			// automatically dequeued
  2.1891 +			if ( type === "fx" ) {
  2.1892 +				queue.unshift( "inprogress" );
  2.1893 +			}
  2.1894 +
  2.1895 +			// clear up the last queue stop function
  2.1896 +			delete hooks.stop;
  2.1897 +			fn.call( elem, next, hooks );
  2.1898 +		}
  2.1899 +
  2.1900 +		if ( !startLength && hooks ) {
  2.1901 +			hooks.empty.fire();
  2.1902 +		}
  2.1903 +	},
  2.1904 +
  2.1905 +	// not intended for public consumption - generates a queueHooks object, or returns the current one
  2.1906 +	_queueHooks: function( elem, type ) {
  2.1907 +		var key = type + "queueHooks";
  2.1908 +		return jQuery._data( elem, key ) || jQuery._data( elem, key, {
  2.1909 +			empty: jQuery.Callbacks("once memory").add(function() {
  2.1910 +				jQuery.removeData( elem, type + "queue", true );
  2.1911 +				jQuery.removeData( elem, key, true );
  2.1912 +			})
  2.1913 +		});
  2.1914 +	}
  2.1915 +});
  2.1916 +
  2.1917 +jQuery.fn.extend({
  2.1918 +	queue: function( type, data ) {
  2.1919 +		var setter = 2;
  2.1920 +
  2.1921 +		if ( typeof type !== "string" ) {
  2.1922 +			data = type;
  2.1923 +			type = "fx";
  2.1924 +			setter--;
  2.1925 +		}
  2.1926 +
  2.1927 +		if ( arguments.length < setter ) {
  2.1928 +			return jQuery.queue( this[0], type );
  2.1929 +		}
  2.1930 +
  2.1931 +		return data === undefined ?
  2.1932 +			this :
  2.1933 +			this.each(function() {
  2.1934 +				var queue = jQuery.queue( this, type, data );
  2.1935 +
  2.1936 +				// ensure a hooks for this queue
  2.1937 +				jQuery._queueHooks( this, type );
  2.1938 +
  2.1939 +				if ( type === "fx" && queue[0] !== "inprogress" ) {
  2.1940 +					jQuery.dequeue( this, type );
  2.1941 +				}
  2.1942 +			});
  2.1943 +	},
  2.1944 +	dequeue: function( type ) {
  2.1945 +		return this.each(function() {
  2.1946 +			jQuery.dequeue( this, type );
  2.1947 +		});
  2.1948 +	},
  2.1949 +	// Based off of the plugin by Clint Helfers, with permission.
  2.1950 +	// http://blindsignals.com/index.php/2009/07/jquery-delay/
  2.1951 +	delay: function( time, type ) {
  2.1952 +		time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
  2.1953 +		type = type || "fx";
  2.1954 +
  2.1955 +		return this.queue( type, function( next, hooks ) {
  2.1956 +			var timeout = setTimeout( next, time );
  2.1957 +			hooks.stop = function() {
  2.1958 +				clearTimeout( timeout );
  2.1959 +			};
  2.1960 +		});
  2.1961 +	},
  2.1962 +	clearQueue: function( type ) {
  2.1963 +		return this.queue( type || "fx", [] );
  2.1964 +	},
  2.1965 +	// Get a promise resolved when queues of a certain type
  2.1966 +	// are emptied (fx is the type by default)
  2.1967 +	promise: function( type, obj ) {
  2.1968 +		var tmp,
  2.1969 +			count = 1,
  2.1970 +			defer = jQuery.Deferred(),
  2.1971 +			elements = this,
  2.1972 +			i = this.length,
  2.1973 +			resolve = function() {
  2.1974 +				if ( !( --count ) ) {
  2.1975 +					defer.resolveWith( elements, [ elements ] );
  2.1976 +				}
  2.1977 +			};
  2.1978 +
  2.1979 +		if ( typeof type !== "string" ) {
  2.1980 +			obj = type;
  2.1981 +			type = undefined;
  2.1982 +		}
  2.1983 +		type = type || "fx";
  2.1984 +
  2.1985 +		while( i-- ) {
  2.1986 +			tmp = jQuery._data( elements[ i ], type + "queueHooks" );
  2.1987 +			if ( tmp && tmp.empty ) {
  2.1988 +				count++;
  2.1989 +				tmp.empty.add( resolve );
  2.1990 +			}
  2.1991 +		}
  2.1992 +		resolve();
  2.1993 +		return defer.promise( obj );
  2.1994 +	}
  2.1995 +});
  2.1996 +var nodeHook, boolHook, fixSpecified,
  2.1997 +	rclass = /[\t\r\n]/g,
  2.1998 +	rreturn = /\r/g,
  2.1999 +	rtype = /^(?:button|input)$/i,
  2.2000 +	rfocusable = /^(?:button|input|object|select|textarea)$/i,
  2.2001 +	rclickable = /^a(?:rea|)$/i,
  2.2002 +	rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,
  2.2003 +	getSetAttribute = jQuery.support.getSetAttribute;
  2.2004 +
  2.2005 +jQuery.fn.extend({
  2.2006 +	attr: function( name, value ) {
  2.2007 +		return jQuery.access( this, jQuery.attr, name, value, arguments.length > 1 );
  2.2008 +	},
  2.2009 +
  2.2010 +	removeAttr: function( name ) {
  2.2011 +		return this.each(function() {
  2.2012 +			jQuery.removeAttr( this, name );
  2.2013 +		});
  2.2014 +	},
  2.2015 +
  2.2016 +	prop: function( name, value ) {
  2.2017 +		return jQuery.access( this, jQuery.prop, name, value, arguments.length > 1 );
  2.2018 +	},
  2.2019 +
  2.2020 +	removeProp: function( name ) {
  2.2021 +		name = jQuery.propFix[ name ] || name;
  2.2022 +		return this.each(function() {
  2.2023 +			// try/catch handles cases where IE balks (such as removing a property on window)
  2.2024 +			try {
  2.2025 +				this[ name ] = undefined;
  2.2026 +				delete this[ name ];
  2.2027 +			} catch( e ) {}
  2.2028 +		});
  2.2029 +	},
  2.2030 +
  2.2031 +	addClass: function( value ) {
  2.2032 +		var classNames, i, l, elem,
  2.2033 +			setClass, c, cl;
  2.2034 +
  2.2035 +		if ( jQuery.isFunction( value ) ) {
  2.2036 +			return this.each(function( j ) {
  2.2037 +				jQuery( this ).addClass( value.call(this, j, this.className) );
  2.2038 +			});
  2.2039 +		}
  2.2040 +
  2.2041 +		if ( value && typeof value === "string" ) {
  2.2042 +			classNames = value.split( core_rspace );
  2.2043 +
  2.2044 +			for ( i = 0, l = this.length; i < l; i++ ) {
  2.2045 +				elem = this[ i ];
  2.2046 +
  2.2047 +				if ( elem.nodeType === 1 ) {
  2.2048 +					if ( !elem.className && classNames.length === 1 ) {
  2.2049 +						elem.className = value;
  2.2050 +
  2.2051 +					} else {
  2.2052 +						setClass = " " + elem.className + " ";
  2.2053 +
  2.2054 +						for ( c = 0, cl = classNames.length; c < cl; c++ ) {
  2.2055 +							if ( setClass.indexOf( " " + classNames[ c ] + " " ) < 0 ) {
  2.2056 +								setClass += classNames[ c ] + " ";
  2.2057 +							}
  2.2058 +						}
  2.2059 +						elem.className = jQuery.trim( setClass );
  2.2060 +					}
  2.2061 +				}
  2.2062 +			}
  2.2063 +		}
  2.2064 +
  2.2065 +		return this;
  2.2066 +	},
  2.2067 +
  2.2068 +	removeClass: function( value ) {
  2.2069 +		var removes, className, elem, c, cl, i, l;
  2.2070 +
  2.2071 +		if ( jQuery.isFunction( value ) ) {
  2.2072 +			return this.each(function( j ) {
  2.2073 +				jQuery( this ).removeClass( value.call(this, j, this.className) );
  2.2074 +			});
  2.2075 +		}
  2.2076 +		if ( (value && typeof value === "string") || value === undefined ) {
  2.2077 +			removes = ( value || "" ).split( core_rspace );
  2.2078 +
  2.2079 +			for ( i = 0, l = this.length; i < l; i++ ) {
  2.2080 +				elem = this[ i ];
  2.2081 +				if ( elem.nodeType === 1 && elem.className ) {
  2.2082 +
  2.2083 +					className = (" " + elem.className + " ").replace( rclass, " " );
  2.2084 +
  2.2085 +					// loop over each item in the removal list
  2.2086 +					for ( c = 0, cl = removes.length; c < cl; c++ ) {
  2.2087 +						// Remove until there is nothing to remove,
  2.2088 +						while ( className.indexOf(" " + removes[ c ] + " ") >= 0 ) {
  2.2089 +							className = className.replace( " " + removes[ c ] + " " , " " );
  2.2090 +						}
  2.2091 +					}
  2.2092 +					elem.className = value ? jQuery.trim( className ) : "";
  2.2093 +				}
  2.2094 +			}
  2.2095 +		}
  2.2096 +
  2.2097 +		return this;
  2.2098 +	},
  2.2099 +
  2.2100 +	toggleClass: function( value, stateVal ) {
  2.2101 +		var type = typeof value,
  2.2102 +			isBool = typeof stateVal === "boolean";
  2.2103 +
  2.2104 +		if ( jQuery.isFunction( value ) ) {
  2.2105 +			return this.each(function( i ) {
  2.2106 +				jQuery( this ).toggleClass( value.call(this, i, this.className, stateVal), stateVal );
  2.2107 +			});
  2.2108 +		}
  2.2109 +
  2.2110 +		return this.each(function() {
  2.2111 +			if ( type === "string" ) {
  2.2112 +				// toggle individual class names
  2.2113 +				var className,
  2.2114 +					i = 0,
  2.2115 +					self = jQuery( this ),
  2.2116 +					state = stateVal,
  2.2117 +					classNames = value.split( core_rspace );
  2.2118 +
  2.2119 +				while ( (className = classNames[ i++ ]) ) {
  2.2120 +					// check each className given, space separated list
  2.2121 +					state = isBool ? state : !self.hasClass( className );
  2.2122 +					self[ state ? "addClass" : "removeClass" ]( className );
  2.2123 +				}
  2.2124 +
  2.2125 +			} else if ( type === "undefined" || type === "boolean" ) {
  2.2126 +				if ( this.className ) {
  2.2127 +					// store className if set
  2.2128 +					jQuery._data( this, "__className__", this.className );
  2.2129 +				}
  2.2130 +
  2.2131 +				// toggle whole className
  2.2132 +				this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || "";
  2.2133 +			}
  2.2134 +		});
  2.2135 +	},
  2.2136 +
  2.2137 +	hasClass: function( selector ) {
  2.2138 +		var className = " " + selector + " ",
  2.2139 +			i = 0,
  2.2140 +			l = this.length;
  2.2141 +		for ( ; i < l; i++ ) {
  2.2142 +			if ( this[i].nodeType === 1 && (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) >= 0 ) {
  2.2143 +				return true;
  2.2144 +			}
  2.2145 +		}
  2.2146 +
  2.2147 +		return false;
  2.2148 +	},
  2.2149 +
  2.2150 +	val: function( value ) {
  2.2151 +		var hooks, ret, isFunction,
  2.2152 +			elem = this[0];
  2.2153 +
  2.2154 +		if ( !arguments.length ) {
  2.2155 +			if ( elem ) {
  2.2156 +				hooks = jQuery.valHooks[ elem.type ] || jQuery.valHooks[ elem.nodeName.toLowerCase() ];
  2.2157 +
  2.2158 +				if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) {
  2.2159 +					return ret;
  2.2160 +				}
  2.2161 +
  2.2162 +				ret = elem.value;
  2.2163 +
  2.2164 +				return typeof ret === "string" ?
  2.2165 +					// handle most common string cases
  2.2166 +					ret.replace(rreturn, "") :
  2.2167 +					// handle cases where value is null/undef or number
  2.2168 +					ret == null ? "" : ret;
  2.2169 +			}
  2.2170 +
  2.2171 +			return;
  2.2172 +		}
  2.2173 +
  2.2174 +		isFunction = jQuery.isFunction( value );
  2.2175 +
  2.2176 +		return this.each(function( i ) {
  2.2177 +			var val,
  2.2178 +				self = jQuery(this);
  2.2179 +
  2.2180 +			if ( this.nodeType !== 1 ) {
  2.2181 +				return;
  2.2182 +			}
  2.2183 +
  2.2184 +			if ( isFunction ) {
  2.2185 +				val = value.call( this, i, self.val() );
  2.2186 +			} else {
  2.2187 +				val = value;
  2.2188 +			}
  2.2189 +
  2.2190 +			// Treat null/undefined as ""; convert numbers to string
  2.2191 +			if ( val == null ) {
  2.2192 +				val = "";
  2.2193 +			} else if ( typeof val === "number" ) {
  2.2194 +				val += "";
  2.2195 +			} else if ( jQuery.isArray( val ) ) {
  2.2196 +				val = jQuery.map(val, function ( value ) {
  2.2197 +					return value == null ? "" : value + "";
  2.2198 +				});
  2.2199 +			}
  2.2200 +
  2.2201 +			hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];
  2.2202 +
  2.2203 +			// If set returns undefined, fall back to normal setting
  2.2204 +			if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) {
  2.2205 +				this.value = val;
  2.2206 +			}
  2.2207 +		});
  2.2208 +	}
  2.2209 +});
  2.2210 +
  2.2211 +jQuery.extend({
  2.2212 +	valHooks: {
  2.2213 +		option: {
  2.2214 +			get: function( elem ) {
  2.2215 +				// attributes.value is undefined in Blackberry 4.7 but
  2.2216 +				// uses .value. See #6932
  2.2217 +				var val = elem.attributes.value;
  2.2218 +				return !val || val.specified ? elem.value : elem.text;
  2.2219 +			}
  2.2220 +		},
  2.2221 +		select: {
  2.2222 +			get: function( elem ) {
  2.2223 +				var value, i, max, option,
  2.2224 +					index = elem.selectedIndex,
  2.2225 +					values = [],
  2.2226 +					options = elem.options,
  2.2227 +					one = elem.type === "select-one";
  2.2228 +
  2.2229 +				// Nothing was selected
  2.2230 +				if ( index < 0 ) {
  2.2231 +					return null;
  2.2232 +				}
  2.2233 +
  2.2234 +				// Loop through all the selected options
  2.2235 +				i = one ? index : 0;
  2.2236 +				max = one ? index + 1 : options.length;
  2.2237 +				for ( ; i < max; i++ ) {
  2.2238 +					option = options[ i ];
  2.2239 +
  2.2240 +					// Don't return options that are disabled or in a disabled optgroup
  2.2241 +					if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) &&
  2.2242 +							(!option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" )) ) {
  2.2243 +
  2.2244 +						// Get the specific value for the option
  2.2245 +						value = jQuery( option ).val();
  2.2246 +
  2.2247 +						// We don't need an array for one selects
  2.2248 +						if ( one ) {
  2.2249 +							return value;
  2.2250 +						}
  2.2251 +
  2.2252 +						// Multi-Selects return an array
  2.2253 +						values.push( value );
  2.2254 +					}
  2.2255 +				}
  2.2256 +
  2.2257 +				// Fixes Bug #2551 -- select.val() broken in IE after form.reset()
  2.2258 +				if ( one && !values.length && options.length ) {
  2.2259 +					return jQuery( options[ index ] ).val();
  2.2260 +				}
  2.2261 +
  2.2262 +				return values;
  2.2263 +			},
  2.2264 +
  2.2265 +			set: function( elem, value ) {
  2.2266 +				var values = jQuery.makeArray( value );
  2.2267 +
  2.2268 +				jQuery(elem).find("option").each(function() {
  2.2269 +					this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
  2.2270 +				});
  2.2271 +
  2.2272 +				if ( !values.length ) {
  2.2273 +					elem.selectedIndex = -1;
  2.2274 +				}
  2.2275 +				return values;
  2.2276 +			}
  2.2277 +		}
  2.2278 +	},
  2.2279 +
  2.2280 +	// Unused in 1.8, left in so attrFn-stabbers won't die; remove in 1.9
  2.2281 +	attrFn: {},
  2.2282 +
  2.2283 +	attr: function( elem, name, value, pass ) {
  2.2284 +		var ret, hooks, notxml,
  2.2285 +			nType = elem.nodeType;
  2.2286 +
  2.2287 +		// don't get/set attributes on text, comment and attribute nodes
  2.2288 +		if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
  2.2289 +			return;
  2.2290 +		}
  2.2291 +
  2.2292 +		if ( pass && jQuery.isFunction( jQuery.fn[ name ] ) ) {
  2.2293 +			return jQuery( elem )[ name ]( value );
  2.2294 +		}
  2.2295 +
  2.2296 +		// Fallback to prop when attributes are not supported
  2.2297 +		if ( typeof elem.getAttribute === "undefined" ) {
  2.2298 +			return jQuery.prop( elem, name, value );
  2.2299 +		}
  2.2300 +
  2.2301 +		notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
  2.2302 +
  2.2303 +		// All attributes are lowercase
  2.2304 +		// Grab necessary hook if one is defined
  2.2305 +		if ( notxml ) {
  2.2306 +			name = name.toLowerCase();
  2.2307 +			hooks = jQuery.attrHooks[ name ] || ( rboolean.test( name ) ? boolHook : nodeHook );
  2.2308 +		}
  2.2309 +
  2.2310 +		if ( value !== undefined ) {
  2.2311 +
  2.2312 +			if ( value === null ) {
  2.2313 +				jQuery.removeAttr( elem, name );
  2.2314 +				return;
  2.2315 +
  2.2316 +			} else if ( hooks && "set" in hooks && notxml && (ret = hooks.set( elem, value, name )) !== undefined ) {
  2.2317 +				return ret;
  2.2318 +
  2.2319 +			} else {
  2.2320 +				elem.setAttribute( name, value + "" );
  2.2321 +				return value;
  2.2322 +			}
  2.2323 +
  2.2324 +		} else if ( hooks && "get" in hooks && notxml && (ret = hooks.get( elem, name )) !== null ) {
  2.2325 +			return ret;
  2.2326 +
  2.2327 +		} else {
  2.2328 +
  2.2329 +			ret = elem.getAttribute( name );
  2.2330 +
  2.2331 +			// Non-existent attributes return null, we normalize to undefined
  2.2332 +			return ret === null ?
  2.2333 +				undefined :
  2.2334 +				ret;
  2.2335 +		}
  2.2336 +	},
  2.2337 +
  2.2338 +	removeAttr: function( elem, value ) {
  2.2339 +		var propName, attrNames, name, isBool,
  2.2340 +			i = 0;
  2.2341 +
  2.2342 +		if ( value && elem.nodeType === 1 ) {
  2.2343 +
  2.2344 +			attrNames = value.split( core_rspace );
  2.2345 +
  2.2346 +			for ( ; i < attrNames.length; i++ ) {
  2.2347 +				name = attrNames[ i ];
  2.2348 +
  2.2349 +				if ( name ) {
  2.2350 +					propName = jQuery.propFix[ name ] || name;
  2.2351 +					isBool = rboolean.test( name );
  2.2352 +
  2.2353 +					// See #9699 for explanation of this approach (setting first, then removal)
  2.2354 +					// Do not do this for boolean attributes (see #10870)
  2.2355 +					if ( !isBool ) {
  2.2356 +						jQuery.attr( elem, name, "" );
  2.2357 +					}
  2.2358 +					elem.removeAttribute( getSetAttribute ? name : propName );
  2.2359 +
  2.2360 +					// Set corresponding property to false for boolean attributes
  2.2361 +					if ( isBool && propName in elem ) {
  2.2362 +						elem[ propName ] = false;
  2.2363 +					}
  2.2364 +				}
  2.2365 +			}
  2.2366 +		}
  2.2367 +	},
  2.2368 +
  2.2369 +	attrHooks: {
  2.2370 +		type: {
  2.2371 +			set: function( elem, value ) {
  2.2372 +				// We can't allow the type property to be changed (since it causes problems in IE)
  2.2373 +				if ( rtype.test( elem.nodeName ) && elem.parentNode ) {
  2.2374 +					jQuery.error( "type property can't be changed" );
  2.2375 +				} else if ( !jQuery.support.radioValue && value === "radio" && jQuery.nodeName(elem, "input") ) {
  2.2376 +					// Setting the type on a radio button after the value resets the value in IE6-9
  2.2377 +					// Reset value to it's default in case type is set after value
  2.2378 +					// This is for element creation
  2.2379 +					var val = elem.value;
  2.2380 +					elem.setAttribute( "type", value );
  2.2381 +					if ( val ) {
  2.2382 +						elem.value = val;
  2.2383 +					}
  2.2384 +					return value;
  2.2385 +				}
  2.2386 +			}
  2.2387 +		},
  2.2388 +		// Use the value property for back compat
  2.2389 +		// Use the nodeHook for button elements in IE6/7 (#1954)
  2.2390 +		value: {
  2.2391 +			get: function( elem, name ) {
  2.2392 +				if ( nodeHook && jQuery.nodeName( elem, "button" ) ) {
  2.2393 +					return nodeHook.get( elem, name );
  2.2394 +				}
  2.2395 +				return name in elem ?
  2.2396 +					elem.value :
  2.2397 +					null;
  2.2398 +			},
  2.2399 +			set: function( elem, value, name ) {
  2.2400 +				if ( nodeHook && jQuery.nodeName( elem, "button" ) ) {
  2.2401 +					return nodeHook.set( elem, value, name );
  2.2402 +				}
  2.2403 +				// Does not return so that setAttribute is also used
  2.2404 +				elem.value = value;
  2.2405 +			}
  2.2406 +		}
  2.2407 +	},
  2.2408 +
  2.2409 +	propFix: {
  2.2410 +		tabindex: "tabIndex",
  2.2411 +		readonly: "readOnly",
  2.2412 +		"for": "htmlFor",
  2.2413 +		"class": "className",
  2.2414 +		maxlength: "maxLength",
  2.2415 +		cellspacing: "cellSpacing",
  2.2416 +		cellpadding: "cellPadding",
  2.2417 +		rowspan: "rowSpan",
  2.2418 +		colspan: "colSpan",
  2.2419 +		usemap: "useMap",
  2.2420 +		frameborder: "frameBorder",
  2.2421 +		contenteditable: "contentEditable"
  2.2422 +	},
  2.2423 +
  2.2424 +	prop: function( elem, name, value ) {
  2.2425 +		var ret, hooks, notxml,
  2.2426 +			nType = elem.nodeType;
  2.2427 +
  2.2428 +		// don't get/set properties on text, comment and attribute nodes
  2.2429 +		if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
  2.2430 +			return;
  2.2431 +		}
  2.2432 +
  2.2433 +		notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
  2.2434 +
  2.2435 +		if ( notxml ) {
  2.2436 +			// Fix name and attach hooks
  2.2437 +			name = jQuery.propFix[ name ] || name;
  2.2438 +			hooks = jQuery.propHooks[ name ];
  2.2439 +		}
  2.2440 +
  2.2441 +		if ( value !== undefined ) {
  2.2442 +			if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {
  2.2443 +				return ret;
  2.2444 +
  2.2445 +			} else {
  2.2446 +				return ( elem[ name ] = value );
  2.2447 +			}
  2.2448 +
  2.2449 +		} else {
  2.2450 +			if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) {
  2.2451 +				return ret;
  2.2452 +
  2.2453 +			} else {
  2.2454 +				return elem[ name ];
  2.2455 +			}
  2.2456 +		}
  2.2457 +	},
  2.2458 +
  2.2459 +	propHooks: {
  2.2460 +		tabIndex: {
  2.2461 +			get: function( elem ) {
  2.2462 +				// elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
  2.2463 +				// http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
  2.2464 +				var attributeNode = elem.getAttributeNode("tabindex");
  2.2465 +
  2.2466 +				return attributeNode && attributeNode.specified ?
  2.2467 +					parseInt( attributeNode.value, 10 ) :
  2.2468 +					rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
  2.2469 +						0 :
  2.2470 +						undefined;
  2.2471 +			}
  2.2472 +		}
  2.2473 +	}
  2.2474 +});
  2.2475 +
  2.2476 +// Hook for boolean attributes
  2.2477 +boolHook = {
  2.2478 +	get: function( elem, name ) {
  2.2479 +		// Align boolean attributes with corresponding properties
  2.2480 +		// Fall back to attribute presence where some booleans are not supported
  2.2481 +		var attrNode,
  2.2482 +			property = jQuery.prop( elem, name );
  2.2483 +		return property === true || typeof property !== "boolean" && ( attrNode = elem.getAttributeNode(name) ) && attrNode.nodeValue !== false ?
  2.2484 +			name.toLowerCase() :
  2.2485 +			undefined;
  2.2486 +	},
  2.2487 +	set: function( elem, value, name ) {
  2.2488 +		var propName;
  2.2489 +		if ( value === false ) {
  2.2490 +			// Remove boolean attributes when set to false
  2.2491 +			jQuery.removeAttr( elem, name );
  2.2492 +		} else {
  2.2493 +			// value is true since we know at this point it's type boolean and not false
  2.2494 +			// Set boolean attributes to the same name and set the DOM property
  2.2495 +			propName = jQuery.propFix[ name ] || name;
  2.2496 +			if ( propName in elem ) {
  2.2497 +				// Only set the IDL specifically if it already exists on the element
  2.2498 +				elem[ propName ] = true;
  2.2499 +			}
  2.2500 +
  2.2501 +			elem.setAttribute( name, name.toLowerCase() );
  2.2502 +		}
  2.2503 +		return name;
  2.2504 +	}
  2.2505 +};
  2.2506 +
  2.2507 +// IE6/7 do not support getting/setting some attributes with get/setAttribute
  2.2508 +if ( !getSetAttribute ) {
  2.2509 +
  2.2510 +	fixSpecified = {
  2.2511 +		name: true,
  2.2512 +		id: true,
  2.2513 +		coords: true
  2.2514 +	};
  2.2515 +
  2.2516 +	// Use this for any attribute in IE6/7
  2.2517 +	// This fixes almost every IE6/7 issue
  2.2518 +	nodeHook = jQuery.valHooks.button = {
  2.2519 +		get: function( elem, name ) {
  2.2520 +			var ret;
  2.2521 +			ret = elem.getAttributeNode( name );
  2.2522 +			return ret && ( fixSpecified[ name ] ? ret.value !== "" : ret.specified ) ?
  2.2523 +				ret.value :
  2.2524 +				undefined;
  2.2525 +		},
  2.2526 +		set: function( elem, value, name ) {
  2.2527 +			// Set the existing or create a new attribute node
  2.2528 +			var ret = elem.getAttributeNode( name );
  2.2529 +			if ( !ret ) {
  2.2530 +				ret = document.createAttribute( name );
  2.2531 +				elem.setAttributeNode( ret );
  2.2532 +			}
  2.2533 +			return ( ret.value = value + "" );
  2.2534 +		}
  2.2535 +	};
  2.2536 +
  2.2537 +	// Set width and height to auto instead of 0 on empty string( Bug #8150 )
  2.2538 +	// This is for removals
  2.2539 +	jQuery.each([ "width", "height" ], function( i, name ) {
  2.2540 +		jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
  2.2541 +			set: function( elem, value ) {
  2.2542 +				if ( value === "" ) {
  2.2543 +					elem.setAttribute( name, "auto" );
  2.2544 +					return value;
  2.2545 +				}
  2.2546 +			}
  2.2547 +		});
  2.2548 +	});
  2.2549 +
  2.2550 +	// Set contenteditable to false on removals(#10429)
  2.2551 +	// Setting to empty string throws an error as an invalid value
  2.2552 +	jQuery.attrHooks.contenteditable = {
  2.2553 +		get: nodeHook.get,
  2.2554 +		set: function( elem, value, name ) {
  2.2555 +			if ( value === "" ) {
  2.2556 +				value = "false";
  2.2557 +			}
  2.2558 +			nodeHook.set( elem, value, name );
  2.2559 +		}
  2.2560 +	};
  2.2561 +}
  2.2562 +
  2.2563 +
  2.2564 +// Some attributes require a special call on IE
  2.2565 +if ( !jQuery.support.hrefNormalized ) {
  2.2566 +	jQuery.each([ "href", "src", "width", "height" ], function( i, name ) {
  2.2567 +		jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
  2.2568 +			get: function( elem ) {
  2.2569 +				var ret = elem.getAttribute( name, 2 );
  2.2570 +				return ret === null ? undefined : ret;
  2.2571 +			}
  2.2572 +		});
  2.2573 +	});
  2.2574 +}
  2.2575 +
  2.2576 +if ( !jQuery.support.style ) {
  2.2577 +	jQuery.attrHooks.style = {
  2.2578 +		get: function( elem ) {
  2.2579 +			// Return undefined in the case of empty string
  2.2580 +			// Normalize to lowercase since IE uppercases css property names
  2.2581 +			return elem.style.cssText.toLowerCase() || undefined;
  2.2582 +		},
  2.2583 +		set: function( elem, value ) {
  2.2584 +			return ( elem.style.cssText = value + "" );
  2.2585 +		}
  2.2586 +	};
  2.2587 +}
  2.2588 +
  2.2589 +// Safari mis-reports the default selected property of an option
  2.2590 +// Accessing the parent's selectedIndex property fixes it
  2.2591 +if ( !jQuery.support.optSelected ) {
  2.2592 +	jQuery.propHooks.selected = jQuery.extend( jQuery.propHooks.selected, {
  2.2593 +		get: function( elem ) {
  2.2594 +			var parent = elem.parentNode;
  2.2595 +
  2.2596 +			if ( parent ) {
  2.2597 +				parent.selectedIndex;
  2.2598 +
  2.2599 +				// Make sure that it also works with optgroups, see #5701
  2.2600 +				if ( parent.parentNode ) {
  2.2601 +					parent.parentNode.selectedIndex;
  2.2602 +				}
  2.2603 +			}
  2.2604 +			return null;
  2.2605 +		}
  2.2606 +	});
  2.2607 +}
  2.2608 +
  2.2609 +// IE6/7 call enctype encoding
  2.2610 +if ( !jQuery.support.enctype ) {
  2.2611 +	jQuery.propFix.enctype = "encoding";
  2.2612 +}
  2.2613 +
  2.2614 +// Radios and checkboxes getter/setter
  2.2615 +if ( !jQuery.support.checkOn ) {
  2.2616 +	jQuery.each([ "radio", "checkbox" ], function() {
  2.2617 +		jQuery.valHooks[ this ] = {
  2.2618 +			get: function( elem ) {
  2.2619 +				// Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
  2.2620 +				return elem.getAttribute("value") === null ? "on" : elem.value;
  2.2621 +			}
  2.2622 +		};
  2.2623 +	});
  2.2624 +}
  2.2625 +jQuery.each([ "radio", "checkbox" ], function() {
  2.2626 +	jQuery.valHooks[ this ] = jQuery.extend( jQuery.valHooks[ this ], {
  2.2627 +		set: function( elem, value ) {
  2.2628 +			if ( jQuery.isArray( value ) ) {
  2.2629 +				return ( elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0 );
  2.2630 +			}
  2.2631 +		}
  2.2632 +	});
  2.2633 +});
  2.2634 +var rformElems = /^(?:textarea|input|select)$/i,
  2.2635 +	rtypenamespace = /^([^\.]*|)(?:\.(.+)|)$/,
  2.2636 +	rhoverHack = /(?:^|\s)hover(\.\S+|)\b/,
  2.2637 +	rkeyEvent = /^key/,
  2.2638 +	rmouseEvent = /^(?:mouse|contextmenu)|click/,
  2.2639 +	rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
  2.2640 +	hoverHack = function( events ) {
  2.2641 +		return jQuery.event.special.hover ? events : events.replace( rhoverHack, "mouseenter$1 mouseleave$1" );
  2.2642 +	};
  2.2643 +
  2.2644 +/*
  2.2645 + * Helper functions for managing events -- not part of the public interface.
  2.2646 + * Props to Dean Edwards' addEvent library for many of the ideas.
  2.2647 + */
  2.2648 +jQuery.event = {
  2.2649 +
  2.2650 +	add: function( elem, types, handler, data, selector ) {
  2.2651 +
  2.2652 +		var elemData, eventHandle, events,
  2.2653 +			t, tns, type, namespaces, handleObj,
  2.2654 +			handleObjIn, handlers, special;
  2.2655 +
  2.2656 +		// Don't attach events to noData or text/comment nodes (allow plain objects tho)
  2.2657 +		if ( elem.nodeType === 3 || elem.nodeType === 8 || !types || !handler || !(elemData = jQuery._data( elem )) ) {
  2.2658 +			return;
  2.2659 +		}
  2.2660 +
  2.2661 +		// Caller can pass in an object of custom data in lieu of the handler
  2.2662 +		if ( handler.handler ) {
  2.2663 +			handleObjIn = handler;
  2.2664 +			handler = handleObjIn.handler;
  2.2665 +			selector = handleObjIn.selector;
  2.2666 +		}
  2.2667 +
  2.2668 +		// Make sure that the handler has a unique ID, used to find/remove it later
  2.2669 +		if ( !handler.guid ) {
  2.2670 +			handler.guid = jQuery.guid++;
  2.2671 +		}
  2.2672 +
  2.2673 +		// Init the element's event structure and main handler, if this is the first
  2.2674 +		events = elemData.events;
  2.2675 +		if ( !events ) {
  2.2676 +			elemData.events = events = {};
  2.2677 +		}
  2.2678 +		eventHandle = elemData.handle;
  2.2679 +		if ( !eventHandle ) {
  2.2680 +			elemData.handle = eventHandle = function( e ) {
  2.2681 +				// Discard the second event of a jQuery.event.trigger() and
  2.2682 +				// when an event is called after a page has unloaded
  2.2683 +				return typeof jQuery !== "undefined" && (!e || jQuery.event.triggered !== e.type) ?
  2.2684 +					jQuery.event.dispatch.apply( eventHandle.elem, arguments ) :
  2.2685 +					undefined;
  2.2686 +			};
  2.2687 +			// Add elem as a property of the handle fn to prevent a memory leak with IE non-native events
  2.2688 +			eventHandle.elem = elem;
  2.2689 +		}
  2.2690 +
  2.2691 +		// Handle multiple events separated by a space
  2.2692 +		// jQuery(...).bind("mouseover mouseout", fn);
  2.2693 +		types = jQuery.trim( hoverHack(types) ).split( " " );
  2.2694 +		for ( t = 0; t < types.length; t++ ) {
  2.2695 +
  2.2696 +			tns = rtypenamespace.exec( types[t] ) || [];
  2.2697 +			type = tns[1];
  2.2698 +			namespaces = ( tns[2] || "" ).split( "." ).sort();
  2.2699 +
  2.2700 +			// If event changes its type, use the special event handlers for the changed type
  2.2701 +			special = jQuery.event.special[ type ] || {};
  2.2702 +
  2.2703 +			// If selector defined, determine special event api type, otherwise given type
  2.2704 +			type = ( selector ? special.delegateType : special.bindType ) || type;
  2.2705 +
  2.2706 +			// Update special based on newly reset type
  2.2707 +			special = jQuery.event.special[ type ] || {};
  2.2708 +
  2.2709 +			// handleObj is passed to all event handlers
  2.2710 +			handleObj = jQuery.extend({
  2.2711 +				type: type,
  2.2712 +				origType: tns[1],
  2.2713 +				data: data,
  2.2714 +				handler: handler,
  2.2715 +				guid: handler.guid,
  2.2716 +				selector: selector,
  2.2717 +				needsContext: selector && jQuery.expr.match.needsContext.test( selector ),
  2.2718 +				namespace: namespaces.join(".")
  2.2719 +			}, handleObjIn );
  2.2720 +
  2.2721 +			// Init the event handler queue if we're the first
  2.2722 +			handlers = events[ type ];
  2.2723 +			if ( !handlers ) {
  2.2724 +				handlers = events[ type ] = [];
  2.2725 +				handlers.delegateCount = 0;
  2.2726 +
  2.2727 +				// Only use addEventListener/attachEvent if the special events handler returns false
  2.2728 +				if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
  2.2729 +					// Bind the global event handler to the element
  2.2730 +					if ( elem.addEventListener ) {
  2.2731 +						elem.addEventListener( type, eventHandle, false );
  2.2732 +
  2.2733 +					} else if ( elem.attachEvent ) {
  2.2734 +						elem.attachEvent( "on" + type, eventHandle );
  2.2735 +					}
  2.2736 +				}
  2.2737 +			}
  2.2738 +
  2.2739 +			if ( special.add ) {
  2.2740 +				special.add.call( elem, handleObj );
  2.2741 +
  2.2742 +				if ( !handleObj.handler.guid ) {
  2.2743 +					handleObj.handler.guid = handler.guid;
  2.2744 +				}
  2.2745 +			}
  2.2746 +
  2.2747 +			// Add to the element's handler list, delegates in front
  2.2748 +			if ( selector ) {
  2.2749 +				handlers.splice( handlers.delegateCount++, 0, handleObj );
  2.2750 +			} else {
  2.2751 +				handlers.push( handleObj );
  2.2752 +			}
  2.2753 +
  2.2754 +			// Keep track of which events have ever been used, for event optimization
  2.2755 +			jQuery.event.global[ type ] = true;
  2.2756 +		}
  2.2757 +
  2.2758 +		// Nullify elem to prevent memory leaks in IE
  2.2759 +		elem = null;
  2.2760 +	},
  2.2761 +
  2.2762 +	global: {},
  2.2763 +
  2.2764 +	// Detach an event or set of events from an element
  2.2765 +	remove: function( elem, types, handler, selector, mappedTypes ) {
  2.2766 +
  2.2767 +		var t, tns, type, origType, namespaces, origCount,
  2.2768 +			j, events, special, eventType, handleObj,
  2.2769 +			elemData = jQuery.hasData( elem ) && jQuery._data( elem );
  2.2770 +
  2.2771 +		if ( !elemData || !(events = elemData.events) ) {
  2.2772 +			return;
  2.2773 +		}
  2.2774 +
  2.2775 +		// Once for each type.namespace in types; type may be omitted
  2.2776 +		types = jQuery.trim( hoverHack( types || "" ) ).split(" ");
  2.2777 +		for ( t = 0; t < types.length; t++ ) {
  2.2778 +			tns = rtypenamespace.exec( types[t] ) || [];
  2.2779 +			type = origType = tns[1];
  2.2780 +			namespaces = tns[2];
  2.2781 +
  2.2782 +			// Unbind all events (on this namespace, if provided) for the element
  2.2783 +			if ( !type ) {
  2.2784 +				for ( type in events ) {
  2.2785 +					jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
  2.2786 +				}
  2.2787 +				continue;
  2.2788 +			}
  2.2789 +
  2.2790 +			special = jQuery.event.special[ type ] || {};
  2.2791 +			type = ( selector? special.delegateType : special.bindType ) || type;
  2.2792 +			eventType = events[ type ] || [];
  2.2793 +			origCount = eventType.length;
  2.2794 +			namespaces = namespaces ? new RegExp("(^|\\.)" + namespaces.split(".").sort().join("\\.(?:.*\\.|)") + "(\\.|$)") : null;
  2.2795 +
  2.2796 +			// Remove matching events
  2.2797 +			for ( j = 0; j < eventType.length; j++ ) {
  2.2798 +				handleObj = eventType[ j ];
  2.2799 +
  2.2800 +				if ( ( mappedTypes || origType === handleObj.origType ) &&
  2.2801 +					 ( !handler || handler.guid === handleObj.guid ) &&
  2.2802 +					 ( !namespaces || namespaces.test( handleObj.namespace ) ) &&
  2.2803 +					 ( !selector || selector === handleObj.selector || selector === "**" && handleObj.selector ) ) {
  2.2804 +					eventType.splice( j--, 1 );
  2.2805 +
  2.2806 +					if ( handleObj.selector ) {
  2.2807 +						eventType.delegateCount--;
  2.2808 +					}
  2.2809 +					if ( special.remove ) {
  2.2810 +						special.remove.call( elem, handleObj );
  2.2811 +					}
  2.2812 +				}
  2.2813 +			}
  2.2814 +
  2.2815 +			// Remove generic event handler if we removed something and no more handlers exist
  2.2816 +			// (avoids potential for endless recursion during removal of special event handlers)
  2.2817 +			if ( eventType.length === 0 && origCount !== eventType.length ) {
  2.2818 +				if ( !special.teardown || special.teardown.call( elem, namespaces, elemData.handle ) === false ) {
  2.2819 +					jQuery.removeEvent( elem, type, elemData.handle );
  2.2820 +				}
  2.2821 +
  2.2822 +				delete events[ type ];
  2.2823 +			}
  2.2824 +		}
  2.2825 +
  2.2826 +		// Remove the expando if it's no longer used
  2.2827 +		if ( jQuery.isEmptyObject( events ) ) {
  2.2828 +			delete elemData.handle;
  2.2829 +
  2.2830 +			// removeData also checks for emptiness and clears the expando if empty
  2.2831 +			// so use it instead of delete
  2.2832 +			jQuery.removeData( elem, "events", true );
  2.2833 +		}
  2.2834 +	},
  2.2835 +
  2.2836 +	// Events that are safe to short-circuit if no handlers are attached.
  2.2837 +	// Native DOM events should not be added, they may have inline handlers.
  2.2838 +	customEvent: {
  2.2839 +		"getData": true,
  2.2840 +		"setData": true,
  2.2841 +		"changeData": true
  2.2842 +	},
  2.2843 +
  2.2844 +	trigger: function( event, data, elem, onlyHandlers ) {
  2.2845 +		// Don't do events on text and comment nodes
  2.2846 +		if ( elem && (elem.nodeType === 3 || elem.nodeType === 8) ) {
  2.2847 +			return;
  2.2848 +		}
  2.2849 +
  2.2850 +		// Event object or event type
  2.2851 +		var cache, exclusive, i, cur, old, ontype, special, handle, eventPath, bubbleType,
  2.2852 +			type = event.type || event,
  2.2853 +			namespaces = [];
  2.2854 +
  2.2855 +		// focus/blur morphs to focusin/out; ensure we're not firing them right now
  2.2856 +		if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
  2.2857 +			return;
  2.2858 +		}
  2.2859 +
  2.2860 +		if ( type.indexOf( "!" ) >= 0 ) {
  2.2861 +			// Exclusive events trigger only for the exact event (no namespaces)
  2.2862 +			type = type.slice(0, -1);
  2.2863 +			exclusive = true;
  2.2864 +		}
  2.2865 +
  2.2866 +		if ( type.indexOf( "." ) >= 0 ) {
  2.2867 +			// Namespaced trigger; create a regexp to match event type in handle()
  2.2868 +			namespaces = type.split(".");
  2.2869 +			type = namespaces.shift();
  2.2870 +			namespaces.sort();
  2.2871 +		}
  2.2872 +
  2.2873 +		if ( (!elem || jQuery.event.customEvent[ type ]) && !jQuery.event.global[ type ] ) {
  2.2874 +			// No jQuery handlers for this event type, and it can't have inline handlers
  2.2875 +			return;
  2.2876 +		}
  2.2877 +
  2.2878 +		// Caller can pass in an Event, Object, or just an event type string
  2.2879 +		event = typeof event === "object" ?
  2.2880 +			// jQuery.Event object
  2.2881 +			event[ jQuery.expando ] ? event :
  2.2882 +			// Object literal
  2.2883 +			new jQuery.Event( type, event ) :
  2.2884 +			// Just the event type (string)
  2.2885 +			new jQuery.Event( type );
  2.2886 +
  2.2887 +		event.type = type;
  2.2888 +		event.isTrigger = true;
  2.2889 +		event.exclusive = exclusive;
  2.2890 +		event.namespace = namespaces.join( "." );
  2.2891 +		event.namespace_re = event.namespace? new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)") : null;
  2.2892 +		ontype = type.indexOf( ":" ) < 0 ? "on" + type : "";
  2.2893 +
  2.2894 +		// Handle a global trigger
  2.2895 +		if ( !elem ) {
  2.2896 +
  2.2897 +			// TODO: Stop taunting the data cache; remove global events and always attach to document
  2.2898 +			cache = jQuery.cache;
  2.2899 +			for ( i in cache ) {
  2.2900 +				if ( cache[ i ].events && cache[ i ].events[ type ] ) {
  2.2901 +					jQuery.event.trigger( event, data, cache[ i ].handle.elem, true );
  2.2902 +				}
  2.2903 +			}
  2.2904 +			return;
  2.2905 +		}
  2.2906 +
  2.2907 +		// Clean up the event in case it is being reused
  2.2908 +		event.result = undefined;
  2.2909 +		if ( !event.target ) {
  2.2910 +			event.target = elem;
  2.2911 +		}
  2.2912 +
  2.2913 +		// Clone any incoming data and prepend the event, creating the handler arg list
  2.2914 +		data = data != null ? jQuery.makeArray( data ) : [];
  2.2915 +		data.unshift( event );
  2.2916 +
  2.2917 +		// Allow special events to draw outside the lines
  2.2918 +		special = jQuery.event.special[ type ] || {};
  2.2919 +		if ( special.trigger && special.trigger.apply( elem, data ) === false ) {
  2.2920 +			return;
  2.2921 +		}
  2.2922 +
  2.2923 +		// Determine event propagation path in advance, per W3C events spec (#9951)
  2.2924 +		// Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
  2.2925 +		eventPath = [[ elem, special.bindType || type ]];
  2.2926 +		if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) {
  2.2927 +
  2.2928 +			bubbleType = special.delegateType || type;
  2.2929 +			cur = rfocusMorph.test( bubbleType + type ) ? elem : elem.parentNode;
  2.2930 +			for ( old = elem; cur; cur = cur.parentNode ) {
  2.2931 +				eventPath.push([ cur, bubbleType ]);
  2.2932 +				old = cur;
  2.2933 +			}
  2.2934 +
  2.2935 +			// Only add window if we got to document (e.g., not plain obj or detached DOM)
  2.2936 +			if ( old === (elem.ownerDocument || document) ) {
  2.2937 +				eventPath.push([ old.defaultView || old.parentWindow || window, bubbleType ]);
  2.2938 +			}
  2.2939 +		}
  2.2940 +
  2.2941 +		// Fire handlers on the event path
  2.2942 +		for ( i = 0; i < eventPath.length && !event.isPropagationStopped(); i++ ) {
  2.2943 +
  2.2944 +			cur = eventPath[i][0];
  2.2945 +			event.type = eventPath[i][1];
  2.2946 +
  2.2947 +			handle = ( jQuery._data( cur, "events" ) || {} )[ event.type ] && jQuery._data( cur, "handle" );
  2.2948 +			if ( handle ) {
  2.2949 +				handle.apply( cur, data );
  2.2950 +			}
  2.2951 +			// Note that this is a bare JS function and not a jQuery handler
  2.2952 +			handle = ontype && cur[ ontype ];
  2.2953 +			if ( handle && jQuery.acceptData( cur ) && handle.apply && handle.apply( cur, data ) === false ) {
  2.2954 +				event.preventDefault();
  2.2955 +			}
  2.2956 +		}
  2.2957 +		event.type = type;
  2.2958 +
  2.2959 +		// If nobody prevented the default action, do it now
  2.2960 +		if ( !onlyHandlers && !event.isDefaultPrevented() ) {
  2.2961 +
  2.2962 +			if ( (!special._default || special._default.apply( elem.ownerDocument, data ) === false) &&
  2.2963 +				!(type === "click" && jQuery.nodeName( elem, "a" )) && jQuery.acceptData( elem ) ) {
  2.2964 +
  2.2965 +				// Call a native DOM method on the target with the same name name as the event.
  2.2966 +				// Can't use an .isFunction() check here because IE6/7 fails that test.
  2.2967 +				// Don't do default actions on window, that's where global variables be (#6170)
  2.2968 +				// IE<9 dies on focus/blur to hidden element (#1486)
  2.2969 +				if ( ontype && elem[ type ] && ((type !== "focus" && type !== "blur") || event.target.offsetWidth !== 0) && !jQuery.isWindow( elem ) ) {
  2.2970 +
  2.2971 +					// Don't re-trigger an onFOO event when we call its FOO() method
  2.2972 +					old = elem[ ontype ];
  2.2973 +
  2.2974 +					if ( old ) {
  2.2975 +						elem[ ontype ] = null;
  2.2976 +					}
  2.2977 +
  2.2978 +					// Prevent re-triggering of the same event, since we already bubbled it above
  2.2979 +					jQuery.event.triggered = type;
  2.2980 +					elem[ type ]();
  2.2981 +					jQuery.event.triggered = undefined;
  2.2982 +
  2.2983 +					if ( old ) {
  2.2984 +						elem[ ontype ] = old;
  2.2985 +					}
  2.2986 +				}
  2.2987 +			}
  2.2988 +		}
  2.2989 +
  2.2990 +		return event.result;
  2.2991 +	},
  2.2992 +
  2.2993 +	dispatch: function( event ) {
  2.2994 +
  2.2995 +		// Make a writable jQuery.Event from the native event object
  2.2996 +		event = jQuery.event.fix( event || window.event );
  2.2997 +
  2.2998 +		var i, j, cur, ret, selMatch, matched, matches, handleObj, sel, related,
  2.2999 +			handlers = ( (jQuery._data( this, "events" ) || {} )[ event.type ] || []),
  2.3000 +			delegateCount = handlers.delegateCount,
  2.3001 +			args = core_slice.call( arguments ),
  2.3002 +			run_all = !event.exclusive && !event.namespace,
  2.3003 +			special = jQuery.event.special[ event.type ] || {},
  2.3004 +			handlerQueue = [];
  2.3005 +
  2.3006 +		// Use the fix-ed jQuery.Event rather than the (read-only) native event
  2.3007 +		args[0] = event;
  2.3008 +		event.delegateTarget = this;
  2.3009 +
  2.3010 +		// Call the preDispatch hook for the mapped type, and let it bail if desired
  2.3011 +		if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
  2.3012 +			return;
  2.3013 +		}
  2.3014 +
  2.3015 +		// Determine handlers that should run if there are delegated events
  2.3016 +		// Avoid non-left-click bubbling in Firefox (#3861)
  2.3017 +		if ( delegateCount && !(event.button && event.type === "click") ) {
  2.3018 +
  2.3019 +			for ( cur = event.target; cur != this; cur = cur.parentNode || this ) {
  2.3020 +
  2.3021 +				// Don't process clicks (ONLY) on disabled elements (#6911, #8165, #11382, #11764)
  2.3022 +				if ( cur.disabled !== true || event.type !== "click" ) {
  2.3023 +					selMatch = {};
  2.3024 +					matches = [];
  2.3025 +					for ( i = 0; i < delegateCount; i++ ) {
  2.3026 +						handleObj = handlers[ i ];
  2.3027 +						sel = handleObj.selector;
  2.3028 +
  2.3029 +						if ( selMatch[ sel ] === undefined ) {
  2.3030 +							selMatch[ sel ] = handleObj.needsContext ?
  2.3031 +								jQuery( sel, this ).index( cur ) >= 0 :
  2.3032 +								jQuery.find( sel, this, null, [ cur ] ).length;
  2.3033 +						}
  2.3034 +						if ( selMatch[ sel ] ) {
  2.3035 +							matches.push( handleObj );
  2.3036 +						}
  2.3037 +					}
  2.3038 +					if ( matches.length ) {
  2.3039 +						handlerQueue.push({ elem: cur, matches: matches });
  2.3040 +					}
  2.3041 +				}
  2.3042 +			}
  2.3043 +		}
  2.3044 +
  2.3045 +		// Add the remaining (directly-bound) handlers
  2.3046 +		if ( handlers.length > delegateCount ) {
  2.3047 +			handlerQueue.push({ elem: this, matches: handlers.slice( delegateCount ) });
  2.3048 +		}
  2.3049 +
  2.3050 +		// Run delegates first; they may want to stop propagation beneath us
  2.3051 +		for ( i = 0; i < handlerQueue.length && !event.isPropagationStopped(); i++ ) {
  2.3052 +			matched = handlerQueue[ i ];
  2.3053 +			event.currentTarget = matched.elem;
  2.3054 +
  2.3055 +			for ( j = 0; j < matched.matches.length && !event.isImmediatePropagationStopped(); j++ ) {
  2.3056 +				handleObj = matched.matches[ j ];
  2.3057 +
  2.3058 +				// Triggered event must either 1) be non-exclusive and have no namespace, or
  2.3059 +				// 2) have namespace(s) a subset or equal to those in the bound event (both can have no namespace).
  2.3060 +				if ( run_all || (!event.namespace && !handleObj.namespace) || event.namespace_re && event.namespace_re.test( handleObj.namespace ) ) {
  2.3061 +
  2.3062 +					event.data = handleObj.data;
  2.3063 +					event.handleObj = handleObj;
  2.3064 +
  2.3065 +					ret = ( (jQuery.event.special[ handleObj.origType ] || {}).handle || handleObj.handler )
  2.3066 +							.apply( matched.elem, args );
  2.3067 +
  2.3068 +					if ( ret !== undefined ) {
  2.3069 +						event.result = ret;
  2.3070 +						if ( ret === false ) {
  2.3071 +							event.preventDefault();
  2.3072 +							event.stopPropagation();
  2.3073 +						}
  2.3074 +					}
  2.3075 +				}
  2.3076 +			}
  2.3077 +		}
  2.3078 +
  2.3079 +		// Call the postDispatch hook for the mapped type
  2.3080 +		if ( special.postDispatch ) {
  2.3081 +			special.postDispatch.call( this, event );
  2.3082 +		}
  2.3083 +
  2.3084 +		return event.result;
  2.3085 +	},
  2.3086 +
  2.3087 +	// Includes some event props shared by KeyEvent and MouseEvent
  2.3088 +	// *** attrChange attrName relatedNode srcElement  are not normalized, non-W3C, deprecated, will be removed in 1.8 ***
  2.3089 +	props: "attrChange attrName relatedNode srcElement altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),
  2.3090 +
  2.3091 +	fixHooks: {},
  2.3092 +
  2.3093 +	keyHooks: {
  2.3094 +		props: "char charCode key keyCode".split(" "),
  2.3095 +		filter: function( event, original ) {
  2.3096 +
  2.3097 +			// Add which for key events
  2.3098 +			if ( event.which == null ) {
  2.3099 +				event.which = original.charCode != null ? original.charCode : original.keyCode;
  2.3100 +			}
  2.3101 +
  2.3102 +			return event;
  2.3103 +		}
  2.3104 +	},
  2.3105 +
  2.3106 +	mouseHooks: {
  2.3107 +		props: "button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "),
  2.3108 +		filter: function( event, original ) {
  2.3109 +			var eventDoc, doc, body,
  2.3110 +				button = original.button,
  2.3111 +				fromElement = original.fromElement;
  2.3112 +
  2.3113 +			// Calculate pageX/Y if missing and clientX/Y available
  2.3114 +			if ( event.pageX == null && original.clientX != null ) {
  2.3115 +				eventDoc = event.target.ownerDocument || document;
  2.3116 +				doc = eventDoc.documentElement;
  2.3117 +				body = eventDoc.body;
  2.3118 +
  2.3119 +				event.pageX = original.clientX + ( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) - ( doc && doc.clientLeft || body && body.clientLeft || 0 );
  2.3120 +				event.pageY = original.clientY + ( doc && doc.scrollTop  || body && body.scrollTop  || 0 ) - ( doc && doc.clientTop  || body && body.clientTop  || 0 );
  2.3121 +			}
  2.3122 +
  2.3123 +			// Add relatedTarget, if necessary
  2.3124 +			if ( !event.relatedTarget && fromElement ) {
  2.3125 +				event.relatedTarget = fromElement === event.target ? original.toElement : fromElement;
  2.3126 +			}
  2.3127 +
  2.3128 +			// Add which for click: 1 === left; 2 === middle; 3 === right
  2.3129 +			// Note: button is not normalized, so don't use it
  2.3130 +			if ( !event.which && button !== undefined ) {
  2.3131 +				event.which = ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) );
  2.3132 +			}
  2.3133 +
  2.3134 +			return event;
  2.3135 +		}
  2.3136 +	},
  2.3137 +
  2.3138 +	fix: function( event ) {
  2.3139 +		if ( event[ jQuery.expando ] ) {
  2.3140 +			return event;
  2.3141 +		}
  2.3142 +
  2.3143 +		// Create a writable copy of the event object and normalize some properties
  2.3144 +		var i, prop,
  2.3145 +			originalEvent = event,
  2.3146 +			fixHook = jQuery.event.fixHooks[ event.type ] || {},
  2.3147 +			copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props;
  2.3148 +
  2.3149 +		event = jQuery.Event( originalEvent );
  2.3150 +
  2.3151 +		for ( i = copy.length; i; ) {
  2.3152 +			prop = copy[ --i ];
  2.3153 +			event[ prop ] = originalEvent[ prop ];
  2.3154 +		}
  2.3155 +
  2.3156 +		// Fix target property, if necessary (#1925, IE 6/7/8 & Safari2)
  2.3157 +		if ( !event.target ) {
  2.3158 +			event.target = originalEvent.srcElement || document;
  2.3159 +		}
  2.3160 +
  2.3161 +		// Target should not be a text node (#504, Safari)
  2.3162 +		if ( event.target.nodeType === 3 ) {
  2.3163 +			event.target = event.target.parentNode;
  2.3164 +		}
  2.3165 +
  2.3166 +		// For mouse/key events, metaKey==false if it's undefined (#3368, #11328; IE6/7/8)
  2.3167 +		event.metaKey = !!event.metaKey;
  2.3168 +
  2.3169 +		return fixHook.filter? fixHook.filter( event, originalEvent ) : event;
  2.3170 +	},
  2.3171 +
  2.3172 +	special: {
  2.3173 +		load: {
  2.3174 +			// Prevent triggered image.load events from bubbling to window.load
  2.3175 +			noBubble: true
  2.3176 +		},
  2.3177 +
  2.3178 +		focus: {
  2.3179 +			delegateType: "focusin"
  2.3180 +		},
  2.3181 +		blur: {
  2.3182 +			delegateType: "focusout"
  2.3183 +		},
  2.3184 +
  2.3185 +		beforeunload: {
  2.3186 +			setup: function( data, namespaces, eventHandle ) {
  2.3187 +				// We only want to do this special case on windows
  2.3188 +				if ( jQuery.isWindow( this ) ) {
  2.3189 +					this.onbeforeunload = eventHandle;
  2.3190 +				}
  2.3191 +			},
  2.3192 +
  2.3193 +			teardown: function( namespaces, eventHandle ) {
  2.3194 +				if ( this.onbeforeunload === eventHandle ) {
  2.3195 +					this.onbeforeunload = null;
  2.3196 +				}
  2.3197 +			}
  2.3198 +		}
  2.3199 +	},
  2.3200 +
  2.3201 +	simulate: function( type, elem, event, bubble ) {
  2.3202 +		// Piggyback on a donor event to simulate a different one.
  2.3203 +		// Fake originalEvent to avoid donor's stopPropagation, but if the
  2.3204 +		// simulated event prevents default then we do the same on the donor.
  2.3205 +		var e = jQuery.extend(
  2.3206 +			new jQuery.Event(),
  2.3207 +			event,
  2.3208 +			{ type: type,
  2.3209 +				isSimulated: true,
  2.3210 +				originalEvent: {}
  2.3211 +			}
  2.3212 +		);
  2.3213 +		if ( bubble ) {
  2.3214 +			jQuery.event.trigger( e, null, elem );
  2.3215 +		} else {
  2.3216 +			jQuery.event.dispatch.call( elem, e );
  2.3217 +		}
  2.3218 +		if ( e.isDefaultPrevented() ) {
  2.3219 +			event.preventDefault();
  2.3220 +		}
  2.3221 +	}
  2.3222 +};
  2.3223 +
  2.3224 +// Some plugins are using, but it's undocumented/deprecated and will be removed.
  2.3225 +// The 1.7 special event interface should provide all the hooks needed now.
  2.3226 +jQuery.event.handle = jQuery.event.dispatch;
  2.3227 +
  2.3228 +jQuery.removeEvent = document.removeEventListener ?
  2.3229 +	function( elem, type, handle ) {
  2.3230 +		if ( elem.removeEventListener ) {
  2.3231 +			elem.removeEventListener( type, handle, false );
  2.3232 +		}
  2.3233 +	} :
  2.3234 +	function( elem, type, handle ) {
  2.3235 +		var name = "on" + type;
  2.3236 +
  2.3237 +		if ( elem.detachEvent ) {
  2.3238 +
  2.3239 +			// #8545, #7054, preventing memory leaks for custom events in IE6-8 –
  2.3240 +			// detachEvent needed property on element, by name of that event, to properly expose it to GC
  2.3241 +			if ( typeof elem[ name ] === "undefined" ) {
  2.3242 +				elem[ name ] = null;
  2.3243 +			}
  2.3244 +
  2.3245 +			elem.detachEvent( name, handle );
  2.3246 +		}
  2.3247 +	};
  2.3248 +
  2.3249 +jQuery.Event = function( src, props ) {
  2.3250 +	// Allow instantiation without the 'new' keyword
  2.3251 +	if ( !(this instanceof jQuery.Event) ) {
  2.3252 +		return new jQuery.Event( src, props );
  2.3253 +	}
  2.3254 +
  2.3255 +	// Event object
  2.3256 +	if ( src && src.type ) {
  2.3257 +		this.originalEvent = src;
  2.3258 +		this.type = src.type;
  2.3259 +
  2.3260 +		// Events bubbling up the document may have been marked as prevented
  2.3261 +		// by a handler lower down the tree; reflect the correct value.
  2.3262 +		this.isDefaultPrevented = ( src.defaultPrevented || src.returnValue === false ||
  2.3263 +			src.getPreventDefault && src.getPreventDefault() ) ? returnTrue : returnFalse;
  2.3264 +
  2.3265 +	// Event type
  2.3266 +	} else {
  2.3267 +		this.type = src;
  2.3268 +	}
  2.3269 +
  2.3270 +	// Put explicitly provided properties onto the event object
  2.3271 +	if ( props ) {
  2.3272 +		jQuery.extend( this, props );
  2.3273 +	}
  2.3274 +
  2.3275 +	// Create a timestamp if incoming event doesn't have one
  2.3276 +	this.timeStamp = src && src.timeStamp || jQuery.now();
  2.3277 +
  2.3278 +	// Mark it as fixed
  2.3279 +	this[ jQuery.expando ] = true;
  2.3280 +};
  2.3281 +
  2.3282 +function returnFalse() {
  2.3283 +	return false;
  2.3284 +}
  2.3285 +function returnTrue() {
  2.3286 +	return true;
  2.3287 +}
  2.3288 +
  2.3289 +// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
  2.3290 +// http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
  2.3291 +jQuery.Event.prototype = {
  2.3292 +	preventDefault: function() {
  2.3293 +		this.isDefaultPrevented = returnTrue;
  2.3294 +
  2.3295 +		var e = this.originalEvent;
  2.3296 +		if ( !e ) {
  2.3297 +			return;
  2.3298 +		}
  2.3299 +
  2.3300 +		// if preventDefault exists run it on the original event
  2.3301 +		if ( e.preventDefault ) {
  2.3302 +			e.preventDefault();
  2.3303 +
  2.3304 +		// otherwise set the returnValue property of the original event to false (IE)
  2.3305 +		} else {
  2.3306 +			e.returnValue = false;
  2.3307 +		}
  2.3308 +	},
  2.3309 +	stopPropagation: function() {
  2.3310 +		this.isPropagationStopped = returnTrue;
  2.3311 +
  2.3312 +		var e = this.originalEvent;
  2.3313 +		if ( !e ) {
  2.3314 +			return;
  2.3315 +		}
  2.3316 +		// if stopPropagation exists run it on the original event
  2.3317 +		if ( e.stopPropagation ) {
  2.3318 +			e.stopPropagation();
  2.3319 +		}
  2.3320 +		// otherwise set the cancelBubble property of the original event to true (IE)
  2.3321 +		e.cancelBubble = true;
  2.3322 +	},
  2.3323 +	stopImmediatePropagation: function() {
  2.3324 +		this.isImmediatePropagationStopped = returnTrue;
  2.3325 +		this.stopPropagation();
  2.3326 +	},
  2.3327 +	isDefaultPrevented: returnFalse,
  2.3328 +	isPropagationStopped: returnFalse,
  2.3329 +	isImmediatePropagationStopped: returnFalse
  2.3330 +};
  2.3331 +
  2.3332 +// Create mouseenter/leave events using mouseover/out and event-time checks
  2.3333 +jQuery.each({
  2.3334 +	mouseenter: "mouseover",
  2.3335 +	mouseleave: "mouseout"
  2.3336 +}, function( orig, fix ) {
  2.3337 +	jQuery.event.special[ orig ] = {
  2.3338 +		delegateType: fix,
  2.3339 +		bindType: fix,
  2.3340 +
  2.3341 +		handle: function( event ) {
  2.3342 +			var ret,
  2.3343 +				target = this,
  2.3344 +				related = event.relatedTarget,
  2.3345 +				handleObj = event.handleObj,
  2.3346 +				selector = handleObj.selector;
  2.3347 +
  2.3348 +			// For mousenter/leave call the handler if related is outside the target.
  2.3349 +			// NB: No relatedTarget if the mouse left/entered the browser window
  2.3350 +			if ( !related || (related !== target && !jQuery.contains( target, related )) ) {
  2.3351 +				event.type = handleObj.origType;
  2.3352 +				ret = handleObj.handler.apply( this, arguments );
  2.3353 +				event.type = fix;
  2.3354 +			}
  2.3355 +			return ret;
  2.3356 +		}
  2.3357 +	};
  2.3358 +});
  2.3359 +
  2.3360 +// IE submit delegation
  2.3361 +if ( !jQuery.support.submitBubbles ) {
  2.3362 +
  2.3363 +	jQuery.event.special.submit = {
  2.3364 +		setup: function() {
  2.3365 +			// Only need this for delegated form submit events
  2.3366 +			if ( jQuery.nodeName( this, "form" ) ) {
  2.3367 +				return false;
  2.3368 +			}
  2.3369 +
  2.3370 +			// Lazy-add a submit handler when a descendant form may potentially be submitted
  2.3371 +			jQuery.event.add( this, "click._submit keypress._submit", function( e ) {
  2.3372 +				// Node name check avoids a VML-related crash in IE (#9807)
  2.3373 +				var elem = e.target,
  2.3374 +					form = jQuery.nodeName( elem, "input" ) || jQuery.nodeName( elem, "button" ) ? elem.form : undefined;
  2.3375 +				if ( form && !jQuery._data( form, "_submit_attached" ) ) {
  2.3376 +					jQuery.event.add( form, "submit._submit", function( event ) {
  2.3377 +						event._submit_bubble = true;
  2.3378 +					});
  2.3379 +					jQuery._data( form, "_submit_attached", true );
  2.3380 +				}
  2.3381 +			});
  2.3382 +			// return undefined since we don't need an event listener
  2.3383 +		},
  2.3384 +
  2.3385 +		postDispatch: function( event ) {
  2.3386 +			// If form was submitted by the user, bubble the event up the tree
  2.3387 +			if ( event._submit_bubble ) {
  2.3388 +				delete event._submit_bubble;
  2.3389 +				if ( this.parentNode && !event.isTrigger ) {
  2.3390 +					jQuery.event.simulate( "submit", this.parentNode, event, true );
  2.3391 +				}
  2.3392 +			}
  2.3393 +		},
  2.3394 +
  2.3395 +		teardown: function() {
  2.3396 +			// Only need this for delegated form submit events
  2.3397 +			if ( jQuery.nodeName( this, "form" ) ) {
  2.3398 +				return false;
  2.3399 +			}
  2.3400 +
  2.3401 +			// Remove delegated handlers; cleanData eventually reaps submit handlers attached above
  2.3402 +			jQuery.event.remove( this, "._submit" );
  2.3403 +		}
  2.3404 +	};
  2.3405 +}
  2.3406 +
  2.3407 +// IE change delegation and checkbox/radio fix
  2.3408 +if ( !jQuery.support.changeBubbles ) {
  2.3409 +
  2.3410 +	jQuery.event.special.change = {
  2.3411 +
  2.3412 +		setup: function() {
  2.3413 +
  2.3414 +			if ( rformElems.test( this.nodeName ) ) {
  2.3415 +				// IE doesn't fire change on a check/radio until blur; trigger it on click
  2.3416 +				// after a propertychange. Eat the blur-change in special.change.handle.
  2.3417 +				// This still fires onchange a second time for check/radio after blur.
  2.3418 +				if ( this.type === "checkbox" || this.type === "radio" ) {
  2.3419 +					jQuery.event.add( this, "propertychange._change", function( event ) {
  2.3420 +						if ( event.originalEvent.propertyName === "checked" ) {
  2.3421 +							this._just_changed = true;
  2.3422 +						}
  2.3423 +					});
  2.3424 +					jQuery.event.add( this, "click._change", function( event ) {
  2.3425 +						if ( this._just_changed && !event.isTrigger ) {
  2.3426 +							this._just_changed = false;
  2.3427 +						}
  2.3428 +						// Allow triggered, simulated change events (#11500)
  2.3429 +						jQuery.event.simulate( "change", this, event, true );
  2.3430 +					});
  2.3431 +				}
  2.3432 +				return false;
  2.3433 +			}
  2.3434 +			// Delegated event; lazy-add a change handler on descendant inputs
  2.3435 +			jQuery.event.add( this, "beforeactivate._change", function( e ) {
  2.3436 +				var elem = e.target;
  2.3437 +
  2.3438 +				if ( rformElems.test( elem.nodeName ) && !jQuery._data( elem, "_change_attached" ) ) {
  2.3439 +					jQuery.event.add( elem, "change._change", function( event ) {
  2.3440 +						if ( this.parentNode && !event.isSimulated && !event.isTrigger ) {
  2.3441 +							jQuery.event.simulate( "change", this.parentNode, event, true );
  2.3442 +						}
  2.3443 +					});
  2.3444 +					jQuery._data( elem, "_change_attached", true );
  2.3445 +				}
  2.3446 +			});
  2.3447 +		},
  2.3448 +
  2.3449 +		handle: function( event ) {
  2.3450 +			var elem = event.target;
  2.3451 +
  2.3452 +			// Swallow native change events from checkbox/radio, we already triggered them above
  2.3453 +			if ( this !== elem || event.isSimulated || event.isTrigger || (elem.type !== "radio" && elem.type !== "checkbox") ) {
  2.3454 +				return event.handleObj.handler.apply( this, arguments );
  2.3455 +			}
  2.3456 +		},
  2.3457 +
  2.3458 +		teardown: function() {
  2.3459 +			jQuery.event.remove( this, "._change" );
  2.3460 +
  2.3461 +			return !rformElems.test( this.nodeName );
  2.3462 +		}
  2.3463 +	};
  2.3464 +}
  2.3465 +
  2.3466 +// Create "bubbling" focus and blur events
  2.3467 +if ( !jQuery.support.focusinBubbles ) {
  2.3468 +	jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
  2.3469 +
  2.3470 +		// Attach a single capturing handler while someone wants focusin/focusout
  2.3471 +		var attaches = 0,
  2.3472 +			handler = function( event ) {
  2.3473 +				jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ), true );
  2.3474 +			};
  2.3475 +
  2.3476 +		jQuery.event.special[ fix ] = {
  2.3477 +			setup: function() {
  2.3478 +				if ( attaches++ === 0 ) {
  2.3479 +					document.addEventListener( orig, handler, true );
  2.3480 +				}
  2.3481 +			},
  2.3482 +			teardown: function() {
  2.3483 +				if ( --attaches === 0 ) {
  2.3484 +					document.removeEventListener( orig, handler, true );
  2.3485 +				}
  2.3486 +			}
  2.3487 +		};
  2.3488 +	});
  2.3489 +}
  2.3490 +
  2.3491 +jQuery.fn.extend({
  2.3492 +
  2.3493 +	on: function( types, selector, data, fn, /*INTERNAL*/ one ) {
  2.3494 +		var origFn, type;
  2.3495 +
  2.3496 +		// Types can be a map of types/handlers
  2.3497 +		if ( typeof types === "object" ) {
  2.3498 +			// ( types-Object, selector, data )
  2.3499 +			if ( typeof selector !== "string" ) { // && selector != null
  2.3500 +				// ( types-Object, data )
  2.3501 +				data = data || selector;
  2.3502 +				selector = undefined;
  2.3503 +			}
  2.3504 +			for ( type in types ) {
  2.3505 +				this.on( type, selector, data, types[ type ], one );
  2.3506 +			}
  2.3507 +			return this;
  2.3508 +		}
  2.3509 +
  2.3510 +		if ( data == null && fn == null ) {
  2.3511 +			// ( types, fn )
  2.3512 +			fn = selector;
  2.3513 +			data = selector = undefined;
  2.3514 +		} else if ( fn == null ) {
  2.3515 +			if ( typeof selector === "string" ) {
  2.3516 +				// ( types, selector, fn )
  2.3517 +				fn = data;
  2.3518 +				data = undefined;
  2.3519 +			} else {
  2.3520 +				// ( types, data, fn )
  2.3521 +				fn = data;
  2.3522 +				data = selector;
  2.3523 +				selector = undefined;
  2.3524 +			}
  2.3525 +		}
  2.3526 +		if ( fn === false ) {
  2.3527 +			fn = returnFalse;
  2.3528 +		} else if ( !fn ) {
  2.3529 +			return this;
  2.3530 +		}
  2.3531 +
  2.3532 +		if ( one === 1 ) {
  2.3533 +			origFn = fn;
  2.3534 +			fn = function( event ) {
  2.3535 +				// Can use an empty set, since event contains the info
  2.3536 +				jQuery().off( event );
  2.3537 +				return origFn.apply( this, arguments );
  2.3538 +			};
  2.3539 +			// Use same guid so caller can remove using origFn
  2.3540 +			fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
  2.3541 +		}
  2.3542 +		return this.each( function() {
  2.3543 +			jQuery.event.add( this, types, fn, data, selector );
  2.3544 +		});
  2.3545 +	},
  2.3546 +	one: function( types, selector, data, fn ) {
  2.3547 +		return this.on( types, selector, data, fn, 1 );
  2.3548 +	},
  2.3549 +	off: function( types, selector, fn ) {
  2.3550 +		var handleObj, type;
  2.3551 +		if ( types && types.preventDefault && types.handleObj ) {
  2.3552 +			// ( event )  dispatched jQuery.Event
  2.3553 +			handleObj = types.handleObj;
  2.3554 +			jQuery( types.delegateTarget ).off(
  2.3555 +				handleObj.namespace ? handleObj.origType + "." + handleObj.namespace : handleObj.origType,
  2.3556 +				handleObj.selector,
  2.3557 +				handleObj.handler
  2.3558 +			);
  2.3559 +			return this;
  2.3560 +		}
  2.3561 +		if ( typeof types === "object" ) {
  2.3562 +			// ( types-object [, selector] )
  2.3563 +			for ( type in types ) {
  2.3564 +				this.off( type, selector, types[ type ] );
  2.3565 +			}
  2.3566 +			return this;
  2.3567 +		}
  2.3568 +		if ( selector === false || typeof selector === "function" ) {
  2.3569 +			// ( types [, fn] )
  2.3570 +			fn = selector;
  2.3571 +			selector = undefined;
  2.3572 +		}
  2.3573 +		if ( fn === false ) {
  2.3574 +			fn = returnFalse;
  2.3575 +		}
  2.3576 +		return this.each(function() {
  2.3577 +			jQuery.event.remove( this, types, fn, selector );
  2.3578 +		});
  2.3579 +	},
  2.3580 +
  2.3581 +	bind: function( types, data, fn ) {
  2.3582 +		return this.on( types, null, data, fn );
  2.3583 +	},
  2.3584 +	unbind: function( types, fn ) {
  2.3585 +		return this.off( types, null, fn );
  2.3586 +	},
  2.3587 +
  2.3588 +	live: function( types, data, fn ) {
  2.3589 +		jQuery( this.context ).on( types, this.selector, data, fn );
  2.3590 +		return this;
  2.3591 +	},
  2.3592 +	die: function( types, fn ) {
  2.3593 +		jQuery( this.context ).off( types, this.selector || "**", fn );
  2.3594 +		return this;
  2.3595 +	},
  2.3596 +
  2.3597 +	delegate: function( selector, types, data, fn ) {
  2.3598 +		return this.on( types, selector, data, fn );
  2.3599 +	},
  2.3600 +	undelegate: function( selector, types, fn ) {
  2.3601 +		// ( namespace ) or ( selector, types [, fn] )
  2.3602 +		return arguments.length === 1 ? this.off( selector, "**" ) : this.off( types, selector || "**", fn );
  2.3603 +	},
  2.3604 +
  2.3605 +	trigger: function( type, data ) {
  2.3606 +		return this.each(function() {
  2.3607 +			jQuery.event.trigger( type, data, this );
  2.3608 +		});
  2.3609 +	},
  2.3610 +	triggerHandler: function( type, data ) {
  2.3611 +		if ( this[0] ) {
  2.3612 +			return jQuery.event.trigger( type, data, this[0], true );
  2.3613 +		}
  2.3614 +	},
  2.3615 +
  2.3616 +	toggle: function( fn ) {
  2.3617 +		// Save reference to arguments for access in closure
  2.3618 +		var args = arguments,
  2.3619 +			guid = fn.guid || jQuery.guid++,
  2.3620 +			i = 0,
  2.3621 +			toggler = function( event ) {
  2.3622 +				// Figure out which function to execute
  2.3623 +				var lastToggle = ( jQuery._data( this, "lastToggle" + fn.guid ) || 0 ) % i;
  2.3624 +				jQuery._data( this, "lastToggle" + fn.guid, lastToggle + 1 );
  2.3625 +
  2.3626 +				// Make sure that clicks stop
  2.3627 +				event.preventDefault();
  2.3628 +
  2.3629 +				// and execute the function
  2.3630 +				return args[ lastToggle ].apply( this, arguments ) || false;
  2.3631 +			};
  2.3632 +
  2.3633 +		// link all the functions, so any of them can unbind this click handler
  2.3634 +		toggler.guid = guid;
  2.3635 +		while ( i < args.length ) {
  2.3636 +			args[ i++ ].guid = guid;
  2.3637 +		}
  2.3638 +
  2.3639 +		return this.click( toggler );
  2.3640 +	},
  2.3641 +
  2.3642 +	hover: function( fnOver, fnOut ) {
  2.3643 +		return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
  2.3644 +	}
  2.3645 +});
  2.3646 +
  2.3647 +jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
  2.3648 +	"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
  2.3649 +	"change select submit keydown keypress keyup error contextmenu").split(" "), function( i, name ) {
  2.3650 +
  2.3651 +	// Handle event binding
  2.3652 +	jQuery.fn[ name ] = function( data, fn ) {
  2.3653 +		if ( fn == null ) {
  2.3654 +			fn = data;
  2.3655 +			data = null;
  2.3656 +		}
  2.3657 +
  2.3658 +		return arguments.length > 0 ?
  2.3659 +			this.on( name, null, data, fn ) :
  2.3660 +			this.trigger( name );
  2.3661 +	};
  2.3662 +
  2.3663 +	if ( rkeyEvent.test( name ) ) {
  2.3664 +		jQuery.event.fixHooks[ name ] = jQuery.event.keyHooks;
  2.3665 +	}
  2.3666 +
  2.3667 +	if ( rmouseEvent.test( name ) ) {
  2.3668 +		jQuery.event.fixHooks[ name ] = jQuery.event.mouseHooks;
  2.3669 +	}
  2.3670 +});
  2.3671 +/*!
  2.3672 + * Sizzle CSS Selector Engine
  2.3673 + * Copyright 2012 jQuery Foundation and other contributors
  2.3674 + * Released under the MIT license
  2.3675 + * http://sizzlejs.com/
  2.3676 + */
  2.3677 +(function( window, undefined ) {
  2.3678 +
  2.3679 +var cachedruns,
  2.3680 +	assertGetIdNotName,
  2.3681 +	Expr,
  2.3682 +	getText,
  2.3683 +	isXML,
  2.3684 +	contains,
  2.3685 +	compile,
  2.3686 +	sortOrder,
  2.3687 +	hasDuplicate,
  2.3688 +	outermostContext,
  2.3689 +
  2.3690 +	baseHasDuplicate = true,
  2.3691 +	strundefined = "undefined",
  2.3692 +
  2.3693 +	expando = ( "sizcache" + Math.random() ).replace( ".", "" ),
  2.3694 +
  2.3695 +	Token = String,
  2.3696 +	document = window.document,
  2.3697 +	docElem = document.documentElement,
  2.3698 +	dirruns = 0,
  2.3699 +	done = 0,
  2.3700 +	pop = [].pop,
  2.3701 +	push = [].push,
  2.3702 +	slice = [].slice,
  2.3703 +	// Use a stripped-down indexOf if a native one is unavailable
  2.3704 +	indexOf = [].indexOf || function( elem ) {
  2.3705 +		var i = 0,
  2.3706 +			len = this.length;
  2.3707 +		for ( ; i < len; i++ ) {
  2.3708 +			if ( this[i] === elem ) {
  2.3709 +				return i;
  2.3710 +			}
  2.3711 +		}
  2.3712 +		return -1;
  2.3713 +	},
  2.3714 +
  2.3715 +	// Augment a function for special use by Sizzle
  2.3716 +	markFunction = function( fn, value ) {
  2.3717 +		fn[ expando ] = value == null || value;
  2.3718 +		return fn;
  2.3719 +	},
  2.3720 +
  2.3721 +	createCache = function() {
  2.3722 +		var cache = {},
  2.3723 +			keys = [];
  2.3724 +
  2.3725 +		return markFunction(function( key, value ) {
  2.3726 +			// Only keep the most recent entries
  2.3727 +			if ( keys.push( key ) > Expr.cacheLength ) {
  2.3728 +				delete cache[ keys.shift() ];
  2.3729 +			}
  2.3730 +
  2.3731 +			return (cache[ key ] = value);
  2.3732 +		}, cache );
  2.3733 +	},
  2.3734 +
  2.3735 +	classCache = createCache(),
  2.3736 +	tokenCache = createCache(),
  2.3737 +	compilerCache = createCache(),
  2.3738 +
  2.3739 +	// Regex
  2.3740 +
  2.3741 +	// Whitespace characters http://www.w3.org/TR/css3-selectors/#whitespace
  2.3742 +	whitespace = "[\\x20\\t\\r\\n\\f]",
  2.3743 +	// http://www.w3.org/TR/css3-syntax/#characters
  2.3744 +	characterEncoding = "(?:\\\\.|[-\\w]|[^\\x00-\\xa0])+",
  2.3745 +
  2.3746 +	// Loosely modeled on CSS identifier characters
  2.3747 +	// An unquoted value should be a CSS identifier (http://www.w3.org/TR/css3-selectors/#attribute-selectors)
  2.3748 +	// Proper syntax: http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
  2.3749 +	identifier = characterEncoding.replace( "w", "w#" ),
  2.3750 +
  2.3751 +	// Acceptable operators http://www.w3.org/TR/selectors/#attribute-selectors
  2.3752 +	operators = "([*^$|!~]?=)",
  2.3753 +	attributes = "\\[" + whitespace + "*(" + characterEncoding + ")" + whitespace +
  2.3754 +		"*(?:" + operators + whitespace + "*(?:(['\"])((?:\\\\.|[^\\\\])*?)\\3|(" + identifier + ")|)|)" + whitespace + "*\\]",
  2.3755 +
  2.3756 +	// Prefer arguments not in parens/brackets,
  2.3757 +	//   then attribute selectors and non-pseudos (denoted by :),
  2.3758 +	//   then anything else
  2.3759 +	// These preferences are here to reduce the number of selectors
  2.3760 +	//   needing tokenize in the PSEUDO preFilter
  2.3761 +	pseudos = ":(" + characterEncoding + ")(?:\\((?:(['\"])((?:\\\\.|[^\\\\])*?)\\2|([^()[\\]]*|(?:(?:" + attributes + ")|[^:]|\\\\.)*|.*))\\)|)",
  2.3762 +
  2.3763 +	// For matchExpr.POS and matchExpr.needsContext
  2.3764 +	pos = ":(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace +
  2.3765 +		"*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)",
  2.3766 +
  2.3767 +	// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
  2.3768 +	rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ),
  2.3769 +
  2.3770 +	rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
  2.3771 +	rcombinators = new RegExp( "^" + whitespace + "*([\\x20\\t\\r\\n\\f>+~])" + whitespace + "*" ),
  2.3772 +	rpseudo = new RegExp( pseudos ),
  2.3773 +
  2.3774 +	// Easily-parseable/retrievable ID or TAG or CLASS selectors
  2.3775 +	rquickExpr = /^(?:#([\w\-]+)|(\w+)|\.([\w\-]+))$/,
  2.3776 +
  2.3777 +	rnot = /^:not/,
  2.3778 +	rsibling = /[\x20\t\r\n\f]*[+~]/,
  2.3779 +	rendsWithNot = /:not\($/,
  2.3780 +
  2.3781 +	rheader = /h\d/i,
  2.3782 +	rinputs = /input|select|textarea|button/i,
  2.3783 +
  2.3784 +	rbackslash = /\\(?!\\)/g,
  2.3785 +
  2.3786 +	matchExpr = {
  2.3787 +		"ID": new RegExp( "^#(" + characterEncoding + ")" ),
  2.3788 +		"CLASS": new RegExp( "^\\.(" + characterEncoding + ")" ),
  2.3789 +		"NAME": new RegExp( "^\\[name=['\"]?(" + characterEncoding + ")['\"]?\\]" ),
  2.3790 +		"TAG": new RegExp( "^(" + characterEncoding.replace( "w", "w*" ) + ")" ),
  2.3791 +		"ATTR": new RegExp( "^" + attributes ),
  2.3792 +		"PSEUDO": new RegExp( "^" + pseudos ),
  2.3793 +		"POS": new RegExp( pos, "i" ),
  2.3794 +		"CHILD": new RegExp( "^:(only|nth|first|last)-child(?:\\(" + whitespace +
  2.3795 +			"*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace +
  2.3796 +			"*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
  2.3797 +		// For use in libraries implementing .is()
  2.3798 +		"needsContext": new RegExp( "^" + whitespace + "*[>+~]|" + pos, "i" )
  2.3799 +	},
  2.3800 +
  2.3801 +	// Support
  2.3802 +
  2.3803 +	// Used for testing something on an element
  2.3804 +	assert = function( fn ) {
  2.3805 +		var div = document.createElement("div");
  2.3806 +
  2.3807 +		try {
  2.3808 +			return fn( div );
  2.3809 +		} catch (e) {
  2.3810 +			return false;
  2.3811 +		} finally {
  2.3812 +			// release memory in IE
  2.3813 +			div = null;
  2.3814 +		}
  2.3815 +	},
  2.3816 +
  2.3817 +	// Check if getElementsByTagName("*") returns only elements
  2.3818 +	assertTagNameNoComments = assert(function( div ) {
  2.3819 +		div.appendChild( document.createComment("") );
  2.3820 +		return !div.getElementsByTagName("*").length;
  2.3821 +	}),
  2.3822 +
  2.3823 +	// Check if getAttribute returns normalized href attributes
  2.3824 +	assertHrefNotNormalized = assert(function( div ) {
  2.3825 +		div.innerHTML = "<a href='#'></a>";
  2.3826 +		return div.firstChild && typeof div.firstChild.getAttribute !== strundefined &&
  2.3827 +			div.firstChild.getAttribute("href") === "#";
  2.3828 +	}),
  2.3829 +
  2.3830 +	// Check if attributes should be retrieved by attribute nodes
  2.3831 +	assertAttributes = assert(function( div ) {
  2.3832 +		div.innerHTML = "<select></select>";
  2.3833 +		var type = typeof div.lastChild.getAttribute("multiple");
  2.3834 +		// IE8 returns a string for some attributes even when not present
  2.3835 +		return type !== "boolean" && type !== "string";
  2.3836 +	}),
  2.3837 +
  2.3838 +	// Check if getElementsByClassName can be trusted
  2.3839 +	assertUsableClassName = assert(function( div ) {
  2.3840 +		// Opera can't find a second classname (in 9.6)
  2.3841 +		div.innerHTML = "<div class='hidden e'></div><div class='hidden'></div>";
  2.3842 +		if ( !div.getElementsByClassName || !div.getElementsByClassName("e").length ) {
  2.3843 +			return false;
  2.3844 +		}
  2.3845 +
  2.3846 +		// Safari 3.2 caches class attributes and doesn't catch changes
  2.3847 +		div.lastChild.className = "e";
  2.3848 +		return div.getElementsByClassName("e").length === 2;
  2.3849 +	}),
  2.3850 +
  2.3851 +	// Check if getElementById returns elements by name
  2.3852 +	// Check if getElementsByName privileges form controls or returns elements by ID
  2.3853 +	assertUsableName = assert(function( div ) {
  2.3854 +		// Inject content
  2.3855 +		div.id = expando + 0;
  2.3856 +		div.innerHTML = "<a name='" + expando + "'></a><div name='" + expando + "'></div>";
  2.3857 +		docElem.insertBefore( div, docElem.firstChild );
  2.3858 +
  2.3859 +		// Test
  2.3860 +		var pass = document.getElementsByName &&
  2.3861 +			// buggy browsers will return fewer than the correct 2
  2.3862 +			document.getElementsByName( expando ).length === 2 +
  2.3863 +			// buggy browsers will return more than the correct 0
  2.3864 +			document.getElementsByName( expando + 0 ).length;
  2.3865 +		assertGetIdNotName = !document.getElementById( expando );
  2.3866 +
  2.3867 +		// Cleanup
  2.3868 +		docElem.removeChild( div );
  2.3869 +
  2.3870 +		return pass;
  2.3871 +	});
  2.3872 +
  2.3873 +// If slice is not available, provide a backup
  2.3874 +try {
  2.3875 +	slice.call( docElem.childNodes, 0 )[0].nodeType;
  2.3876 +} catch ( e ) {
  2.3877 +	slice = function( i ) {
  2.3878 +		var elem,
  2.3879 +			results = [];
  2.3880 +		for ( ; (elem = this[i]); i++ ) {
  2.3881 +			results.push( elem );
  2.3882 +		}
  2.3883 +		return results;
  2.3884 +	};
  2.3885 +}
  2.3886 +
  2.3887 +function Sizzle( selector, context, results, seed ) {
  2.3888 +	results = results || [];
  2.3889 +	context = context || document;
  2.3890 +	var match, elem, xml, m,
  2.3891 +		nodeType = context.nodeType;
  2.3892 +
  2.3893 +	if ( !selector || typeof selector !== "string" ) {
  2.3894 +		return results;
  2.3895 +	}
  2.3896 +
  2.3897 +	if ( nodeType !== 1 && nodeType !== 9 ) {
  2.3898 +		return [];
  2.3899 +	}
  2.3900 +
  2.3901 +	xml = isXML( context );
  2.3902 +
  2.3903 +	if ( !xml && !seed ) {
  2.3904 +		if ( (match = rquickExpr.exec( selector )) ) {
  2.3905 +			// Speed-up: Sizzle("#ID")
  2.3906 +			if ( (m = match[1]) ) {
  2.3907 +				if ( nodeType === 9 ) {
  2.3908 +					elem = context.getElementById( m );
  2.3909 +					// Check parentNode to catch when Blackberry 4.6 returns
  2.3910 +					// nodes that are no longer in the document #6963
  2.3911 +					if ( elem && elem.parentNode ) {
  2.3912 +						// Handle the case where IE, Opera, and Webkit return items
  2.3913 +						// by name instead of ID
  2.3914 +						if ( elem.id === m ) {
  2.3915 +							results.push( elem );
  2.3916 +							return results;
  2.3917 +						}
  2.3918 +					} else {
  2.3919 +						return results;
  2.3920 +					}
  2.3921 +				} else {
  2.3922 +					// Context is not a document
  2.3923 +					if ( context.ownerDocument && (elem = context.ownerDocument.getElementById( m )) &&
  2.3924 +						contains( context, elem ) && elem.id === m ) {
  2.3925 +						results.push( elem );
  2.3926 +						return results;
  2.3927 +					}
  2.3928 +				}
  2.3929 +
  2.3930 +			// Speed-up: Sizzle("TAG")
  2.3931 +			} else if ( match[2] ) {
  2.3932 +				push.apply( results, slice.call(context.getElementsByTagName( selector ), 0) );
  2.3933 +				return results;
  2.3934 +
  2.3935 +			// Speed-up: Sizzle(".CLASS")
  2.3936 +			} else if ( (m = match[3]) && assertUsableClassName && context.getElementsByClassName ) {
  2.3937 +				push.apply( results, slice.call(context.getElementsByClassName( m ), 0) );
  2.3938 +				return results;
  2.3939 +			}
  2.3940 +		}
  2.3941 +	}
  2.3942 +
  2.3943 +	// All others
  2.3944 +	return select( selector.replace( rtrim, "$1" ), context, results, seed, xml );
  2.3945 +}
  2.3946 +
  2.3947 +Sizzle.matches = function( expr, elements ) {
  2.3948 +	return Sizzle( expr, null, null, elements );
  2.3949 +};
  2.3950 +
  2.3951 +Sizzle.matchesSelector = function( elem, expr ) {
  2.3952 +	return Sizzle( expr, null, null, [ elem ] ).length > 0;
  2.3953 +};
  2.3954 +
  2.3955 +// Returns a function to use in pseudos for input types
  2.3956 +function createInputPseudo( type ) {
  2.3957 +	return function( elem ) {
  2.3958 +		var name = elem.nodeName.toLowerCase();
  2.3959 +		return name === "input" && elem.type === type;
  2.3960 +	};
  2.3961 +}
  2.3962 +
  2.3963 +// Returns a function to use in pseudos for buttons
  2.3964 +function createButtonPseudo( type ) {
  2.3965 +	return function( elem ) {
  2.3966 +		var name = elem.nodeName.toLowerCase();
  2.3967 +		return (name === "input" || name === "button") && elem.type === type;
  2.3968 +	};
  2.3969 +}
  2.3970 +
  2.3971 +// Returns a function to use in pseudos for positionals
  2.3972 +function createPositionalPseudo( fn ) {
  2.3973 +	return markFunction(function( argument ) {
  2.3974 +		argument = +argument;
  2.3975 +		return markFunction(function( seed, matches ) {
  2.3976 +			var j,
  2.3977 +				matchIndexes = fn( [], seed.length, argument ),
  2.3978 +				i = matchIndexes.length;
  2.3979 +
  2.3980 +			// Match elements found at the specified indexes
  2.3981 +			while ( i-- ) {
  2.3982 +				if ( seed[ (j = matchIndexes[i]) ] ) {
  2.3983 +					seed[j] = !(matches[j] = seed[j]);
  2.3984 +				}
  2.3985 +			}
  2.3986 +		});
  2.3987 +	});
  2.3988 +}
  2.3989 +
  2.3990 +/**
  2.3991 + * Utility function for retrieving the text value of an array of DOM nodes
  2.3992 + * @param {Array|Element} elem
  2.3993 + */
  2.3994 +getText = Sizzle.getText = function( elem ) {
  2.3995 +	var node,
  2.3996 +		ret = "",
  2.3997 +		i = 0,
  2.3998 +		nodeType = elem.nodeType;
  2.3999 +
  2.4000 +	if ( nodeType ) {
  2.4001 +		if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
  2.4002 +			// Use textContent for elements
  2.4003 +			// innerText usage removed for consistency of new lines (see #11153)
  2.4004 +			if ( typeof elem.textContent === "string" ) {
  2.4005 +				return elem.textContent;
  2.4006 +			} else {
  2.4007 +				// Traverse its children
  2.4008 +				for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
  2.4009 +					ret += getText( elem );
  2.4010 +				}
  2.4011 +			}
  2.4012 +		} else if ( nodeType === 3 || nodeType === 4 ) {
  2.4013 +			return elem.nodeValue;
  2.4014 +		}
  2.4015 +		// Do not include comment or processing instruction nodes
  2.4016 +	} else {
  2.4017 +
  2.4018 +		// If no nodeType, this is expected to be an array
  2.4019 +		for ( ; (node = elem[i]); i++ ) {
  2.4020 +			// Do not traverse comment nodes
  2.4021 +			ret += getText( node );
  2.4022 +		}
  2.4023 +	}
  2.4024 +	return ret;
  2.4025 +};
  2.4026 +
  2.4027 +isXML = Sizzle.isXML = function( elem ) {
  2.4028 +	// documentElement is verified for cases where it doesn't yet exist
  2.4029 +	// (such as loading iframes in IE - #4833)
  2.4030 +	var documentElement = elem && (elem.ownerDocument || elem).documentElement;
  2.4031 +	return documentElement ? documentElement.nodeName !== "HTML" : false;
  2.4032 +};
  2.4033 +
  2.4034 +// Element contains another
  2.4035 +contains = Sizzle.contains = docElem.contains ?
  2.4036 +	function( a, b ) {
  2.4037 +		var adown = a.nodeType === 9 ? a.documentElement : a,
  2.4038 +			bup = b && b.parentNode;
  2.4039 +		return a === bup || !!( bup && bup.nodeType === 1 && adown.contains && adown.contains(bup) );
  2.4040 +	} :
  2.4041 +	docElem.compareDocumentPosition ?
  2.4042 +	function( a, b ) {
  2.4043 +		return b && !!( a.compareDocumentPosition( b ) & 16 );
  2.4044 +	} :
  2.4045 +	function( a, b ) {
  2.4046 +		while ( (b = b.parentNode) ) {
  2.4047 +			if ( b === a ) {
  2.4048 +				return true;
  2.4049 +			}
  2.4050 +		}
  2.4051 +		return false;
  2.4052 +	};
  2.4053 +
  2.4054 +Sizzle.attr = function( elem, name ) {
  2.4055 +	var val,
  2.4056 +		xml = isXML( elem );
  2.4057 +
  2.4058 +	if ( !xml ) {
  2.4059 +		name = name.toLowerCase();
  2.4060 +	}
  2.4061 +	if ( (val = Expr.attrHandle[ name ]) ) {
  2.4062 +		return val( elem );
  2.4063 +	}
  2.4064 +	if ( xml || assertAttributes ) {
  2.4065 +		return elem.getAttribute( name );
  2.4066 +	}
  2.4067 +	val = elem.getAttributeNode( name );
  2.4068 +	return val ?
  2.4069 +		typeof elem[ name ] === "boolean" ?
  2.4070 +			elem[ name ] ? name : null :
  2.4071 +			val.specified ? val.value : null :
  2.4072 +		null;
  2.4073 +};
  2.4074 +
  2.4075 +Expr = Sizzle.selectors = {
  2.4076 +
  2.4077 +	// Can be adjusted by the user
  2.4078 +	cacheLength: 50,
  2.4079 +
  2.4080 +	createPseudo: markFunction,
  2.4081 +
  2.4082 +	match: matchExpr,
  2.4083 +
  2.4084 +	// IE6/7 return a modified href
  2.4085 +	attrHandle: assertHrefNotNormalized ?
  2.4086 +		{} :
  2.4087 +		{
  2.4088 +			"href": function( elem ) {
  2.4089 +				return elem.getAttribute( "href", 2 );
  2.4090 +			},
  2.4091 +			"type": function( elem ) {
  2.4092 +				return elem.getAttribute("type");
  2.4093 +			}
  2.4094 +		},
  2.4095 +
  2.4096 +	find: {
  2.4097 +		"ID": assertGetIdNotName ?
  2.4098 +			function( id, context, xml ) {
  2.4099 +				if ( typeof context.getElementById !== strundefined && !xml ) {
  2.4100 +					var m = context.getElementById( id );
  2.4101 +					// Check parentNode to catch when Blackberry 4.6 returns
  2.4102 +					// nodes that are no longer in the document #6963
  2.4103 +					return m && m.parentNode ? [m] : [];
  2.4104 +				}
  2.4105 +			} :
  2.4106 +			function( id, context, xml ) {
  2.4107 +				if ( typeof context.getElementById !== strundefined && !xml ) {
  2.4108 +					var m = context.getElementById( id );
  2.4109 +
  2.4110 +					return m ?
  2.4111 +						m.id === id || typeof m.getAttributeNode !== strundefined && m.getAttributeNode("id").value === id ?
  2.4112 +							[m] :
  2.4113 +							undefined :
  2.4114 +						[];
  2.4115 +				}
  2.4116 +			},
  2.4117 +
  2.4118 +		"TAG": assertTagNameNoComments ?
  2.4119 +			function( tag, context ) {
  2.4120 +				if ( typeof context.getElementsByTagName !== strundefined ) {
  2.4121 +					return context.getElementsByTagName( tag );
  2.4122 +				}
  2.4123 +			} :
  2.4124 +			function( tag, context ) {
  2.4125 +				var results = context.getElementsByTagName( tag );
  2.4126 +
  2.4127 +				// Filter out possible comments
  2.4128 +				if ( tag === "*" ) {
  2.4129 +					var elem,
  2.4130 +						tmp = [],
  2.4131 +						i = 0;
  2.4132 +
  2.4133 +					for ( ; (elem = results[i]); i++ ) {
  2.4134 +						if ( elem.nodeType === 1 ) {
  2.4135 +							tmp.push( elem );
  2.4136 +						}
  2.4137 +					}
  2.4138 +
  2.4139 +					return tmp;
  2.4140 +				}
  2.4141 +				return results;
  2.4142 +			},
  2.4143 +
  2.4144 +		"NAME": assertUsableName && function( tag, context ) {
  2.4145 +			if ( typeof context.getElementsByName !== strundefined ) {
  2.4146 +				return context.getElementsByName( name );
  2.4147 +			}
  2.4148 +		},
  2.4149 +
  2.4150 +		"CLASS": assertUsableClassName && function( className, context, xml ) {
  2.4151 +			if ( typeof context.getElementsByClassName !== strundefined && !xml ) {
  2.4152 +				return context.getElementsByClassName( className );
  2.4153 +			}
  2.4154 +		}
  2.4155 +	},
  2.4156 +
  2.4157 +	relative: {
  2.4158 +		">": { dir: "parentNode", first: true },
  2.4159 +		" ": { dir: "parentNode" },
  2.4160 +		"+": { dir: "previousSibling", first: true },
  2.4161 +		"~": { dir: "previousSibling" }
  2.4162 +	},
  2.4163 +
  2.4164 +	preFilter: {
  2.4165 +		"ATTR": function( match ) {
  2.4166 +			match[1] = match[1].replace( rbackslash, "" );
  2.4167 +
  2.4168 +			// Move the given value to match[3] whether quoted or unquoted
  2.4169 +			match[3] = ( match[4] || match[5] || "" ).replace( rbackslash, "" );
  2.4170 +
  2.4171 +			if ( match[2] === "~=" ) {
  2.4172 +				match[3] = " " + match[3] + " ";
  2.4173 +			}
  2.4174 +
  2.4175 +			return match.slice( 0, 4 );
  2.4176 +		},
  2.4177 +
  2.4178 +		"CHILD": function( match ) {
  2.4179 +			/* matches from matchExpr["CHILD"]
  2.4180 +				1 type (only|nth|...)
  2.4181 +				2 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
  2.4182 +				3 xn-component of xn+y argument ([+-]?\d*n|)
  2.4183 +				4 sign of xn-component
  2.4184 +				5 x of xn-component
  2.4185 +				6 sign of y-component
  2.4186 +				7 y of y-component
  2.4187 +			*/
  2.4188 +			match[1] = match[1].toLowerCase();
  2.4189 +
  2.4190 +			if ( match[1] === "nth" ) {
  2.4191 +				// nth-child requires argument
  2.4192 +				if ( !match[2] ) {
  2.4193 +					Sizzle.error( match[0] );
  2.4194 +				}
  2.4195 +
  2.4196 +				// numeric x and y parameters for Expr.filter.CHILD
  2.4197 +				// remember that false/true cast respectively to 0/1
  2.4198 +				match[3] = +( match[3] ? match[4] + (match[5] || 1) : 2 * ( match[2] === "even" || match[2] === "odd" ) );
  2.4199 +				match[4] = +( ( match[6] + match[7] ) || match[2] === "odd" );
  2.4200 +
  2.4201 +			// other types prohibit arguments
  2.4202 +			} else if ( match[2] ) {
  2.4203 +				Sizzle.error( match[0] );
  2.4204 +			}
  2.4205 +
  2.4206 +			return match;
  2.4207 +		},
  2.4208 +
  2.4209 +		"PSEUDO": function( match ) {
  2.4210 +			var unquoted, excess;
  2.4211 +			if ( matchExpr["CHILD"].test( match[0] ) ) {
  2.4212 +				return null;
  2.4213 +			}
  2.4214 +
  2.4215 +			if ( match[3] ) {
  2.4216 +				match[2] = match[3];
  2.4217 +			} else if ( (unquoted = match[4]) ) {
  2.4218 +				// Only check arguments that contain a pseudo
  2.4219 +				if ( rpseudo.test(unquoted) &&
  2.4220 +					// Get excess from tokenize (recursively)
  2.4221 +					(excess = tokenize( unquoted, true )) &&
  2.4222 +					// advance to the next closing parenthesis
  2.4223 +					(excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) {
  2.4224 +
  2.4225 +					// excess is a negative index
  2.4226 +					unquoted = unquoted.slice( 0, excess );
  2.4227 +					match[0] = match[0].slice( 0, excess );
  2.4228 +				}
  2.4229 +				match[2] = unquoted;
  2.4230 +			}
  2.4231 +
  2.4232 +			// Return only captures needed by the pseudo filter method (type and argument)
  2.4233 +			return match.slice( 0, 3 );
  2.4234 +		}
  2.4235 +	},
  2.4236 +
  2.4237 +	filter: {
  2.4238 +		"ID": assertGetIdNotName ?
  2.4239 +			function( id ) {
  2.4240 +				id = id.replace( rbackslash, "" );
  2.4241 +				return function( elem ) {
  2.4242 +					return elem.getAttribute("id") === id;
  2.4243 +				};
  2.4244 +			} :
  2.4245 +			function( id ) {
  2.4246 +				id = id.replace( rbackslash, "" );
  2.4247 +				return function( elem ) {
  2.4248 +					var node = typeof elem.getAttributeNode !== strundefined && elem.getAttributeNode("id");
  2.4249 +					return node && node.value === id;
  2.4250 +				};
  2.4251 +			},
  2.4252 +
  2.4253 +		"TAG": function( nodeName ) {
  2.4254 +			if ( nodeName === "*" ) {
  2.4255 +				return function() { return true; };
  2.4256 +			}
  2.4257 +			nodeName = nodeName.replace( rbackslash, "" ).toLowerCase();
  2.4258 +
  2.4259 +			return function( elem ) {
  2.4260 +				return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
  2.4261 +			};
  2.4262 +		},
  2.4263 +
  2.4264 +		"CLASS": function( className ) {
  2.4265 +			var pattern = classCache[ expando ][ className ];
  2.4266 +			if ( !pattern ) {
  2.4267 +				pattern = classCache( className, new RegExp("(^|" + whitespace + ")" + className + "(" + whitespace + "|$)") );
  2.4268 +			}
  2.4269 +			return function( elem ) {
  2.4270 +				return pattern.test( elem.className || (typeof elem.getAttribute !== strundefined && elem.getAttribute("class")) || "" );
  2.4271 +			};
  2.4272 +		},
  2.4273 +
  2.4274 +		"ATTR": function( name, operator, check ) {
  2.4275 +			return function( elem, context ) {
  2.4276 +				var result = Sizzle.attr( elem, name );
  2.4277 +
  2.4278 +				if ( result == null ) {
  2.4279 +					return operator === "!=";
  2.4280 +				}
  2.4281 +				if ( !operator ) {
  2.4282 +					return true;
  2.4283 +				}
  2.4284 +
  2.4285 +				result += "";
  2.4286 +
  2.4287 +				return operator === "=" ? result === check :
  2.4288 +					operator === "!=" ? result !== check :
  2.4289 +					operator === "^=" ? check && result.indexOf( check ) === 0 :
  2.4290 +					operator === "*=" ? check && result.indexOf( check ) > -1 :
  2.4291 +					operator === "$=" ? check && result.substr( result.length - check.length ) === check :
  2.4292 +					operator === "~=" ? ( " " + result + " " ).indexOf( check ) > -1 :
  2.4293 +					operator === "|=" ? result === check || result.substr( 0, check.length + 1 ) === check + "-" :
  2.4294 +					false;
  2.4295 +			};
  2.4296 +		},
  2.4297 +
  2.4298 +		"CHILD": function( type, argument, first, last ) {
  2.4299 +
  2.4300 +			if ( type === "nth" ) {
  2.4301 +				return function( elem ) {
  2.4302 +					var node, diff,
  2.4303 +						parent = elem.parentNode;
  2.4304 +
  2.4305 +					if ( first === 1 && last === 0 ) {
  2.4306 +						return true;
  2.4307 +					}
  2.4308 +
  2.4309 +					if ( parent ) {
  2.4310 +						diff = 0;
  2.4311 +						for ( node = parent.firstChild; node; node = node.nextSibling ) {
  2.4312 +							if ( node.nodeType === 1 ) {
  2.4313 +								diff++;
  2.4314 +								if ( elem === node ) {
  2.4315 +									break;
  2.4316 +								}
  2.4317 +							}
  2.4318 +						}
  2.4319 +					}
  2.4320 +
  2.4321 +					// Incorporate the offset (or cast to NaN), then check against cycle size
  2.4322 +					diff -= last;
  2.4323 +					return diff === first || ( diff % first === 0 && diff / first >= 0 );
  2.4324 +				};
  2.4325 +			}
  2.4326 +
  2.4327 +			return function( elem ) {
  2.4328 +				var node = elem;
  2.4329 +
  2.4330 +				switch ( type ) {
  2.4331 +					case "only":
  2.4332 +					case "first":
  2.4333 +						while ( (node = node.previousSibling) ) {
  2.4334 +							if ( node.nodeType === 1 ) {
  2.4335 +								return false;
  2.4336 +							}
  2.4337 +						}
  2.4338 +
  2.4339 +						if ( type === "first" ) {
  2.4340 +							return true;
  2.4341 +						}
  2.4342 +
  2.4343 +						node = elem;
  2.4344 +
  2.4345 +						/* falls through */
  2.4346 +					case "last":
  2.4347 +						while ( (node = node.nextSibling) ) {
  2.4348 +							if ( node.nodeType === 1 ) {
  2.4349 +								return false;
  2.4350 +							}
  2.4351 +						}
  2.4352 +
  2.4353 +						return true;
  2.4354 +				}
  2.4355 +			};
  2.4356 +		},
  2.4357 +
  2.4358 +		"PSEUDO": function( pseudo, argument ) {
  2.4359 +			// pseudo-class names are case-insensitive
  2.4360 +			// http://www.w3.org/TR/selectors/#pseudo-classes
  2.4361 +			// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
  2.4362 +			// Remember that setFilters inherits from pseudos
  2.4363 +			var args,
  2.4364 +				fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
  2.4365 +					Sizzle.error( "unsupported pseudo: " + pseudo );
  2.4366 +
  2.4367 +			// The user may use createPseudo to indicate that
  2.4368 +			// arguments are needed to create the filter function
  2.4369 +			// just as Sizzle does
  2.4370 +			if ( fn[ expando ] ) {
  2.4371 +				return fn( argument );
  2.4372 +			}
  2.4373 +
  2.4374 +			// But maintain support for old signatures
  2.4375 +			if ( fn.length > 1 ) {
  2.4376 +				args = [ pseudo, pseudo, "", argument ];
  2.4377 +				return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
  2.4378 +					markFunction(function( seed, matches ) {
  2.4379 +						var idx,
  2.4380 +							matched = fn( seed, argument ),
  2.4381 +							i = matched.length;
  2.4382 +						while ( i-- ) {
  2.4383 +							idx = indexOf.call( seed, matched[i] );
  2.4384 +							seed[ idx ] = !( matches[ idx ] = matched[i] );
  2.4385 +						}
  2.4386 +					}) :
  2.4387 +					function( elem ) {
  2.4388 +						return fn( elem, 0, args );
  2.4389 +					};
  2.4390 +			}
  2.4391 +
  2.4392 +			return fn;
  2.4393 +		}
  2.4394 +	},
  2.4395 +
  2.4396 +	pseudos: {
  2.4397 +		"not": markFunction(function( selector ) {
  2.4398 +			// Trim the selector passed to compile
  2.4399 +			// to avoid treating leading and trailing
  2.4400 +			// spaces as combinators
  2.4401 +			var input = [],
  2.4402 +				results = [],
  2.4403 +				matcher = compile( selector.replace( rtrim, "$1" ) );
  2.4404 +
  2.4405 +			return matcher[ expando ] ?
  2.4406 +				markFunction(function( seed, matches, context, xml ) {
  2.4407 +					var elem,
  2.4408 +						unmatched = matcher( seed, null, xml, [] ),
  2.4409 +						i = seed.length;
  2.4410 +
  2.4411 +					// Match elements unmatched by `matcher`
  2.4412 +					while ( i-- ) {
  2.4413 +						if ( (elem = unmatched[i]) ) {
  2.4414 +							seed[i] = !(matches[i] = elem);
  2.4415 +						}
  2.4416 +					}
  2.4417 +				}) :
  2.4418 +				function( elem, context, xml ) {
  2.4419 +					input[0] = elem;
  2.4420 +					matcher( input, null, xml, results );
  2.4421 +					return !results.pop();
  2.4422 +				};
  2.4423 +		}),
  2.4424 +
  2.4425 +		"has": markFunction(function( selector ) {
  2.4426 +			return function( elem ) {
  2.4427 +				return Sizzle( selector, elem ).length > 0;
  2.4428 +			};
  2.4429 +		}),
  2.4430 +
  2.4431 +		"contains": markFunction(function( text ) {
  2.4432 +			return function( elem ) {
  2.4433 +				return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1;
  2.4434 +			};
  2.4435 +		}),
  2.4436 +
  2.4437 +		"enabled": function( elem ) {
  2.4438 +			return elem.disabled === false;
  2.4439 +		},
  2.4440 +
  2.4441 +		"disabled": function( elem ) {
  2.4442 +			return elem.disabled === true;
  2.4443 +		},
  2.4444 +
  2.4445 +		"checked": function( elem ) {
  2.4446 +			// In CSS3, :checked should return both checked and selected elements
  2.4447 +			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
  2.4448 +			var nodeName = elem.nodeName.toLowerCase();
  2.4449 +			return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);
  2.4450 +		},
  2.4451 +
  2.4452 +		"selected": function( elem ) {
  2.4453 +			// Accessing this property makes selected-by-default
  2.4454 +			// options in Safari work properly
  2.4455 +			if ( elem.parentNode ) {
  2.4456 +				elem.parentNode.selectedIndex;
  2.4457 +			}
  2.4458 +
  2.4459 +			return elem.selected === true;
  2.4460 +		},
  2.4461 +
  2.4462 +		"parent": function( elem ) {
  2.4463 +			return !Expr.pseudos["empty"]( elem );
  2.4464 +		},
  2.4465 +
  2.4466 +		"empty": function( elem ) {
  2.4467 +			// http://www.w3.org/TR/selectors/#empty-pseudo
  2.4468 +			// :empty is only affected by element nodes and content nodes(including text(3), cdata(4)),
  2.4469 +			//   not comment, processing instructions, or others
  2.4470 +			// Thanks to Diego Perini for the nodeName shortcut
  2.4471 +			//   Greater than "@" means alpha characters (specifically not starting with "#" or "?")
  2.4472 +			var nodeType;
  2.4473 +			elem = elem.firstChild;
  2.4474 +			while ( elem ) {
  2.4475 +				if ( elem.nodeName > "@" || (nodeType = elem.nodeType) === 3 || nodeType === 4 ) {
  2.4476 +					return false;
  2.4477 +				}
  2.4478 +				elem = elem.nextSibling;
  2.4479 +			}
  2.4480 +			return true;
  2.4481 +		},
  2.4482 +
  2.4483 +		"header": function( elem ) {
  2.4484 +			return rheader.test( elem.nodeName );
  2.4485 +		},
  2.4486 +
  2.4487 +		"text": function( elem ) {
  2.4488 +			var type, attr;
  2.4489 +			// IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc)
  2.4490 +			// use getAttribute instead to test this case
  2.4491 +			return elem.nodeName.toLowerCase() === "input" &&
  2.4492 +				(type = elem.type) === "text" &&
  2.4493 +				( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === type );
  2.4494 +		},
  2.4495 +
  2.4496 +		// Input types
  2.4497 +		"radio": createInputPseudo("radio"),
  2.4498 +		"checkbox": createInputPseudo("checkbox"),
  2.4499 +		"file": createInputPseudo("file"),
  2.4500 +		"password": createInputPseudo("password"),
  2.4501 +		"image": createInputPseudo("image"),
  2.4502 +
  2.4503 +		"submit": createButtonPseudo("submit"),
  2.4504 +		"reset": createButtonPseudo("reset"),
  2.4505 +
  2.4506 +		"button": function( elem ) {
  2.4507 +			var name = elem.nodeName.toLowerCase();
  2.4508 +			return name === "input" && elem.type === "button" || name === "button";
  2.4509 +		},
  2.4510 +
  2.4511 +		"input": function( elem ) {
  2.4512 +			return rinputs.test( elem.nodeName );
  2.4513 +		},
  2.4514 +
  2.4515 +		"focus": function( elem ) {
  2.4516 +			var doc = elem.ownerDocument;
  2.4517 +			return elem === doc.activeElement && (!doc.hasFocus || doc.hasFocus()) && !!(elem.type || elem.href);
  2.4518 +		},
  2.4519 +
  2.4520 +		"active": function( elem ) {
  2.4521 +			return elem === elem.ownerDocument.activeElement;
  2.4522 +		},
  2.4523 +
  2.4524 +		// Positional types
  2.4525 +		"first": createPositionalPseudo(function( matchIndexes, length, argument ) {
  2.4526 +			return [ 0 ];
  2.4527 +		}),
  2.4528 +
  2.4529 +		"last": createPositionalPseudo(function( matchIndexes, length, argument ) {
  2.4530 +			return [ length - 1 ];
  2.4531 +		}),
  2.4532 +
  2.4533 +		"eq": createPositionalPseudo(function( matchIndexes, length, argument ) {
  2.4534 +			return [ argument < 0 ? argument + length : argument ];
  2.4535 +		}),
  2.4536 +
  2.4537 +		"even": createPositionalPseudo(function( matchIndexes, length, argument ) {
  2.4538 +			for ( var i = 0; i < length; i += 2 ) {
  2.4539 +				matchIndexes.push( i );
  2.4540 +			}
  2.4541 +			return matchIndexes;
  2.4542 +		}),
  2.4543 +
  2.4544 +		"odd": createPositionalPseudo(function( matchIndexes, length, argument ) {
  2.4545 +			for ( var i = 1; i < length; i += 2 ) {
  2.4546 +				matchIndexes.push( i );
  2.4547 +			}
  2.4548 +			return matchIndexes;
  2.4549 +		}),
  2.4550 +
  2.4551 +		"lt": createPositionalPseudo(function( matchIndexes, length, argument ) {
  2.4552 +			for ( var i = argument < 0 ? argument + length : argument; --i >= 0; ) {
  2.4553 +				matchIndexes.push( i );
  2.4554 +			}
  2.4555 +			return matchIndexes;
  2.4556 +		}),
  2.4557 +
  2.4558 +		"gt": createPositionalPseudo(function( matchIndexes, length, argument ) {
  2.4559 +			for ( var i = argument < 0 ? argument + length : argument; ++i < length; ) {
  2.4560 +				matchIndexes.push( i );
  2.4561 +			}
  2.4562 +			return matchIndexes;
  2.4563 +		})
  2.4564 +	}
  2.4565 +};
  2.4566 +
  2.4567 +function siblingCheck( a, b, ret ) {
  2.4568 +	if ( a === b ) {
  2.4569 +		return ret;
  2.4570 +	}
  2.4571 +
  2.4572 +	var cur = a.nextSibling;
  2.4573 +
  2.4574 +	while ( cur ) {
  2.4575 +		if ( cur === b ) {
  2.4576 +			return -1;
  2.4577 +		}
  2.4578 +
  2.4579 +		cur = cur.nextSibling;
  2.4580 +	}
  2.4581 +
  2.4582 +	return 1;
  2.4583 +}
  2.4584 +
  2.4585 +sortOrder = docElem.compareDocumentPosition ?
  2.4586 +	function( a, b ) {
  2.4587 +		if ( a === b ) {
  2.4588 +			hasDuplicate = true;
  2.4589 +			return 0;
  2.4590 +		}
  2.4591 +
  2.4592 +		return ( !a.compareDocumentPosition || !b.compareDocumentPosition ?
  2.4593 +			a.compareDocumentPosition :
  2.4594 +			a.compareDocumentPosition(b) & 4
  2.4595 +		) ? -1 : 1;
  2.4596 +	} :
  2.4597 +	function( a, b ) {
  2.4598 +		// The nodes are identical, we can exit early
  2.4599 +		if ( a === b ) {
  2.4600 +			hasDuplicate = true;
  2.4601 +			return 0;
  2.4602 +
  2.4603 +		// Fallback to using sourceIndex (in IE) if it's available on both nodes
  2.4604 +		} else if ( a.sourceIndex && b.sourceIndex ) {
  2.4605 +			return a.sourceIndex - b.sourceIndex;
  2.4606 +		}
  2.4607 +
  2.4608 +		var al, bl,
  2.4609 +			ap = [],
  2.4610 +			bp = [],
  2.4611 +			aup = a.parentNode,
  2.4612 +			bup = b.parentNode,
  2.4613 +			cur = aup;
  2.4614 +
  2.4615 +		// If the nodes are siblings (or identical) we can do a quick check
  2.4616 +		if ( aup === bup ) {
  2.4617 +			return siblingCheck( a, b );
  2.4618 +
  2.4619 +		// If no parents were found then the nodes are disconnected
  2.4620 +		} else if ( !aup ) {
  2.4621 +			return -1;
  2.4622 +
  2.4623 +		} else if ( !bup ) {
  2.4624 +			return 1;
  2.4625 +		}
  2.4626 +
  2.4627 +		// Otherwise they're somewhere else in the tree so we need
  2.4628 +		// to build up a full list of the parentNodes for comparison
  2.4629 +		while ( cur ) {
  2.4630 +			ap.unshift( cur );
  2.4631 +			cur = cur.parentNode;
  2.4632 +		}
  2.4633 +
  2.4634 +		cur = bup;
  2.4635 +
  2.4636 +		while ( cur ) {
  2.4637 +			bp.unshift( cur );
  2.4638 +			cur = cur.parentNode;
  2.4639 +		}
  2.4640 +
  2.4641 +		al = ap.length;
  2.4642 +		bl = bp.length;
  2.4643 +
  2.4644 +		// Start walking down the tree looking for a discrepancy
  2.4645 +		for ( var i = 0; i < al && i < bl; i++ ) {
  2.4646 +			if ( ap[i] !== bp[i] ) {
  2.4647 +				return siblingCheck( ap[i], bp[i] );
  2.4648 +			}
  2.4649 +		}
  2.4650 +
  2.4651 +		// We ended someplace up the tree so do a sibling check
  2.4652 +		return i === al ?
  2.4653 +			siblingCheck( a, bp[i], -1 ) :
  2.4654 +			siblingCheck( ap[i], b, 1 );
  2.4655 +	};
  2.4656 +
  2.4657 +// Always assume the presence of duplicates if sort doesn't
  2.4658 +// pass them to our comparison function (as in Google Chrome).
  2.4659 +[0, 0].sort( sortOrder );
  2.4660 +baseHasDuplicate = !hasDuplicate;
  2.4661 +
  2.4662 +// Document sorting and removing duplicates
  2.4663 +Sizzle.uniqueSort = function( results ) {
  2.4664 +	var elem,
  2.4665 +		i = 1;
  2.4666 +
  2.4667 +	hasDuplicate = baseHasDuplicate;
  2.4668 +	results.sort( sortOrder );
  2.4669 +
  2.4670 +	if ( hasDuplicate ) {
  2.4671 +		for ( ; (elem = results[i]); i++ ) {
  2.4672 +			if ( elem === results[ i - 1 ] ) {
  2.4673 +				results.splice( i--, 1 );
  2.4674 +			}
  2.4675 +		}
  2.4676 +	}
  2.4677 +
  2.4678 +	return results;
  2.4679 +};
  2.4680 +
  2.4681 +Sizzle.error = function( msg ) {
  2.4682 +	throw new Error( "Syntax error, unrecognized expression: " + msg );
  2.4683 +};
  2.4684 +
  2.4685 +function tokenize( selector, parseOnly ) {
  2.4686 +	var matched, match, tokens, type, soFar, groups, preFilters,
  2.4687 +		cached = tokenCache[ expando ][ selector ];
  2.4688 +
  2.4689 +	if ( cached ) {
  2.4690 +		return parseOnly ? 0 : cached.slice( 0 );
  2.4691 +	}
  2.4692 +
  2.4693 +	soFar = selector;
  2.4694 +	groups = [];
  2.4695 +	preFilters = Expr.preFilter;
  2.4696 +
  2.4697 +	while ( soFar ) {
  2.4698 +
  2.4699 +		// Comma and first run
  2.4700 +		if ( !matched || (match = rcomma.exec( soFar )) ) {
  2.4701 +			if ( match ) {
  2.4702 +				soFar = soFar.slice( match[0].length );
  2.4703 +			}
  2.4704 +			groups.push( tokens = [] );
  2.4705 +		}
  2.4706 +
  2.4707 +		matched = false;
  2.4708 +
  2.4709 +		// Combinators
  2.4710 +		if ( (match = rcombinators.exec( soFar )) ) {
  2.4711 +			tokens.push( matched = new Token( match.shift() ) );
  2.4712 +			soFar = soFar.slice( matched.length );
  2.4713 +
  2.4714 +			// Cast descendant combinators to space
  2.4715 +			matched.type = match[0].replace( rtrim, " " );
  2.4716 +		}
  2.4717 +
  2.4718 +		// Filters
  2.4719 +		for ( type in Expr.filter ) {
  2.4720 +			if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||
  2.4721 +				// The last two arguments here are (context, xml) for backCompat
  2.4722 +				(match = preFilters[ type ]( match, document, true ))) ) {
  2.4723 +
  2.4724 +				tokens.push( matched = new Token( match.shift() ) );
  2.4725 +				soFar = soFar.slice( matched.length );
  2.4726 +				matched.type = type;
  2.4727 +				matched.matches = match;
  2.4728 +			}
  2.4729 +		}
  2.4730 +
  2.4731 +		if ( !matched ) {
  2.4732 +			break;
  2.4733 +		}
  2.4734 +	}
  2.4735 +
  2.4736 +	// Return the length of the invalid excess
  2.4737 +	// if we're just parsing
  2.4738 +	// Otherwise, throw an error or return tokens
  2.4739 +	return parseOnly ?
  2.4740 +		soFar.length :
  2.4741 +		soFar ?
  2.4742 +			Sizzle.error( selector ) :
  2.4743 +			// Cache the tokens
  2.4744 +			tokenCache( selector, groups ).slice( 0 );
  2.4745 +}
  2.4746 +
  2.4747 +function addCombinator( matcher, combinator, base ) {
  2.4748 +	var dir = combinator.dir,
  2.4749 +		checkNonElements = base && combinator.dir === "parentNode",
  2.4750 +		doneName = done++;
  2.4751 +
  2.4752 +	return combinator.first ?
  2.4753 +		// Check against closest ancestor/preceding element
  2.4754 +		function( elem, context, xml ) {
  2.4755 +			while ( (elem = elem[ dir ]) ) {
  2.4756 +				if ( checkNonElements || elem.nodeType === 1  ) {
  2.4757 +					return matcher( elem, context, xml );
  2.4758 +				}
  2.4759 +			}
  2.4760 +		} :
  2.4761 +
  2.4762 +		// Check against all ancestor/preceding elements
  2.4763 +		function( elem, context, xml ) {
  2.4764 +			// We can't set arbitrary data on XML nodes, so they don't benefit from dir caching
  2.4765 +			if ( !xml ) {
  2.4766 +				var cache,
  2.4767 +					dirkey = dirruns + " " + doneName + " ",
  2.4768 +					cachedkey = dirkey + cachedruns;
  2.4769 +				while ( (elem = elem[ dir ]) ) {
  2.4770 +					if ( checkNonElements || elem.nodeType === 1 ) {
  2.4771 +						if ( (cache = elem[ expando ]) === cachedkey ) {
  2.4772 +							return elem.sizset;
  2.4773 +						} else if ( typeof cache === "string" && cache.indexOf(dirkey) === 0 ) {
  2.4774 +							if ( elem.sizset ) {
  2.4775 +								return elem;
  2.4776 +							}
  2.4777 +						} else {
  2.4778 +							elem[ expando ] = cachedkey;
  2.4779 +							if ( matcher( elem, context, xml ) ) {
  2.4780 +								elem.sizset = true;
  2.4781 +								return elem;
  2.4782 +							}
  2.4783 +							elem.sizset = false;
  2.4784 +						}
  2.4785 +					}
  2.4786 +				}
  2.4787 +			} else {
  2.4788 +				while ( (elem = elem[ dir ]) ) {
  2.4789 +					if ( checkNonElements || elem.nodeType === 1 ) {
  2.4790 +						if ( matcher( elem, context, xml ) ) {
  2.4791 +							return elem;
  2.4792 +						}
  2.4793 +					}
  2.4794 +				}
  2.4795 +			}
  2.4796 +		};
  2.4797 +}
  2.4798 +
  2.4799 +function elementMatcher( matchers ) {
  2.4800 +	return matchers.length > 1 ?
  2.4801 +		function( elem, context, xml ) {
  2.4802 +			var i = matchers.length;
  2.4803 +			while ( i-- ) {
  2.4804 +				if ( !matchers[i]( elem, context, xml ) ) {
  2.4805 +					return false;
  2.4806 +				}
  2.4807 +			}
  2.4808 +			return true;
  2.4809 +		} :
  2.4810 +		matchers[0];
  2.4811 +}
  2.4812 +
  2.4813 +function condense( unmatched, map, filter, context, xml ) {
  2.4814 +	var elem,
  2.4815 +		newUnmatched = [],
  2.4816 +		i = 0,
  2.4817 +		len = unmatched.length,
  2.4818 +		mapped = map != null;
  2.4819 +
  2.4820 +	for ( ; i < len; i++ ) {
  2.4821 +		if ( (elem = unmatched[i]) ) {
  2.4822 +			if ( !filter || filter( elem, context, xml ) ) {
  2.4823 +				newUnmatched.push( elem );
  2.4824 +				if ( mapped ) {
  2.4825 +					map.push( i );
  2.4826 +				}
  2.4827 +			}
  2.4828 +		}
  2.4829 +	}
  2.4830 +
  2.4831 +	return newUnmatched;
  2.4832 +}
  2.4833 +
  2.4834 +function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
  2.4835 +	if ( postFilter && !postFilter[ expando ] ) {
  2.4836 +		postFilter = setMatcher( postFilter );
  2.4837 +	}
  2.4838 +	if ( postFinder && !postFinder[ expando ] ) {
  2.4839 +		postFinder = setMatcher( postFinder, postSelector );
  2.4840 +	}
  2.4841 +	return markFunction(function( seed, results, context, xml ) {
  2.4842 +		// Positional selectors apply to seed elements, so it is invalid to follow them with relative ones
  2.4843 +		if ( seed && postFinder ) {
  2.4844 +			return;
  2.4845 +		}
  2.4846 +
  2.4847 +		var i, elem, postFilterIn,
  2.4848 +			preMap = [],
  2.4849 +			postMap = [],
  2.4850 +			preexisting = results.length,
  2.4851 +
  2.4852 +			// Get initial elements from seed or context
  2.4853 +			elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [], seed ),
  2.4854 +
  2.4855 +			// Prefilter to get matcher input, preserving a map for seed-results synchronization
  2.4856 +			matcherIn = preFilter && ( seed || !selector ) ?
  2.4857 +				condense( elems, preMap, preFilter, context, xml ) :
  2.4858 +				elems,
  2.4859 +
  2.4860 +			matcherOut = matcher ?
  2.4861 +				// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
  2.4862 +				postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
  2.4863 +
  2.4864 +					// ...intermediate processing is necessary
  2.4865 +					[] :
  2.4866 +
  2.4867 +					// ...otherwise use results directly
  2.4868 +					results :
  2.4869 +				matcherIn;
  2.4870 +
  2.4871 +		// Find primary matches
  2.4872 +		if ( matcher ) {
  2.4873 +			matcher( matcherIn, matcherOut, context, xml );
  2.4874 +		}
  2.4875 +
  2.4876 +		// Apply postFilter
  2.4877 +		if ( postFilter ) {
  2.4878 +			postFilterIn = condense( matcherOut, postMap );
  2.4879 +			postFilter( postFilterIn, [], context, xml );
  2.4880 +
  2.4881 +			// Un-match failing elements by moving them back to matcherIn
  2.4882 +			i = postFilterIn.length;
  2.4883 +			while ( i-- ) {
  2.4884 +				if ( (elem = postFilterIn[i]) ) {
  2.4885 +					matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);
  2.4886 +				}
  2.4887 +			}
  2.4888 +		}
  2.4889 +
  2.4890 +		// Keep seed and results synchronized
  2.4891 +		if ( seed ) {
  2.4892 +			// Ignore postFinder because it can't coexist with seed
  2.4893 +			i = preFilter && matcherOut.length;
  2.4894 +			while ( i-- ) {
  2.4895 +				if ( (elem = matcherOut[i]) ) {
  2.4896 +					seed[ preMap[i] ] = !(results[ preMap[i] ] = elem);
  2.4897 +				}
  2.4898 +			}
  2.4899 +		} else {
  2.4900 +			matcherOut = condense(
  2.4901 +				matcherOut === results ?
  2.4902 +					matcherOut.splice( preexisting, matcherOut.length ) :
  2.4903 +					matcherOut
  2.4904 +			);
  2.4905 +			if ( postFinder ) {
  2.4906 +				postFinder( null, results, matcherOut, xml );
  2.4907 +			} else {
  2.4908 +				push.apply( results, matcherOut );
  2.4909 +			}
  2.4910 +		}
  2.4911 +	});
  2.4912 +}
  2.4913 +
  2.4914 +function matcherFromTokens( tokens ) {
  2.4915 +	var checkContext, matcher, j,
  2.4916 +		len = tokens.length,
  2.4917 +		leadingRelative = Expr.relative[ tokens[0].type ],
  2.4918 +		implicitRelative = leadingRelative || Expr.relative[" "],
  2.4919 +		i = leadingRelative ? 1 : 0,
  2.4920 +
  2.4921 +		// The foundational matcher ensures that elements are reachable from top-level context(s)
  2.4922 +		matchContext = addCombinator( function( elem ) {
  2.4923 +			return elem === checkContext;
  2.4924 +		}, implicitRelative, true ),
  2.4925 +		matchAnyContext = addCombinator( function( elem ) {
  2.4926 +			return indexOf.call( checkContext, elem ) > -1;
  2.4927 +		}, implicitRelative, true ),
  2.4928 +		matchers = [ function( elem, context, xml ) {
  2.4929 +			return ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
  2.4930 +				(checkContext = context).nodeType ?
  2.4931 +					matchContext( elem, context, xml ) :
  2.4932 +					matchAnyContext( elem, context, xml ) );
  2.4933 +		} ];
  2.4934 +
  2.4935 +	for ( ; i < len; i++ ) {
  2.4936 +		if ( (matcher = Expr.relative[ tokens[i].type ]) ) {
  2.4937 +			matchers = [ addCombinator( elementMatcher( matchers ), matcher ) ];
  2.4938 +		} else {
  2.4939 +			// The concatenated values are (context, xml) for backCompat
  2.4940 +			matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );
  2.4941 +
  2.4942 +			// Return special upon seeing a positional matcher
  2.4943 +			if ( matcher[ expando ] ) {
  2.4944 +				// Find the next relative operator (if any) for proper handling
  2.4945 +				j = ++i;
  2.4946 +				for ( ; j < len; j++ ) {
  2.4947 +					if ( Expr.relative[ tokens[j].type ] ) {
  2.4948 +						break;
  2.4949 +					}
  2.4950 +				}
  2.4951 +				return setMatcher(
  2.4952 +					i > 1 && elementMatcher( matchers ),
  2.4953 +					i > 1 && tokens.slice( 0, i - 1 ).join("").replace( rtrim, "$1" ),
  2.4954 +					matcher,
  2.4955 +					i < j && matcherFromTokens( tokens.slice( i, j ) ),
  2.4956 +					j < len && matcherFromTokens( (tokens = tokens.slice( j )) ),
  2.4957 +					j < len && tokens.join("")
  2.4958 +				);
  2.4959 +			}
  2.4960 +			matchers.push( matcher );
  2.4961 +		}
  2.4962 +	}
  2.4963 +
  2.4964 +	return elementMatcher( matchers );
  2.4965 +}
  2.4966 +
  2.4967 +function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
  2.4968 +	var bySet = setMatchers.length > 0,
  2.4969 +		byElement = elementMatchers.length > 0,
  2.4970 +		superMatcher = function( seed, context, xml, results, expandContext ) {
  2.4971 +			var elem, j, matcher,
  2.4972 +				setMatched = [],
  2.4973 +				matchedCount = 0,
  2.4974 +				i = "0",
  2.4975 +				unmatched = seed && [],
  2.4976 +				outermost = expandContext != null,
  2.4977 +				contextBackup = outermostContext,
  2.4978 +				// We must always have either seed elements or context
  2.4979 +				elems = seed || byElement && Expr.find["TAG"]( "*", expandContext && context.parentNode || context ),
  2.4980 +				// Nested matchers should use non-integer dirruns
  2.4981 +				dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.E);
  2.4982 +
  2.4983 +			if ( outermost ) {
  2.4984 +				outermostContext = context !== document && context;
  2.4985 +				cachedruns = superMatcher.el;
  2.4986 +			}
  2.4987 +
  2.4988 +			// Add elements passing elementMatchers directly to results
  2.4989 +			for ( ; (elem = elems[i]) != null; i++ ) {
  2.4990 +				if ( byElement && elem ) {
  2.4991 +					for ( j = 0; (matcher = elementMatchers[j]); j++ ) {
  2.4992 +						if ( matcher( elem, context, xml ) ) {
  2.4993 +							results.push( elem );
  2.4994 +							break;
  2.4995 +						}
  2.4996 +					}
  2.4997 +					if ( outermost ) {
  2.4998 +						dirruns = dirrunsUnique;
  2.4999 +						cachedruns = ++superMatcher.el;
  2.5000 +					}
  2.5001 +				}
  2.5002 +
  2.5003 +				// Track unmatched elements for set filters
  2.5004 +				if ( bySet ) {
  2.5005 +					// They will have gone through all possible matchers
  2.5006 +					if ( (elem = !matcher && elem) ) {
  2.5007 +						matchedCount--;
  2.5008 +					}
  2.5009 +
  2.5010 +					// Lengthen the array for every element, matched or not
  2.5011 +					if ( seed ) {
  2.5012 +						unmatched.push( elem );
  2.5013 +					}
  2.5014 +				}
  2.5015 +			}
  2.5016 +
  2.5017 +			// Apply set filters to unmatched elements
  2.5018 +			matchedCount += i;
  2.5019 +			if ( bySet && i !== matchedCount ) {
  2.5020 +				for ( j = 0; (matcher = setMatchers[j]); j++ ) {
  2.5021 +					matcher( unmatched, setMatched, context, xml );
  2.5022 +				}
  2.5023 +
  2.5024 +				if ( seed ) {
  2.5025 +					// Reintegrate element matches to eliminate the need for sorting
  2.5026 +					if ( matchedCount > 0 ) {
  2.5027 +						while ( i-- ) {
  2.5028 +							if ( !(unmatched[i] || setMatched[i]) ) {
  2.5029 +								setMatched[i] = pop.call( results );
  2.5030 +							}
  2.5031 +						}
  2.5032 +					}
  2.5033 +
  2.5034 +					// Discard index placeholder values to get only actual matches
  2.5035 +					setMatched = condense( setMatched );
  2.5036 +				}
  2.5037 +
  2.5038 +				// Add matches to results
  2.5039 +				push.apply( results, setMatched );
  2.5040 +
  2.5041 +				// Seedless set matches succeeding multiple successful matchers stipulate sorting
  2.5042 +				if ( outermost && !seed && setMatched.length > 0 &&
  2.5043 +					( matchedCount + setMatchers.length ) > 1 ) {
  2.5044 +
  2.5045 +					Sizzle.uniqueSort( results );
  2.5046 +				}
  2.5047 +			}
  2.5048 +
  2.5049 +			// Override manipulation of globals by nested matchers
  2.5050 +			if ( outermost ) {
  2.5051 +				dirruns = dirrunsUnique;
  2.5052 +				outermostContext = contextBackup;
  2.5053 +			}
  2.5054 +
  2.5055 +			return unmatched;
  2.5056 +		};
  2.5057 +
  2.5058 +	superMatcher.el = 0;
  2.5059 +	return bySet ?
  2.5060 +		markFunction( superMatcher ) :
  2.5061 +		superMatcher;
  2.5062 +}
  2.5063 +
  2.5064 +compile = Sizzle.compile = function( selector, group /* Internal Use Only */ ) {
  2.5065 +	var i,
  2.5066 +		setMatchers = [],
  2.5067 +		elementMatchers = [],
  2.5068 +		cached = compilerCache[ expando ][ selector ];
  2.5069 +
  2.5070 +	if ( !cached ) {
  2.5071 +		// Generate a function of recursive functions that can be used to check each element
  2.5072 +		if ( !group ) {
  2.5073 +			group = tokenize( selector );
  2.5074 +		}
  2.5075 +		i = group.length;
  2.5076 +		while ( i-- ) {
  2.5077 +			cached = matcherFromTokens( group[i] );
  2.5078 +			if ( cached[ expando ] ) {
  2.5079 +				setMatchers.push( cached );
  2.5080 +			} else {
  2.5081 +				elementMatchers.push( cached );
  2.5082 +			}
  2.5083 +		}
  2.5084 +
  2.5085 +		// Cache the compiled function
  2.5086 +		cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );
  2.5087 +	}
  2.5088 +	return cached;
  2.5089 +};
  2.5090 +
  2.5091 +function multipleContexts( selector, contexts, results, seed ) {
  2.5092 +	var i = 0,
  2.5093 +		len = contexts.length;
  2.5094 +	for ( ; i < len; i++ ) {
  2.5095 +		Sizzle( selector, contexts[i], results, seed );
  2.5096 +	}
  2.5097 +	return results;
  2.5098 +}
  2.5099 +
  2.5100 +function select( selector, context, results, seed, xml ) {
  2.5101 +	var i, tokens, token, type, find,
  2.5102 +		match = tokenize( selector ),
  2.5103 +		j = match.length;
  2.5104 +
  2.5105 +	if ( !seed ) {
  2.5106 +		// Try to minimize operations if there is only one group
  2.5107 +		if ( match.length === 1 ) {
  2.5108 +
  2.5109 +			// Take a shortcut and set the context if the root selector is an ID
  2.5110 +			tokens = match[0] = match[0].slice( 0 );
  2.5111 +			if ( tokens.length > 2 && (token = tokens[0]).type === "ID" &&
  2.5112 +					context.nodeType === 9 && !xml &&
  2.5113 +					Expr.relative[ tokens[1].type ] ) {
  2.5114 +
  2.5115 +				context = Expr.find["ID"]( token.matches[0].replace( rbackslash, "" ), context, xml )[0];
  2.5116 +				if ( !context ) {
  2.5117 +					return results;
  2.5118 +				}
  2.5119 +
  2.5120 +				selector = selector.slice( tokens.shift().length );
  2.5121 +			}
  2.5122 +
  2.5123 +			// Fetch a seed set for right-to-left matching
  2.5124 +			for ( i = matchExpr["POS"].test( selector ) ? -1 : tokens.length - 1; i >= 0; i-- ) {
  2.5125 +				token = tokens[i];
  2.5126 +
  2.5127 +				// Abort if we hit a combinator
  2.5128 +				if ( Expr.relative[ (type = token.type) ] ) {
  2.5129 +					break;
  2.5130 +				}
  2.5131 +				if ( (find = Expr.find[ type ]) ) {
  2.5132 +					// Search, expanding context for leading sibling combinators
  2.5133 +					if ( (seed = find(
  2.5134 +						token.matches[0].replace( rbackslash, "" ),
  2.5135 +						rsibling.test( tokens[0].type ) && context.parentNode || context,
  2.5136 +						xml
  2.5137 +					)) ) {
  2.5138 +
  2.5139 +						// If seed is empty or no tokens remain, we can return early
  2.5140 +						tokens.splice( i, 1 );
  2.5141 +						selector = seed.length && tokens.join("");
  2.5142 +						if ( !selector ) {
  2.5143 +							push.apply( results, slice.call( seed, 0 ) );
  2.5144 +							return results;
  2.5145 +						}
  2.5146 +
  2.5147 +						break;
  2.5148 +					}
  2.5149 +				}
  2.5150 +			}
  2.5151 +		}
  2.5152 +	}
  2.5153 +
  2.5154 +	// Compile and execute a filtering function
  2.5155 +	// Provide `match` to avoid retokenization if we modified the selector above
  2.5156 +	compile( selector, match )(
  2.5157 +		seed,
  2.5158 +		context,
  2.5159 +		xml,
  2.5160 +		results,
  2.5161 +		rsibling.test( selector )
  2.5162 +	);
  2.5163 +	return results;
  2.5164 +}
  2.5165 +
  2.5166 +if ( document.querySelectorAll ) {
  2.5167 +	(function() {
  2.5168 +		var disconnectedMatch,
  2.5169 +			oldSelect = select,
  2.5170 +			rescape = /'|\\/g,
  2.5171 +			rattributeQuotes = /\=[\x20\t\r\n\f]*([^'"\]]*)[\x20\t\r\n\f]*\]/g,
  2.5172 +
  2.5173 +			// qSa(:focus) reports false when true (Chrome 21),
  2.5174 +			// A support test would require too much code (would include document ready)
  2.5175 +			rbuggyQSA = [":focus"],
  2.5176 +
  2.5177 +			// matchesSelector(:focus) reports false when true (Chrome 21),
  2.5178 +			// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
  2.5179 +			// A support test would require too much code (would include document ready)
  2.5180 +			// just skip matchesSelector for :active
  2.5181 +			rbuggyMatches = [ ":active", ":focus" ],
  2.5182 +			matches = docElem.matchesSelector ||
  2.5183 +				docElem.mozMatchesSelector ||
  2.5184 +				docElem.webkitMatchesSelector ||
  2.5185 +				docElem.oMatchesSelector ||
  2.5186 +				docElem.msMatchesSelector;
  2.5187 +
  2.5188 +		// Build QSA regex
  2.5189 +		// Regex strategy adopted from Diego Perini
  2.5190 +		assert(function( div ) {
  2.5191 +			// Select is set to empty string on purpose
  2.5192 +			// This is to test IE's treatment of not explictly
  2.5193 +			// setting a boolean content attribute,
  2.5194 +			// since its presence should be enough
  2.5195 +			// http://bugs.jquery.com/ticket/12359
  2.5196 +			div.innerHTML = "<select><option selected=''></option></select>";
  2.5197 +
  2.5198 +			// IE8 - Some boolean attributes are not treated correctly
  2.5199 +			if ( !div.querySelectorAll("[selected]").length ) {
  2.5200 +				rbuggyQSA.push( "\\[" + whitespace + "*(?:checked|disabled|ismap|multiple|readonly|selected|value)" );
  2.5201 +			}
  2.5202 +
  2.5203 +			// Webkit/Opera - :checked should return selected option elements
  2.5204 +			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
  2.5205 +			// IE8 throws error here (do not put tests after this one)
  2.5206 +			if ( !div.querySelectorAll(":checked").length ) {
  2.5207 +				rbuggyQSA.push(":checked");
  2.5208 +			}
  2.5209 +		});
  2.5210 +
  2.5211 +		assert(function( div ) {
  2.5212 +
  2.5213 +			// Opera 10-12/IE9 - ^= $= *= and empty values
  2.5214 +			// Should not select anything
  2.5215 +			div.innerHTML = "<p test=''></p>";
  2.5216 +			if ( div.querySelectorAll("[test^='']").length ) {
  2.5217 +				rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:\"\"|'')" );
  2.5218 +			}
  2.5219 +
  2.5220 +			// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
  2.5221 +			// IE8 throws error here (do not put tests after this one)
  2.5222 +			div.innerHTML = "<input type='hidden'/>";
  2.5223 +			if ( !div.querySelectorAll(":enabled").length ) {
  2.5224 +				rbuggyQSA.push(":enabled", ":disabled");
  2.5225 +			}
  2.5226 +		});
  2.5227 +
  2.5228 +		// rbuggyQSA always contains :focus, so no need for a length check
  2.5229 +		rbuggyQSA = /* rbuggyQSA.length && */ new RegExp( rbuggyQSA.join("|") );
  2.5230 +
  2.5231 +		select = function( selector, context, results, seed, xml ) {
  2.5232 +			// Only use querySelectorAll when not filtering,
  2.5233 +			// when this is not xml,
  2.5234 +			// and when no QSA bugs apply
  2.5235 +			if ( !seed && !xml && (!rbuggyQSA || !rbuggyQSA.test( selector )) ) {
  2.5236 +				var groups, i,
  2.5237 +					old = true,
  2.5238 +					nid = expando,
  2.5239 +					newContext = context,
  2.5240 +					newSelector = context.nodeType === 9 && selector;
  2.5241 +
  2.5242 +				// qSA works strangely on Element-rooted queries
  2.5243 +				// We can work around this by specifying an extra ID on the root
  2.5244 +				// and working up from there (Thanks to Andrew Dupont for the technique)
  2.5245 +				// IE 8 doesn't work on object elements
  2.5246 +				if ( context.nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) {
  2.5247 +					groups = tokenize( selector );
  2.5248 +
  2.5249 +					if ( (old = context.getAttribute("id")) ) {
  2.5250 +						nid = old.replace( rescape, "\\$&" );
  2.5251 +					} else {
  2.5252 +						context.setAttribute( "id", nid );
  2.5253 +					}
  2.5254 +					nid = "[id='" + nid + "'] ";
  2.5255 +
  2.5256 +					i = groups.length;
  2.5257 +					while ( i-- ) {
  2.5258 +						groups[i] = nid + groups[i].join("");
  2.5259 +					}
  2.5260 +					newContext = rsibling.test( selector ) && context.parentNode || context;
  2.5261 +					newSelector = groups.join(",");
  2.5262 +				}
  2.5263 +
  2.5264 +				if ( newSelector ) {
  2.5265 +					try {
  2.5266 +						push.apply( results, slice.call( newContext.querySelectorAll(
  2.5267 +							newSelector
  2.5268 +						), 0 ) );
  2.5269 +						return results;
  2.5270 +					} catch(qsaError) {
  2.5271 +					} finally {
  2.5272 +						if ( !old ) {
  2.5273 +							context.removeAttribute("id");
  2.5274 +						}
  2.5275 +					}
  2.5276 +				}
  2.5277 +			}
  2.5278 +
  2.5279 +			return oldSelect( selector, context, results, seed, xml );
  2.5280 +		};
  2.5281 +
  2.5282 +		if ( matches ) {
  2.5283 +			assert(function( div ) {
  2.5284 +				// Check to see if it's possible to do matchesSelector
  2.5285 +				// on a disconnected node (IE 9)
  2.5286 +				disconnectedMatch = matches.call( div, "div" );
  2.5287 +
  2.5288 +				// This should fail with an exception
  2.5289 +				// Gecko does not error, returns false instead
  2.5290 +				try {
  2.5291 +					matches.call( div, "[test!='']:sizzle" );
  2.5292 +					rbuggyMatches.push( "!=", pseudos );
  2.5293 +				} catch ( e ) {}
  2.5294 +			});
  2.5295 +
  2.5296 +			// rbuggyMatches always contains :active and :focus, so no need for a length check
  2.5297 +			rbuggyMatches = /* rbuggyMatches.length && */ new RegExp( rbuggyMatches.join("|") );
  2.5298 +
  2.5299 +			Sizzle.matchesSelector = function( elem, expr ) {
  2.5300 +				// Make sure that attribute selectors are quoted
  2.5301 +				expr = expr.replace( rattributeQuotes, "='$1']" );
  2.5302 +
  2.5303 +				// rbuggyMatches always contains :active, so no need for an existence check
  2.5304 +				if ( !isXML( elem ) && !rbuggyMatches.test( expr ) && (!rbuggyQSA || !rbuggyQSA.test( expr )) ) {
  2.5305 +					try {
  2.5306 +						var ret = matches.call( elem, expr );
  2.5307 +
  2.5308 +						// IE 9's matchesSelector returns false on disconnected nodes
  2.5309 +						if ( ret || disconnectedMatch ||
  2.5310 +								// As well, disconnected nodes are said to be in a document
  2.5311 +								// fragment in IE 9
  2.5312 +								elem.document && elem.document.nodeType !== 11 ) {
  2.5313 +							return ret;
  2.5314 +						}
  2.5315 +					} catch(e) {}
  2.5316 +				}
  2.5317 +
  2.5318 +				return Sizzle( expr, null, null, [ elem ] ).length > 0;
  2.5319 +			};
  2.5320 +		}
  2.5321 +	})();
  2.5322 +}
  2.5323 +
  2.5324 +// Deprecated
  2.5325 +Expr.pseudos["nth"] = Expr.pseudos["eq"];
  2.5326 +
  2.5327 +// Back-compat
  2.5328 +function setFilters() {}
  2.5329 +Expr.filters = setFilters.prototype = Expr.pseudos;
  2.5330 +Expr.setFilters = new setFilters();
  2.5331 +
  2.5332 +// Override sizzle attribute retrieval
  2.5333 +Sizzle.attr = jQuery.attr;
  2.5334 +jQuery.find = Sizzle;
  2.5335 +jQuery.expr = Sizzle.selectors;
  2.5336 +jQuery.expr[":"] = jQuery.expr.pseudos;
  2.5337 +jQuery.unique = Sizzle.uniqueSort;
  2.5338 +jQuery.text = Sizzle.getText;
  2.5339 +jQuery.isXMLDoc = Sizzle.isXML;
  2.5340 +jQuery.contains = Sizzle.contains;
  2.5341 +
  2.5342 +
  2.5343 +})( window );
  2.5344 +var runtil = /Until$/,
  2.5345 +	rparentsprev = /^(?:parents|prev(?:Until|All))/,
  2.5346 +	isSimple = /^.[^:#\[\.,]*$/,
  2.5347 +	rneedsContext = jQuery.expr.match.needsContext,
  2.5348 +	// methods guaranteed to produce a unique set when starting from a unique set
  2.5349 +	guaranteedUnique = {
  2.5350 +		children: true,
  2.5351 +		contents: true,
  2.5352 +		next: true,
  2.5353 +		prev: true
  2.5354 +	};
  2.5355 +
  2.5356 +jQuery.fn.extend({
  2.5357 +	find: function( selector ) {
  2.5358 +		var i, l, length, n, r, ret,
  2.5359 +			self = this;
  2.5360 +
  2.5361 +		if ( typeof selector !== "string" ) {
  2.5362 +			return jQuery( selector ).filter(function() {
  2.5363 +				for ( i = 0, l = self.length; i < l; i++ ) {
  2.5364 +					if ( jQuery.contains( self[ i ], this ) ) {
  2.5365 +						return true;
  2.5366 +					}
  2.5367 +				}
  2.5368 +			});
  2.5369 +		}
  2.5370 +
  2.5371 +		ret = this.pushStack( "", "find", selector );
  2.5372 +
  2.5373 +		for ( i = 0, l = this.length; i < l; i++ ) {
  2.5374 +			length = ret.length;
  2.5375 +			jQuery.find( selector, this[i], ret );
  2.5376 +
  2.5377 +			if ( i > 0 ) {
  2.5378 +				// Make sure that the results are unique
  2.5379 +				for ( n = length; n < ret.length; n++ ) {
  2.5380 +					for ( r = 0; r < length; r++ ) {
  2.5381 +						if ( ret[r] === ret[n] ) {
  2.5382 +							ret.splice(n--, 1);
  2.5383 +							break;
  2.5384 +						}
  2.5385 +					}
  2.5386 +				}
  2.5387 +			}
  2.5388 +		}
  2.5389 +
  2.5390 +		return ret;
  2.5391 +	},
  2.5392 +
  2.5393 +	has: function( target ) {
  2.5394 +		var i,
  2.5395 +			targets = jQuery( target, this ),
  2.5396 +			len = targets.length;
  2.5397 +
  2.5398 +		return this.filter(function() {
  2.5399 +			for ( i = 0; i < len; i++ ) {
  2.5400 +				if ( jQuery.contains( this, targets[i] ) ) {
  2.5401 +					return true;
  2.5402 +				}
  2.5403 +			}
  2.5404 +		});
  2.5405 +	},
  2.5406 +
  2.5407 +	not: function( selector ) {
  2.5408 +		return this.pushStack( winnow(this, selector, false), "not", selector);
  2.5409 +	},
  2.5410 +
  2.5411 +	filter: function( selector ) {
  2.5412 +		return this.pushStack( winnow(this, selector, true), "filter", selector );
  2.5413 +	},
  2.5414 +
  2.5415 +	is: function( selector ) {
  2.5416 +		return !!selector && (
  2.5417 +			typeof selector === "string" ?
  2.5418 +				// If this is a positional/relative selector, check membership in the returned set
  2.5419 +				// so $("p:first").is("p:last") won't return true for a doc with two "p".
  2.5420 +				rneedsContext.test( selector ) ?
  2.5421 +					jQuery( selector, this.context ).index( this[0] ) >= 0 :
  2.5422 +					jQuery.filter( selector, this ).length > 0 :
  2.5423 +				this.filter( selector ).length > 0 );
  2.5424 +	},
  2.5425 +
  2.5426 +	closest: function( selectors, context ) {
  2.5427 +		var cur,
  2.5428 +			i = 0,
  2.5429 +			l = this.length,
  2.5430 +			ret = [],
  2.5431 +			pos = rneedsContext.test( selectors ) || typeof selectors !== "string" ?
  2.5432 +				jQuery( selectors, context || this.context ) :
  2.5433 +				0;
  2.5434 +
  2.5435 +		for ( ; i < l; i++ ) {
  2.5436 +			cur = this[i];
  2.5437 +
  2.5438 +			while ( cur && cur.ownerDocument && cur !== context && cur.nodeType !== 11 ) {
  2.5439 +				if ( pos ? pos.index(cur) > -1 : jQuery.find.matchesSelector(cur, selectors) ) {
  2.5440 +					ret.push( cur );
  2.5441 +					break;
  2.5442 +				}
  2.5443 +				cur = cur.parentNode;
  2.5444 +			}
  2.5445 +		}
  2.5446 +
  2.5447 +		ret = ret.length > 1 ? jQuery.unique( ret ) : ret;
  2.5448 +
  2.5449 +		return this.pushStack( ret, "closest", selectors );
  2.5450 +	},
  2.5451 +
  2.5452 +	// Determine the position of an element within
  2.5453 +	// the matched set of elements
  2.5454 +	index: function( elem ) {
  2.5455 +
  2.5456 +		// No argument, return index in parent
  2.5457 +		if ( !elem ) {
  2.5458 +			return ( this[0] && this[0].parentNode ) ? this.prevAll().length : -1;
  2.5459 +		}
  2.5460 +
  2.5461 +		// index in selector
  2.5462 +		if ( typeof elem === "string" ) {
  2.5463 +			return jQuery.inArray( this[0], jQuery( elem ) );
  2.5464 +		}
  2.5465 +
  2.5466 +		// Locate the position of the desired element
  2.5467 +		return jQuery.inArray(
  2.5468 +			// If it receives a jQuery object, the first element is used
  2.5469 +			elem.jquery ? elem[0] : elem, this );
  2.5470 +	},
  2.5471 +
  2.5472 +	add: function( selector, context ) {
  2.5473 +		var set = typeof selector === "string" ?
  2.5474 +				jQuery( selector, context ) :
  2.5475 +				jQuery.makeArray( selector && selector.nodeType ? [ selector ] : selector ),
  2.5476 +			all = jQuery.merge( this.get(), set );
  2.5477 +
  2.5478 +		return this.pushStack( isDisconnected( set[0] ) || isDisconnected( all[0] ) ?
  2.5479 +			all :
  2.5480 +			jQuery.unique( all ) );
  2.5481 +	},
  2.5482 +
  2.5483 +	addBack: function( selector ) {
  2.5484 +		return this.add( selector == null ?
  2.5485 +			this.prevObject : this.prevObject.filter(selector)
  2.5486 +		);
  2.5487 +	}
  2.5488 +});
  2.5489 +
  2.5490 +jQuery.fn.andSelf = jQuery.fn.addBack;
  2.5491 +
  2.5492 +// A painfully simple check to see if an element is disconnected
  2.5493 +// from a document (should be improved, where feasible).
  2.5494 +function isDisconnected( node ) {
  2.5495 +	return !node || !node.parentNode || node.parentNode.nodeType === 11;
  2.5496 +}
  2.5497 +
  2.5498 +function sibling( cur, dir ) {
  2.5499 +	do {
  2.5500 +		cur = cur[ dir ];
  2.5501 +	} while ( cur && cur.nodeType !== 1 );
  2.5502 +
  2.5503 +	return cur;
  2.5504 +}
  2.5505 +
  2.5506 +jQuery.each({
  2.5507 +	parent: function( elem ) {
  2.5508 +		var parent = elem.parentNode;
  2.5509 +		return parent && parent.nodeType !== 11 ? parent : null;
  2.5510 +	},
  2.5511 +	parents: function( elem ) {
  2.5512 +		return jQuery.dir( elem, "parentNode" );
  2.5513 +	},
  2.5514 +	parentsUntil: function( elem, i, until ) {
  2.5515 +		return jQuery.dir( elem, "parentNode", until );
  2.5516 +	},
  2.5517 +	next: function( elem ) {
  2.5518 +		return sibling( elem, "nextSibling" );
  2.5519 +	},
  2.5520 +	prev: function( elem ) {
  2.5521 +		return sibling( elem, "previousSibling" );
  2.5522 +	},
  2.5523 +	nextAll: function( elem ) {
  2.5524 +		return jQuery.dir( elem, "nextSibling" );
  2.5525 +	},
  2.5526 +	prevAll: function( elem ) {
  2.5527 +		return jQuery.dir( elem, "previousSibling" );
  2.5528 +	},
  2.5529 +	nextUntil: function( elem, i, until ) {
  2.5530 +		return jQuery.dir( elem, "nextSibling", until );
  2.5531 +	},
  2.5532 +	prevUntil: function( elem, i, until ) {
  2.5533 +		return jQuery.dir( elem, "previousSibling", until );
  2.5534 +	},
  2.5535 +	siblings: function( elem ) {
  2.5536 +		return jQuery.sibling( ( elem.parentNode || {} ).firstChild, elem );
  2.5537 +	},
  2.5538 +	children: function( elem ) {
  2.5539 +		return jQuery.sibling( elem.firstChild );
  2.5540 +	},
  2.5541 +	contents: function( elem ) {
  2.5542 +		return jQuery.nodeName( elem, "iframe" ) ?
  2.5543 +			elem.contentDocument || elem.contentWindow.document :
  2.5544 +			jQuery.merge( [], elem.childNodes );
  2.5545 +	}
  2.5546 +}, function( name, fn ) {
  2.5547 +	jQuery.fn[ name ] = function( until, selector ) {
  2.5548 +		var ret = jQuery.map( this, fn, until );
  2.5549 +
  2.5550 +		if ( !runtil.test( name ) ) {
  2.5551 +			selector = until;
  2.5552 +		}
  2.5553 +
  2.5554 +		if ( selector && typeof selector === "string" ) {
  2.5555 +			ret = jQuery.filter( selector, ret );
  2.5556 +		}
  2.5557 +
  2.5558 +		ret = this.length > 1 && !guaranteedUnique[ name ] ? jQuery.unique( ret ) : ret;
  2.5559 +
  2.5560 +		if ( this.length > 1 && rparentsprev.test( name ) ) {
  2.5561 +			ret = ret.reverse();
  2.5562 +		}
  2.5563 +
  2.5564 +		return this.pushStack( ret, name, core_slice.call( arguments ).join(",") );
  2.5565 +	};
  2.5566 +});
  2.5567 +
  2.5568 +jQuery.extend({
  2.5569 +	filter: function( expr, elems, not ) {
  2.5570 +		if ( not ) {
  2.5571 +			expr = ":not(" + expr + ")";
  2.5572 +		}
  2.5573 +
  2.5574 +		return elems.length === 1 ?
  2.5575 +			jQuery.find.matchesSelector(elems[0], expr) ? [ elems[0] ] : [] :
  2.5576 +			jQuery.find.matches(expr, elems);
  2.5577 +	},
  2.5578 +
  2.5579 +	dir: function( elem, dir, until ) {
  2.5580 +		var matched = [],
  2.5581 +			cur = elem[ dir ];
  2.5582 +
  2.5583 +		while ( cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery( cur ).is( until )) ) {
  2.5584 +			if ( cur.nodeType === 1 ) {
  2.5585 +				matched.push( cur );
  2.5586 +			}
  2.5587 +			cur = cur[dir];
  2.5588 +		}
  2.5589 +		return matched;
  2.5590 +	},
  2.5591 +
  2.5592 +	sibling: function( n, elem ) {
  2.5593 +		var r = [];
  2.5594 +
  2.5595 +		for ( ; n; n = n.nextSibling ) {
  2.5596 +			if ( n.nodeType === 1 && n !== elem ) {
  2.5597 +				r.push( n );
  2.5598 +			}
  2.5599 +		}
  2.5600 +
  2.5601 +		return r;
  2.5602 +	}
  2.5603 +});
  2.5604 +
  2.5605 +// Implement the identical functionality for filter and not
  2.5606 +function winnow( elements, qualifier, keep ) {
  2.5607 +
  2.5608 +	// Can't pass null or undefined to indexOf in Firefox 4
  2.5609 +	// Set to 0 to skip string check
  2.5610 +	qualifier = qualifier || 0;
  2.5611 +
  2.5612 +	if ( jQuery.isFunction( qualifier ) ) {
  2.5613 +		return jQuery.grep(elements, function( elem, i ) {
  2.5614 +			var retVal = !!qualifier.call( elem, i, elem );
  2.5615 +			return retVal === keep;
  2.5616 +		});
  2.5617 +
  2.5618 +	} else if ( qualifier.nodeType ) {
  2.5619 +		return jQuery.grep(elements, function( elem, i ) {
  2.5620 +			return ( elem === qualifier ) === keep;
  2.5621 +		});
  2.5622 +
  2.5623 +	} else if ( typeof qualifier === "string" ) {
  2.5624 +		var filtered = jQuery.grep(elements, function( elem ) {
  2.5625 +			return elem.nodeType === 1;
  2.5626 +		});
  2.5627 +
  2.5628 +		if ( isSimple.test( qualifier ) ) {
  2.5629 +			return jQuery.filter(qualifier, filtered, !keep);
  2.5630 +		} else {
  2.5631 +			qualifier = jQuery.filter( qualifier, filtered );
  2.5632 +		}
  2.5633 +	}
  2.5634 +
  2.5635 +	return jQuery.grep(elements, function( elem, i ) {
  2.5636 +		return ( jQuery.inArray( elem, qualifier ) >= 0 ) === keep;
  2.5637 +	});
  2.5638 +}
  2.5639 +function createSafeFragment( document ) {
  2.5640 +	var list = nodeNames.split( "|" ),
  2.5641 +	safeFrag = document.createDocumentFragment();
  2.5642 +
  2.5643 +	if ( safeFrag.createElement ) {
  2.5644 +		while ( list.length ) {
  2.5645 +			safeFrag.createElement(
  2.5646 +				list.pop()
  2.5647 +			);
  2.5648 +		}
  2.5649 +	}
  2.5650 +	return safeFrag;
  2.5651 +}
  2.5652 +
  2.5653 +var nodeNames = "abbr|article|aside|audio|bdi|canvas|data|datalist|details|figcaption|figure|footer|" +
  2.5654 +		"header|hgroup|mark|meter|nav|output|progress|section|summary|time|video",
  2.5655 +	rinlinejQuery = / jQuery\d+="(?:null|\d+)"/g,
  2.5656 +	rleadingWhitespace = /^\s+/,
  2.5657 +	rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi,
  2.5658 +	rtagName = /<([\w:]+)/,
  2.5659 +	rtbody = /<tbody/i,
  2.5660 +	rhtml = /<|&#?\w+;/,
  2.5661 +	rnoInnerhtml = /<(?:script|style|link)/i,
  2.5662 +	rnocache = /<(?:script|object|embed|option|style)/i,
  2.5663 +	rnoshimcache = new RegExp("<(?:" + nodeNames + ")[\\s/>]", "i"),
  2.5664 +	rcheckableType = /^(?:checkbox|radio)$/,
  2.5665 +	// checked="checked" or checked
  2.5666 +	rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
  2.5667 +	rscriptType = /\/(java|ecma)script/i,
  2.5668 +	rcleanScript = /^\s*<!(?:\[CDATA\[|\-\-)|[\]\-]{2}>\s*$/g,
  2.5669 +	wrapMap = {
  2.5670 +		option: [ 1, "<select multiple='multiple'>", "</select>" ],
  2.5671 +		legend: [ 1, "<fieldset>", "</fieldset>" ],
  2.5672 +		thead: [ 1, "<table>", "</table>" ],
  2.5673 +		tr: [ 2, "<table><tbody>", "</tbody></table>" ],
  2.5674 +		td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
  2.5675 +		col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ],
  2.5676 +		area: [ 1, "<map>", "</map>" ],
  2.5677 +		_default: [ 0, "", "" ]
  2.5678 +	},
  2.5679 +	safeFragment = createSafeFragment( document ),
  2.5680 +	fragmentDiv = safeFragment.appendChild( document.createElement("div") );
  2.5681 +
  2.5682 +wrapMap.optgroup = wrapMap.option;
  2.5683 +wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
  2.5684 +wrapMap.th = wrapMap.td;
  2.5685 +
  2.5686 +// IE6-8 can't serialize link, script, style, or any html5 (NoScope) tags,
  2.5687 +// unless wrapped in a div with non-breaking characters in front of it.
  2.5688 +if ( !jQuery.support.htmlSerialize ) {
  2.5689 +	wrapMap._default = [ 1, "X<div>", "</div>" ];
  2.5690 +}
  2.5691 +
  2.5692 +jQuery.fn.extend({
  2.5693 +	text: function( value ) {
  2.5694 +		return jQuery.access( this, function( value ) {
  2.5695 +			return value === undefined ?
  2.5696 +				jQuery.text( this ) :
  2.5697 +				this.empty().append( ( this[0] && this[0].ownerDocument || document ).createTextNode( value ) );
  2.5698 +		}, null, value, arguments.length );
  2.5699 +	},
  2.5700 +
  2.5701 +	wrapAll: function( html ) {
  2.5702 +		if ( jQuery.isFunction( html ) ) {
  2.5703 +			return this.each(function(i) {
  2.5704 +				jQuery(this).wrapAll( html.call(this, i) );
  2.5705 +			});
  2.5706 +		}
  2.5707 +
  2.5708 +		if ( this[0] ) {
  2.5709 +			// The elements to wrap the target around
  2.5710 +			var wrap = jQuery( html, this[0].ownerDocument ).eq(0).clone(true);
  2.5711 +
  2.5712 +			if ( this[0].parentNode ) {
  2.5713 +				wrap.insertBefore( this[0] );
  2.5714 +			}
  2.5715 +
  2.5716 +			wrap.map(function() {
  2.5717 +				var elem = this;
  2.5718 +
  2.5719 +				while ( elem.firstChild && elem.firstChild.nodeType === 1 ) {
  2.5720 +					elem = elem.firstChild;
  2.5721 +				}
  2.5722 +
  2.5723 +				return elem;
  2.5724 +			}).append( this );
  2.5725 +		}
  2.5726 +
  2.5727 +		return this;
  2.5728 +	},
  2.5729 +
  2.5730 +	wrapInner: function( html ) {
  2.5731 +		if ( jQuery.isFunction( html ) ) {
  2.5732 +			return this.each(function(i) {
  2.5733 +				jQuery(this).wrapInner( html.call(this, i) );
  2.5734 +			});
  2.5735 +		}
  2.5736 +
  2.5737 +		return this.each(function() {
  2.5738 +			var self = jQuery( this ),
  2.5739 +				contents = self.contents();
  2.5740 +
  2.5741 +			if ( contents.length ) {
  2.5742 +				contents.wrapAll( html );
  2.5743 +
  2.5744 +			} else {
  2.5745 +				self.append( html );
  2.5746 +			}
  2.5747 +		});
  2.5748 +	},
  2.5749 +
  2.5750 +	wrap: function( html ) {
  2.5751 +		var isFunction = jQuery.isFunction( html );
  2.5752 +
  2.5753 +		return this.each(function(i) {
  2.5754 +			jQuery( this ).wrapAll( isFunction ? html.call(this, i) : html );
  2.5755 +		});
  2.5756 +	},
  2.5757 +
  2.5758 +	unwrap: function() {
  2.5759 +		return this.parent().each(function() {
  2.5760 +			if ( !jQuery.nodeName( this, "body" ) ) {
  2.5761 +				jQuery( this ).replaceWith( this.childNodes );
  2.5762 +			}
  2.5763 +		}).end();
  2.5764 +	},
  2.5765 +
  2.5766 +	append: function() {
  2.5767 +		return this.domManip(arguments, true, function( elem ) {
  2.5768 +			if ( this.nodeType === 1 || this.nodeType === 11 ) {
  2.5769 +				this.appendChild( elem );
  2.5770 +			}
  2.5771 +		});
  2.5772 +	},
  2.5773 +
  2.5774 +	prepend: function() {
  2.5775 +		return this.domManip(arguments, true, function( elem ) {
  2.5776 +			if ( this.nodeType === 1 || this.nodeType === 11 ) {
  2.5777 +				this.insertBefore( elem, this.firstChild );
  2.5778 +			}
  2.5779 +		});
  2.5780 +	},
  2.5781 +
  2.5782 +	before: function() {
  2.5783 +		if ( !isDisconnected( this[0] ) ) {
  2.5784 +			return this.domManip(arguments, false, function( elem ) {
  2.5785 +				this.parentNode.insertBefore( elem, this );
  2.5786 +			});
  2.5787 +		}
  2.5788 +
  2.5789 +		if ( arguments.length ) {
  2.5790 +			var set = jQuery.clean( arguments );
  2.5791 +			return this.pushStack( jQuery.merge( set, this ), "before", this.selector );
  2.5792 +		}
  2.5793 +	},
  2.5794 +
  2.5795 +	after: function() {
  2.5796 +		if ( !isDisconnected( this[0] ) ) {
  2.5797 +			return this.domManip(arguments, false, function( elem ) {
  2.5798 +				this.parentNode.insertBefore( elem, this.nextSibling );
  2.5799 +			});
  2.5800 +		}
  2.5801 +
  2.5802 +		if ( arguments.length ) {
  2.5803 +			var set = jQuery.clean( arguments );
  2.5804 +			return this.pushStack( jQuery.merge( this, set ), "after", this.selector );
  2.5805 +		}
  2.5806 +	},
  2.5807 +
  2.5808 +	// keepData is for internal use only--do not document
  2.5809 +	remove: function( selector, keepData ) {
  2.5810 +		var elem,
  2.5811 +			i = 0;
  2.5812 +
  2.5813 +		for ( ; (elem = this[i]) != null; i++ ) {
  2.5814 +			if ( !selector || jQuery.filter( selector, [ elem ] ).length ) {
  2.5815 +				if ( !keepData && elem.nodeType === 1 ) {
  2.5816 +					jQuery.cleanData( elem.getElementsByTagName("*") );
  2.5817 +					jQuery.cleanData( [ elem ] );
  2.5818 +				}
  2.5819 +
  2.5820 +				if ( elem.parentNode ) {
  2.5821 +					elem.parentNode.removeChild( elem );
  2.5822 +				}
  2.5823 +			}
  2.5824 +		}
  2.5825 +
  2.5826 +		return this;
  2.5827 +	},
  2.5828 +
  2.5829 +	empty: function() {
  2.5830 +		var elem,
  2.5831 +			i = 0;
  2.5832 +
  2.5833 +		for ( ; (elem = this[i]) != null; i++ ) {
  2.5834 +			// Remove element nodes and prevent memory leaks
  2.5835 +			if ( elem.nodeType === 1 ) {
  2.5836 +				jQuery.cleanData( elem.getElementsByTagName("*") );
  2.5837 +			}
  2.5838 +
  2.5839 +			// Remove any remaining nodes
  2.5840 +			while ( elem.firstChild ) {
  2.5841 +				elem.removeChild( elem.firstChild );
  2.5842 +			}
  2.5843 +		}
  2.5844 +
  2.5845 +		return this;
  2.5846 +	},
  2.5847 +
  2.5848 +	clone: function( dataAndEvents, deepDataAndEvents ) {
  2.5849 +		dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
  2.5850 +		deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
  2.5851 +
  2.5852 +		return this.map( function () {
  2.5853 +			return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
  2.5854 +		});
  2.5855 +	},
  2.5856 +
  2.5857 +	html: function( value ) {
  2.5858 +		return jQuery.access( this, function( value ) {
  2.5859 +			var elem = this[0] || {},
  2.5860 +				i = 0,
  2.5861 +				l = this.length;
  2.5862 +
  2.5863 +			if ( value === undefined ) {
  2.5864 +				return elem.nodeType === 1 ?
  2.5865 +					elem.innerHTML.replace( rinlinejQuery, "" ) :
  2.5866 +					undefined;
  2.5867 +			}
  2.5868 +
  2.5869 +			// See if we can take a shortcut and just use innerHTML
  2.5870 +			if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
  2.5871 +				( jQuery.support.htmlSerialize || !rnoshimcache.test( value )  ) &&
  2.5872 +				( jQuery.support.leadingWhitespace || !rleadingWhitespace.test( value ) ) &&
  2.5873 +				!wrapMap[ ( rtagName.exec( value ) || ["", ""] )[1].toLowerCase() ] ) {
  2.5874 +
  2.5875 +				value = value.replace( rxhtmlTag, "<$1></$2>" );
  2.5876 +
  2.5877 +				try {
  2.5878 +					for (; i < l; i++ ) {
  2.5879 +						// Remove element nodes and prevent memory leaks
  2.5880 +						elem = this[i] || {};
  2.5881 +						if ( elem.nodeType === 1 ) {
  2.5882 +							jQuery.cleanData( elem.getElementsByTagName( "*" ) );
  2.5883 +							elem.innerHTML = value;
  2.5884 +						}
  2.5885 +					}
  2.5886 +
  2.5887 +					elem = 0;
  2.5888 +
  2.5889 +				// If using innerHTML throws an exception, use the fallback method
  2.5890 +				} catch(e) {}
  2.5891 +			}
  2.5892 +
  2.5893 +			if ( elem ) {
  2.5894 +				this.empty().append( value );
  2.5895 +			}
  2.5896 +		}, null, value, arguments.length );
  2.5897 +	},
  2.5898 +
  2.5899 +	replaceWith: function( value ) {
  2.5900 +		if ( !isDisconnected( this[0] ) ) {
  2.5901 +			// Make sure that the elements are removed from the DOM before they are inserted
  2.5902 +			// this can help fix replacing a parent with child elements
  2.5903 +			if ( jQuery.isFunction( value ) ) {
  2.5904 +				return this.each(function(i) {
  2.5905 +					var self = jQuery(this), old = self.html();
  2.5906 +					self.replaceWith( value.call( this, i, old ) );
  2.5907 +				});
  2.5908 +			}
  2.5909 +
  2.5910 +			if ( typeof value !== "string" ) {
  2.5911 +				value = jQuery( value ).detach();
  2.5912 +			}
  2.5913 +
  2.5914 +			return this.each(function() {
  2.5915 +				var next = this.nextSibling,
  2.5916 +					parent = this.parentNode;
  2.5917 +
  2.5918 +				jQuery( this ).remove();
  2.5919 +
  2.5920 +				if ( next ) {
  2.5921 +					jQuery(next).before( value );
  2.5922 +				} else {
  2.5923 +					jQuery(parent).append( value );
  2.5924 +				}
  2.5925 +			});
  2.5926 +		}
  2.5927 +
  2.5928 +		return this.length ?
  2.5929 +			this.pushStack( jQuery(jQuery.isFunction(value) ? value() : value), "replaceWith", value ) :
  2.5930 +			this;
  2.5931 +	},
  2.5932 +
  2.5933 +	detach: function( selector ) {
  2.5934 +		return this.remove( selector, true );
  2.5935 +	},
  2.5936 +
  2.5937 +	domManip: function( args, table, callback ) {
  2.5938 +
  2.5939 +		// Flatten any nested arrays
  2.5940 +		args = [].concat.apply( [], args );
  2.5941 +
  2.5942 +		var results, first, fragment, iNoClone,
  2.5943 +			i = 0,
  2.5944 +			value = args[0],
  2.5945 +			scripts = [],
  2.5946 +			l = this.length;
  2.5947 +
  2.5948 +		// We can't cloneNode fragments that contain checked, in WebKit
  2.5949 +		if ( !jQuery.support.checkClone && l > 1 && typeof value === "string" && rchecked.test( value ) ) {
  2.5950 +			return this.each(function() {
  2.5951 +				jQuery(this).domManip( args, table, callback );
  2.5952 +			});
  2.5953 +		}
  2.5954 +
  2.5955 +		if ( jQuery.isFunction(value) ) {
  2.5956 +			return this.each(function(i) {
  2.5957 +				var self = jQuery(this);
  2.5958 +				args[0] = value.call( this, i, table ? self.html() : undefined );
  2.5959 +				self.domManip( args, table, callback );
  2.5960 +			});
  2.5961 +		}
  2.5962 +
  2.5963 +		if ( this[0] ) {
  2.5964 +			results = jQuery.buildFragment( args, this, scripts );
  2.5965 +			fragment = results.fragment;
  2.5966 +			first = fragment.firstChild;
  2.5967 +
  2.5968 +			if ( fragment.childNodes.length === 1 ) {
  2.5969 +				fragment = first;
  2.5970 +			}
  2.5971 +
  2.5972 +			if ( first ) {
  2.5973 +				table = table && jQuery.nodeName( first, "tr" );
  2.5974 +
  2.5975 +				// Use the original fragment for the last item instead of the first because it can end up
  2.5976 +				// being emptied incorrectly in certain situations (#8070).
  2.5977 +				// Fragments from the fragment cache must always be cloned and never used in place.
  2.5978 +				for ( iNoClone = results.cacheable || l - 1; i < l; i++ ) {
  2.5979 +					callback.call(
  2.5980 +						table && jQuery.nodeName( this[i], "table" ) ?
  2.5981 +							findOrAppend( this[i], "tbody" ) :
  2.5982 +							this[i],
  2.5983 +						i === iNoClone ?
  2.5984 +							fragment :
  2.5985 +							jQuery.clone( fragment, true, true )
  2.5986 +					);
  2.5987 +				}
  2.5988 +			}
  2.5989 +
  2.5990 +			// Fix #11809: Avoid leaking memory
  2.5991 +			fragment = first = null;
  2.5992 +
  2.5993 +			if ( scripts.length ) {
  2.5994 +				jQuery.each( scripts, function( i, elem ) {
  2.5995 +					if ( elem.src ) {
  2.5996 +						if ( jQuery.ajax ) {
  2.5997 +							jQuery.ajax({
  2.5998 +								url: elem.src,
  2.5999 +								type: "GET",
  2.6000 +								dataType: "script",
  2.6001 +								async: false,
  2.6002 +								global: false,
  2.6003 +								"throws": true
  2.6004 +							});
  2.6005 +						} else {
  2.6006 +							jQuery.error("no ajax");
  2.6007 +						}
  2.6008 +					} else {
  2.6009 +						jQuery.globalEval( ( elem.text || elem.textContent || elem.innerHTML || "" ).replace( rcleanScript, "" ) );
  2.6010 +					}
  2.6011 +
  2.6012 +					if ( elem.parentNode ) {
  2.6013 +						elem.parentNode.removeChild( elem );
  2.6014 +					}
  2.6015 +				});
  2.6016 +			}
  2.6017 +		}
  2.6018 +
  2.6019 +		return this;
  2.6020 +	}
  2.6021 +});
  2.6022 +
  2.6023 +function findOrAppend( elem, tag ) {
  2.6024 +	return elem.getElementsByTagName( tag )[0] || elem.appendChild( elem.ownerDocument.createElement( tag ) );
  2.6025 +}
  2.6026 +
  2.6027 +function cloneCopyEvent( src, dest ) {
  2.6028 +
  2.6029 +	if ( dest.nodeType !== 1 || !jQuery.hasData( src ) ) {
  2.6030 +		return;
  2.6031 +	}
  2.6032 +
  2.6033 +	var type, i, l,
  2.6034 +		oldData = jQuery._data( src ),
  2.6035 +		curData = jQuery._data( dest, oldData ),
  2.6036 +		events = oldData.events;
  2.6037 +
  2.6038 +	if ( events ) {
  2.6039 +		delete curData.handle;
  2.6040 +		curData.events = {};
  2.6041 +
  2.6042 +		for ( type in events ) {
  2.6043 +			for ( i = 0, l = events[ type ].length; i < l; i++ ) {
  2.6044 +				jQuery.event.add( dest, type, events[ type ][ i ] );
  2.6045 +			}
  2.6046 +		}
  2.6047 +	}
  2.6048 +
  2.6049 +	// make the cloned public data object a copy from the original
  2.6050 +	if ( curData.data ) {
  2.6051 +		curData.data = jQuery.extend( {}, curData.data );
  2.6052 +	}
  2.6053 +}
  2.6054 +
  2.6055 +function cloneFixAttributes( src, dest ) {
  2.6056 +	var nodeName;
  2.6057 +
  2.6058 +	// We do not need to do anything for non-Elements
  2.6059 +	if ( dest.nodeType !== 1 ) {
  2.6060 +		return;
  2.6061 +	}
  2.6062 +
  2.6063 +	// clearAttributes removes the attributes, which we don't want,
  2.6064 +	// but also removes the attachEvent events, which we *do* want
  2.6065 +	if ( dest.clearAttributes ) {
  2.6066 +		dest.clearAttributes();
  2.6067 +	}
  2.6068 +
  2.6069 +	// mergeAttributes, in contrast, only merges back on the
  2.6070 +	// original attributes, not the events
  2.6071 +	if ( dest.mergeAttributes ) {
  2.6072 +		dest.mergeAttributes( src );
  2.6073 +	}
  2.6074 +
  2.6075 +	nodeName = dest.nodeName.toLowerCase();
  2.6076 +
  2.6077 +	if ( nodeName === "object" ) {
  2.6078 +		// IE6-10 improperly clones children of object elements using classid.
  2.6079 +		// IE10 throws NoModificationAllowedError if parent is null, #12132.
  2.6080 +		if ( dest.parentNode ) {
  2.6081 +			dest.outerHTML = src.outerHTML;
  2.6082 +		}
  2.6083 +
  2.6084 +		// This path appears unavoidable for IE9. When cloning an object
  2.6085 +		// element in IE9, the outerHTML strategy above is not sufficient.
  2.6086 +		// If the src has innerHTML and the destination does not,
  2.6087 +		// copy the src.innerHTML into the dest.innerHTML. #10324
  2.6088 +		if ( jQuery.support.html5Clone && (src.innerHTML && !jQuery.trim(dest.innerHTML)) ) {
  2.6089 +			dest.innerHTML = src.innerHTML;
  2.6090 +		}
  2.6091 +
  2.6092 +	} else if ( nodeName === "input" && rcheckableType.test( src.type ) ) {
  2.6093 +		// IE6-8 fails to persist the checked state of a cloned checkbox
  2.6094 +		// or radio button. Worse, IE6-7 fail to give the cloned element
  2.6095 +		// a checked appearance if the defaultChecked value isn't also set
  2.6096 +
  2.6097 +		dest.defaultChecked = dest.checked = src.checked;
  2.6098 +
  2.6099 +		// IE6-7 get confused and end up setting the value of a cloned
  2.6100 +		// checkbox/radio button to an empty string instead of "on"
  2.6101 +		if ( dest.value !== src.value ) {
  2.6102 +			dest.value = src.value;
  2.6103 +		}
  2.6104 +
  2.6105 +	// IE6-8 fails to return the selected option to the default selected
  2.6106 +	// state when cloning options
  2.6107 +	} else if ( nodeName === "option" ) {
  2.6108 +		dest.selected = src.defaultSelected;
  2.6109 +
  2.6110 +	// IE6-8 fails to set the defaultValue to the correct value when
  2.6111 +	// cloning other types of input fields
  2.6112 +	} else if ( nodeName === "input" || nodeName === "textarea" ) {
  2.6113 +		dest.defaultValue = src.defaultValue;
  2.6114 +
  2.6115 +	// IE blanks contents when cloning scripts
  2.6116 +	} else if ( nodeName === "script" && dest.text !== src.text ) {
  2.6117 +		dest.text = src.text;
  2.6118 +	}
  2.6119 +
  2.6120 +	// Event data gets referenced instead of copied if the expando
  2.6121 +	// gets copied too
  2.6122 +	dest.removeAttribute( jQuery.expando );
  2.6123 +}
  2.6124 +
  2.6125 +jQuery.buildFragment = function( args, context, scripts ) {
  2.6126 +	var fragment, cacheable, cachehit,
  2.6127 +		first = args[ 0 ];
  2.6128 +
  2.6129 +	// Set context from what may come in as undefined or a jQuery collection or a node
  2.6130 +	// Updated to fix #12266 where accessing context[0] could throw an exception in IE9/10 &
  2.6131 +	// also doubles as fix for #8950 where plain objects caused createDocumentFragment exception
  2.6132 +	context = context || document;
  2.6133 +	context = !context.nodeType && context[0] || context;
  2.6134 +	context = context.ownerDocument || context;
  2.6135 +
  2.6136 +	// Only cache "small" (1/2 KB) HTML strings that are associated with the main document
  2.6137 +	// Cloning options loses the selected state, so don't cache them
  2.6138 +	// IE 6 doesn't like it when you put <object> or <embed> elements in a fragment
  2.6139 +	// Also, WebKit does not clone 'checked' attributes on cloneNode, so don't cache
  2.6140 +	// Lastly, IE6,7,8 will not correctly reuse cached fragments that were created from unknown elems #10501
  2.6141 +	if ( args.length === 1 && typeof first === "string" && first.length < 512 && context === document &&
  2.6142 +		first.charAt(0) === "<" && !rnocache.test( first ) &&
  2.6143 +		(jQuery.support.checkClone || !rchecked.test( first )) &&
  2.6144 +		(jQuery.support.html5Clone || !rnoshimcache.test( first )) ) {
  2.6145 +
  2.6146 +		// Mark cacheable and look for a hit
  2.6147 +		cacheable = true;
  2.6148 +		fragment = jQuery.fragments[ first ];
  2.6149 +		cachehit = fragment !== undefined;
  2.6150 +	}
  2.6151 +
  2.6152 +	if ( !fragment ) {
  2.6153 +		fragment = context.createDocumentFragment();
  2.6154 +		jQuery.clean( args, context, fragment, scripts );
  2.6155 +
  2.6156 +		// Update the cache, but only store false
  2.6157 +		// unless this is a second parsing of the same content
  2.6158 +		if ( cacheable ) {
  2.6159 +			jQuery.fragments[ first ] = cachehit && fragment;
  2.6160 +		}
  2.6161 +	}
  2.6162 +
  2.6163 +	return { fragment: fragment, cacheable: cacheable };
  2.6164 +};
  2.6165 +
  2.6166 +jQuery.fragments = {};
  2.6167 +
  2.6168 +jQuery.each({
  2.6169 +	appendTo: "append",
  2.6170 +	prependTo: "prepend",
  2.6171 +	insertBefore: "before",
  2.6172 +	insertAfter: "after",
  2.6173 +	replaceAll: "replaceWith"
  2.6174 +}, function( name, original ) {
  2.6175 +	jQuery.fn[ name ] = function( selector ) {
  2.6176 +		var elems,
  2.6177 +			i = 0,
  2.6178 +			ret = [],
  2.6179 +			insert = jQuery( selector ),
  2.6180 +			l = insert.length,
  2.6181 +			parent = this.length === 1 && this[0].parentNode;
  2.6182 +
  2.6183 +		if ( (parent == null || parent && parent.nodeType === 11 && parent.childNodes.length === 1) && l === 1 ) {
  2.6184 +			insert[ original ]( this[0] );
  2.6185 +			return this;
  2.6186 +		} else {
  2.6187 +			for ( ; i < l; i++ ) {
  2.6188 +				elems = ( i > 0 ? this.clone(true) : this ).get();
  2.6189 +				jQuery( insert[i] )[ original ]( elems );
  2.6190 +				ret = ret.concat( elems );
  2.6191 +			}
  2.6192 +
  2.6193 +			return this.pushStack( ret, name, insert.selector );
  2.6194 +		}
  2.6195 +	};
  2.6196 +});
  2.6197 +
  2.6198 +function getAll( elem ) {
  2.6199 +	if ( typeof elem.getElementsByTagName !== "undefined" ) {
  2.6200 +		return elem.getElementsByTagName( "*" );
  2.6201 +
  2.6202 +	} else if ( typeof elem.querySelectorAll !== "undefined" ) {
  2.6203 +		return elem.querySelectorAll( "*" );
  2.6204 +
  2.6205 +	} else {
  2.6206 +		return [];
  2.6207 +	}
  2.6208 +}
  2.6209 +
  2.6210 +// Used in clean, fixes the defaultChecked property
  2.6211 +function fixDefaultChecked( elem ) {
  2.6212 +	if ( rcheckableType.test( elem.type ) ) {
  2.6213 +		elem.defaultChecked = elem.checked;
  2.6214 +	}
  2.6215 +}
  2.6216 +
  2.6217 +jQuery.extend({
  2.6218 +	clone: function( elem, dataAndEvents, deepDataAndEvents ) {
  2.6219 +		var srcElements,
  2.6220 +			destElements,
  2.6221 +			i,
  2.6222 +			clone;
  2.6223 +
  2.6224 +		if ( jQuery.support.html5Clone || jQuery.isXMLDoc(elem) || !rnoshimcache.test( "<" + elem.nodeName + ">" ) ) {
  2.6225 +			clone = elem.cloneNode( true );
  2.6226 +
  2.6227 +		// IE<=8 does not properly clone detached, unknown element nodes
  2.6228 +		} else {
  2.6229 +			fragmentDiv.innerHTML = elem.outerHTML;
  2.6230 +			fragmentDiv.removeChild( clone = fragmentDiv.firstChild );
  2.6231 +		}
  2.6232 +
  2.6233 +		if ( (!jQuery.support.noCloneEvent || !jQuery.support.noCloneChecked) &&
  2.6234 +				(elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem) ) {
  2.6235 +			// IE copies events bound via attachEvent when using cloneNode.
  2.6236 +			// Calling detachEvent on the clone will also remove the events
  2.6237 +			// from the original. In order to get around this, we use some
  2.6238 +			// proprietary methods to clear the events. Thanks to MooTools
  2.6239 +			// guys for this hotness.
  2.6240 +
  2.6241 +			cloneFixAttributes( elem, clone );
  2.6242 +
  2.6243 +			// Using Sizzle here is crazy slow, so we use getElementsByTagName instead
  2.6244 +			srcElements = getAll( elem );
  2.6245 +			destElements = getAll( clone );
  2.6246 +
  2.6247 +			// Weird iteration because IE will replace the length property
  2.6248 +			// with an element if you are cloning the body and one of the
  2.6249 +			// elements on the page has a name or id of "length"
  2.6250 +			for ( i = 0; srcElements[i]; ++i ) {
  2.6251 +				// Ensure that the destination node is not null; Fixes #9587
  2.6252 +				if ( destElements[i] ) {
  2.6253 +					cloneFixAttributes( srcElements[i], destElements[i] );
  2.6254 +				}
  2.6255 +			}
  2.6256 +		}
  2.6257 +
  2.6258 +		// Copy the events from the original to the clone
  2.6259 +		if ( dataAndEvents ) {
  2.6260 +			cloneCopyEvent( elem, clone );
  2.6261 +
  2.6262 +			if ( deepDataAndEvents ) {
  2.6263 +				srcElements = getAll( elem );
  2.6264 +				destElements = getAll( clone );
  2.6265 +
  2.6266 +				for ( i = 0; srcElements[i]; ++i ) {
  2.6267 +					cloneCopyEvent( srcElements[i], destElements[i] );
  2.6268 +				}
  2.6269 +			}
  2.6270 +		}
  2.6271 +
  2.6272 +		srcElements = destElements = null;
  2.6273 +
  2.6274 +		// Return the cloned set
  2.6275 +		return clone;
  2.6276 +	},
  2.6277 +
  2.6278 +	clean: function( elems, context, fragment, scripts ) {
  2.6279 +		var i, j, elem, tag, wrap, depth, div, hasBody, tbody, len, handleScript, jsTags,
  2.6280 +			safe = context === document && safeFragment,
  2.6281 +			ret = [];
  2.6282 +
  2.6283 +		// Ensure that context is a document
  2.6284 +		if ( !context || typeof context.createDocumentFragment === "undefined" ) {
  2.6285 +			context = document;
  2.6286 +		}
  2.6287 +
  2.6288 +		// Use the already-created safe fragment if context permits
  2.6289 +		for ( i = 0; (elem = elems[i]) != null; i++ ) {
  2.6290 +			if ( typeof elem === "number" ) {
  2.6291 +				elem += "";
  2.6292 +			}
  2.6293 +
  2.6294 +			if ( !elem ) {
  2.6295 +				continue;
  2.6296 +			}
  2.6297 +
  2.6298 +			// Convert html string into DOM nodes
  2.6299 +			if ( typeof elem === "string" ) {
  2.6300 +				if ( !rhtml.test( elem ) ) {
  2.6301 +					elem = context.createTextNode( elem );
  2.6302 +				} else {
  2.6303 +					// Ensure a safe container in which to render the html
  2.6304 +					safe = safe || createSafeFragment( context );
  2.6305 +					div = context.createElement("div");
  2.6306 +					safe.appendChild( div );
  2.6307 +
  2.6308 +					// Fix "XHTML"-style tags in all browsers
  2.6309 +					elem = elem.replace(rxhtmlTag, "<$1></$2>");
  2.6310 +
  2.6311 +					// Go to html and back, then peel off extra wrappers
  2.6312 +					tag = ( rtagName.exec( elem ) || ["", ""] )[1].toLowerCase();
  2.6313 +					wrap = wrapMap[ tag ] || wrapMap._default;
  2.6314 +					depth = wrap[0];
  2.6315 +					div.innerHTML = wrap[1] + elem + wrap[2];
  2.6316 +
  2.6317 +					// Move to the right depth
  2.6318 +					while ( depth-- ) {
  2.6319 +						div = div.lastChild;
  2.6320 +					}
  2.6321 +
  2.6322 +					// Remove IE's autoinserted <tbody> from table fragments
  2.6323 +					if ( !jQuery.support.tbody ) {
  2.6324 +
  2.6325 +						// String was a <table>, *may* have spurious <tbody>
  2.6326 +						hasBody = rtbody.test(elem);
  2.6327 +							tbody = tag === "table" && !hasBody ?
  2.6328 +								div.firstChild && div.firstChild.childNodes :
  2.6329 +
  2.6330 +								// String was a bare <thead> or <tfoot>
  2.6331 +								wrap[1] === "<table>" && !hasBody ?
  2.6332 +									div.childNodes :
  2.6333 +									[];
  2.6334 +
  2.6335 +						for ( j = tbody.length - 1; j >= 0 ; --j ) {
  2.6336 +							if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length ) {
  2.6337 +								tbody[ j ].parentNode.removeChild( tbody[ j ] );
  2.6338 +							}
  2.6339 +						}
  2.6340 +					}
  2.6341 +
  2.6342 +					// IE completely kills leading whitespace when innerHTML is used
  2.6343 +					if ( !jQuery.support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {
  2.6344 +						div.insertBefore( context.createTextNode( rleadingWhitespace.exec(elem)[0] ), div.firstChild );
  2.6345 +					}
  2.6346 +
  2.6347 +					elem = div.childNodes;
  2.6348 +
  2.6349 +					// Take out of fragment container (we need a fresh div each time)
  2.6350 +					div.parentNode.removeChild( div );
  2.6351 +				}
  2.6352 +			}
  2.6353 +
  2.6354 +			if ( elem.nodeType ) {
  2.6355 +				ret.push( elem );
  2.6356 +			} else {
  2.6357 +				jQuery.merge( ret, elem );
  2.6358 +			}
  2.6359 +		}
  2.6360 +
  2.6361 +		// Fix #11356: Clear elements from safeFragment
  2.6362 +		if ( div ) {
  2.6363 +			elem = div = safe = null;
  2.6364 +		}
  2.6365 +
  2.6366 +		// Reset defaultChecked for any radios and checkboxes
  2.6367 +		// about to be appended to the DOM in IE 6/7 (#8060)
  2.6368 +		if ( !jQuery.support.appendChecked ) {
  2.6369 +			for ( i = 0; (elem = ret[i]) != null; i++ ) {
  2.6370 +				if ( jQuery.nodeName( elem, "input" ) ) {
  2.6371 +					fixDefaultChecked( elem );
  2.6372 +				} else if ( typeof elem.getElementsByTagName !== "undefined" ) {
  2.6373 +					jQuery.grep( elem.getElementsByTagName("input"), fixDefaultChecked );
  2.6374 +				}
  2.6375 +			}
  2.6376 +		}
  2.6377 +
  2.6378 +		// Append elements to a provided document fragment
  2.6379 +		if ( fragment ) {
  2.6380 +			// Special handling of each script element
  2.6381 +			handleScript = function( elem ) {
  2.6382 +				// Check if we consider it executable
  2.6383 +				if ( !elem.type || rscriptType.test( elem.type ) ) {
  2.6384 +					// Detach the script and store it in the scripts array (if provided) or the fragment
  2.6385 +					// Return truthy to indicate that it has been handled
  2.6386 +					return scripts ?
  2.6387 +						scripts.push( elem.parentNode ? elem.parentNode.removeChild( elem ) : elem ) :
  2.6388 +						fragment.appendChild( elem );
  2.6389 +				}
  2.6390 +			};
  2.6391 +
  2.6392 +			for ( i = 0; (elem = ret[i]) != null; i++ ) {
  2.6393 +				// Check if we're done after handling an executable script
  2.6394 +				if ( !( jQuery.nodeName( elem, "script" ) && handleScript( elem ) ) ) {
  2.6395 +					// Append to fragment and handle embedded scripts
  2.6396 +					fragment.appendChild( elem );
  2.6397 +					if ( typeof elem.getElementsByTagName !== "undefined" ) {
  2.6398 +						// handleScript alters the DOM, so use jQuery.merge to ensure snapshot iteration
  2.6399 +						jsTags = jQuery.grep( jQuery.merge( [], elem.getElementsByTagName("script") ), handleScript );
  2.6400 +
  2.6401 +						// Splice the scripts into ret after their former ancestor and advance our index beyond them
  2.6402 +						ret.splice.apply( ret, [i + 1, 0].concat( jsTags ) );
  2.6403 +						i += jsTags.length;
  2.6404 +					}
  2.6405 +				}
  2.6406 +			}
  2.6407 +		}
  2.6408 +
  2.6409 +		return ret;
  2.6410 +	},
  2.6411 +
  2.6412 +	cleanData: function( elems, /* internal */ acceptData ) {
  2.6413 +		var data, id, elem, type,
  2.6414 +			i = 0,
  2.6415 +			internalKey = jQuery.expando,
  2.6416 +			cache = jQuery.cache,
  2.6417 +			deleteExpando = jQuery.support.deleteExpando,
  2.6418 +			special = jQuery.event.special;
  2.6419 +
  2.6420 +		for ( ; (elem = elems[i]) != null; i++ ) {
  2.6421 +
  2.6422 +			if ( acceptData || jQuery.acceptData( elem ) ) {
  2.6423 +
  2.6424 +				id = elem[ internalKey ];
  2.6425 +				data = id && cache[ id ];
  2.6426 +
  2.6427 +				if ( data ) {
  2.6428 +					if ( data.events ) {
  2.6429 +						for ( type in data.events ) {
  2.6430 +							if ( special[ type ] ) {
  2.6431 +								jQuery.event.remove( elem, type );
  2.6432 +
  2.6433 +							// This is a shortcut to avoid jQuery.event.remove's overhead
  2.6434 +							} else {
  2.6435 +								jQuery.removeEvent( elem, type, data.handle );
  2.6436 +							}
  2.6437 +						}
  2.6438 +					}
  2.6439 +
  2.6440 +					// Remove cache only if it was not already removed by jQuery.event.remove
  2.6441 +					if ( cache[ id ] ) {
  2.6442 +
  2.6443 +						delete cache[ id ];
  2.6444 +
  2.6445 +						// IE does not allow us to delete expando properties from nodes,
  2.6446 +						// nor does it have a removeAttribute function on Document nodes;
  2.6447 +						// we must handle all of these cases
  2.6448 +						if ( deleteExpando ) {
  2.6449 +							delete elem[ internalKey ];
  2.6450 +
  2.6451 +						} else if ( elem.removeAttribute ) {
  2.6452 +							elem.removeAttribute( internalKey );
  2.6453 +
  2.6454 +						} else {
  2.6455 +							elem[ internalKey ] = null;
  2.6456 +						}
  2.6457 +
  2.6458 +						jQuery.deletedIds.push( id );
  2.6459 +					}
  2.6460 +				}
  2.6461 +			}
  2.6462 +		}
  2.6463 +	}
  2.6464 +});
  2.6465 +// Limit scope pollution from any deprecated API
  2.6466 +(function() {
  2.6467 +
  2.6468 +var matched, browser;
  2.6469 +
  2.6470 +// Use of jQuery.browser is frowned upon.
  2.6471 +// More details: http://api.jquery.com/jQuery.browser
  2.6472 +// jQuery.uaMatch maintained for back-compat
  2.6473 +jQuery.uaMatch = function( ua ) {
  2.6474 +	ua = ua.toLowerCase();
  2.6475 +
  2.6476 +	var match = /(chrome)[ \/]([\w.]+)/.exec( ua ) ||
  2.6477 +		/(webkit)[ \/]([\w.]+)/.exec( ua ) ||
  2.6478 +		/(opera)(?:.*version|)[ \/]([\w.]+)/.exec( ua ) ||
  2.6479 +		/(msie) ([\w.]+)/.exec( ua ) ||
  2.6480 +		ua.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec( ua ) ||
  2.6481 +		[];
  2.6482 +
  2.6483 +	return {
  2.6484 +		browser: match[ 1 ] || "",
  2.6485 +		version: match[ 2 ] || "0"
  2.6486 +	};
  2.6487 +};
  2.6488 +
  2.6489 +matched = jQuery.uaMatch( navigator.userAgent );
  2.6490 +browser = {};
  2.6491 +
  2.6492 +if ( matched.browser ) {
  2.6493 +	browser[ matched.browser ] = true;
  2.6494 +	browser.version = matched.version;
  2.6495 +}
  2.6496 +
  2.6497 +// Chrome is Webkit, but Webkit is also Safari.
  2.6498 +if ( browser.chrome ) {
  2.6499 +	browser.webkit = true;
  2.6500 +} else if ( browser.webkit ) {
  2.6501 +	browser.safari = true;
  2.6502 +}
  2.6503 +
  2.6504 +jQuery.browser = browser;
  2.6505 +
  2.6506 +jQuery.sub = function() {
  2.6507 +	function jQuerySub( selector, context ) {
  2.6508 +		return new jQuerySub.fn.init( selector, context );
  2.6509 +	}
  2.6510 +	jQuery.extend( true, jQuerySub, this );
  2.6511 +	jQuerySub.superclass = this;
  2.6512 +	jQuerySub.fn = jQuerySub.prototype = this();
  2.6513 +	jQuerySub.fn.constructor = jQuerySub;
  2.6514 +	jQuerySub.sub = this.sub;
  2.6515 +	jQuerySub.fn.init = function init( selector, context ) {
  2.6516 +		if ( context && context instanceof jQuery && !(context instanceof jQuerySub) ) {
  2.6517 +			context = jQuerySub( context );
  2.6518 +		}
  2.6519 +
  2.6520 +		return jQuery.fn.init.call( this, selector, context, rootjQuerySub );
  2.6521 +	};
  2.6522 +	jQuerySub.fn.init.prototype = jQuerySub.fn;
  2.6523 +	var rootjQuerySub = jQuerySub(document);
  2.6524 +	return jQuerySub;
  2.6525 +};
  2.6526 +
  2.6527 +})();
  2.6528 +var curCSS, iframe, iframeDoc,
  2.6529 +	ralpha = /alpha\([^)]*\)/i,
  2.6530 +	ropacity = /opacity=([^)]*)/,
  2.6531 +	rposition = /^(top|right|bottom|left)$/,
  2.6532 +	// swappable if display is none or starts with table except "table", "table-cell", or "table-caption"
  2.6533 +	// see here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
  2.6534 +	rdisplayswap = /^(none|table(?!-c[ea]).+)/,
  2.6535 +	rmargin = /^margin/,
  2.6536 +	rnumsplit = new RegExp( "^(" + core_pnum + ")(.*)$", "i" ),
  2.6537 +	rnumnonpx = new RegExp( "^(" + core_pnum + ")(?!px)[a-z%]+$", "i" ),
  2.6538 +	rrelNum = new RegExp( "^([-+])=(" + core_pnum + ")", "i" ),
  2.6539 +	elemdisplay = {},
  2.6540 +
  2.6541 +	cssShow = { position: "absolute", visibility: "hidden", display: "block" },
  2.6542 +	cssNormalTransform = {
  2.6543 +		letterSpacing: 0,
  2.6544 +		fontWeight: 400
  2.6545 +	},
  2.6546 +
  2.6547 +	cssExpand = [ "Top", "Right", "Bottom", "Left" ],
  2.6548 +	cssPrefixes = [ "Webkit", "O", "Moz", "ms" ],
  2.6549 +
  2.6550 +	eventsToggle = jQuery.fn.toggle;
  2.6551 +
  2.6552 +// return a css property mapped to a potentially vendor prefixed property
  2.6553 +function vendorPropName( style, name ) {
  2.6554 +
  2.6555 +	// shortcut for names that are not vendor prefixed
  2.6556 +	if ( name in style ) {
  2.6557 +		return name;
  2.6558 +	}
  2.6559 +
  2.6560 +	// check for vendor prefixed names
  2.6561 +	var capName = name.charAt(0).toUpperCase() + name.slice(1),
  2.6562 +		origName = name,
  2.6563 +		i = cssPrefixes.length;
  2.6564 +
  2.6565 +	while ( i-- ) {
  2.6566 +		name = cssPrefixes[ i ] + capName;
  2.6567 +		if ( name in style ) {
  2.6568 +			return name;
  2.6569 +		}
  2.6570 +	}
  2.6571 +
  2.6572 +	return origName;
  2.6573 +}
  2.6574 +
  2.6575 +function isHidden( elem, el ) {
  2.6576 +	elem = el || elem;
  2.6577 +	return jQuery.css( elem, "display" ) === "none" || !jQuery.contains( elem.ownerDocument, elem );
  2.6578 +}
  2.6579 +
  2.6580 +function showHide( elements, show ) {
  2.6581 +	var elem, display,
  2.6582 +		values = [],
  2.6583 +		index = 0,
  2.6584 +		length = elements.length;
  2.6585 +
  2.6586 +	for ( ; index < length; index++ ) {
  2.6587 +		elem = elements[ index ];
  2.6588 +		if ( !elem.style ) {
  2.6589 +			continue;
  2.6590 +		}
  2.6591 +		values[ index ] = jQuery._data( elem, "olddisplay" );
  2.6592 +		if ( show ) {
  2.6593 +			// Reset the inline display of this element to learn if it is
  2.6594 +			// being hidden by cascaded rules or not
  2.6595 +			if ( !values[ index ] && elem.style.display === "none" ) {
  2.6596 +				elem.style.display = "";
  2.6597 +			}
  2.6598 +
  2.6599 +			// Set elements which have been overridden with display: none
  2.6600 +			// in a stylesheet to whatever the default browser style is
  2.6601 +			// for such an element
  2.6602 +			if ( elem.style.display === "" && isHidden( elem ) ) {
  2.6603 +				values[ index ] = jQuery._data( elem, "olddisplay", css_defaultDisplay(elem.nodeName) );
  2.6604 +			}
  2.6605 +		} else {
  2.6606 +			display = curCSS( elem, "display" );
  2.6607 +
  2.6608 +			if ( !values[ index ] && display !== "none" ) {
  2.6609 +				jQuery._data( elem, "olddisplay", display );
  2.6610 +			}
  2.6611 +		}
  2.6612 +	}
  2.6613 +
  2.6614 +	// Set the display of most of the elements in a second loop
  2.6615 +	// to avoid the constant reflow
  2.6616 +	for ( index = 0; index < length; index++ ) {
  2.6617 +		elem = elements[ index ];
  2.6618 +		if ( !elem.style ) {
  2.6619 +			continue;
  2.6620 +		}
  2.6621 +		if ( !show || elem.style.display === "none" || elem.style.display === "" ) {
  2.6622 +			elem.style.display = show ? values[ index ] || "" : "none";
  2.6623 +		}
  2.6624 +	}
  2.6625 +
  2.6626 +	return elements;
  2.6627 +}
  2.6628 +
  2.6629 +jQuery.fn.extend({
  2.6630 +	css: function( name, value ) {
  2.6631 +		return jQuery.access( this, function( elem, name, value ) {
  2.6632 +			return value !== undefined ?
  2.6633 +				jQuery.style( elem, name, value ) :
  2.6634 +				jQuery.css( elem, name );
  2.6635 +		}, name, value, arguments.length > 1 );
  2.6636 +	},
  2.6637 +	show: function() {
  2.6638 +		return showHide( this, true );
  2.6639 +	},
  2.6640 +	hide: function() {
  2.6641 +		return showHide( this );
  2.6642 +	},
  2.6643 +	toggle: function( state, fn2 ) {
  2.6644 +		var bool = typeof state === "boolean";
  2.6645 +
  2.6646 +		if ( jQuery.isFunction( state ) && jQuery.isFunction( fn2 ) ) {
  2.6647 +			return eventsToggle.apply( this, arguments );
  2.6648 +		}
  2.6649 +
  2.6650 +		return this.each(function() {
  2.6651 +			if ( bool ? state : isHidden( this ) ) {
  2.6652 +				jQuery( this ).show();
  2.6653 +			} else {
  2.6654 +				jQuery( this ).hide();
  2.6655 +			}
  2.6656 +		});
  2.6657 +	}
  2.6658 +});
  2.6659 +
  2.6660 +jQuery.extend({
  2.6661 +	// Add in style property hooks for overriding the default
  2.6662 +	// behavior of getting and setting a style property
  2.6663 +	cssHooks: {
  2.6664 +		opacity: {
  2.6665 +			get: function( elem, computed ) {
  2.6666 +				if ( computed ) {
  2.6667 +					// We should always get a number back from opacity
  2.6668 +					var ret = curCSS( elem, "opacity" );
  2.6669 +					return ret === "" ? "1" : ret;
  2.6670 +
  2.6671 +				}
  2.6672 +			}
  2.6673 +		}
  2.6674 +	},
  2.6675 +
  2.6676 +	// Exclude the following css properties to add px
  2.6677 +	cssNumber: {
  2.6678 +		"fillOpacity": true,
  2.6679 +		"fontWeight": true,
  2.6680 +		"lineHeight": true,
  2.6681 +		"opacity": true,
  2.6682 +		"orphans": true,
  2.6683 +		"widows": true,
  2.6684 +		"zIndex": true,
  2.6685 +		"zoom": true
  2.6686 +	},
  2.6687 +
  2.6688 +	// Add in properties whose names you wish to fix before
  2.6689 +	// setting or getting the value
  2.6690 +	cssProps: {
  2.6691 +		// normalize float css property
  2.6692 +		"float": jQuery.support.cssFloat ? "cssFloat" : "styleFloat"
  2.6693 +	},
  2.6694 +
  2.6695 +	// Get and set the style property on a DOM Node
  2.6696 +	style: function( elem, name, value, extra ) {
  2.6697 +		// Don't set styles on text and comment nodes
  2.6698 +		if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
  2.6699 +			return;
  2.6700 +		}
  2.6701 +
  2.6702 +		// Make sure that we're working with the right name
  2.6703 +		var ret, type, hooks,
  2.6704 +			origName = jQuery.camelCase( name ),
  2.6705 +			style = elem.style;
  2.6706 +
  2.6707 +		name = jQuery.cssProps[ origName ] || ( jQuery.cssProps[ origName ] = vendorPropName( style, origName ) );
  2.6708 +
  2.6709 +		// gets hook for the prefixed version
  2.6710 +		// followed by the unprefixed version
  2.6711 +		hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
  2.6712 +
  2.6713 +		// Check if we're setting a value
  2.6714 +		if ( value !== undefined ) {
  2.6715 +			type = typeof value;
  2.6716 +
  2.6717 +			// convert relative number strings (+= or -=) to relative numbers. #7345
  2.6718 +			if ( type === "string" && (ret = rrelNum.exec( value )) ) {
  2.6719 +				value = ( ret[1] + 1 ) * ret[2] + parseFloat( jQuery.css( elem, name ) );
  2.6720 +				// Fixes bug #9237
  2.6721 +				type = "number";
  2.6722 +			}
  2.6723 +
  2.6724 +			// Make sure that NaN and null values aren't set. See: #7116
  2.6725 +			if ( value == null || type === "number" && isNaN( value ) ) {
  2.6726 +				return;
  2.6727 +			}
  2.6728 +
  2.6729 +			// If a number was passed in, add 'px' to the (except for certain CSS properties)
  2.6730 +			if ( type === "number" && !jQuery.cssNumber[ origName ] ) {
  2.6731 +				value += "px";
  2.6732 +			}
  2.6733 +
  2.6734 +			// If a hook was provided, use that value, otherwise just set the specified value
  2.6735 +			if ( !hooks || !("set" in hooks) || (value = hooks.set( elem, value, extra )) !== undefined ) {
  2.6736 +				// Wrapped to prevent IE from throwing errors when 'invalid' values are provided
  2.6737 +				// Fixes bug #5509
  2.6738 +				try {
  2.6739 +					style[ name ] = value;
  2.6740 +				} catch(e) {}
  2.6741 +			}
  2.6742 +
  2.6743 +		} else {
  2.6744 +			// If a hook was provided get the non-computed value from there
  2.6745 +			if ( hooks && "get" in hooks && (ret = hooks.get( elem, false, extra )) !== undefined ) {
  2.6746 +				return ret;
  2.6747 +			}
  2.6748 +
  2.6749 +			// Otherwise just get the value from the style object
  2.6750 +			return style[ name ];
  2.6751 +		}
  2.6752 +	},
  2.6753 +
  2.6754 +	css: function( elem, name, numeric, extra ) {
  2.6755 +		var val, num, hooks,
  2.6756 +			origName = jQuery.camelCase( name );
  2.6757 +
  2.6758 +		// Make sure that we're working with the right name
  2.6759 +		name = jQuery.cssProps[ origName ] || ( jQuery.cssProps[ origName ] = vendorPropName( elem.style, origName ) );
  2.6760 +
  2.6761 +		// gets hook for the prefixed version
  2.6762 +		// followed by the unprefixed version
  2.6763 +		hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
  2.6764 +
  2.6765 +		// If a hook was provided get the computed value from there
  2.6766 +		if ( hooks && "get" in hooks ) {
  2.6767 +			val = hooks.get( elem, true, extra );
  2.6768 +		}
  2.6769 +
  2.6770 +		// Otherwise, if a way to get the computed value exists, use that
  2.6771 +		if ( val === undefined ) {
  2.6772 +			val = curCSS( elem, name );
  2.6773 +		}
  2.6774 +
  2.6775 +		//convert "normal" to computed value
  2.6776 +		if ( val === "normal" && name in cssNormalTransform ) {
  2.6777 +			val = cssNormalTransform[ name ];
  2.6778 +		}
  2.6779 +
  2.6780 +		// Return, converting to number if forced or a qualifier was provided and val looks numeric
  2.6781 +		if ( numeric || extra !== undefined ) {
  2.6782 +			num = parseFloat( val );
  2.6783 +			return numeric || jQuery.isNumeric( num ) ? num || 0 : val;
  2.6784 +		}
  2.6785 +		return val;
  2.6786 +	},
  2.6787 +
  2.6788 +	// A method for quickly swapping in/out CSS properties to get correct calculations
  2.6789 +	swap: function( elem, options, callback ) {
  2.6790 +		var ret, name,
  2.6791 +			old = {};
  2.6792 +
  2.6793 +		// Remember the old values, and insert the new ones
  2.6794 +		for ( name in options ) {
  2.6795 +			old[ name ] = elem.style[ name ];
  2.6796 +			elem.style[ name ] = options[ name ];
  2.6797 +		}
  2.6798 +
  2.6799 +		ret = callback.call( elem );
  2.6800 +
  2.6801 +		// Revert the old values
  2.6802 +		for ( name in options ) {
  2.6803 +			elem.style[ name ] = old[ name ];
  2.6804 +		}
  2.6805 +
  2.6806 +		return ret;
  2.6807 +	}
  2.6808 +});
  2.6809 +
  2.6810 +// NOTE: To any future maintainer, we've window.getComputedStyle
  2.6811 +// because jsdom on node.js will break without it.
  2.6812 +if ( window.getComputedStyle ) {
  2.6813 +	curCSS = function( elem, name ) {
  2.6814 +		var ret, width, minWidth, maxWidth,
  2.6815 +			computed = window.getComputedStyle( elem, null ),
  2.6816 +			style = elem.style;
  2.6817 +
  2.6818 +		if ( computed ) {
  2.6819 +
  2.6820 +			ret = computed[ name ];
  2.6821 +			if ( ret === "" && !jQuery.contains( elem.ownerDocument, elem ) ) {
  2.6822 +				ret = jQuery.style( elem, name );
  2.6823 +			}
  2.6824 +
  2.6825 +			// A tribute to the "awesome hack by Dean Edwards"
  2.6826 +			// Chrome < 17 and Safari 5.0 uses "computed value" instead of "used value" for margin-right
  2.6827 +			// Safari 5.1.7 (at least) returns percentage for a larger set of values, but width seems to be reliably pixels
  2.6828 +			// this is against the CSSOM draft spec: http://dev.w3.org/csswg/cssom/#resolved-values
  2.6829 +			if ( rnumnonpx.test( ret ) && rmargin.test( name ) ) {
  2.6830 +				width = style.width;
  2.6831 +				minWidth = style.minWidth;
  2.6832 +				maxWidth = style.maxWidth;
  2.6833 +
  2.6834 +				style.minWidth = style.maxWidth = style.width = ret;
  2.6835 +				ret = computed.width;
  2.6836 +
  2.6837 +				style.width = width;
  2.6838 +				style.minWidth = minWidth;
  2.6839 +				style.maxWidth = maxWidth;
  2.6840 +			}
  2.6841 +		}
  2.6842 +
  2.6843 +		return ret;
  2.6844 +	};
  2.6845 +} else if ( document.documentElement.currentStyle ) {
  2.6846 +	curCSS = function( elem, name ) {
  2.6847 +		var left, rsLeft,
  2.6848 +			ret = elem.currentStyle && elem.currentStyle[ name ],
  2.6849 +			style = elem.style;
  2.6850 +
  2.6851 +		// Avoid setting ret to empty string here
  2.6852 +		// so we don't default to auto
  2.6853 +		if ( ret == null && style && style[ name ] ) {
  2.6854 +			ret = style[ name ];
  2.6855 +		}
  2.6856 +
  2.6857 +		// From the awesome hack by Dean Edwards
  2.6858 +		// http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
  2.6859 +
  2.6860 +		// If we're not dealing with a regular pixel number
  2.6861 +		// but a number that has a weird ending, we need to convert it to pixels
  2.6862 +		// but not position css attributes, as those are proportional to the parent element instead
  2.6863 +		// and we can't measure the parent instead because it might trigger a "stacking dolls" problem
  2.6864 +		if ( rnumnonpx.test( ret ) && !rposition.test( name ) ) {
  2.6865 +
  2.6866 +			// Remember the original values
  2.6867 +			left = style.left;
  2.6868 +			rsLeft = elem.runtimeStyle && elem.runtimeStyle.left;
  2.6869 +
  2.6870 +			// Put in the new values to get a computed value out
  2.6871 +			if ( rsLeft ) {
  2.6872 +				elem.runtimeStyle.left = elem.currentStyle.left;
  2.6873 +			}
  2.6874 +			style.left = name === "fontSize" ? "1em" : ret;
  2.6875 +			ret = style.pixelLeft + "px";
  2.6876 +
  2.6877 +			// Revert the changed values
  2.6878 +			style.left = left;
  2.6879 +			if ( rsLeft ) {
  2.6880 +				elem.runtimeStyle.left = rsLeft;
  2.6881 +			}
  2.6882 +		}
  2.6883 +
  2.6884 +		return ret === "" ? "auto" : ret;
  2.6885 +	};
  2.6886 +}
  2.6887 +
  2.6888 +function setPositiveNumber( elem, value, subtract ) {
  2.6889 +	var matches = rnumsplit.exec( value );
  2.6890 +	return matches ?
  2.6891 +			Math.max( 0, matches[ 1 ] - ( subtract || 0 ) ) + ( matches[ 2 ] || "px" ) :
  2.6892 +			value;
  2.6893 +}
  2.6894 +
  2.6895 +function augmentWidthOrHeight( elem, name, extra, isBorderBox ) {
  2.6896 +	var i = extra === ( isBorderBox ? "border" : "content" ) ?
  2.6897 +		// If we already have the right measurement, avoid augmentation
  2.6898 +		4 :
  2.6899 +		// Otherwise initialize for horizontal or vertical properties
  2.6900 +		name === "width" ? 1 : 0,
  2.6901 +
  2.6902 +		val = 0;
  2.6903 +
  2.6904 +	for ( ; i < 4; i += 2 ) {
  2.6905 +		// both box models exclude margin, so add it if we want it
  2.6906 +		if ( extra === "margin" ) {
  2.6907 +			// we use jQuery.css instead of curCSS here
  2.6908 +			// because of the reliableMarginRight CSS hook!
  2.6909 +			val += jQuery.css( elem, extra + cssExpand[ i ], true );
  2.6910 +		}
  2.6911 +
  2.6912 +		// From this point on we use curCSS for maximum performance (relevant in animations)
  2.6913 +		if ( isBorderBox ) {
  2.6914 +			// border-box includes padding, so remove it if we want content
  2.6915 +			if ( extra === "content" ) {
  2.6916 +				val -= parseFloat( curCSS( elem, "padding" + cssExpand[ i ] ) ) || 0;
  2.6917 +			}
  2.6918 +
  2.6919 +			// at this point, extra isn't border nor margin, so remove border
  2.6920 +			if ( extra !== "margin" ) {
  2.6921 +				val -= parseFloat( curCSS( elem, "border" + cssExpand[ i ] + "Width" ) ) || 0;
  2.6922 +			}
  2.6923 +		} else {
  2.6924 +			// at this point, extra isn't content, so add padding
  2.6925 +			val += parseFloat( curCSS( elem, "padding" + cssExpand[ i ] ) ) || 0;
  2.6926 +
  2.6927 +			// at this point, extra isn't content nor padding, so add border
  2.6928 +			if ( extra !== "padding" ) {
  2.6929 +				val += parseFloat( curCSS( elem, "border" + cssExpand[ i ] + "Width" ) ) || 0;
  2.6930 +			}
  2.6931 +		}
  2.6932 +	}
  2.6933 +
  2.6934 +	return val;
  2.6935 +}
  2.6936 +
  2.6937 +function getWidthOrHeight( elem, name, extra ) {
  2.6938 +
  2.6939 +	// Start with offset property, which is equivalent to the border-box value
  2.6940 +	var val = name === "width" ? elem.offsetWidth : elem.offsetHeight,
  2.6941 +		valueIsBorderBox = true,
  2.6942 +		isBorderBox = jQuery.support.boxSizing && jQuery.css( elem, "boxSizing" ) === "border-box";
  2.6943 +
  2.6944 +	// some non-html elements return undefined for offsetWidth, so check for null/undefined
  2.6945 +	// svg - https://bugzilla.mozilla.org/show_bug.cgi?id=649285
  2.6946 +	// MathML - https://bugzilla.mozilla.org/show_bug.cgi?id=491668
  2.6947 +	if ( val <= 0 || val == null ) {
  2.6948 +		// Fall back to computed then uncomputed css if necessary
  2.6949 +		val = curCSS( elem, name );
  2.6950 +		if ( val < 0 || val == null ) {
  2.6951 +			val = elem.style[ name ];
  2.6952 +		}
  2.6953 +
  2.6954 +		// Computed unit is not pixels. Stop here and return.
  2.6955 +		if ( rnumnonpx.test(val) ) {
  2.6956 +			return val;
  2.6957 +		}
  2.6958 +
  2.6959 +		// we need the check for style in case a browser which returns unreliable values
  2.6960 +		// for getComputedStyle silently falls back to the reliable elem.style
  2.6961 +		valueIsBorderBox = isBorderBox && ( jQuery.support.boxSizingReliable || val === elem.style[ name ] );
  2.6962 +
  2.6963 +		// Normalize "", auto, and prepare for extra
  2.6964 +		val = parseFloat( val ) || 0;
  2.6965 +	}
  2.6966 +
  2.6967 +	// use the active box-sizing model to add/subtract irrelevant styles
  2.6968 +	return ( val +
  2.6969 +		augmentWidthOrHeight(
  2.6970 +			elem,
  2.6971 +			name,
  2.6972 +			extra || ( isBorderBox ? "border" : "content" ),
  2.6973 +			valueIsBorderBox
  2.6974 +		)
  2.6975 +	) + "px";
  2.6976 +}
  2.6977 +
  2.6978 +
  2.6979 +// Try to determine the default display value of an element
  2.6980 +function css_defaultDisplay( nodeName ) {
  2.6981 +	if ( elemdisplay[ nodeName ] ) {
  2.6982 +		return elemdisplay[ nodeName ];
  2.6983 +	}
  2.6984 +
  2.6985 +	var elem = jQuery( "<" + nodeName + ">" ).appendTo( document.body ),
  2.6986 +		display = elem.css("display");
  2.6987 +	elem.remove();
  2.6988 +
  2.6989 +	// If the simple way fails,
  2.6990 +	// get element's real default display by attaching it to a temp iframe
  2.6991 +	if ( display === "none" || display === "" ) {
  2.6992 +		// Use the already-created iframe if possible
  2.6993 +		iframe = document.body.appendChild(
  2.6994 +			iframe || jQuery.extend( document.createElement("iframe"), {
  2.6995 +				frameBorder: 0,
  2.6996 +				width: 0,
  2.6997 +				height: 0
  2.6998 +			})
  2.6999 +		);
  2.7000 +
  2.7001 +		// Create a cacheable copy of the iframe document on first call.
  2.7002 +		// IE and Opera will allow us to reuse the iframeDoc without re-writing the fake HTML
  2.7003 +		// document to it; WebKit & Firefox won't allow reusing the iframe document.
  2.7004 +		if ( !iframeDoc || !iframe.createElement ) {
  2.7005 +			iframeDoc = ( iframe.contentWindow || iframe.contentDocument ).document;
  2.7006 +			iframeDoc.write("<!doctype html><html><body>");
  2.7007 +			iframeDoc.close();
  2.7008 +		}
  2.7009 +
  2.7010 +		elem = iframeDoc.body.appendChild( iframeDoc.createElement(nodeName) );
  2.7011 +
  2.7012 +		display = curCSS( elem, "display" );
  2.7013 +		document.body.removeChild( iframe );
  2.7014 +	}
  2.7015 +
  2.7016 +	// Store the correct default display
  2.7017 +	elemdisplay[ nodeName ] = display;
  2.7018 +
  2.7019 +	return display;
  2.7020 +}
  2.7021 +
  2.7022 +jQuery.each([ "height", "width" ], function( i, name ) {
  2.7023 +	jQuery.cssHooks[ name ] = {
  2.7024 +		get: function( elem, computed, extra ) {
  2.7025 +			if ( computed ) {
  2.7026 +				// certain elements can have dimension info if we invisibly show them
  2.7027 +				// however, it must have a current display style that would benefit from this
  2.7028 +				if ( elem.offsetWidth === 0 && rdisplayswap.test( curCSS( elem, "display" ) ) ) {
  2.7029 +					return jQuery.swap( elem, cssShow, function() {
  2.7030 +						return getWidthOrHeight( elem, name, extra );
  2.7031 +					});
  2.7032 +				} else {
  2.7033 +					return getWidthOrHeight( elem, name, extra );
  2.7034 +				}
  2.7035 +			}
  2.7036 +		},
  2.7037 +
  2.7038 +		set: function( elem, value, extra ) {
  2.7039 +			return setPositiveNumber( elem, value, extra ?
  2.7040 +				augmentWidthOrHeight(
  2.7041 +					elem,
  2.7042 +					name,
  2.7043 +					extra,
  2.7044 +					jQuery.support.boxSizing && jQuery.css( elem, "boxSizing" ) === "border-box"
  2.7045 +				) : 0
  2.7046 +			);
  2.7047 +		}
  2.7048 +	};
  2.7049 +});
  2.7050 +
  2.7051 +if ( !jQuery.support.opacity ) {
  2.7052 +	jQuery.cssHooks.opacity = {
  2.7053 +		get: function( elem, computed ) {
  2.7054 +			// IE uses filters for opacity
  2.7055 +			return ropacity.test( (computed && elem.currentStyle ? elem.currentStyle.filter : elem.style.filter) || "" ) ?
  2.7056 +				( 0.01 * parseFloat( RegExp.$1 ) ) + "" :
  2.7057 +				computed ? "1" : "";
  2.7058 +		},
  2.7059 +
  2.7060 +		set: function( elem, value ) {
  2.7061 +			var style = elem.style,
  2.7062 +				currentStyle = elem.currentStyle,
  2.7063 +				opacity = jQuery.isNumeric( value ) ? "alpha(opacity=" + value * 100 + ")" : "",
  2.7064 +				filter = currentStyle && currentStyle.filter || style.filter || "";
  2.7065 +
  2.7066 +			// IE has trouble with opacity if it does not have layout
  2.7067 +			// Force it by setting the zoom level
  2.7068 +			style.zoom = 1;
  2.7069 +
  2.7070 +			// if setting opacity to 1, and no other filters exist - attempt to remove filter attribute #6652
  2.7071 +			if ( value >= 1 && jQuery.trim( filter.replace( ralpha, "" ) ) === "" &&
  2.7072 +				style.removeAttribute ) {
  2.7073 +
  2.7074 +				// Setting style.filter to null, "" & " " still leave "filter:" in the cssText
  2.7075 +				// if "filter:" is present at all, clearType is disabled, we want to avoid this
  2.7076 +				// style.removeAttribute is IE Only, but so apparently is this code path...
  2.7077 +				style.removeAttribute( "filter" );
  2.7078 +
  2.7079 +				// if there there is no filter style applied in a css rule, we are done
  2.7080 +				if ( currentStyle && !currentStyle.filter ) {
  2.7081 +					return;
  2.7082 +				}
  2.7083 +			}
  2.7084 +
  2.7085 +			// otherwise, set new filter values
  2.7086 +			style.filter = ralpha.test( filter ) ?
  2.7087 +				filter.replace( ralpha, opacity ) :
  2.7088 +				filter + " " + opacity;
  2.7089 +		}
  2.7090 +	};
  2.7091 +}
  2.7092 +
  2.7093 +// These hooks cannot be added until DOM ready because the support test
  2.7094 +// for it is not run until after DOM ready
  2.7095 +jQuery(function() {
  2.7096 +	if ( !jQuery.support.reliableMarginRight ) {
  2.7097 +		jQuery.cssHooks.marginRight = {
  2.7098 +			get: function( elem, computed ) {
  2.7099 +				// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
  2.7100 +				// Work around by temporarily setting element display to inline-block
  2.7101 +				return jQuery.swap( elem, { "display": "inline-block" }, function() {
  2.7102 +					if ( computed ) {
  2.7103 +						return curCSS( elem, "marginRight" );
  2.7104 +					}
  2.7105 +				});
  2.7106 +			}
  2.7107 +		};
  2.7108 +	}
  2.7109 +
  2.7110 +	// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084
  2.7111 +	// getComputedStyle returns percent when specified for top/left/bottom/right
  2.7112 +	// rather than make the css module depend on the offset module, we just check for it here
  2.7113 +	if ( !jQuery.support.pixelPosition && jQuery.fn.position ) {
  2.7114 +		jQuery.each( [ "top", "left" ], function( i, prop ) {
  2.7115 +			jQuery.cssHooks[ prop ] = {
  2.7116 +				get: function( elem, computed ) {
  2.7117 +					if ( computed ) {
  2.7118 +						var ret = curCSS( elem, prop );
  2.7119 +						// if curCSS returns percentage, fallback to offset
  2.7120 +						return rnumnonpx.test( ret ) ? jQuery( elem ).position()[ prop ] + "px" : ret;
  2.7121 +					}
  2.7122 +				}
  2.7123 +			};
  2.7124 +		});
  2.7125 +	}
  2.7126 +
  2.7127 +});
  2.7128 +
  2.7129 +if ( jQuery.expr && jQuery.expr.filters ) {
  2.7130 +	jQuery.expr.filters.hidden = function( elem ) {
  2.7131 +		return ( elem.offsetWidth === 0 && elem.offsetHeight === 0 ) || (!jQuery.support.reliableHiddenOffsets && ((elem.style && elem.style.display) || curCSS( elem, "display" )) === "none");
  2.7132 +	};
  2.7133 +
  2.7134 +	jQuery.expr.filters.visible = function( elem ) {
  2.7135 +		return !jQuery.expr.filters.hidden( elem );
  2.7136 +	};
  2.7137 +}
  2.7138 +
  2.7139 +// These hooks are used by animate to expand properties
  2.7140 +jQuery.each({
  2.7141 +	margin: "",
  2.7142 +	padding: "",
  2.7143 +	border: "Width"
  2.7144 +}, function( prefix, suffix ) {
  2.7145 +	jQuery.cssHooks[ prefix + suffix ] = {
  2.7146 +		expand: function( value ) {
  2.7147 +			var i,
  2.7148 +
  2.7149 +				// assumes a single number if not a string
  2.7150 +				parts = typeof value === "string" ? value.split(" ") : [ value ],
  2.7151 +				expanded = {};
  2.7152 +
  2.7153 +			for ( i = 0; i < 4; i++ ) {
  2.7154 +				expanded[ prefix + cssExpand[ i ] + suffix ] =
  2.7155 +					parts[ i ] || parts[ i - 2 ] || parts[ 0 ];
  2.7156 +			}
  2.7157 +
  2.7158 +			return expanded;
  2.7159 +		}
  2.7160 +	};
  2.7161 +
  2.7162 +	if ( !rmargin.test( prefix ) ) {
  2.7163 +		jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;
  2.7164 +	}
  2.7165 +});
  2.7166 +var r20 = /%20/g,
  2.7167 +	rbracket = /\[\]$/,
  2.7168 +	rCRLF = /\r?\n/g,
  2.7169 +	rinput = /^(?:color|date|datetime|datetime-local|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i,
  2.7170 +	rselectTextarea = /^(?:select|textarea)/i;
  2.7171 +
  2.7172 +jQuery.fn.extend({
  2.7173 +	serialize: function() {
  2.7174 +		return jQuery.param( this.serializeArray() );
  2.7175 +	},
  2.7176 +	serializeArray: function() {
  2.7177 +		return this.map(function(){
  2.7178 +			return this.elements ? jQuery.makeArray( this.elements ) : this;
  2.7179 +		})
  2.7180 +		.filter(function(){
  2.7181 +			return this.name && !this.disabled &&
  2.7182 +				( this.checked || rselectTextarea.test( this.nodeName ) ||
  2.7183 +					rinput.test( this.type ) );
  2.7184 +		})
  2.7185 +		.map(function( i, elem ){
  2.7186 +			var val = jQuery( this ).val();
  2.7187 +
  2.7188 +			return val == null ?
  2.7189 +				null :
  2.7190 +				jQuery.isArray( val ) ?
  2.7191 +					jQuery.map( val, function( val, i ){
  2.7192 +						return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
  2.7193 +					}) :
  2.7194 +					{ name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
  2.7195 +		}).get();
  2.7196 +	}
  2.7197 +});
  2.7198 +
  2.7199 +//Serialize an array of form elements or a set of
  2.7200 +//key/values into a query string
  2.7201 +jQuery.param = function( a, traditional ) {
  2.7202 +	var prefix,
  2.7203 +		s = [],
  2.7204 +		add = function( key, value ) {
  2.7205 +			// If value is a function, invoke it and return its value
  2.7206 +			value = jQuery.isFunction( value ) ? value() : ( value == null ? "" : value );
  2.7207 +			s[ s.length ] = encodeURIComponent( key ) + "=" + encodeURIComponent( value );
  2.7208 +		};
  2.7209 +
  2.7210 +	// Set traditional to true for jQuery <= 1.3.2 behavior.
  2.7211 +	if ( traditional === undefined ) {
  2.7212 +		traditional = jQuery.ajaxSettings && jQuery.ajaxSettings.traditional;
  2.7213 +	}
  2.7214 +
  2.7215 +	// If an array was passed in, assume that it is an array of form elements.
  2.7216 +	if ( jQuery.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {
  2.7217 +		// Serialize the form elements
  2.7218 +		jQuery.each( a, function() {
  2.7219 +			add( this.name, this.value );
  2.7220 +		});
  2.7221 +
  2.7222 +	} else {
  2.7223 +		// If traditional, encode the "old" way (the way 1.3.2 or older
  2.7224 +		// did it), otherwise encode params recursively.
  2.7225 +		for ( prefix in a ) {
  2.7226 +			buildParams( prefix, a[ prefix ], traditional, add );
  2.7227 +		}
  2.7228 +	}
  2.7229 +
  2.7230 +	// Return the resulting serialization
  2.7231 +	return s.join( "&" ).replace( r20, "+" );
  2.7232 +};
  2.7233 +
  2.7234 +function buildParams( prefix, obj, traditional, add ) {
  2.7235 +	var name;
  2.7236 +
  2.7237 +	if ( jQuery.isArray( obj ) ) {
  2.7238 +		// Serialize array item.
  2.7239 +		jQuery.each( obj, function( i, v ) {
  2.7240 +			if ( traditional || rbracket.test( prefix ) ) {
  2.7241 +				// Treat each array item as a scalar.
  2.7242 +				add( prefix, v );
  2.7243 +
  2.7244 +			} else {
  2.7245 +				// If array item is non-scalar (array or object), encode its
  2.7246 +				// numeric index to resolve deserialization ambiguity issues.
  2.7247 +				// Note that rack (as of 1.0.0) can't currently deserialize
  2.7248 +				// nested arrays properly, and attempting to do so may cause
  2.7249 +				// a server error. Possible fixes are to modify rack's
  2.7250 +				// deserialization algorithm or to provide an option or flag
  2.7251 +				// to force array serialization to be shallow.
  2.7252 +				buildParams( prefix + "[" + ( typeof v === "object" ? i : "" ) + "]", v, traditional, add );
  2.7253 +			}
  2.7254 +		});
  2.7255 +
  2.7256 +	} else if ( !traditional && jQuery.type( obj ) === "object" ) {
  2.7257 +		// Serialize object item.
  2.7258 +		for ( name in obj ) {
  2.7259 +			buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add );
  2.7260 +		}
  2.7261 +
  2.7262 +	} else {
  2.7263 +		// Serialize scalar item.
  2.7264 +		add( prefix, obj );
  2.7265 +	}
  2.7266 +}
  2.7267 +var
  2.7268 +	// Document location
  2.7269 +	ajaxLocParts,
  2.7270 +	ajaxLocation,
  2.7271 +
  2.7272 +	rhash = /#.*$/,
  2.7273 +	rheaders = /^(.*?):[ \t]*([^\r\n]*)\r?$/mg, // IE leaves an \r character at EOL
  2.7274 +	// #7653, #8125, #8152: local protocol detection
  2.7275 +	rlocalProtocol = /^(?:about|app|app\-storage|.+\-extension|file|res|widget):$/,
  2.7276 +	rnoContent = /^(?:GET|HEAD)$/,
  2.7277 +	rprotocol = /^\/\//,
  2.7278 +	rquery = /\?/,
  2.7279 +	rscript = /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,
  2.7280 +	rts = /([?&])_=[^&]*/,
  2.7281 +	rurl = /^([\w\+\.\-]+:)(?:\/\/([^\/?#:]*)(?::(\d+)|)|)/,
  2.7282 +
  2.7283 +	// Keep a copy of the old load method
  2.7284 +	_load = jQuery.fn.load,
  2.7285 +
  2.7286 +	/* Prefilters
  2.7287 +	 * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
  2.7288 +	 * 2) These are called:
  2.7289 +	 *    - BEFORE asking for a transport
  2.7290 +	 *    - AFTER param serialization (s.data is a string if s.processData is true)
  2.7291 +	 * 3) key is the dataType
  2.7292 +	 * 4) the catchall symbol "*" can be used
  2.7293 +	 * 5) execution will start with transport dataType and THEN continue down to "*" if needed
  2.7294 +	 */
  2.7295 +	prefilters = {},
  2.7296 +
  2.7297 +	/* Transports bindings
  2.7298 +	 * 1) key is the dataType
  2.7299 +	 * 2) the catchall symbol "*" can be used
  2.7300 +	 * 3) selection will start with transport dataType and THEN go to "*" if needed
  2.7301 +	 */
  2.7302 +	transports = {},
  2.7303 +
  2.7304 +	// Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
  2.7305 +	allTypes = ["*/"] + ["*"];
  2.7306 +
  2.7307 +// #8138, IE may throw an exception when accessing
  2.7308 +// a field from window.location if document.domain has been set
  2.7309 +try {
  2.7310 +	ajaxLocation = location.href;
  2.7311 +} catch( e ) {
  2.7312 +	// Use the href attribute of an A element
  2.7313 +	// since IE will modify it given document.location
  2.7314 +	ajaxLocation = document.createElement( "a" );
  2.7315 +	ajaxLocation.href = "";
  2.7316 +	ajaxLocation = ajaxLocation.href;
  2.7317 +}
  2.7318 +
  2.7319 +// Segment location into parts
  2.7320 +ajaxLocParts = rurl.exec( ajaxLocation.toLowerCase() ) || [];
  2.7321 +
  2.7322 +// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
  2.7323 +function addToPrefiltersOrTransports( structure ) {
  2.7324 +
  2.7325 +	// dataTypeExpression is optional and defaults to "*"
  2.7326 +	return function( dataTypeExpression, func ) {
  2.7327 +
  2.7328 +		if ( typeof dataTypeExpression !== "string" ) {
  2.7329 +			func = dataTypeExpression;
  2.7330 +			dataTypeExpression = "*";
  2.7331 +		}
  2.7332 +
  2.7333 +		var dataType, list, placeBefore,
  2.7334 +			dataTypes = dataTypeExpression.toLowerCase().split( core_rspace ),
  2.7335 +			i = 0,
  2.7336 +			length = dataTypes.length;
  2.7337 +
  2.7338 +		if ( jQuery.isFunction( func ) ) {
  2.7339 +			// For each dataType in the dataTypeExpression
  2.7340 +			for ( ; i < length; i++ ) {
  2.7341 +				dataType = dataTypes[ i ];
  2.7342 +				// We control if we're asked to add before
  2.7343 +				// any existing element
  2.7344 +				placeBefore = /^\+/.test( dataType );
  2.7345 +				if ( placeBefore ) {
  2.7346 +					dataType = dataType.substr( 1 ) || "*";
  2.7347 +				}
  2.7348 +				list = structure[ dataType ] = structure[ dataType ] || [];
  2.7349 +				// then we add to the structure accordingly
  2.7350 +				list[ placeBefore ? "unshift" : "push" ]( func );
  2.7351 +			}
  2.7352 +		}
  2.7353 +	};
  2.7354 +}
  2.7355 +
  2.7356 +// Base inspection function for prefilters and transports
  2.7357 +function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR,
  2.7358 +		dataType /* internal */, inspected /* internal */ ) {
  2.7359 +
  2.7360 +	dataType = dataType || options.dataTypes[ 0 ];
  2.7361 +	inspected = inspected || {};
  2.7362 +
  2.7363 +	inspected[ dataType ] = true;
  2.7364 +
  2.7365 +	var selection,
  2.7366 +		list = structure[ dataType ],
  2.7367 +		i = 0,
  2.7368 +		length = list ? list.length : 0,
  2.7369 +		executeOnly = ( structure === prefilters );
  2.7370 +
  2.7371 +	for ( ; i < length && ( executeOnly || !selection ); i++ ) {
  2.7372 +		selection = list[ i ]( options, originalOptions, jqXHR );
  2.7373 +		// If we got redirected to another dataType
  2.7374 +		// we try there if executing only and not done already
  2.7375 +		if ( typeof selection === "string" ) {
  2.7376 +			if ( !executeOnly || inspected[ selection ] ) {
  2.7377 +				selection = undefined;
  2.7378 +			} else {
  2.7379 +				options.dataTypes.unshift( selection );
  2.7380 +				selection = inspectPrefiltersOrTransports(
  2.7381 +						structure, options, originalOptions, jqXHR, selection, inspected );
  2.7382 +			}
  2.7383 +		}
  2.7384 +	}
  2.7385 +	// If we're only executing or nothing was selected
  2.7386 +	// we try the catchall dataType if not done already
  2.7387 +	if ( ( executeOnly || !selection ) && !inspected[ "*" ] ) {
  2.7388 +		selection = inspectPrefiltersOrTransports(
  2.7389 +				structure, options, originalOptions, jqXHR, "*", inspected );
  2.7390 +	}
  2.7391 +	// unnecessary when only executing (prefilters)
  2.7392 +	// but it'll be ignored by the caller in that case
  2.7393 +	return selection;
  2.7394 +}
  2.7395 +
  2.7396 +// A special extend for ajax options
  2.7397 +// that takes "flat" options (not to be deep extended)
  2.7398 +// Fixes #9887
  2.7399 +function ajaxExtend( target, src ) {
  2.7400 +	var key, deep,
  2.7401 +		flatOptions = jQuery.ajaxSettings.flatOptions || {};
  2.7402 +	for ( key in src ) {
  2.7403 +		if ( src[ key ] !== undefined ) {
  2.7404 +			( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];
  2.7405 +		}
  2.7406 +	}
  2.7407 +	if ( deep ) {
  2.7408 +		jQuery.extend( true, target, deep );
  2.7409 +	}
  2.7410 +}
  2.7411 +
  2.7412 +jQuery.fn.load = function( url, params, callback ) {
  2.7413 +	if ( typeof url !== "string" && _load ) {
  2.7414 +		return _load.apply( this, arguments );
  2.7415 +	}
  2.7416 +
  2.7417 +	// Don't do a request if no elements are being requested
  2.7418 +	if ( !this.length ) {
  2.7419 +		return this;
  2.7420 +	}
  2.7421 +
  2.7422 +	var selector, type, response,
  2.7423 +		self = this,
  2.7424 +		off = url.indexOf(" ");
  2.7425 +
  2.7426 +	if ( off >= 0 ) {
  2.7427 +		selector = url.slice( off, url.length );
  2.7428 +		url = url.slice( 0, off );
  2.7429 +	}
  2.7430 +
  2.7431 +	// If it's a function
  2.7432 +	if ( jQuery.isFunction( params ) ) {
  2.7433 +
  2.7434 +		// We assume that it's the callback
  2.7435 +		callback = params;
  2.7436 +		params = undefined;
  2.7437 +
  2.7438 +	// Otherwise, build a param string
  2.7439 +	} else if ( params && typeof params === "object" ) {
  2.7440 +		type = "POST";
  2.7441 +	}
  2.7442 +
  2.7443 +	// Request the remote document
  2.7444 +	jQuery.ajax({
  2.7445 +		url: url,
  2.7446 +
  2.7447 +		// if "type" variable is undefined, then "GET" method will be used
  2.7448 +		type: type,
  2.7449 +		dataType: "html",
  2.7450 +		data: params,
  2.7451 +		complete: function( jqXHR, status ) {
  2.7452 +			if ( callback ) {
  2.7453 +				self.each( callback, response || [ jqXHR.responseText, status, jqXHR ] );
  2.7454 +			}
  2.7455 +		}
  2.7456 +	}).done(function( responseText ) {
  2.7457 +
  2.7458 +		// Save response for use in complete callback
  2.7459 +		response = arguments;
  2.7460 +
  2.7461 +		// See if a selector was specified
  2.7462 +		self.html( selector ?
  2.7463 +
  2.7464 +			// Create a dummy div to hold the results
  2.7465 +			jQuery("<div>")
  2.7466 +
  2.7467 +				// inject the contents of the document in, removing the scripts
  2.7468 +				// to avoid any 'Permission Denied' errors in IE
  2.7469 +				.append( responseText.replace( rscript, "" ) )
  2.7470 +
  2.7471 +				// Locate the specified elements
  2.7472 +				.find( selector ) :
  2.7473 +
  2.7474 +			// If not, just inject the full result
  2.7475 +			responseText );
  2.7476 +
  2.7477 +	});
  2.7478 +
  2.7479 +	return this;
  2.7480 +};
  2.7481 +
  2.7482 +// Attach a bunch of functions for handling common AJAX events
  2.7483 +jQuery.each( "ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split( " " ), function( i, o ){
  2.7484 +	jQuery.fn[ o ] = function( f ){
  2.7485 +		return this.on( o, f );
  2.7486 +	};
  2.7487 +});
  2.7488 +
  2.7489 +jQuery.each( [ "get", "post" ], function( i, method ) {
  2.7490 +	jQuery[ method ] = function( url, data, callback, type ) {
  2.7491 +		// shift arguments if data argument was omitted
  2.7492 +		if ( jQuery.isFunction( data ) ) {
  2.7493 +			type = type || callback;
  2.7494 +			callback = data;
  2.7495 +			data = undefined;
  2.7496 +		}
  2.7497 +
  2.7498 +		return jQuery.ajax({
  2.7499 +			type: method,
  2.7500 +			url: url,
  2.7501 +			data: data,
  2.7502 +			success: callback,
  2.7503 +			dataType: type
  2.7504 +		});
  2.7505 +	};
  2.7506 +});
  2.7507 +
  2.7508 +jQuery.extend({
  2.7509 +
  2.7510 +	getScript: function( url, callback ) {
  2.7511 +		return jQuery.get( url, undefined, callback, "script" );
  2.7512 +	},
  2.7513 +
  2.7514 +	getJSON: function( url, data, callback ) {
  2.7515 +		return jQuery.get( url, data, callback, "json" );
  2.7516 +	},
  2.7517 +
  2.7518 +	// Creates a full fledged settings object into target
  2.7519 +	// with both ajaxSettings and settings fields.
  2.7520 +	// If target is omitted, writes into ajaxSettings.
  2.7521 +	ajaxSetup: function( target, settings ) {
  2.7522 +		if ( settings ) {
  2.7523 +			// Building a settings object
  2.7524 +			ajaxExtend( target, jQuery.ajaxSettings );
  2.7525 +		} else {
  2.7526 +			// Extending ajaxSettings
  2.7527 +			settings = target;
  2.7528 +			target = jQuery.ajaxSettings;
  2.7529 +		}
  2.7530 +		ajaxExtend( target, settings );
  2.7531 +		return target;
  2.7532 +	},
  2.7533 +
  2.7534 +	ajaxSettings: {
  2.7535 +		url: ajaxLocation,
  2.7536 +		isLocal: rlocalProtocol.test( ajaxLocParts[ 1 ] ),
  2.7537 +		global: true,
  2.7538 +		type: "GET",
  2.7539 +		contentType: "application/x-www-form-urlencoded; charset=UTF-8",
  2.7540 +		processData: true,
  2.7541 +		async: true,
  2.7542 +		/*
  2.7543 +		timeout: 0,
  2.7544 +		data: null,
  2.7545 +		dataType: null,
  2.7546 +		username: null,
  2.7547 +		password: null,
  2.7548 +		cache: null,
  2.7549 +		throws: false,
  2.7550 +		traditional: false,
  2.7551 +		headers: {},
  2.7552 +		*/
  2.7553 +
  2.7554 +		accepts: {
  2.7555 +			xml: "application/xml, text/xml",
  2.7556 +			html: "text/html",
  2.7557 +			text: "text/plain",
  2.7558 +			json: "application/json, text/javascript",
  2.7559 +			"*": allTypes
  2.7560 +		},
  2.7561 +
  2.7562 +		contents: {
  2.7563 +			xml: /xml/,
  2.7564 +			html: /html/,
  2.7565 +			json: /json/
  2.7566 +		},
  2.7567 +
  2.7568 +		responseFields: {
  2.7569 +			xml: "responseXML",
  2.7570 +			text: "responseText"
  2.7571 +		},
  2.7572 +
  2.7573 +		// List of data converters
  2.7574 +		// 1) key format is "source_type destination_type" (a single space in-between)
  2.7575 +		// 2) the catchall symbol "*" can be used for source_type
  2.7576 +		converters: {
  2.7577 +
  2.7578 +			// Convert anything to text
  2.7579 +			"* text": window.String,
  2.7580 +
  2.7581 +			// Text to html (true = no transformation)
  2.7582 +			"text html": true,
  2.7583 +
  2.7584 +			// Evaluate text as a json expression
  2.7585 +			"text json": jQuery.parseJSON,
  2.7586 +
  2.7587 +			// Parse text as xml
  2.7588 +			"text xml": jQuery.parseXML
  2.7589 +		},
  2.7590 +
  2.7591 +		// For options that shouldn't be deep extended:
  2.7592 +		// you can add your own custom options here if
  2.7593 +		// and when you create one that shouldn't be
  2.7594 +		// deep extended (see ajaxExtend)
  2.7595 +		flatOptions: {
  2.7596 +			context: true,
  2.7597 +			url: true
  2.7598 +		}
  2.7599 +	},
  2.7600 +
  2.7601 +	ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
  2.7602 +	ajaxTransport: addToPrefiltersOrTransports( transports ),
  2.7603 +
  2.7604 +	// Main method
  2.7605 +	ajax: function( url, options ) {
  2.7606 +
  2.7607 +		// If url is an object, simulate pre-1.5 signature
  2.7608 +		if ( typeof url === "object" ) {
  2.7609 +			options = url;
  2.7610 +			url = undefined;
  2.7611 +		}
  2.7612 +
  2.7613 +		// Force options to be an object
  2.7614 +		options = options || {};
  2.7615 +
  2.7616 +		var // ifModified key
  2.7617 +			ifModifiedKey,
  2.7618 +			// Response headers
  2.7619 +			responseHeadersString,
  2.7620 +			responseHeaders,
  2.7621 +			// transport
  2.7622 +			transport,
  2.7623 +			// timeout handle
  2.7624 +			timeoutTimer,
  2.7625 +			// Cross-domain detection vars
  2.7626 +			parts,
  2.7627 +			// To know if global events are to be dispatched
  2.7628 +			fireGlobals,
  2.7629 +			// Loop variable
  2.7630 +			i,
  2.7631 +			// Create the final options object
  2.7632 +			s = jQuery.ajaxSetup( {}, options ),
  2.7633 +			// Callbacks context
  2.7634 +			callbackContext = s.context || s,
  2.7635 +			// Context for global events
  2.7636 +			// It's the callbackContext if one was provided in the options
  2.7637 +			// and if it's a DOM node or a jQuery collection
  2.7638 +			globalEventContext = callbackContext !== s &&
  2.7639 +				( callbackContext.nodeType || callbackContext instanceof jQuery ) ?
  2.7640 +						jQuery( callbackContext ) : jQuery.event,
  2.7641 +			// Deferreds
  2.7642 +			deferred = jQuery.Deferred(),
  2.7643 +			completeDeferred = jQuery.Callbacks( "once memory" ),
  2.7644 +			// Status-dependent callbacks
  2.7645 +			statusCode = s.statusCode || {},
  2.7646 +			// Headers (they are sent all at once)
  2.7647 +			requestHeaders = {},
  2.7648 +			requestHeadersNames = {},
  2.7649 +			// The jqXHR state
  2.7650 +			state = 0,
  2.7651 +			// Default abort message
  2.7652 +			strAbort = "canceled",
  2.7653 +			// Fake xhr
  2.7654 +			jqXHR = {
  2.7655 +
  2.7656 +				readyState: 0,
  2.7657 +
  2.7658 +				// Caches the header
  2.7659 +				setRequestHeader: function( name, value ) {
  2.7660 +					if ( !state ) {
  2.7661 +						var lname = name.toLowerCase();
  2.7662 +						name = requestHeadersNames[ lname ] = requestHeadersNames[ lname ] || name;
  2.7663 +						requestHeaders[ name ] = value;
  2.7664 +					}
  2.7665 +					return this;
  2.7666 +				},
  2.7667 +
  2.7668 +				// Raw string
  2.7669 +				getAllResponseHeaders: function() {
  2.7670 +					return state === 2 ? responseHeadersString : null;
  2.7671 +				},
  2.7672 +
  2.7673 +				// Builds headers hashtable if needed
  2.7674 +				getResponseHeader: function( key ) {
  2.7675 +					var match;
  2.7676 +					if ( state === 2 ) {
  2.7677 +						if ( !responseHeaders ) {
  2.7678 +							responseHeaders = {};
  2.7679 +							while( ( match = rheaders.exec( responseHeadersString ) ) ) {
  2.7680 +								responseHeaders[ match[1].toLowerCase() ] = match[ 2 ];
  2.7681 +							}
  2.7682 +						}
  2.7683 +						match = responseHeaders[ key.toLowerCase() ];
  2.7684 +					}
  2.7685 +					return match === undefined ? null : match;
  2.7686 +				},
  2.7687 +
  2.7688 +				// Overrides response content-type header
  2.7689 +				overrideMimeType: function( type ) {
  2.7690 +					if ( !state ) {
  2.7691 +						s.mimeType = type;
  2.7692 +					}
  2.7693 +					return this;
  2.7694 +				},
  2.7695 +
  2.7696 +				// Cancel the request
  2.7697 +				abort: function( statusText ) {
  2.7698 +					statusText = statusText || strAbort;
  2.7699 +					if ( transport ) {
  2.7700 +						transport.abort( statusText );
  2.7701 +					}
  2.7702 +					done( 0, statusText );
  2.7703 +					return this;
  2.7704 +				}
  2.7705 +			};
  2.7706 +
  2.7707 +		// Callback for when everything is done
  2.7708 +		// It is defined here because jslint complains if it is declared
  2.7709 +		// at the end of the function (which would be more logical and readable)
  2.7710 +		function done( status, nativeStatusText, responses, headers ) {
  2.7711 +			var isSuccess, success, error, response, modified,
  2.7712 +				statusText = nativeStatusText;
  2.7713 +
  2.7714 +			// Called once
  2.7715 +			if ( state === 2 ) {
  2.7716 +				return;
  2.7717 +			}
  2.7718 +
  2.7719 +			// State is "done" now
  2.7720 +			state = 2;
  2.7721 +
  2.7722 +			// Clear timeout if it exists
  2.7723 +			if ( timeoutTimer ) {
  2.7724 +				clearTimeout( timeoutTimer );
  2.7725 +			}
  2.7726 +
  2.7727 +			// Dereference transport for early garbage collection
  2.7728 +			// (no matter how long the jqXHR object will be used)
  2.7729 +			transport = undefined;
  2.7730 +
  2.7731 +			// Cache response headers
  2.7732 +			responseHeadersString = headers || "";
  2.7733 +
  2.7734 +			// Set readyState
  2.7735 +			jqXHR.readyState = status > 0 ? 4 : 0;
  2.7736 +
  2.7737 +			// Get response data
  2.7738 +			if ( responses ) {
  2.7739 +				response = ajaxHandleResponses( s, jqXHR, responses );
  2.7740 +			}
  2.7741 +
  2.7742 +			// If successful, handle type chaining
  2.7743 +			if ( status >= 200 && status < 300 || status === 304 ) {
  2.7744 +
  2.7745 +				// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
  2.7746 +				if ( s.ifModified ) {
  2.7747 +
  2.7748 +					modified = jqXHR.getResponseHeader("Last-Modified");
  2.7749 +					if ( modified ) {
  2.7750 +						jQuery.lastModified[ ifModifiedKey ] = modified;
  2.7751 +					}
  2.7752 +					modified = jqXHR.getResponseHeader("Etag");
  2.7753 +					if ( modified ) {
  2.7754 +						jQuery.etag[ ifModifiedKey ] = modified;
  2.7755 +					}
  2.7756 +				}
  2.7757 +
  2.7758 +				// If not modified
  2.7759 +				if ( status === 304 ) {
  2.7760 +
  2.7761 +					statusText = "notmodified";
  2.7762 +					isSuccess = true;
  2.7763 +
  2.7764 +				// If we have data
  2.7765 +				} else {
  2.7766 +
  2.7767 +					isSuccess = ajaxConvert( s, response );
  2.7768 +					statusText = isSuccess.state;
  2.7769 +					success = isSuccess.data;
  2.7770 +					error = isSuccess.error;
  2.7771 +					isSuccess = !error;
  2.7772 +				}
  2.7773 +			} else {
  2.7774 +				// We extract error from statusText
  2.7775 +				// then normalize statusText and status for non-aborts
  2.7776 +				error = statusText;
  2.7777 +				if ( !statusText || status ) {
  2.7778 +					statusText = "error";
  2.7779 +					if ( status < 0 ) {
  2.7780 +						status = 0;
  2.7781 +					}
  2.7782 +				}
  2.7783 +			}
  2.7784 +
  2.7785 +			// Set data for the fake xhr object
  2.7786 +			jqXHR.status = status;
  2.7787 +			jqXHR.statusText = ( nativeStatusText || statusText ) + "";
  2.7788 +
  2.7789 +			// Success/Error
  2.7790 +			if ( isSuccess ) {
  2.7791 +				deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
  2.7792 +			} else {
  2.7793 +				deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
  2.7794 +			}
  2.7795 +
  2.7796 +			// Status-dependent callbacks
  2.7797 +			jqXHR.statusCode( statusCode );
  2.7798 +			statusCode = undefined;
  2.7799 +
  2.7800 +			if ( fireGlobals ) {
  2.7801 +				globalEventContext.trigger( "ajax" + ( isSuccess ? "Success" : "Error" ),
  2.7802 +						[ jqXHR, s, isSuccess ? success : error ] );
  2.7803 +			}
  2.7804 +
  2.7805 +			// Complete
  2.7806 +			completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );
  2.7807 +
  2.7808 +			if ( fireGlobals ) {
  2.7809 +				globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );
  2.7810 +				// Handle the global AJAX counter
  2.7811 +				if ( !( --jQuery.active ) ) {
  2.7812 +					jQuery.event.trigger( "ajaxStop" );
  2.7813 +				}
  2.7814 +			}
  2.7815 +		}
  2.7816 +
  2.7817 +		// Attach deferreds
  2.7818 +		deferred.promise( jqXHR );
  2.7819 +		jqXHR.success = jqXHR.done;
  2.7820 +		jqXHR.error = jqXHR.fail;
  2.7821 +		jqXHR.complete = completeDeferred.add;
  2.7822 +
  2.7823 +		// Status-dependent callbacks
  2.7824 +		jqXHR.statusCode = function( map ) {
  2.7825 +			if ( map ) {
  2.7826 +				var tmp;
  2.7827 +				if ( state < 2 ) {
  2.7828 +					for ( tmp in map ) {
  2.7829 +						statusCode[ tmp ] = [ statusCode[tmp], map[tmp] ];
  2.7830 +					}
  2.7831 +				} else {
  2.7832 +					tmp = map[ jqXHR.status ];
  2.7833 +					jqXHR.always( tmp );
  2.7834 +				}
  2.7835 +			}
  2.7836 +			return this;
  2.7837 +		};
  2.7838 +
  2.7839 +		// Remove hash character (#7531: and string promotion)
  2.7840 +		// Add protocol if not provided (#5866: IE7 issue with protocol-less urls)
  2.7841 +		// We also use the url parameter if available
  2.7842 +		s.url = ( ( url || s.url ) + "" ).replace( rhash, "" ).replace( rprotocol, ajaxLocParts[ 1 ] + "//" );
  2.7843 +
  2.7844 +		// Extract dataTypes list
  2.7845 +		s.dataTypes = jQuery.trim( s.dataType || "*" ).toLowerCase().split( core_rspace );
  2.7846 +
  2.7847 +		// A cross-domain request is in order when we have a protocol:host:port mismatch
  2.7848 +		if ( s.crossDomain == null ) {
  2.7849 +			parts = rurl.exec( s.url.toLowerCase() ) || false;
  2.7850 +			s.crossDomain = parts && ( parts.join(":") + ( parts[ 3 ] ? "" : parts[ 1 ] === "http:" ? 80 : 443 ) ) !==
  2.7851 +				( ajaxLocParts.join(":") + ( ajaxLocParts[ 3 ] ? "" : ajaxLocParts[ 1 ] === "http:" ? 80 : 443 ) );
  2.7852 +		}
  2.7853 +
  2.7854 +		// Convert data if not already a string
  2.7855 +		if ( s.data && s.processData && typeof s.data !== "string" ) {
  2.7856 +			s.data = jQuery.param( s.data, s.traditional );
  2.7857 +		}
  2.7858 +
  2.7859 +		// Apply prefilters
  2.7860 +		inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
  2.7861 +
  2.7862 +		// If request was aborted inside a prefilter, stop there
  2.7863 +		if ( state === 2 ) {
  2.7864 +			return jqXHR;
  2.7865 +		}
  2.7866 +
  2.7867 +		// We can fire global events as of now if asked to
  2.7868 +		fireGlobals = s.global;
  2.7869 +
  2.7870 +		// Uppercase the type
  2.7871 +		s.type = s.type.toUpperCase();
  2.7872 +
  2.7873 +		// Determine if request has content
  2.7874 +		s.hasContent = !rnoContent.test( s.type );
  2.7875 +
  2.7876 +		// Watch for a new set of requests
  2.7877 +		if ( fireGlobals && jQuery.active++ === 0 ) {
  2.7878 +			jQuery.event.trigger( "ajaxStart" );
  2.7879 +		}
  2.7880 +
  2.7881 +		// More options handling for requests with no content
  2.7882 +		if ( !s.hasContent ) {
  2.7883 +
  2.7884 +			// If data is available, append data to url
  2.7885 +			if ( s.data ) {
  2.7886 +				s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.data;
  2.7887 +				// #9682: remove data so that it's not used in an eventual retry
  2.7888 +				delete s.data;
  2.7889 +			}
  2.7890 +
  2.7891 +			// Get ifModifiedKey before adding the anti-cache parameter
  2.7892 +			ifModifiedKey = s.url;
  2.7893 +
  2.7894 +			// Add anti-cache in url if needed
  2.7895 +			if ( s.cache === false ) {
  2.7896 +
  2.7897 +				var ts = jQuery.now(),
  2.7898 +					// try replacing _= if it is there
  2.7899 +					ret = s.url.replace( rts, "$1_=" + ts );
  2.7900 +
  2.7901 +				// if nothing was replaced, add timestamp to the end
  2.7902 +				s.url = ret + ( ( ret === s.url ) ? ( rquery.test( s.url ) ? "&" : "?" ) + "_=" + ts : "" );
  2.7903 +			}
  2.7904 +		}
  2.7905 +
  2.7906 +		// Set the correct header, if data is being sent
  2.7907 +		if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
  2.7908 +			jqXHR.setRequestHeader( "Content-Type", s.contentType );
  2.7909 +		}
  2.7910 +
  2.7911 +		// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
  2.7912 +		if ( s.ifModified ) {
  2.7913 +			ifModifiedKey = ifModifiedKey || s.url;
  2.7914 +			if ( jQuery.lastModified[ ifModifiedKey ] ) {
  2.7915 +				jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ ifModifiedKey ] );
  2.7916 +			}
  2.7917 +			if ( jQuery.etag[ ifModifiedKey ] ) {
  2.7918 +				jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ ifModifiedKey ] );
  2.7919 +			}
  2.7920 +		}
  2.7921 +
  2.7922 +		// Set the Accepts header for the server, depending on the dataType
  2.7923 +		jqXHR.setRequestHeader(
  2.7924 +			"Accept",
  2.7925 +			s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[0] ] ?
  2.7926 +				s.accepts[ s.dataTypes[0] ] + ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
  2.7927 +				s.accepts[ "*" ]
  2.7928 +		);
  2.7929 +
  2.7930 +		// Check for headers option
  2.7931 +		for ( i in s.headers ) {
  2.7932 +			jqXHR.setRequestHeader( i, s.headers[ i ] );
  2.7933 +		}
  2.7934 +
  2.7935 +		// Allow custom headers/mimetypes and early abort
  2.7936 +		if ( s.beforeSend && ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || state === 2 ) ) {
  2.7937 +				// Abort if not done already and return
  2.7938 +				return jqXHR.abort();
  2.7939 +
  2.7940 +		}
  2.7941 +
  2.7942 +		// aborting is no longer a cancellation
  2.7943 +		strAbort = "abort";
  2.7944 +
  2.7945 +		// Install callbacks on deferreds
  2.7946 +		for ( i in { success: 1, error: 1, complete: 1 } ) {
  2.7947 +			jqXHR[ i ]( s[ i ] );
  2.7948 +		}
  2.7949 +
  2.7950 +		// Get transport
  2.7951 +		transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );
  2.7952 +
  2.7953 +		// If no transport, we auto-abort
  2.7954 +		if ( !transport ) {
  2.7955 +			done( -1, "No Transport" );
  2.7956 +		} else {
  2.7957 +			jqXHR.readyState = 1;
  2.7958 +			// Send global event
  2.7959 +			if ( fireGlobals ) {
  2.7960 +				globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
  2.7961 +			}
  2.7962 +			// Timeout
  2.7963 +			if ( s.async && s.timeout > 0 ) {
  2.7964 +				timeoutTimer = setTimeout( function(){
  2.7965 +					jqXHR.abort( "timeout" );
  2.7966 +				}, s.timeout );
  2.7967 +			}
  2.7968 +
  2.7969 +			try {
  2.7970 +				state = 1;
  2.7971 +				transport.send( requestHeaders, done );
  2.7972 +			} catch (e) {
  2.7973 +				// Propagate exception as error if not done
  2.7974 +				if ( state < 2 ) {
  2.7975 +					done( -1, e );
  2.7976 +				// Simply rethrow otherwise
  2.7977 +				} else {
  2.7978 +					throw e;
  2.7979 +				}
  2.7980 +			}
  2.7981 +		}
  2.7982 +
  2.7983 +		return jqXHR;
  2.7984 +	},
  2.7985 +
  2.7986 +	// Counter for holding the number of active queries
  2.7987 +	active: 0,
  2.7988 +
  2.7989 +	// Last-Modified header cache for next request
  2.7990 +	lastModified: {},
  2.7991 +	etag: {}
  2.7992 +
  2.7993 +});
  2.7994 +
  2.7995 +/* Handles responses to an ajax request:
  2.7996 + * - sets all responseXXX fields accordingly
  2.7997 + * - finds the right dataType (mediates between content-type and expected dataType)
  2.7998 + * - returns the corresponding response
  2.7999 + */
  2.8000 +function ajaxHandleResponses( s, jqXHR, responses ) {
  2.8001 +
  2.8002 +	var ct, type, finalDataType, firstDataType,
  2.8003 +		contents = s.contents,
  2.8004 +		dataTypes = s.dataTypes,
  2.8005 +		responseFields = s.responseFields;
  2.8006 +
  2.8007 +	// Fill responseXXX fields
  2.8008 +	for ( type in responseFields ) {
  2.8009 +		if ( type in responses ) {
  2.8010 +			jqXHR[ responseFields[type] ] = responses[ type ];
  2.8011 +		}
  2.8012 +	}
  2.8013 +
  2.8014 +	// Remove auto dataType and get content-type in the process
  2.8015 +	while( dataTypes[ 0 ] === "*" ) {
  2.8016 +		dataTypes.shift();
  2.8017 +		if ( ct === undefined ) {
  2.8018 +			ct = s.mimeType || jqXHR.getResponseHeader( "content-type" );
  2.8019 +		}
  2.8020 +	}
  2.8021 +
  2.8022 +	// Check if we're dealing with a known content-type
  2.8023 +	if ( ct ) {
  2.8024 +		for ( type in contents ) {
  2.8025 +			if ( contents[ type ] && contents[ type ].test( ct ) ) {
  2.8026 +				dataTypes.unshift( type );
  2.8027 +				break;
  2.8028 +			}
  2.8029 +		}
  2.8030 +	}
  2.8031 +
  2.8032 +	// Check to see if we have a response for the expected dataType
  2.8033 +	if ( dataTypes[ 0 ] in responses ) {
  2.8034 +		finalDataType = dataTypes[ 0 ];
  2.8035 +	} else {
  2.8036 +		// Try convertible dataTypes
  2.8037 +		for ( type in responses ) {
  2.8038 +			if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[0] ] ) {
  2.8039 +				finalDataType = type;
  2.8040 +				break;
  2.8041 +			}
  2.8042 +			if ( !firstDataType ) {
  2.8043 +				firstDataType = type;
  2.8044 +			}
  2.8045 +		}
  2.8046 +		// Or just use first one
  2.8047 +		finalDataType = finalDataType || firstDataType;
  2.8048 +	}
  2.8049 +
  2.8050 +	// If we found a dataType
  2.8051 +	// We add the dataType to the list if needed
  2.8052 +	// and return the corresponding response
  2.8053 +	if ( finalDataType ) {
  2.8054 +		if ( finalDataType !== dataTypes[ 0 ] ) {
  2.8055 +			dataTypes.unshift( finalDataType );
  2.8056 +		}
  2.8057 +		return responses[ finalDataType ];
  2.8058 +	}
  2.8059 +}
  2.8060 +
  2.8061 +// Chain conversions given the request and the original response
  2.8062 +function ajaxConvert( s, response ) {
  2.8063 +
  2.8064 +	var conv, conv2, current, tmp,
  2.8065 +		// Work with a copy of dataTypes in case we need to modify it for conversion
  2.8066 +		dataTypes = s.dataTypes.slice(),
  2.8067 +		prev = dataTypes[ 0 ],
  2.8068 +		converters = {},
  2.8069 +		i = 0;
  2.8070 +
  2.8071 +	// Apply the dataFilter if provided
  2.8072 +	if ( s.dataFilter ) {
  2.8073 +		response = s.dataFilter( response, s.dataType );
  2.8074 +	}
  2.8075 +
  2.8076 +	// Create converters map with lowercased keys
  2.8077 +	if ( dataTypes[ 1 ] ) {
  2.8078 +		for ( conv in s.converters ) {
  2.8079 +			converters[ conv.toLowerCase() ] = s.converters[ conv ];
  2.8080 +		}
  2.8081 +	}
  2.8082 +
  2.8083 +	// Convert to each sequential dataType, tolerating list modification
  2.8084 +	for ( ; (current = dataTypes[++i]); ) {
  2.8085 +
  2.8086 +		// There's only work to do if current dataType is non-auto
  2.8087 +		if ( current !== "*" ) {
  2.8088 +
  2.8089 +			// Convert response if prev dataType is non-auto and differs from current
  2.8090 +			if ( prev !== "*" && prev !== current ) {
  2.8091 +
  2.8092 +				// Seek a direct converter
  2.8093 +				conv = converters[ prev + " " + current ] || converters[ "* " + current ];
  2.8094 +
  2.8095 +				// If none found, seek a pair
  2.8096 +				if ( !conv ) {
  2.8097 +					for ( conv2 in converters ) {
  2.8098 +
  2.8099 +						// If conv2 outputs current
  2.8100 +						tmp = conv2.split(" ");
  2.8101 +						if ( tmp[ 1 ] === current ) {
  2.8102 +
  2.8103 +							// If prev can be converted to accepted input
  2.8104 +							conv = converters[ prev + " " + tmp[ 0 ] ] ||
  2.8105 +								converters[ "* " + tmp[ 0 ] ];
  2.8106 +							if ( conv ) {
  2.8107 +								// Condense equivalence converters
  2.8108 +								if ( conv === true ) {
  2.8109 +									conv = converters[ conv2 ];
  2.8110 +
  2.8111 +								// Otherwise, insert the intermediate dataType
  2.8112 +								} else if ( converters[ conv2 ] !== true ) {
  2.8113 +									current = tmp[ 0 ];
  2.8114 +									dataTypes.splice( i--, 0, current );
  2.8115 +								}
  2.8116 +
  2.8117 +								break;
  2.8118 +							}
  2.8119 +						}
  2.8120 +					}
  2.8121 +				}
  2.8122 +
  2.8123 +				// Apply converter (if not an equivalence)
  2.8124 +				if ( conv !== true ) {
  2.8125 +
  2.8126 +					// Unless errors are allowed to bubble, catch and return them
  2.8127 +					if ( conv && s["throws"] ) {
  2.8128 +						response = conv( response );
  2.8129 +					} else {
  2.8130 +						try {
  2.8131 +							response = conv( response );
  2.8132 +						} catch ( e ) {
  2.8133 +							return { state: "parsererror", error: conv ? e : "No conversion from " + prev + " to " + current };
  2.8134 +						}
  2.8135 +					}
  2.8136 +				}
  2.8137 +			}
  2.8138 +
  2.8139 +			// Update prev for next iteration
  2.8140 +			prev = current;
  2.8141 +		}
  2.8142 +	}
  2.8143 +
  2.8144 +	return { state: "success", data: response };
  2.8145 +}
  2.8146 +var oldCallbacks = [],
  2.8147 +	rquestion = /\?/,
  2.8148 +	rjsonp = /(=)\?(?=&|$)|\?\?/,
  2.8149 +	nonce = jQuery.now();
  2.8150 +
  2.8151 +// Default jsonp settings
  2.8152 +jQuery.ajaxSetup({
  2.8153 +	jsonp: "callback",
  2.8154 +	jsonpCallback: function() {
  2.8155 +		var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( nonce++ ) );
  2.8156 +		this[ callback ] = true;
  2.8157 +		return callback;
  2.8158 +	}
  2.8159 +});
  2.8160 +
  2.8161 +// Detect, normalize options and install callbacks for jsonp requests
  2.8162 +jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
  2.8163 +
  2.8164 +	var callbackName, overwritten, responseContainer,
  2.8165 +		data = s.data,
  2.8166 +		url = s.url,
  2.8167 +		hasCallback = s.jsonp !== false,
  2.8168 +		replaceInUrl = hasCallback && rjsonp.test( url ),
  2.8169 +		replaceInData = hasCallback && !replaceInUrl && typeof data === "string" &&
  2.8170 +			!( s.contentType || "" ).indexOf("application/x-www-form-urlencoded") &&
  2.8171 +			rjsonp.test( data );
  2.8172 +
  2.8173 +	// Handle iff the expected data type is "jsonp" or we have a parameter to set
  2.8174 +	if ( s.dataTypes[ 0 ] === "jsonp" || replaceInUrl || replaceInData ) {
  2.8175 +
  2.8176 +		// Get callback name, remembering preexisting value associated with it
  2.8177 +		callbackName = s.jsonpCallback = jQuery.isFunction( s.jsonpCallback ) ?
  2.8178 +			s.jsonpCallback() :
  2.8179 +			s.jsonpCallback;
  2.8180 +		overwritten = window[ callbackName ];
  2.8181 +
  2.8182 +		// Insert callback into url or form data
  2.8183 +		if ( replaceInUrl ) {
  2.8184 +			s.url = url.replace( rjsonp, "$1" + callbackName );
  2.8185 +		} else if ( replaceInData ) {
  2.8186 +			s.data = data.replace( rjsonp, "$1" + callbackName );
  2.8187 +		} else if ( hasCallback ) {
  2.8188 +			s.url += ( rquestion.test( url ) ? "&" : "?" ) + s.jsonp + "=" + callbackName;
  2.8189 +		}
  2.8190 +
  2.8191 +		// Use data converter to retrieve json after script execution
  2.8192 +		s.converters["script json"] = function() {
  2.8193 +			if ( !responseContainer ) {
  2.8194 +				jQuery.error( callbackName + " was not called" );
  2.8195 +			}
  2.8196 +			return responseContainer[ 0 ];
  2.8197 +		};
  2.8198 +
  2.8199 +		// force json dataType
  2.8200 +		s.dataTypes[ 0 ] = "json";
  2.8201 +
  2.8202 +		// Install callback
  2.8203 +		window[ callbackName ] = function() {
  2.8204 +			responseContainer = arguments;
  2.8205 +		};
  2.8206 +
  2.8207 +		// Clean-up function (fires after converters)
  2.8208 +		jqXHR.always(function() {
  2.8209 +			// Restore preexisting value
  2.8210 +			window[ callbackName ] = overwritten;
  2.8211 +
  2.8212 +			// Save back as free
  2.8213 +			if ( s[ callbackName ] ) {
  2.8214 +				// make sure that re-using the options doesn't screw things around
  2.8215 +				s.jsonpCallback = originalSettings.jsonpCallback;
  2.8216 +
  2.8217 +				// save the callback name for future use
  2.8218 +				oldCallbacks.push( callbackName );
  2.8219 +			}
  2.8220 +
  2.8221 +			// Call if it was a function and we have a response
  2.8222 +			if ( responseContainer && jQuery.isFunction( overwritten ) ) {
  2.8223 +				overwritten( responseContainer[ 0 ] );
  2.8224 +			}
  2.8225 +
  2.8226 +			responseContainer = overwritten = undefined;
  2.8227 +		});
  2.8228 +
  2.8229 +		// Delegate to script
  2.8230 +		return "script";
  2.8231 +	}
  2.8232 +});
  2.8233 +// Install script dataType
  2.8234 +jQuery.ajaxSetup({
  2.8235 +	accepts: {
  2.8236 +		script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
  2.8237 +	},
  2.8238 +	contents: {
  2.8239 +		script: /javascript|ecmascript/
  2.8240 +	},
  2.8241 +	converters: {
  2.8242 +		"text script": function( text ) {
  2.8243 +			jQuery.globalEval( text );
  2.8244 +			return text;
  2.8245 +		}
  2.8246 +	}
  2.8247 +});
  2.8248 +
  2.8249 +// Handle cache's special case and global
  2.8250 +jQuery.ajaxPrefilter( "script", function( s ) {
  2.8251 +	if ( s.cache === undefined ) {
  2.8252 +		s.cache = false;
  2.8253 +	}
  2.8254 +	if ( s.crossDomain ) {
  2.8255 +		s.type = "GET";
  2.8256 +		s.global = false;
  2.8257 +	}
  2.8258 +});
  2.8259 +
  2.8260 +// Bind script tag hack transport
  2.8261 +jQuery.ajaxTransport( "script", function(s) {
  2.8262 +
  2.8263 +	// This transport only deals with cross domain requests
  2.8264 +	if ( s.crossDomain ) {
  2.8265 +
  2.8266 +		var script,
  2.8267 +			head = document.head || document.getElementsByTagName( "head" )[0] || document.documentElement;
  2.8268 +
  2.8269 +		return {
  2.8270 +
  2.8271 +			send: function( _, callback ) {
  2.8272 +
  2.8273 +				script = document.createElement( "script" );
  2.8274 +
  2.8275 +				script.async = "async";
  2.8276 +
  2.8277 +				if ( s.scriptCharset ) {
  2.8278 +					script.charset = s.scriptCharset;
  2.8279 +				}
  2.8280 +
  2.8281 +				script.src = s.url;
  2.8282 +
  2.8283 +				// Attach handlers for all browsers
  2.8284 +				script.onload = script.onreadystatechange = function( _, isAbort ) {
  2.8285 +
  2.8286 +					if ( isAbort || !script.readyState || /loaded|complete/.test( script.readyState ) ) {
  2.8287 +
  2.8288 +						// Handle memory leak in IE
  2.8289 +						script.onload = script.onreadystatechange = null;
  2.8290 +
  2.8291 +						// Remove the script
  2.8292 +						if ( head && script.parentNode ) {
  2.8293 +							head.removeChild( script );
  2.8294 +						}
  2.8295 +
  2.8296 +						// Dereference the script
  2.8297 +						script = undefined;
  2.8298 +
  2.8299 +						// Callback if not abort
  2.8300 +						if ( !isAbort ) {
  2.8301 +							callback( 200, "success" );
  2.8302 +						}
  2.8303 +					}
  2.8304 +				};
  2.8305 +				// Use insertBefore instead of appendChild  to circumvent an IE6 bug.
  2.8306 +				// This arises when a base node is used (#2709 and #4378).
  2.8307 +				head.insertBefore( script, head.firstChild );
  2.8308 +			},
  2.8309 +
  2.8310 +			abort: function() {
  2.8311 +				if ( script ) {
  2.8312 +					script.onload( 0, 1 );
  2.8313 +				}
  2.8314 +			}
  2.8315 +		};
  2.8316 +	}
  2.8317 +});
  2.8318 +var xhrCallbacks,
  2.8319 +	// #5280: Internet Explorer will keep connections alive if we don't abort on unload
  2.8320 +	xhrOnUnloadAbort = window.ActiveXObject ? function() {
  2.8321 +		// Abort all pending requests
  2.8322 +		for ( var key in xhrCallbacks ) {
  2.8323 +			xhrCallbacks[ key ]( 0, 1 );
  2.8324 +		}
  2.8325 +	} : false,
  2.8326 +	xhrId = 0;
  2.8327 +
  2.8328 +// Functions to create xhrs
  2.8329 +function createStandardXHR() {
  2.8330 +	try {
  2.8331 +		return new window.XMLHttpRequest();
  2.8332 +	} catch( e ) {}
  2.8333 +}
  2.8334 +
  2.8335 +function createActiveXHR() {
  2.8336 +	try {
  2.8337 +		return new window.ActiveXObject( "Microsoft.XMLHTTP" );
  2.8338 +	} catch( e ) {}
  2.8339 +}
  2.8340 +
  2.8341 +// Create the request object
  2.8342 +// (This is still attached to ajaxSettings for backward compatibility)
  2.8343 +jQuery.ajaxSettings.xhr = window.ActiveXObject ?
  2.8344 +	/* Microsoft failed to properly
  2.8345 +	 * implement the XMLHttpRequest in IE7 (can't request local files),
  2.8346 +	 * so we use the ActiveXObject when it is available
  2.8347 +	 * Additionally XMLHttpRequest can be disabled in IE7/IE8 so
  2.8348 +	 * we need a fallback.
  2.8349 +	 */
  2.8350 +	function() {
  2.8351 +		return !this.isLocal && createStandardXHR() || createActiveXHR();
  2.8352 +	} :
  2.8353 +	// For all other browsers, use the standard XMLHttpRequest object
  2.8354 +	createStandardXHR;
  2.8355 +
  2.8356 +// Determine support properties
  2.8357 +(function( xhr ) {
  2.8358 +	jQuery.extend( jQuery.support, {
  2.8359 +		ajax: !!xhr,
  2.8360 +		cors: !!xhr && ( "withCredentials" in xhr )
  2.8361 +	});
  2.8362 +})( jQuery.ajaxSettings.xhr() );
  2.8363 +
  2.8364 +// Create transport if the browser can provide an xhr
  2.8365 +if ( jQuery.support.ajax ) {
  2.8366 +
  2.8367 +	jQuery.ajaxTransport(function( s ) {
  2.8368 +		// Cross domain only allowed if supported through XMLHttpRequest
  2.8369 +		if ( !s.crossDomain || jQuery.support.cors ) {
  2.8370 +
  2.8371 +			var callback;
  2.8372 +
  2.8373 +			return {
  2.8374 +				send: function( headers, complete ) {
  2.8375 +
  2.8376 +					// Get a new xhr
  2.8377 +					var handle, i,
  2.8378 +						xhr = s.xhr();
  2.8379 +
  2.8380 +					// Open the socket
  2.8381 +					// Passing null username, generates a login popup on Opera (#2865)
  2.8382 +					if ( s.username ) {
  2.8383 +						xhr.open( s.type, s.url, s.async, s.username, s.password );
  2.8384 +					} else {
  2.8385 +						xhr.open( s.type, s.url, s.async );
  2.8386 +					}
  2.8387 +
  2.8388 +					// Apply custom fields if provided
  2.8389 +					if ( s.xhrFields ) {
  2.8390 +						for ( i in s.xhrFields ) {
  2.8391 +							xhr[ i ] = s.xhrFields[ i ];
  2.8392 +						}
  2.8393 +					}
  2.8394 +
  2.8395 +					// Override mime type if needed
  2.8396 +					if ( s.mimeType && xhr.overrideMimeType ) {
  2.8397 +						xhr.overrideMimeType( s.mimeType );
  2.8398 +					}
  2.8399 +
  2.8400 +					// X-Requested-With header
  2.8401 +					// For cross-domain requests, seeing as conditions for a preflight are
  2.8402 +					// akin to a jigsaw puzzle, we simply never set it to be sure.
  2.8403 +					// (it can always be set on a per-request basis or even using ajaxSetup)
  2.8404 +					// For same-domain requests, won't change header if already provided.
  2.8405 +					if ( !s.crossDomain && !headers["X-Requested-With"] ) {
  2.8406 +						headers[ "X-Requested-With" ] = "XMLHttpRequest";
  2.8407 +					}
  2.8408 +
  2.8409 +					// Need an extra try/catch for cross domain requests in Firefox 3
  2.8410 +					try {
  2.8411 +						for ( i in headers ) {
  2.8412 +							xhr.setRequestHeader( i, headers[ i ] );
  2.8413 +						}
  2.8414 +					} catch( _ ) {}
  2.8415 +
  2.8416 +					// Do send the request
  2.8417 +					// This may raise an exception which is actually
  2.8418 +					// handled in jQuery.ajax (so no try/catch here)
  2.8419 +					xhr.send( ( s.hasContent && s.data ) || null );
  2.8420 +
  2.8421 +					// Listener
  2.8422 +					callback = function( _, isAbort ) {
  2.8423 +
  2.8424 +						var status,
  2.8425 +							statusText,
  2.8426 +							responseHeaders,
  2.8427 +							responses,
  2.8428 +							xml;
  2.8429 +
  2.8430 +						// Firefox throws exceptions when accessing properties
  2.8431 +						// of an xhr when a network error occurred
  2.8432 +						// http://helpful.knobs-dials.com/index.php/Component_returned_failure_code:_0x80040111_(NS_ERROR_NOT_AVAILABLE)
  2.8433 +						try {
  2.8434 +
  2.8435 +							// Was never called and is aborted or complete
  2.8436 +							if ( callback && ( isAbort || xhr.readyState === 4 ) ) {
  2.8437 +
  2.8438 +								// Only called once
  2.8439 +								callback = undefined;
  2.8440 +
  2.8441 +								// Do not keep as active anymore
  2.8442 +								if ( handle ) {
  2.8443 +									xhr.onreadystatechange = jQuery.noop;
  2.8444 +									if ( xhrOnUnloadAbort ) {
  2.8445 +										delete xhrCallbacks[ handle ];
  2.8446 +									}
  2.8447 +								}
  2.8448 +
  2.8449 +								// If it's an abort
  2.8450 +								if ( isAbort ) {
  2.8451 +									// Abort it manually if needed
  2.8452 +									if ( xhr.readyState !== 4 ) {
  2.8453 +										xhr.abort();
  2.8454 +									}
  2.8455 +								} else {
  2.8456 +									status = xhr.status;
  2.8457 +									responseHeaders = xhr.getAllResponseHeaders();
  2.8458 +									responses = {};
  2.8459 +									xml = xhr.responseXML;
  2.8460 +
  2.8461 +									// Construct response list
  2.8462 +									if ( xml && xml.documentElement /* #4958 */ ) {
  2.8463 +										responses.xml = xml;
  2.8464 +									}
  2.8465 +
  2.8466 +									// When requesting binary data, IE6-9 will throw an exception
  2.8467 +									// on any attempt to access responseText (#11426)
  2.8468 +									try {
  2.8469 +										responses.text = xhr.responseText;
  2.8470 +									} catch( _ ) {
  2.8471 +									}
  2.8472 +
  2.8473 +									// Firefox throws an exception when accessing
  2.8474 +									// statusText for faulty cross-domain requests
  2.8475 +									try {
  2.8476 +										statusText = xhr.statusText;
  2.8477 +									} catch( e ) {
  2.8478 +										// We normalize with Webkit giving an empty statusText
  2.8479 +										statusText = "";
  2.8480 +									}
  2.8481 +
  2.8482 +									// Filter status for non standard behaviors
  2.8483 +
  2.8484 +									// If the request is local and we have data: assume a success
  2.8485 +									// (success with no data won't get notified, that's the best we
  2.8486 +									// can do given current implementations)
  2.8487 +									if ( !status && s.isLocal && !s.crossDomain ) {
  2.8488 +										status = responses.text ? 200 : 404;
  2.8489 +									// IE - #1450: sometimes returns 1223 when it should be 204
  2.8490 +									} else if ( status === 1223 ) {
  2.8491 +										status = 204;
  2.8492 +									}
  2.8493 +								}
  2.8494 +							}
  2.8495 +						} catch( firefoxAccessException ) {
  2.8496 +							if ( !isAbort ) {
  2.8497 +								complete( -1, firefoxAccessException );
  2.8498 +							}
  2.8499 +						}
  2.8500 +
  2.8501 +						// Call complete if needed
  2.8502 +						if ( responses ) {
  2.8503 +							complete( status, statusText, responses, responseHeaders );
  2.8504 +						}
  2.8505 +					};
  2.8506 +
  2.8507 +					if ( !s.async ) {
  2.8508 +						// if we're in sync mode we fire the callback
  2.8509 +						callback();
  2.8510 +					} else if ( xhr.readyState === 4 ) {
  2.8511 +						// (IE6 & IE7) if it's in cache and has been
  2.8512 +						// retrieved directly we need to fire the callback
  2.8513 +						setTimeout( callback, 0 );
  2.8514 +					} else {
  2.8515 +						handle = ++xhrId;
  2.8516 +						if ( xhrOnUnloadAbort ) {
  2.8517 +							// Create the active xhrs callbacks list if needed
  2.8518 +							// and attach the unload handler
  2.8519 +							if ( !xhrCallbacks ) {
  2.8520 +								xhrCallbacks = {};
  2.8521 +								jQuery( window ).unload( xhrOnUnloadAbort );
  2.8522 +							}
  2.8523 +							// Add to list of active xhrs callbacks
  2.8524 +							xhrCallbacks[ handle ] = callback;
  2.8525 +						}
  2.8526 +						xhr.onreadystatechange = callback;
  2.8527 +					}
  2.8528 +				},
  2.8529 +
  2.8530 +				abort: function() {
  2.8531 +					if ( callback ) {
  2.8532 +						callback(0,1);
  2.8533 +					}
  2.8534 +				}
  2.8535 +			};
  2.8536 +		}
  2.8537 +	});
  2.8538 +}
  2.8539 +var fxNow, timerId,
  2.8540 +	rfxtypes = /^(?:toggle|show|hide)$/,
  2.8541 +	rfxnum = new RegExp( "^(?:([-+])=|)(" + core_pnum + ")([a-z%]*)$", "i" ),
  2.8542 +	rrun = /queueHooks$/,
  2.8543 +	animationPrefilters = [ defaultPrefilter ],
  2.8544 +	tweeners = {
  2.8545 +		"*": [function( prop, value ) {
  2.8546 +			var end, unit,
  2.8547 +				tween = this.createTween( prop, value ),
  2.8548 +				parts = rfxnum.exec( value ),
  2.8549 +				target = tween.cur(),
  2.8550 +				start = +target || 0,
  2.8551 +				scale = 1,
  2.8552 +				maxIterations = 20;
  2.8553 +
  2.8554 +			if ( parts ) {
  2.8555 +				end = +parts[2];
  2.8556 +				unit = parts[3] || ( jQuery.cssNumber[ prop ] ? "" : "px" );
  2.8557 +
  2.8558 +				// We need to compute starting value
  2.8559 +				if ( unit !== "px" && start ) {
  2.8560 +					// Iteratively approximate from a nonzero starting point
  2.8561 +					// Prefer the current property, because this process will be trivial if it uses the same units
  2.8562 +					// Fallback to end or a simple constant
  2.8563 +					start = jQuery.css( tween.elem, prop, true ) || end || 1;
  2.8564 +
  2.8565 +					do {
  2.8566 +						// If previous iteration zeroed out, double until we get *something*
  2.8567 +						// Use a string for doubling factor so we don't accidentally see scale as unchanged below
  2.8568 +						scale = scale || ".5";
  2.8569 +
  2.8570 +						// Adjust and apply
  2.8571 +						start = start / scale;
  2.8572 +						jQuery.style( tween.elem, prop, start + unit );
  2.8573 +
  2.8574 +					// Update scale, tolerating zero or NaN from tween.cur()
  2.8575 +					// And breaking the loop if scale is unchanged or perfect, or if we've just had enough
  2.8576 +					} while ( scale !== (scale = tween.cur() / target) && scale !== 1 && --maxIterations );
  2.8577 +				}
  2.8578 +
  2.8579 +				tween.unit = unit;
  2.8580 +				tween.start = start;
  2.8581 +				// If a +=/-= token was provided, we're doing a relative animation
  2.8582 +				tween.end = parts[1] ? start + ( parts[1] + 1 ) * end : end;
  2.8583 +			}
  2.8584 +			return tween;
  2.8585 +		}]
  2.8586 +	};
  2.8587 +
  2.8588 +// Animations created synchronously will run synchronously
  2.8589 +function createFxNow() {
  2.8590 +	setTimeout(function() {
  2.8591 +		fxNow = undefined;
  2.8592 +	}, 0 );
  2.8593 +	return ( fxNow = jQuery.now() );
  2.8594 +}
  2.8595 +
  2.8596 +function createTweens( animation, props ) {
  2.8597 +	jQuery.each( props, function( prop, value ) {
  2.8598 +		var collection = ( tweeners[ prop ] || [] ).concat( tweeners[ "*" ] ),
  2.8599 +			index = 0,
  2.8600 +			length = collection.length;
  2.8601 +		for ( ; index < length; index++ ) {
  2.8602 +			if ( collection[ index ].call( animation, prop, value ) ) {
  2.8603 +
  2.8604 +				// we're done with this property
  2.8605 +				return;
  2.8606 +			}
  2.8607 +		}
  2.8608 +	});
  2.8609 +}
  2.8610 +
  2.8611 +function Animation( elem, properties, options ) {
  2.8612 +	var result,
  2.8613 +		index = 0,
  2.8614 +		tweenerIndex = 0,
  2.8615 +		length = animationPrefilters.length,
  2.8616 +		deferred = jQuery.Deferred().always( function() {
  2.8617 +			// don't match elem in the :animated selector
  2.8618 +			delete tick.elem;
  2.8619 +		}),
  2.8620 +		tick = function() {
  2.8621 +			var currentTime = fxNow || createFxNow(),
  2.8622 +				remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),
  2.8623 +				percent = 1 - ( remaining / animation.duration || 0 ),
  2.8624 +				index = 0,
  2.8625 +				length = animation.tweens.length;
  2.8626 +
  2.8627 +			for ( ; index < length ; index++ ) {
  2.8628 +				animation.tweens[ index ].run( percent );
  2.8629 +			}
  2.8630 +
  2.8631 +			deferred.notifyWith( elem, [ animation, percent, remaining ]);
  2.8632 +
  2.8633 +			if ( percent < 1 && length ) {
  2.8634 +				return remaining;
  2.8635 +			} else {
  2.8636 +				deferred.resolveWith( elem, [ animation ] );
  2.8637 +				return false;
  2.8638 +			}
  2.8639 +		},
  2.8640 +		animation = deferred.promise({
  2.8641 +			elem: elem,
  2.8642 +			props: jQuery.extend( {}, properties ),
  2.8643 +			opts: jQuery.extend( true, { specialEasing: {} }, options ),
  2.8644 +			originalProperties: properties,
  2.8645 +			originalOptions: options,
  2.8646 +			startTime: fxNow || createFxNow(),
  2.8647 +			duration: options.duration,
  2.8648 +			tweens: [],
  2.8649 +			createTween: function( prop, end, easing ) {
  2.8650 +				var tween = jQuery.Tween( elem, animation.opts, prop, end,
  2.8651 +						animation.opts.specialEasing[ prop ] || animation.opts.easing );
  2.8652 +				animation.tweens.push( tween );
  2.8653 +				return tween;
  2.8654 +			},
  2.8655 +			stop: function( gotoEnd ) {
  2.8656 +				var index = 0,
  2.8657 +					// if we are going to the end, we want to run all the tweens
  2.8658 +					// otherwise we skip this part
  2.8659 +					length = gotoEnd ? animation.tweens.length : 0;
  2.8660 +
  2.8661 +				for ( ; index < length ; index++ ) {
  2.8662 +					animation.tweens[ index ].run( 1 );
  2.8663 +				}
  2.8664 +
  2.8665 +				// resolve when we played the last frame
  2.8666 +				// otherwise, reject
  2.8667 +				if ( gotoEnd ) {
  2.8668 +					deferred.resolveWith( elem, [ animation, gotoEnd ] );
  2.8669 +				} else {
  2.8670 +					deferred.rejectWith( elem, [ animation, gotoEnd ] );
  2.8671 +				}
  2.8672 +				return this;
  2.8673 +			}
  2.8674 +		}),
  2.8675 +		props = animation.props;
  2.8676 +
  2.8677 +	propFilter( props, animation.opts.specialEasing );
  2.8678 +
  2.8679 +	for ( ; index < length ; index++ ) {
  2.8680 +		result = animationPrefilters[ index ].call( animation, elem, props, animation.opts );
  2.8681 +		if ( result ) {
  2.8682 +			return result;
  2.8683 +		}
  2.8684 +	}
  2.8685 +
  2.8686 +	createTweens( animation, props );
  2.8687 +
  2.8688 +	if ( jQuery.isFunction( animation.opts.start ) ) {
  2.8689 +		animation.opts.start.call( elem, animation );
  2.8690 +	}
  2.8691 +
  2.8692 +	jQuery.fx.timer(
  2.8693 +		jQuery.extend( tick, {
  2.8694 +			anim: animation,
  2.8695 +			queue: animation.opts.queue,
  2.8696 +			elem: elem
  2.8697 +		})
  2.8698 +	);
  2.8699 +
  2.8700 +	// attach callbacks from options
  2.8701 +	return animation.progress( animation.opts.progress )
  2.8702 +		.done( animation.opts.done, animation.opts.complete )
  2.8703 +		.fail( animation.opts.fail )
  2.8704 +		.always( animation.opts.always );
  2.8705 +}
  2.8706 +
  2.8707 +function propFilter( props, specialEasing ) {
  2.8708 +	var index, name, easing, value, hooks;
  2.8709 +
  2.8710 +	// camelCase, specialEasing and expand cssHook pass
  2.8711 +	for ( index in props ) {
  2.8712 +		name = jQuery.camelCase( index );
  2.8713 +		easing = specialEasing[ name ];
  2.8714 +		value = props[ index ];
  2.8715 +		if ( jQuery.isArray( value ) ) {
  2.8716 +			easing = value[ 1 ];
  2.8717 +			value = props[ index ] = value[ 0 ];
  2.8718 +		}
  2.8719 +
  2.8720 +		if ( index !== name ) {
  2.8721 +			props[ name ] = value;
  2.8722 +			delete props[ index ];
  2.8723 +		}
  2.8724 +
  2.8725 +		hooks = jQuery.cssHooks[ name ];
  2.8726 +		if ( hooks && "expand" in hooks ) {
  2.8727 +			value = hooks.expand( value );
  2.8728 +			delete props[ name ];
  2.8729 +
  2.8730 +			// not quite $.extend, this wont overwrite keys already present.
  2.8731 +			// also - reusing 'index' from above because we have the correct "name"
  2.8732 +			for ( index in value ) {
  2.8733 +				if ( !( index in props ) ) {
  2.8734 +					props[ index ] = value[ index ];
  2.8735 +					specialEasing[ index ] = easing;
  2.8736 +				}
  2.8737 +			}
  2.8738 +		} else {
  2.8739 +			specialEasing[ name ] = easing;
  2.8740 +		}
  2.8741 +	}
  2.8742 +}
  2.8743 +
  2.8744 +jQuery.Animation = jQuery.extend( Animation, {
  2.8745 +
  2.8746 +	tweener: function( props, callback ) {
  2.8747 +		if ( jQuery.isFunction( props ) ) {
  2.8748 +			callback = props;
  2.8749 +			props = [ "*" ];
  2.8750 +		} else {
  2.8751 +			props = props.split(" ");
  2.8752 +		}
  2.8753 +
  2.8754 +		var prop,
  2.8755 +			index = 0,
  2.8756 +			length = props.length;
  2.8757 +
  2.8758 +		for ( ; index < length ; index++ ) {
  2.8759 +			prop = props[ index ];
  2.8760 +			tweeners[ prop ] = tweeners[ prop ] || [];
  2.8761 +			tweeners[ prop ].unshift( callback );
  2.8762 +		}
  2.8763 +	},
  2.8764 +
  2.8765 +	prefilter: function( callback, prepend ) {
  2.8766 +		if ( prepend ) {
  2.8767 +			animationPrefilters.unshift( callback );
  2.8768 +		} else {
  2.8769 +			animationPrefilters.push( callback );
  2.8770 +		}
  2.8771 +	}
  2.8772 +});
  2.8773 +
  2.8774 +function defaultPrefilter( elem, props, opts ) {
  2.8775 +	var index, prop, value, length, dataShow, tween, hooks, oldfire,
  2.8776 +		anim = this,
  2.8777 +		style = elem.style,
  2.8778 +		orig = {},
  2.8779 +		handled = [],
  2.8780 +		hidden = elem.nodeType && isHidden( elem );
  2.8781 +
  2.8782 +	// handle queue: false promises
  2.8783 +	if ( !opts.queue ) {
  2.8784 +		hooks = jQuery._queueHooks( elem, "fx" );
  2.8785 +		if ( hooks.unqueued == null ) {
  2.8786 +			hooks.unqueued = 0;
  2.8787 +			oldfire = hooks.empty.fire;
  2.8788 +			hooks.empty.fire = function() {
  2.8789 +				if ( !hooks.unqueued ) {
  2.8790 +					oldfire();
  2.8791 +				}
  2.8792 +			};
  2.8793 +		}
  2.8794 +		hooks.unqueued++;
  2.8795 +
  2.8796 +		anim.always(function() {
  2.8797 +			// doing this makes sure that the complete handler will be called
  2.8798 +			// before this completes
  2.8799 +			anim.always(function() {
  2.8800 +				hooks.unqueued--;
  2.8801 +				if ( !jQuery.queue( elem, "fx" ).length ) {
  2.8802 +					hooks.empty.fire();
  2.8803 +				}
  2.8804 +			});
  2.8805 +		});
  2.8806 +	}
  2.8807 +
  2.8808 +	// height/width overflow pass
  2.8809 +	if ( elem.nodeType === 1 && ( "height" in props || "width" in props ) ) {
  2.8810 +		// Make sure that nothing sneaks out
  2.8811 +		// Record all 3 overflow attributes because IE does not
  2.8812 +		// change the overflow attribute when overflowX and
  2.8813 +		// overflowY are set to the same value
  2.8814 +		opts.overflow = [ style.overflow, style.overflowX, style.overflowY ];
  2.8815 +
  2.8816 +		// Set display property to inline-block for height/width
  2.8817 +		// animations on inline elements that are having width/height animated
  2.8818 +		if ( jQuery.css( elem, "display" ) === "inline" &&
  2.8819 +				jQuery.css( elem, "float" ) === "none" ) {
  2.8820 +
  2.8821 +			// inline-level elements accept inline-block;
  2.8822 +			// block-level elements need to be inline with layout
  2.8823 +			if ( !jQuery.support.inlineBlockNeedsLayout || css_defaultDisplay( elem.nodeName ) === "inline" ) {
  2.8824 +				style.display = "inline-block";
  2.8825 +
  2.8826 +			} else {
  2.8827 +				style.zoom = 1;
  2.8828 +			}
  2.8829 +		}
  2.8830 +	}
  2.8831 +
  2.8832 +	if ( opts.overflow ) {
  2.8833 +		style.overflow = "hidden";
  2.8834 +		if ( !jQuery.support.shrinkWrapBlocks ) {
  2.8835 +			anim.done(function() {
  2.8836 +				style.overflow = opts.overflow[ 0 ];
  2.8837 +				style.overflowX = opts.overflow[ 1 ];
  2.8838 +				style.overflowY = opts.overflow[ 2 ];
  2.8839 +			});
  2.8840 +		}
  2.8841 +	}
  2.8842 +
  2.8843 +
  2.8844 +	// show/hide pass
  2.8845 +	for ( index in props ) {
  2.8846 +		value = props[ index ];
  2.8847 +		if ( rfxtypes.exec( value ) ) {
  2.8848 +			delete props[ index ];
  2.8849 +			if ( value === ( hidden ? "hide" : "show" ) ) {
  2.8850 +				continue;
  2.8851 +			}
  2.8852 +			handled.push( index );
  2.8853 +		}
  2.8854 +	}
  2.8855 +
  2.8856 +	length = handled.length;
  2.8857 +	if ( length ) {
  2.8858 +		dataShow = jQuery._data( elem, "fxshow" ) || jQuery._data( elem, "fxshow", {} );
  2.8859 +		if ( hidden ) {
  2.8860 +			jQuery( elem ).show();
  2.8861 +		} else {
  2.8862 +			anim.done(function() {
  2.8863 +				jQuery( elem ).hide();
  2.8864 +			});
  2.8865 +		}
  2.8866 +		anim.done(function() {
  2.8867 +			var prop;
  2.8868 +			jQuery.removeData( elem, "fxshow", true );
  2.8869 +			for ( prop in orig ) {
  2.8870 +				jQuery.style( elem, prop, orig[ prop ] );
  2.8871 +			}
  2.8872 +		});
  2.8873 +		for ( index = 0 ; index < length ; index++ ) {
  2.8874 +			prop = handled[ index ];
  2.8875 +			tween = anim.createTween( prop, hidden ? dataShow[ prop ] : 0 );
  2.8876 +			orig[ prop ] = dataShow[ prop ] || jQuery.style( elem, prop );
  2.8877 +
  2.8878 +			if ( !( prop in dataShow ) ) {
  2.8879 +				dataShow[ prop ] = tween.start;
  2.8880 +				if ( hidden ) {
  2.8881 +					tween.end = tween.start;
  2.8882 +					tween.start = prop === "width" || prop === "height" ? 1 : 0;
  2.8883 +				}
  2.8884 +			}
  2.8885 +		}
  2.8886 +	}
  2.8887 +}
  2.8888 +
  2.8889 +function Tween( elem, options, prop, end, easing ) {
  2.8890 +	return new Tween.prototype.init( elem, options, prop, end, easing );
  2.8891 +}
  2.8892 +jQuery.Tween = Tween;
  2.8893 +
  2.8894 +Tween.prototype = {
  2.8895 +	constructor: Tween,
  2.8896 +	init: function( elem, options, prop, end, easing, unit ) {
  2.8897 +		this.elem = elem;
  2.8898 +		this.prop = prop;
  2.8899 +		this.easing = easing || "swing";
  2.8900 +		this.options = options;
  2.8901 +		this.start = this.now = this.cur();
  2.8902 +		this.end = end;
  2.8903 +		this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" );
  2.8904 +	},
  2.8905 +	cur: function() {
  2.8906 +		var hooks = Tween.propHooks[ this.prop ];
  2.8907 +
  2.8908 +		return hooks && hooks.get ?
  2.8909 +			hooks.get( this ) :
  2.8910 +			Tween.propHooks._default.get( this );
  2.8911 +	},
  2.8912 +	run: function( percent ) {
  2.8913 +		var eased,
  2.8914 +			hooks = Tween.propHooks[ this.prop ];
  2.8915 +
  2.8916 +		if ( this.options.duration ) {
  2.8917 +			this.pos = eased = jQuery.easing[ this.easing ](
  2.8918 +				percent, this.options.duration * percent, 0, 1, this.options.duration
  2.8919 +			);
  2.8920 +		} else {
  2.8921 +			this.pos = eased = percent;
  2.8922 +		}
  2.8923 +		this.now = ( this.end - this.start ) * eased + this.start;
  2.8924 +
  2.8925 +		if ( this.options.step ) {
  2.8926 +			this.options.step.call( this.elem, this.now, this );
  2.8927 +		}
  2.8928 +
  2.8929 +		if ( hooks && hooks.set ) {
  2.8930 +			hooks.set( this );
  2.8931 +		} else {
  2.8932 +			Tween.propHooks._default.set( this );
  2.8933 +		}
  2.8934 +		return this;
  2.8935 +	}
  2.8936 +};
  2.8937 +
  2.8938 +Tween.prototype.init.prototype = Tween.prototype;
  2.8939 +
  2.8940 +Tween.propHooks = {
  2.8941 +	_default: {
  2.8942 +		get: function( tween ) {
  2.8943 +			var result;
  2.8944 +
  2.8945 +			if ( tween.elem[ tween.prop ] != null &&
  2.8946 +				(!tween.elem.style || tween.elem.style[ tween.prop ] == null) ) {
  2.8947 +				return tween.elem[ tween.prop ];
  2.8948 +			}
  2.8949 +
  2.8950 +			// passing any value as a 4th parameter to .css will automatically
  2.8951 +			// attempt a parseFloat and fallback to a string if the parse fails
  2.8952 +			// so, simple values such as "10px" are parsed to Float.
  2.8953 +			// complex values such as "rotate(1rad)" are returned as is.
  2.8954 +			result = jQuery.css( tween.elem, tween.prop, false, "" );
  2.8955 +			// Empty strings, null, undefined and "auto" are converted to 0.
  2.8956 +			return !result || result === "auto" ? 0 : result;
  2.8957 +		},
  2.8958 +		set: function( tween ) {
  2.8959 +			// use step hook for back compat - use cssHook if its there - use .style if its
  2.8960 +			// available and use plain properties where available
  2.8961 +			if ( jQuery.fx.step[ tween.prop ] ) {
  2.8962 +				jQuery.fx.step[ tween.prop ]( tween );
  2.8963 +			} else if ( tween.elem.style && ( tween.elem.style[ jQuery.cssProps[ tween.prop ] ] != null || jQuery.cssHooks[ tween.prop ] ) ) {
  2.8964 +				jQuery.style( tween.elem, tween.prop, tween.now + tween.unit );
  2.8965 +			} else {
  2.8966 +				tween.elem[ tween.prop ] = tween.now;
  2.8967 +			}
  2.8968 +		}
  2.8969 +	}
  2.8970 +};
  2.8971 +
  2.8972 +// Remove in 2.0 - this supports IE8's panic based approach
  2.8973 +// to setting things on disconnected nodes
  2.8974 +
  2.8975 +Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
  2.8976 +	set: function( tween ) {
  2.8977 +		if ( tween.elem.nodeType && tween.elem.parentNode ) {
  2.8978 +			tween.elem[ tween.prop ] = tween.now;
  2.8979 +		}
  2.8980 +	}
  2.8981 +};
  2.8982 +
  2.8983 +jQuery.each([ "toggle", "show", "hide" ], function( i, name ) {
  2.8984 +	var cssFn = jQuery.fn[ name ];
  2.8985 +	jQuery.fn[ name ] = function( speed, easing, callback ) {
  2.8986 +		return speed == null || typeof speed === "boolean" ||
  2.8987 +			// special check for .toggle( handler, handler, ... )
  2.8988 +			( !i && jQuery.isFunction( speed ) && jQuery.isFunction( easing ) ) ?
  2.8989 +			cssFn.apply( this, arguments ) :
  2.8990 +			this.animate( genFx( name, true ), speed, easing, callback );
  2.8991 +	};
  2.8992 +});
  2.8993 +
  2.8994 +jQuery.fn.extend({
  2.8995 +	fadeTo: function( speed, to, easing, callback ) {
  2.8996 +
  2.8997 +		// show any hidden elements after setting opacity to 0
  2.8998 +		return this.filter( isHidden ).css( "opacity", 0 ).show()
  2.8999 +
  2.9000 +			// animate to the value specified
  2.9001 +			.end().animate({ opacity: to }, speed, easing, callback );
  2.9002 +	},
  2.9003 +	animate: function( prop, speed, easing, callback ) {
  2.9004 +		var empty = jQuery.isEmptyObject( prop ),
  2.9005 +			optall = jQuery.speed( speed, easing, callback ),
  2.9006 +			doAnimation = function() {
  2.9007 +				// Operate on a copy of prop so per-property easing won't be lost
  2.9008 +				var anim = Animation( this, jQuery.extend( {}, prop ), optall );
  2.9009 +
  2.9010 +				// Empty animations resolve immediately
  2.9011 +				if ( empty ) {
  2.9012 +					anim.stop( true );
  2.9013 +				}
  2.9014 +			};
  2.9015 +
  2.9016 +		return empty || optall.queue === false ?
  2.9017 +			this.each( doAnimation ) :
  2.9018 +			this.queue( optall.queue, doAnimation );
  2.9019 +	},
  2.9020 +	stop: function( type, clearQueue, gotoEnd ) {
  2.9021 +		var stopQueue = function( hooks ) {
  2.9022 +			var stop = hooks.stop;
  2.9023 +			delete hooks.stop;
  2.9024 +			stop( gotoEnd );
  2.9025 +		};
  2.9026 +
  2.9027 +		if ( typeof type !== "string" ) {
  2.9028 +			gotoEnd = clearQueue;
  2.9029 +			clearQueue = type;
  2.9030 +			type = undefined;
  2.9031 +		}
  2.9032 +		if ( clearQueue && type !== false ) {
  2.9033 +			this.queue( type || "fx", [] );
  2.9034 +		}
  2.9035 +
  2.9036 +		return this.each(function() {
  2.9037 +			var dequeue = true,
  2.9038 +				index = type != null && type + "queueHooks",
  2.9039 +				timers = jQuery.timers,
  2.9040 +				data = jQuery._data( this );
  2.9041 +
  2.9042 +			if ( index ) {
  2.9043 +				if ( data[ index ] && data[ index ].stop ) {
  2.9044 +					stopQueue( data[ index ] );
  2.9045 +				}
  2.9046 +			} else {
  2.9047 +				for ( index in data ) {
  2.9048 +					if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {
  2.9049 +						stopQueue( data[ index ] );
  2.9050 +					}
  2.9051 +				}
  2.9052 +			}
  2.9053 +
  2.9054 +			for ( index = timers.length; index--; ) {
  2.9055 +				if ( timers[ index ].elem === this && (type == null || timers[ index ].queue === type) ) {
  2.9056 +					timers[ index ].anim.stop( gotoEnd );
  2.9057 +					dequeue = false;
  2.9058 +					timers.splice( index, 1 );
  2.9059 +				}
  2.9060 +			}
  2.9061 +
  2.9062 +			// start the next in the queue if the last step wasn't forced
  2.9063 +			// timers currently will call their complete callbacks, which will dequeue
  2.9064 +			// but only if they were gotoEnd
  2.9065 +			if ( dequeue || !gotoEnd ) {
  2.9066 +				jQuery.dequeue( this, type );
  2.9067 +			}
  2.9068 +		});
  2.9069 +	}
  2.9070 +});
  2.9071 +
  2.9072 +// Generate parameters to create a standard animation
  2.9073 +function genFx( type, includeWidth ) {
  2.9074 +	var which,
  2.9075 +		attrs = { height: type },
  2.9076 +		i = 0;
  2.9077 +
  2.9078 +	// if we include width, step value is 1 to do all cssExpand values,
  2.9079 +	// if we don't include width, step value is 2 to skip over Left and Right
  2.9080 +	includeWidth = includeWidth? 1 : 0;
  2.9081 +	for( ; i < 4 ; i += 2 - includeWidth ) {
  2.9082 +		which = cssExpand[ i ];
  2.9083 +		attrs[ "margin" + which ] = attrs[ "padding" + which ] = type;
  2.9084 +	}
  2.9085 +
  2.9086 +	if ( includeWidth ) {
  2.9087 +		attrs.opacity = attrs.width = type;
  2.9088 +	}
  2.9089 +
  2.9090 +	return attrs;
  2.9091 +}
  2.9092 +
  2.9093 +// Generate shortcuts for custom animations
  2.9094 +jQuery.each({
  2.9095 +	slideDown: genFx("show"),
  2.9096 +	slideUp: genFx("hide"),
  2.9097 +	slideToggle: genFx("toggle"),
  2.9098 +	fadeIn: { opacity: "show" },
  2.9099 +	fadeOut: { opacity: "hide" },
  2.9100 +	fadeToggle: { opacity: "toggle" }
  2.9101 +}, function( name, props ) {
  2.9102 +	jQuery.fn[ name ] = function( speed, easing, callback ) {
  2.9103 +		return this.animate( props, speed, easing, callback );
  2.9104 +	};
  2.9105 +});
  2.9106 +
  2.9107 +jQuery.speed = function( speed, easing, fn ) {
  2.9108 +	var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
  2.9109 +		complete: fn || !fn && easing ||
  2.9110 +			jQuery.isFunction( speed ) && speed,
  2.9111 +		duration: speed,
  2.9112 +		easing: fn && easing || easing && !jQuery.isFunction( easing ) && easing
  2.9113 +	};
  2.9114 +
  2.9115 +	opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
  2.9116 +		opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[ opt.duration ] : jQuery.fx.speeds._default;
  2.9117 +
  2.9118 +	// normalize opt.queue - true/undefined/null -> "fx"
  2.9119 +	if ( opt.queue == null || opt.queue === true ) {
  2.9120 +		opt.queue = "fx";
  2.9121 +	}
  2.9122 +
  2.9123 +	// Queueing
  2.9124 +	opt.old = opt.complete;
  2.9125 +
  2.9126 +	opt.complete = function() {
  2.9127 +		if ( jQuery.isFunction( opt.old ) ) {
  2.9128 +			opt.old.call( this );
  2.9129 +		}
  2.9130 +
  2.9131 +		if ( opt.queue ) {
  2.9132 +			jQuery.dequeue( this, opt.queue );
  2.9133 +		}
  2.9134 +	};
  2.9135 +
  2.9136 +	return opt;
  2.9137 +};
  2.9138 +
  2.9139 +jQuery.easing = {
  2.9140 +	linear: function( p ) {
  2.9141 +		return p;
  2.9142 +	},
  2.9143 +	swing: function( p ) {
  2.9144 +		return 0.5 - Math.cos( p*Math.PI ) / 2;
  2.9145 +	}
  2.9146 +};
  2.9147 +
  2.9148 +jQuery.timers = [];
  2.9149 +jQuery.fx = Tween.prototype.init;
  2.9150 +jQuery.fx.tick = function() {
  2.9151 +	var timer,
  2.9152 +		timers = jQuery.timers,
  2.9153 +		i = 0;
  2.9154 +
  2.9155 +	for ( ; i < timers.length; i++ ) {
  2.9156 +		timer = timers[ i ];
  2.9157 +		// Checks the timer has not already been removed
  2.9158 +		if ( !timer() && timers[ i ] === timer ) {
  2.9159 +			timers.splice( i--, 1 );
  2.9160 +		}
  2.9161 +	}
  2.9162 +
  2.9163 +	if ( !timers.length ) {
  2.9164 +		jQuery.fx.stop();
  2.9165 +	}
  2.9166 +};
  2.9167 +
  2.9168 +jQuery.fx.timer = function( timer ) {
  2.9169 +	if ( timer() && jQuery.timers.push( timer ) && !timerId ) {
  2.9170 +		timerId = setInterval( jQuery.fx.tick, jQuery.fx.interval );
  2.9171 +	}
  2.9172 +};
  2.9173 +
  2.9174 +jQuery.fx.interval = 13;
  2.9175 +
  2.9176 +jQuery.fx.stop = function() {
  2.9177 +	clearInterval( timerId );
  2.9178 +	timerId = null;
  2.9179 +};
  2.9180 +
  2.9181 +jQuery.fx.speeds = {
  2.9182 +	slow: 600,
  2.9183 +	fast: 200,
  2.9184 +	// Default speed
  2.9185 +	_default: 400
  2.9186 +};
  2.9187 +
  2.9188 +// Back Compat <1.8 extension point
  2.9189 +jQuery.fx.step = {};
  2.9190 +
  2.9191 +if ( jQuery.expr && jQuery.expr.filters ) {
  2.9192 +	jQuery.expr.filters.animated = function( elem ) {
  2.9193 +		return jQuery.grep(jQuery.timers, function( fn ) {
  2.9194 +			return elem === fn.elem;
  2.9195 +		}).length;
  2.9196 +	};
  2.9197 +}
  2.9198 +var rroot = /^(?:body|html)$/i;
  2.9199 +
  2.9200 +jQuery.fn.offset = function( options ) {
  2.9201 +	if ( arguments.length ) {
  2.9202 +		return options === undefined ?
  2.9203 +			this :
  2.9204 +			this.each(function( i ) {
  2.9205 +				jQuery.offset.setOffset( this, options, i );
  2.9206 +			});
  2.9207 +	}
  2.9208 +
  2.9209 +	var docElem, body, win, clientTop, clientLeft, scrollTop, scrollLeft,
  2.9210 +		box = { top: 0, left: 0 },
  2.9211 +		elem = this[ 0 ],
  2.9212 +		doc = elem && elem.ownerDocument;
  2.9213 +
  2.9214 +	if ( !doc ) {
  2.9215 +		return;
  2.9216 +	}
  2.9217 +
  2.9218 +	if ( (body = doc.body) === elem ) {
  2.9219 +		return jQuery.offset.bodyOffset( elem );
  2.9220 +	}
  2.9221 +
  2.9222 +	docElem = doc.documentElement;
  2.9223 +
  2.9224 +	// Make sure it's not a disconnected DOM node
  2.9225 +	if ( !jQuery.contains( docElem, elem ) ) {
  2.9226 +		return box;
  2.9227 +	}
  2.9228 +
  2.9229 +	// If we don't have gBCR, just use 0,0 rather than error
  2.9230 +	// BlackBerry 5, iOS 3 (original iPhone)
  2.9231 +	if ( typeof elem.getBoundingClientRect !== "undefined" ) {
  2.9232 +		box = elem.getBoundingClientRect();
  2.9233 +	}
  2.9234 +	win = getWindow( doc );
  2.9235 +	clientTop  = docElem.clientTop  || body.clientTop  || 0;
  2.9236 +	clientLeft = docElem.clientLeft || body.clientLeft || 0;
  2.9237 +	scrollTop  = win.pageYOffset || docElem.scrollTop;
  2.9238 +	scrollLeft = win.pageXOffset || docElem.scrollLeft;
  2.9239 +	return {
  2.9240 +		top: box.top  + scrollTop  - clientTop,
  2.9241 +		left: box.left + scrollLeft - clientLeft
  2.9242 +	};
  2.9243 +};
  2.9244 +
  2.9245 +jQuery.offset = {
  2.9246 +
  2.9247 +	bodyOffset: function( body ) {
  2.9248 +		var top = body.offsetTop,
  2.9249 +			left = body.offsetLeft;
  2.9250 +
  2.9251 +		if ( jQuery.support.doesNotIncludeMarginInBodyOffset ) {
  2.9252 +			top  += parseFloat( jQuery.css(body, "marginTop") ) || 0;
  2.9253 +			left += parseFloat( jQuery.css(body, "marginLeft") ) || 0;
  2.9254 +		}
  2.9255 +
  2.9256 +		return { top: top, left: left };
  2.9257 +	},
  2.9258 +
  2.9259 +	setOffset: function( elem, options, i ) {
  2.9260 +		var position = jQuery.css( elem, "position" );
  2.9261 +
  2.9262 +		// set position first, in-case top/left are set even on static elem
  2.9263 +		if ( position === "static" ) {
  2.9264 +			elem.style.position = "relative";
  2.9265 +		}
  2.9266 +
  2.9267 +		var curElem = jQuery( elem ),
  2.9268 +			curOffset = curElem.offset(),
  2.9269 +			curCSSTop = jQuery.css( elem, "top" ),
  2.9270 +			curCSSLeft = jQuery.css( elem, "left" ),
  2.9271 +			calculatePosition = ( position === "absolute" || position === "fixed" ) && jQuery.inArray("auto", [curCSSTop, curCSSLeft]) > -1,
  2.9272 +			props = {}, curPosition = {}, curTop, curLeft;
  2.9273 +
  2.9274 +		// need to be able to calculate position if either top or left is auto and position is either absolute or fixed
  2.9275 +		if ( calculatePosition ) {
  2.9276 +			curPosition = curElem.position();
  2.9277 +			curTop = curPosition.top;
  2.9278 +			curLeft = curPosition.left;
  2.9279 +		} else {
  2.9280 +			curTop = parseFloat( curCSSTop ) || 0;
  2.9281 +			curLeft = parseFloat( curCSSLeft ) || 0;
  2.9282 +		}
  2.9283 +
  2.9284 +		if ( jQuery.isFunction( options ) ) {
  2.9285 +			options = options.call( elem, i, curOffset );
  2.9286 +		}
  2.9287 +
  2.9288 +		if ( options.top != null ) {
  2.9289 +			props.top = ( options.top - curOffset.top ) + curTop;
  2.9290 +		}
  2.9291 +		if ( options.left != null ) {
  2.9292 +			props.left = ( options.left - curOffset.left ) + curLeft;
  2.9293 +		}
  2.9294 +
  2.9295 +		if ( "using" in options ) {
  2.9296 +			options.using.call( elem, props );
  2.9297 +		} else {
  2.9298 +			curElem.css( props );
  2.9299 +		}
  2.9300 +	}
  2.9301 +};
  2.9302 +
  2.9303 +
  2.9304 +jQuery.fn.extend({
  2.9305 +
  2.9306 +	position: function() {
  2.9307 +		if ( !this[0] ) {
  2.9308 +			return;
  2.9309 +		}
  2.9310 +
  2.9311 +		var elem = this[0],
  2.9312 +
  2.9313 +		// Get *real* offsetParent
  2.9314 +		offsetParent = this.offsetParent(),
  2.9315 +
  2.9316 +		// Get correct offsets
  2.9317 +		offset       = this.offset(),
  2.9318 +		parentOffset = rroot.test(offsetParent[0].nodeName) ? { top: 0, left: 0 } : offsetParent.offset();
  2.9319 +
  2.9320 +		// Subtract element margins
  2.9321 +		// note: when an element has margin: auto the offsetLeft and marginLeft
  2.9322 +		// are the same in Safari causing offset.left to incorrectly be 0
  2.9323 +		offset.top  -= parseFloat( jQuery.css(elem, "marginTop") ) || 0;
  2.9324 +		offset.left -= parseFloat( jQuery.css(elem, "marginLeft") ) || 0;
  2.9325 +
  2.9326 +		// Add offsetParent borders
  2.9327 +		parentOffset.top  += parseFloat( jQuery.css(offsetParent[0], "borderTopWidth") ) || 0;
  2.9328 +		parentOffset.left += parseFloat( jQuery.css(offsetParent[0], "borderLeftWidth") ) || 0;
  2.9329 +
  2.9330 +		// Subtract the two offsets
  2.9331 +		return {
  2.9332 +			top:  offset.top  - parentOffset.top,
  2.9333 +			left: offset.left - parentOffset.left
  2.9334 +		};
  2.9335 +	},
  2.9336 +
  2.9337 +	offsetParent: function() {
  2.9338 +		return this.map(function() {
  2.9339 +			var offsetParent = this.offsetParent || document.body;
  2.9340 +			while ( offsetParent && (!rroot.test(offsetParent.nodeName) && jQuery.css(offsetParent, "position") === "static") ) {
  2.9341 +				offsetParent = offsetParent.offsetParent;
  2.9342 +			}
  2.9343 +			return offsetParent || document.body;
  2.9344 +		});
  2.9345 +	}
  2.9346 +});
  2.9347 +
  2.9348 +
  2.9349 +// Create scrollLeft and scrollTop methods
  2.9350 +jQuery.each( {scrollLeft: "pageXOffset", scrollTop: "pageYOffset"}, function( method, prop ) {
  2.9351 +	var top = /Y/.test( prop );
  2.9352 +
  2.9353 +	jQuery.fn[ method ] = function( val ) {
  2.9354 +		return jQuery.access( this, function( elem, method, val ) {
  2.9355 +			var win = getWindow( elem );
  2.9356 +
  2.9357 +			if ( val === undefined ) {
  2.9358 +				return win ? (prop in win) ? win[ prop ] :
  2.9359 +					win.document.documentElement[ method ] :
  2.9360 +					elem[ method ];
  2.9361 +			}
  2.9362 +
  2.9363 +			if ( win ) {
  2.9364 +				win.scrollTo(
  2.9365 +					!top ? val : jQuery( win ).scrollLeft(),
  2.9366 +					 top ? val : jQuery( win ).scrollTop()
  2.9367 +				);
  2.9368 +
  2.9369 +			} else {
  2.9370 +				elem[ method ] = val;
  2.9371 +			}
  2.9372 +		}, method, val, arguments.length, null );
  2.9373 +	};
  2.9374 +});
  2.9375 +
  2.9376 +function getWindow( elem ) {
  2.9377 +	return jQuery.isWindow( elem ) ?
  2.9378 +		elem :
  2.9379 +		elem.nodeType === 9 ?
  2.9380 +			elem.defaultView || elem.parentWindow :
  2.9381 +			false;
  2.9382 +}
  2.9383 +// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods
  2.9384 +jQuery.each( { Height: "height", Width: "width" }, function( name, type ) {
  2.9385 +	jQuery.each( { padding: "inner" + name, content: type, "": "outer" + name }, function( defaultExtra, funcName ) {
  2.9386 +		// margin is only for outerHeight, outerWidth
  2.9387 +		jQuery.fn[ funcName ] = function( margin, value ) {
  2.9388 +			var chainable = arguments.length && ( defaultExtra || typeof margin !== "boolean" ),
  2.9389 +				extra = defaultExtra || ( margin === true || value === true ? "margin" : "border" );
  2.9390 +
  2.9391 +			return jQuery.access( this, function( elem, type, value ) {
  2.9392 +				var doc;
  2.9393 +
  2.9394 +				if ( jQuery.isWindow( elem ) ) {
  2.9395 +					// As of 5/8/2012 this will yield incorrect results for Mobile Safari, but there
  2.9396 +					// isn't a whole lot we can do. See pull request at this URL for discussion:
  2.9397 +					// https://github.com/jquery/jquery/pull/764
  2.9398 +					return elem.document.documentElement[ "client" + name ];
  2.9399 +				}
  2.9400 +
  2.9401 +				// Get document width or height
  2.9402 +				if ( elem.nodeType === 9 ) {
  2.9403 +					doc = elem.documentElement;
  2.9404 +
  2.9405 +					// Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height], whichever is greatest
  2.9406 +					// unfortunately, this causes bug #3838 in IE6/8 only, but there is currently no good, small way to fix it.
  2.9407 +					return Math.max(
  2.9408 +						elem.body[ "scroll" + name ], doc[ "scroll" + name ],
  2.9409 +						elem.body[ "offset" + name ], doc[ "offset" + name ],
  2.9410 +						doc[ "client" + name ]
  2.9411 +					);
  2.9412 +				}
  2.9413 +
  2.9414 +				return value === undefined ?
  2.9415 +					// Get width or height on the element, requesting but not forcing parseFloat
  2.9416 +					jQuery.css( elem, type, value, extra ) :
  2.9417 +
  2.9418 +					// Set width or height on the element
  2.9419 +					jQuery.style( elem, type, value, extra );
  2.9420 +			}, type, chainable ? margin : undefined, chainable, null );
  2.9421 +		};
  2.9422 +	});
  2.9423 +});
  2.9424 +// Expose jQuery to the global object
  2.9425 +window.jQuery = window.$ = jQuery;
  2.9426 +
  2.9427 +// Expose jQuery as an AMD module, but only for AMD loaders that
  2.9428 +// understand the issues with loading multiple versions of jQuery
  2.9429 +// in a page that all might call define(). The loader will indicate
  2.9430 +// they have special allowances for multiple jQuery versions by
  2.9431 +// specifying define.amd.jQuery = true. Register as a named module,
  2.9432 +// since jQuery can be concatenated with other files that may use define,
  2.9433 +// but not use a proper concatenation script that understands anonymous
  2.9434 +// AMD modules. A named AMD is safest and most robust way to register.
  2.9435 +// Lowercase jquery is used because AMD module names are derived from
  2.9436 +// file names, and jQuery is normally delivered in a lowercase file name.
  2.9437 +// Do this after creating the global so that if an AMD module wants to call
  2.9438 +// noConflict to hide this version of jQuery, it will work.
  2.9439 +if ( typeof define === "function" && define.amd && define.amd.jQuery ) {
  2.9440 +	define( "jquery", [], function () { return jQuery; } );
  2.9441 +}
  2.9442 +
  2.9443 +})( window );
     3.1 --- a/endpoint/WebContent/query.jsp	Tue Oct 02 15:12:45 2012 +0300
     3.2 +++ b/endpoint/WebContent/query.jsp	Tue Oct 02 18:35:44 2012 +0300
     3.3 @@ -12,6 +12,7 @@
     3.4  <head>
     3.5  	<meta name="viewport" content="initial-scale=1.0, user-scalable=no" />
     3.6  	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
     3.7 +	<script type="text/javascript" src="js/more_link.js"></script>
     3.8  	<link rel="stylesheet" href="style.css" type="text/css" />
     3.9  	<script type="text/javascript">
    3.10  		function toggleMe(a) {
    3.11 @@ -27,6 +28,41 @@
    3.12  			return true;
    3.13  		}
    3.14  	</script>
    3.15 +	<script>
    3.16 +		$(document).ready(function() {
    3.17 +		var showChar = 100;
    3.18 +		var ellipsestext = "...";
    3.19 +		var moretext = "more";
    3.20 +		var lesstext = "less";
    3.21 +		$('.more').each(function() {
    3.22 +			var content = $(this).html();
    3.23 +	
    3.24 +			if(content.length > showChar) {
    3.25 +	
    3.26 +				var c = content.substr(0, showChar);
    3.27 +				var h = content.substr(showChar-1, content.length - showChar);
    3.28 +	
    3.29 +				var html = c + '<span class="moreelipses">'+ellipsestext+'</span>&nbsp;<span class="morecontent"><span>' + h + '</span>&nbsp;&nbsp;<a href="" class="morelink">'+moretext+'</a></span>';
    3.30 +	
    3.31 +				$(this).html(html);
    3.32 +			}
    3.33 +	
    3.34 +		});
    3.35 +	
    3.36 +		$(".morelink").click(function(){
    3.37 +			if($(this).hasClass("less")) {
    3.38 +				$(this).removeClass("less");
    3.39 +				$(this).html(moretext);
    3.40 +			} else {
    3.41 +				$(this).addClass("less");
    3.42 +				$(this).html(lesstext);
    3.43 +			}
    3.44 +			$(this).parent().prev().toggle();
    3.45 +			$(this).prev().toggle();
    3.46 +			return false;
    3.47 +		});
    3.48 +	});
    3.49 +</script>
    3.50  <%
    3.51  	if (request.getAttribute("pathToKML") != null) {
    3.52  	if ("map_local".equals(request.getAttribute("handle"))) {
     4.1 --- a/endpoint/WebContent/style.css	Tue Oct 02 15:12:45 2012 +0300
     4.2 +++ b/endpoint/WebContent/style.css	Tue Oct 02 18:35:44 2012 +0300
     4.3 @@ -201,4 +201,18 @@
     4.4  	letter-spacing:.1em;
     4.5  	text-decoration: none;
     4.6  	}
     4.7 -	
     4.8 \ No newline at end of file
     4.9 +	
    4.10 +.comment {
    4.11 +	width: 400px;
    4.12 +	background-color: #f0f0f0;
    4.13 +	margin: 10px;
    4.14 +}
    4.15 +a.morelink {
    4.16 +	text-decoration:none;
    4.17 +	outline: none;
    4.18 +	color: blue;
    4.19 +}
    4.20 +.morecontent span {
    4.21 +	display: none;
    4.22 +
    4.23 +}	
    4.24 \ No newline at end of file
     5.1 --- a/resultio/src/main/java/org/openrdf/query/resultio/sparqlhtml/stSPARQLResultsHTMLWriter.java	Tue Oct 02 15:12:45 2012 +0300
     5.2 +++ b/resultio/src/main/java/org/openrdf/query/resultio/sparqlhtml/stSPARQLResultsHTMLWriter.java	Tue Oct 02 18:35:44 2012 +0300
     5.3 @@ -43,6 +43,7 @@
     5.4  	public static final String TABLE_HEADER_CLASS	= "query_results_header";
     5.5  	public static final String TABLE_DATA_CLASS		= "query_results_data";
     5.6  	public static final String TABLE_CLASS			= "query_results_table";
     5.7 +	public static final String MORE_LINK			= "comment more";
     5.8  	
     5.9  	/**
    5.10  	 * The underlying XML formatter.
    5.11 @@ -121,13 +122,13 @@
    5.12  					if(boundValue instanceof BNode) {
    5.13  						value.insert(0, "_:");
    5.14  					}
    5.15 -					
    5.16 -					xmlWriter.setAttribute(STYLE, TABLE_DATA_CLASS);
    5.17 -					xmlWriter.setAttribute(ID, LINK_ID);
    5.18 -					xmlWriter.startTag(TABLE_DATA_TAG);
    5.19 +										
    5.20  					// If the value is a uri, make it link
    5.21  					if(boundValue instanceof URI)
    5.22 -					{
    5.23 +					{						
    5.24 +						xmlWriter.setAttribute(ID, LINK_ID);						
    5.25 +						xmlWriter.startTag(TABLE_DATA_TAG);
    5.26 +						
    5.27  						// select all the triples that contain the boundValue  
    5.28  						String query= "select * " +
    5.29  								"where " +
    5.30 @@ -142,20 +143,20 @@
    5.31  						xmlWriter.setAttribute(LINK_REF, href);
    5.32  						xmlWriter.startTag(LINK);							
    5.33  						xmlWriter.text(boundValue.toString());					
    5.34 -						xmlWriter.endTag(LINK);		
    5.35 +						xmlWriter.endTag(LINK);							
    5.36  					}
    5.37  					else
    5.38 -					{						
    5.39 +					{	
    5.40 +						xmlWriter.setAttribute(STYLE, MORE_LINK);						
    5.41 +						xmlWriter.startTag(TABLE_DATA_TAG);
    5.42  						xmlWriter.text(boundValue.toString());
    5.43  					}																					
    5.44  					xmlWriter.endTag(TABLE_DATA_TAG);							
    5.45 -					value.setLength(0);					 
    5.46 -				}					
    5.47 -				
    5.48 +				}									
    5.49  				value.setLength(0);
    5.50  			}
    5.51 +			xmlWriter.endTag(TABLE_ROW_TAG);
    5.52  			
    5.53 -			xmlWriter.endTag(TABLE_ROW_TAG);
    5.54  		} catch (IOException e) {
    5.55  			throw new TupleQueryResultHandlerException(e);
    5.56  		}