text: /*
      json2.js
      2007-11-06
  
      Public Domain
  
      No warranty expressed or implied. Use at your own risk.
  
      See http://www.JSON.org/js.html
  
      This file creates a global JSON object containing two methods:
  
          JSON.stringify(value, whitelist)
              value       any JavaScript value, usually an object or array.
  
              whitelist   an optional that determines how object values are
                          stringified.
  
              This method produces a JSON text from a JavaScript value.
              There are three possible ways to stringify an object, depending
              on the optional whitelist parameter.
  
              If an object has a toJSON method, then the toJSON() method will be
              called. The value returned from the toJSON method will be
              stringified.
  
              Otherwise, if the optional whitelist parameter is an array, then
              the elements of the array will be used to select members of the
              object for stringification.
  
              Otherwise, if there is no whitelist parameter, then all of the
              members of the object will be stringified.
  
              Values that do not have JSON representaions, such as undefined or
              functions, will not be serialized. Such values in objects will be
              dropped, in arrays will be replaced with null. JSON.stringify()
              returns undefined. Dates will be stringified as quoted ISO dates.
  
              Example:
  
              var text = JSON.stringify(['e', {pluribus: 'unum'}]);
              // text is '["e",{"pluribus":"unum"}]'
  
          JSON.parse(text, filter)
              This method parses a JSON text to produce an object or
              array. It can throw a SyntaxError exception.
  
              The optional filter parameter is a function that can filter and
              transform the results. It receives each of the keys and values, and
              its return value is used instead of the original value. If it
              returns what it received, then structure is not modified. If it
              returns undefined then the member is deleted.
  
              Example:
  
              // Parse the text. If a key contains the string 'date' then
              // convert the value to a date.
  
              myData = JSON.parse(text, function (key, value) {
                  return key.indexOf('date') >= 0 ? new Date(value) : value;
              });
  
      This is a reference implementation. You are free to copy, modify, or
      redistribute.
  
      Use your own copy. It is extremely unwise to load third party
      code into your pages.
  */
  
  /*jslint evil: true */
  /*extern JSON */
  
  if (!this.JSON) {
  
      JSON = function () {
  
          function f(n) {    // Format integers to have at least two digits.
              return n < 10 ? '0' + n : n;
          }
  
          Date.prototype.toJSON = function () {
  
  // Eventually, this method will be based on the date.toISOString method.
  
              return this.getUTCFullYear()   + '-' +
                   f(this.getUTCMonth() + 1) + '-' +
                   f(this.getUTCDate())      + 'T' +
                   f(this.getUTCHours())     + ':' +
                   f(this.getUTCMinutes())   + ':' +
                   f(this.getUTCSeconds())   + 'Z';
          };
  
  
          var m = {    // table of character substitutions
              '\b': '\\b',
              '\t': '\\t',
              '\n': '\\n',
              '\f': '\\f',
              '\r': '\\r',
              '"' : '\\"',
              '\\': '\\\\'
          };
  
          function stringify(value, whitelist) {
              var a,          // The array holding the partial texts.
                  i,          // The loop counter.
                  k,          // The member key.
                  l,          // Length.
                  r = /["\\\x00-\x1f\x7f-\x9f]/g,
                  v;          // The member value.
  
              switch (typeof value) {
              case 'string':
  
  // If the string contains no control characters, no quote characters, and no
  // backslash characters, then we can safely slap some quotes around it.
  // Otherwise we must also replace the offending characters with safe sequences.
  
                  return r.test(value) ?
                      '"' + value.replace(r, function (a) {
                          var c = m[a];
                          if (c) {
                              return c;
                          }
                          c = a.charCodeAt();
                          return '\\u00' + Math.floor(c / 16).toString(16) +
                                                     (c % 16).toString(16);
                      }) + '"' :
                      '"' + value + '"';
  
              case 'number':
  
  // JSON numbers must be finite. Encode non-finite numbers as null.
  
                  return isFinite(value) ? String(value) : 'null';
  
              case 'boolean':
              case 'null':
                  return String(value);
  
              case 'object':
  
  // Due to a specification blunder in ECMAScript,
  // typeof null is 'object', so watch out for that case.
  
                  if (!value) {
                      return 'null';
                  }
  
  // If the object has a toJSON method, call it, and stringify the result.
  
                  if (typeof value.toJSON === 'function') {
                      return stringify(value.toJSON());
                  }
                  a = [];
                  if (typeof value.length === 'number' &&
                          !(value.propertyIsEnumerable('length'))) {
  
  // The object is an array. Stringify every element. Use null as a placeholder
  // for non-JSON values.
  
                      l = value.length;
                      for (i = 0; i < l; i += 1) {
                          a.push(stringify(value[i], whitelist) || 'null');
                      }
  
  // Join all of the elements together and wrap them in brackets.
  
                      return '[' + a.join(',') + ']';
                  }
                  if (whitelist) {
  
  // If a whitelist (array of keys) is provided, use it to select the components
  // of the object.
  
                      l = whitelist.length;
                      for (i = 0; i < l; i += 1) {
                          k = whitelist[i];
                          if (typeof k === 'string') {
                              v = stringify(value[k], whitelist);
                              if (v) {
                                  a.push(stringify(k) + ':' + v);
                              }
                          }
                      }
                  } else {
  
  // Otherwise, iterate through all of the keys in the object.
  
                      for (k in value) {
                          if (typeof k === 'string') {
                              v = stringify(value[k], whitelist);
                              if (v) {
                                  a.push(stringify(k) + ':' + v);
                              }
                          }
                      }
                  }
  
  // Join all of the member texts together and wrap them in braces.
  
                  return '{' + a.join(',') + '}';
              }
          }
  
          return {
              stringify: stringify,
              parse: function (text, filter) {
                  var j;
  
                  function walk(k, v) {
                      var i, n;
                      if (v && typeof v === 'object') {
                          for (i in v) {
                              if (Object.prototype.hasOwnProperty.apply(v, [i])) {
                                  n = walk(i, v[i]);
                                  if (n !== undefined) {
                                      v[i] = n;
                                  }
                              }
                          }
                      }
                      return filter(k, v);
                  }
  
  
  // Parsing happens in three stages. In the first stage, we run the text against
  // regular expressions that look for non-JSON patterns. We are especially
  // concerned with '()' and 'new' because they can cause invocation, and '='
  // because it can cause mutation. But just to be safe, we want to reject all
  // unexpected forms.
  
  // We split the first stage into 4 regexp operations in order to work around
  // crippling inefficiencies in IE's and Safari's regexp engines. First we
  // replace all backslash pairs with '@' (a non-JSON character). Second, we
  // replace all simple value tokens with ']' characters. Third, we delete all
  // open brackets that follow a colon or comma or that begin the text. Finally,
  // we look to see that the remaining characters are only whitespace or ']' or
  // ',' or ':' or '{' or '}'. If that is so, then the text is safe for eval.
  
                  if (/^[\],:{}\s]*$/.test(text.replace(/\\./g, '@').
  replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(:?[eE][+\-]?\d+)?/g, ']').
  replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) {
  
  // In the second stage we use the eval function to compile the text into a
  // JavaScript structure. The '{' operator is subject to a syntactic ambiguity
  // in JavaScript: it can begin a block or an object literal. We wrap the text
  // in parens to eliminate the ambiguity.
  
                      j = eval('(' + text + ')');
  
  // In the optional third stage, we recursively walk the new structure, passing
  // each name/value pair to a filter function for possible transformation.
  
                      return typeof filter === 'function' ? walk('', j) : j;
                  }
  
  // If the text is not JSON parseable, then a SyntaxError is thrown.
  
                  throw new SyntaxError('parseJSON');
              }
          };
      }();
  }
  /*!
   * jQuery JavaScript Library v1.6.1
   * http://jquery.com/
   *
   * Copyright 2011, John Resig
   * Dual licensed under the MIT or GPL Version 2 licenses.
   * http://jquery.org/license
   *
   * Includes Sizzle.js
   * http://sizzlejs.com/
   * Copyright 2011, The Dojo Foundation
   * Released under the MIT, BSD, and GPL Licenses.
   *
   * Date: Thu May 12 15:04:36 2011 -0400
   */
  (function( window, undefined ) {
  
  // Use the correct document accordingly with window argument (sandbox)
  var document = window.document,
  	navigator = window.navigator,
  	location = window.location;
  var jQuery = (function() {
  
  // Define a local copy of jQuery
  var jQuery = function( selector, context ) {
  		// The jQuery object is actually just the init constructor 'enhanced'
  		return new jQuery.fn.init( selector, context, rootjQuery );
  	},
  
  	// Map over jQuery in case of overwrite
  	_jQuery = window.jQuery,
  
  	// Map over the $ in case of overwrite
  	_$ = window.$,
  
  	// A central reference to the root jQuery(document)
  	rootjQuery,
  
  	// A simple way to check for HTML strings or ID strings
  	// (both of which we optimize for)
  	quickExpr = /^(?:[^<]*(<[\w\W]+>)[^>]*$|#([\w\-]*)$)/,
  
  	// Check if a string has a non-whitespace character in it
  	rnotwhite = /\S/,
  
  	// Used for trimming whitespace
  	trimLeft = /^\s+/,
  	trimRight = /\s+$/,
  
  	// Check for digits
  	rdigit = /\d/,
  
  	// Match a standalone tag
  	rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/,
  
  	// JSON RegExp
  	rvalidchars = /^[\],:{}\s]*$/,
  	rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,
  	rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
  	rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
  
  	// Useragent RegExp
  	rwebkit = /(webkit)[ \/]([\w.]+)/,
  	ropera = /(opera)(?:.*version)?[ \/]([\w.]+)/,
  	rmsie = /(msie) ([\w.]+)/,
  	rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/,
  
  	// Keep a UserAgent string for use with jQuery.browser
  	userAgent = navigator.userAgent,
  
  	// For matching the engine and version of the browser
  	browserMatch,
  
  	// The deferred used on DOM ready
  	readyList,
  
  	// The ready event handler
  	DOMContentLoaded,
  
  	// Save a reference to some core methods
  	toString = Object.prototype.toString,
  	hasOwn = Object.prototype.hasOwnProperty,
  	push = Array.prototype.push,
  	slice = Array.prototype.slice,
  	trim = String.prototype.trim,
  	indexOf = Array.prototype.indexOf,
  
  	// [[Class]] -> type pairs
  	class2type = {};
  
  jQuery.fn = jQuery.prototype = {
  	constructor: jQuery,
  	init: function( selector, context, rootjQuery ) {
  		var match, elem, ret, doc;
  
  		// Handle $(""), $(null), or $(undefined)
  		if ( !selector ) {
  			return this;
  		}
  
  		// Handle $(DOMElement)
  		if ( selector.nodeType ) {
  			this.context = this[0] = selector;
  			this.length = 1;
  			return this;
  		}
  
  		// The body element only exists once, optimize finding it
  		if ( selector === "body" && !context && document.body ) {
  			this.context = document;
  			this[0] = document.body;
  			this.selector = selector;
  			this.length = 1;
  			return this;
  		}
  
  		// Handle HTML strings
  		if ( typeof selector === "string" ) {
  			// Are we dealing with HTML string or an ID?
  			if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) {
  				// Assume that strings that start and end with <> are HTML and skip the regex check
  				match = [ null, selector, null ];
  
  			} else {
  				match = quickExpr.exec( selector );
  			}
  
  			// Verify a match, and that no context was specified for #id
  			if ( match && (match[1] || !context) ) {
  
  				// HANDLE: $(html) -> $(array)
  				if ( match[1] ) {
  					context = context instanceof jQuery ? context[0] : context;
  					doc = (context ? context.ownerDocument || context : document);
  
  					// If a single string is passed in and it's a single tag
  					// just do a createElement and skip the rest
  					ret = rsingleTag.exec( selector );
  
  					if ( ret ) {
  						if ( jQuery.isPlainObject( context ) ) {
  							selector = [ document.createElement( ret[1] ) ];
  							jQuery.fn.attr.call( selector, context, true );
  
  						} else {
  							selector = [ doc.createElement( ret[1] ) ];
  						}
  
  					} else {
  						ret = jQuery.buildFragment( [ match[1] ], [ doc ] );
  						selector = (ret.cacheable ? jQuery.clone(ret.fragment) : ret.fragment).childNodes;
  					}
  
  					return jQuery.merge( this, selector );
  
  				// HANDLE: $("#id")
  				} else {
  					elem = document.getElementById( match[2] );
  
  					// Check parentNode to catch when Blackberry 4.6 returns
  					// nodes that are no longer in the document #6963
  					if ( elem && elem.parentNode ) {
  						// Handle the case where IE and Opera return items
  						// by name instead of ID
  						if ( elem.id !== match[2] ) {
  							return rootjQuery.find( selector );
  						}
  
  						// Otherwise, we inject the element directly into the jQuery object
  						this.length = 1;
  						this[0] = elem;
  					}
  
  					this.context = document;
  					this.selector = selector;
  					return this;
  				}
  
  			// HANDLE: $(expr, $(...))
  			} else if ( !context || context.jquery ) {
  				return (context || rootjQuery).find( selector );
  
  			// HANDLE: $(expr, context)
  			// (which is just equivalent to: $(context).find(expr)
  			} else {
  				return this.constructor( context ).find( selector );
  			}
  
  		// HANDLE: $(function)
  		// Shortcut for document ready
  		} else if ( jQuery.isFunction( selector ) ) {
  			return rootjQuery.ready( selector );
  		}
  
  		if (selector.selector !== undefined) {
  			this.selector = selector.selector;
  			this.context = selector.context;
  		}
  
  		return jQuery.makeArray( selector, this );
  	},
  
  	// Start with an empty selector
  	selector: "",
  
  	// The current version of jQuery being used
  	jquery: "1.6.1",
  
  	// The default length of a jQuery object is 0
  	length: 0,
  
  	// The number of elements contained in the matched element set
  	size: function() {
  		return this.length;
  	},
  
  	toArray: function() {
  		return slice.call( this, 0 );
  	},
  
  	// Get the Nth element in the matched element set OR
  	// Get the whole matched element set as a clean array
  	get: function( num ) {
  		return num == null ?
  
  			// Return a 'clean' array
  			this.toArray() :
  
  			// Return just the object
  			( num < 0 ? this[ this.length + num ] : this[ num ] );
  	},
  
  	// Take an array of elements and push it onto the stack
  	// (returning the new matched element set)
  	pushStack: function( elems, name, selector ) {
  		// Build a new jQuery matched element set
  		var ret = this.constructor();
  
  		if ( jQuery.isArray( elems ) ) {
  			push.apply( ret, elems );
  
  		} else {
  			jQuery.merge( ret, elems );
  		}
  
  		// Add the old object onto the stack (as a reference)
  		ret.prevObject = this;
  
  		ret.context = this.context;
  
  		if ( name === "find" ) {
  			ret.selector = this.selector + (this.selector ? " " : "") + selector;
  		} else if ( name ) {
  			ret.selector = this.selector + "." + name + "(" + selector + ")";
  		}
  
  		// Return the newly-formed element set
  		return ret;
  	},
  
  	// Execute a callback for every element in the matched set.
  	// (You can seed the arguments with an array of args, but this is
  	// only used internally.)
  	each: function( callback, args ) {
  		return jQuery.each( this, callback, args );
  	},
  
  	ready: function( fn ) {
  		// Attach the listeners
  		jQuery.bindReady();
  
  		// Add the callback
  		readyList.done( fn );
  
  		return this;
  	},
  
  	eq: function( i ) {
  		return i === -1 ?
  			this.slice( i ) :
  			this.slice( i, +i + 1 );
  	},
  
  	first: function() {
  		return this.eq( 0 );
  	},
  
  	last: function() {
  		return this.eq( -1 );
  	},
  
  	slice: function() {
  		return this.pushStack( slice.apply( this, arguments ),
  			"slice", slice.call(arguments).join(",") );
  	},
  
  	map: function( callback ) {
  		return this.pushStack( jQuery.map(this, function( elem, i ) {
  			return callback.call( elem, i, elem );
  		}));
  	},
  
  	end: function() {
  		return this.prevObject || this.constructor(null);
  	},
  
  	// For internal use only.
  	// Behaves like an Array's method, not like a jQuery method.
  	push: push,
  	sort: [].sort,
  	splice: [].splice
  };
  
  // Give the init function the jQuery prototype for later instantiation
  jQuery.fn.init.prototype = jQuery.fn;
  
  jQuery.extend = jQuery.fn.extend = function() {
  	var options, name, src, copy, copyIsArray, clone,
  		target = arguments[0] || {},
  		i = 1,
  		length = arguments.length,
  		deep = false;
  
  	// Handle a deep copy situation
  	if ( typeof target === "boolean" ) {
  		deep = target;
  		target = arguments[1] || {};
  		// skip the boolean and the target
  		i = 2;
  	}
  
  	// Handle case when target is a string or something (possible in deep copy)
  	if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
  		target = {};
  	}
  
  	// extend jQuery itself if only one argument is passed
  	if ( length === i ) {
  		target = this;
  		--i;
  	}
  
  	for ( ; i < length; i++ ) {
  		// Only deal with non-null/undefined values
  		if ( (options = arguments[ i ]) != null ) {
  			// Extend the base object
  			for ( name in options ) {
  				src = target[ name ];
  				copy = options[ name ];
  
  				// Prevent never-ending loop
  				if ( target === copy ) {
  					continue;
  				}
  
  				// Recurse if we're merging plain objects or arrays
  				if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
  					if ( copyIsArray ) {
  						copyIsArray = false;
  						clone = src && jQuery.isArray(src) ? src : [];
  
  					} else {
  						clone = src && jQuery.isPlainObject(src) ? src : {};
  					}
  
  					// Never move original objects, clone them
  					target[ name ] = jQuery.extend( deep, clone, copy );
  
  				// Don't bring in undefined values
  				} else if ( copy !== undefined ) {
  					target[ name ] = copy;
  				}
  			}
  		}
  	}
  
  	// Return the modified object
  	return target;
  };
  
  jQuery.extend({
  	noConflict: function( deep ) {
  		if ( window.$ === jQuery ) {
  			window.$ = _$;
  		}
  
  		if ( deep && window.jQuery === jQuery ) {
  			window.jQuery = _jQuery;
  		}
  
  		return jQuery;
  	},
  
  	// Is the DOM ready to be used? Set to true once it occurs.
  	isReady: false,
  
  	// A counter to track how many items to wait for before
  	// the ready event fires. See #6781
  	readyWait: 1,
  
  	// Hold (or release) the ready event
  	holdReady: function( hold ) {
  		if ( hold ) {
  			jQuery.readyWait++;
  		} else {
  			jQuery.ready( true );
  		}
  	},
  
  	// Handle when the DOM is ready
  	ready: function( wait ) {
  		// Either a released hold or an DOMready/load event and not yet ready
  		if ( (wait === true && !--jQuery.readyWait) || (wait !== true && !jQuery.isReady) ) {
  			// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
  			if ( !document.body ) {
  				return setTimeout( jQuery.ready, 1 );
  			}
  
  			// Remember that the DOM is ready
  			jQuery.isReady = true;
  
  			// If a normal DOM Ready event fired, decrement, and wait if need be
  			if ( wait !== true && --jQuery.readyWait > 0 ) {
  				return;
  			}
  
  			// If there are functions bound, to execute
  			readyList.resolveWith( document, [ jQuery ] );
  
  			// Trigger any bound ready events
  			if ( jQuery.fn.trigger ) {
  				jQuery( document ).trigger( "ready" ).unbind( "ready" );
  			}
  		}
  	},
  
  	bindReady: function() {
  		if ( readyList ) {
  			return;
  		}
  
  		readyList = jQuery._Deferred();
  
  		// Catch cases where $(document).ready() is called after the
  		// browser event has already occurred.
  		if ( document.readyState === "complete" ) {
  			// Handle it asynchronously to allow scripts the opportunity to delay ready
  			return setTimeout( jQuery.ready, 1 );
  		}
  
  		// Mozilla, Opera and webkit nightlies currently support this event
  		if ( document.addEventListener ) {
  			// Use the handy event callback
  			document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
  
  			// A fallback to window.onload, that will always work
  			window.addEventListener( "load", jQuery.ready, false );
  
  		// If IE event model is used
  		} else if ( document.attachEvent ) {
  			// ensure firing before onload,
  			// maybe late but safe also for iframes
  			document.attachEvent( "onreadystatechange", DOMContentLoaded );
  
  			// A fallback to window.onload, that will always work
  			window.attachEvent( "onload", jQuery.ready );
  
  			// If IE and not a frame
  			// continually check to see if the document is ready
  			var toplevel = false;
  
  			try {
  				toplevel = window.frameElement == null;
  			} catch(e) {}
  
  			if ( document.documentElement.doScroll && toplevel ) {
  				doScrollCheck();
  			}
  		}
  	},
  
  	// See test/unit/core.js for details concerning isFunction.
  	// Since version 1.3, DOM methods and functions like alert
  	// aren't supported. They return false on IE (#2968).
  	isFunction: function( obj ) {
  		return jQuery.type(obj) === "function";
  	},
  
  	isArray: Array.isArray || function( obj ) {
  		return jQuery.type(obj) === "array";
  	},
  
  	// A crude way of determining if an object is a window
  	isWindow: function( obj ) {
  		return obj && typeof obj === "object" && "setInterval" in obj;
  	},
  
  	isNaN: function( obj ) {
  		return obj == null || !rdigit.test( obj ) || isNaN( obj );
  	},
  
  	type: function( obj ) {
  		return obj == null ?
  			String( obj ) :
  			class2type[ toString.call(obj) ] || "object";
  	},
  
  	isPlainObject: function( obj ) {
  		// Must be an Object.
  		// Because of IE, we also have to check the presence of the constructor property.
  		// Make sure that DOM nodes and window objects don't pass through, as well
  		if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
  			return false;
  		}
  
  		// Not own constructor property must be Object
  		if ( obj.constructor &&
  			!hasOwn.call(obj, "constructor") &&
  			!hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
  			return false;
  		}
  
  		// Own properties are enumerated firstly, so to speed up,
  		// if last one is own, then all properties are own.
  
  		var key;
  		for ( key in obj ) {}
  
  		return key === undefined || hasOwn.call( obj, key );
  	},
  
  	isEmptyObject: function( obj ) {
  		for ( var name in obj ) {
  			return false;
  		}
  		return true;
  	},
  
  	error: function( msg ) {
  		throw msg;
  	},
  
  	parseJSON: function( data ) {
  		if ( typeof data !== "string" || !data ) {
  			return null;
  		}
  
  		// Make sure leading/trailing whitespace is removed (IE can't handle it)
  		data = jQuery.trim( data );
  
  		// Attempt to parse using the native JSON parser first
  		if ( window.JSON && window.JSON.parse ) {
  			return window.JSON.parse( data );
  		}
  
  		// Make sure the incoming data is actual JSON
  		// Logic borrowed from http://json.org/json2.js
  		if ( rvalidchars.test( data.replace( rvalidescape, "@" )
  			.replace( rvalidtokens, "]" )
  			.replace( rvalidbraces, "")) ) {
  
  			return (new Function( "return " + data ))();
  
  		}
  		jQuery.error( "Invalid JSON: " + data );
  	},
  
  	// Cross-browser xml parsing
  	// (xml & tmp used internally)
  	parseXML: function( data , xml , tmp ) {
  
  		if ( window.DOMParser ) { // Standard
  			tmp = new DOMParser();
  			xml = tmp.parseFromString( data , "text/xml" );
  		} else { // IE
  			xml = new ActiveXObject( "Microsoft.XMLDOM" );
  			xml.async = "false";
  			xml.loadXML( data );
  		}
  
  		tmp = xml.documentElement;
  
  		if ( ! tmp || ! tmp.nodeName || tmp.nodeName === "parsererror" ) {
  			jQuery.error( "Invalid XML: " + data );
  		}
  
  		return xml;
  	},
  
  	noop: function() {},
  
  	// Evaluates a script in a global context
  	// Workarounds based on findings by Jim Driscoll
  	// http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context
  	globalEval: function( data ) {
  		if ( data && rnotwhite.test( data ) ) {
  			// We use execScript on Internet Explorer
  			// We use an anonymous function so that context is window
  			// rather than jQuery in Firefox
  			( window.execScript || function( data ) {
  				window[ "eval" ].call( window, data );
  			} )( data );
  		}
  	},
  
  	nodeName: function( elem, name ) {
  		return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();
  	},
  
  	// args is for internal usage only
  	each: function( object, callback, args ) {
  		var name, i = 0,
  			length = object.length,
  			isObj = length === undefined || jQuery.isFunction( object );
  
  		if ( args ) {
  			if ( isObj ) {
  				for ( name in object ) {
  					if ( callback.apply( object[ name ], args ) === false ) {
  						break;
  					}
  				}
  			} else {
  				for ( ; i < length; ) {
  					if ( callback.apply( object[ i++ ], args ) === false ) {
  						break;
  					}
  				}
  			}
  
  		// A special, fast, case for the most common use of each
  		} else {
  			if ( isObj ) {
  				for ( name in object ) {
  					if ( callback.call( object[ name ], name, object[ name ] ) === false ) {
  						break;
  					}
  				}
  			} else {
  				for ( ; i < length; ) {
  					if ( callback.call( object[ i ], i, object[ i++ ] ) === false ) {
  						break;
  					}
  				}
  			}
  		}
  
  		return object;
  	},
  
  	// Use native String.trim function wherever possible
  	trim: trim ?
  		function( text ) {
  			return text == null ?
  				"" :
  				trim.call( text );
  		} :
  
  		// Otherwise use our own trimming functionality
  		function( text ) {
  			return text == null ?
  				"" :
  				text.toString().replace( trimLeft, "" ).replace( trimRight, "" );
  		},
  
  	// results is for internal usage only
  	makeArray: function( array, results ) {
  		var ret = results || [];
  
  		if ( array != null ) {
  			// The window, strings (and functions) also have 'length'
  			// The extra typeof function check is to prevent crashes
  			// in Safari 2 (See: #3039)
  			// Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
  			var type = jQuery.type( array );
  
  			if ( array.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( array ) ) {
  				push.call( ret, array );
  			} else {
  				jQuery.merge( ret, array );
  			}
  		}
  
  		return ret;
  	},
  
  	inArray: function( elem, array ) {
  
  		if ( indexOf ) {
  			return indexOf.call( array, elem );
  		}
  
  		for ( var i = 0, length = array.length; i < length; i++ ) {
  			if ( array[ i ] === elem ) {
  				return i;
  			}
  		}
  
  		return -1;
  	},
  
  	merge: function( first, second ) {
  		var i = first.length,
  			j = 0;
  
  		if ( typeof second.length === "number" ) {
  			for ( var l = second.length; j < l; j++ ) {
  				first[ i++ ] = second[ j ];
  			}
  
  		} else {
  			while ( second[j] !== undefined ) {
  				first[ i++ ] = second[ j++ ];
  			}
  		}
  
  		first.length = i;
  
  		return first;
  	},
  
  	grep: function( elems, callback, inv ) {
  		var ret = [], retVal;
  		inv = !!inv;
  
  		// Go through the array, only saving the items
  		// that pass the validator function
  		for ( var i = 0, length = elems.length; i < length; i++ ) {
  			retVal = !!callback( elems[ i ], i );
  			if ( inv !== retVal ) {
  				ret.push( elems[ i ] );
  			}
  		}
  
  		return ret;
  	},
  
  	// arg is for internal usage only
  	map: function( elems, callback, arg ) {
  		var value, key, ret = [],
  			i = 0,
  			length = elems.length,
  			// jquery objects are treated as arrays
  			isArray = elems instanceof jQuery || length !== undefined && typeof length === "number" && ( ( length > 0 && elems[ 0 ] && elems[ length -1 ] ) || length === 0 || jQuery.isArray( elems ) ) ;
  
  		// Go through the array, translating each of the items to their
  		if ( isArray ) {
  			for ( ; i < length; i++ ) {
  				value = callback( elems[ i ], i, arg );
  
  				if ( value != null ) {
  					ret[ ret.length ] = value;
  				}
  			}
  
  		// Go through every key on the object,
  		} else {
  			for ( key in elems ) {
  				value = callback( elems[ key ], key, arg );
  
  				if ( value != null ) {
  					ret[ ret.length ] = value;
  				}
  			}
  		}
  
  		// Flatten any nested arrays
  		return ret.concat.apply( [], ret );
  	},
  
  	// A global GUID counter for objects
  	guid: 1,
  
  	// Bind a function to a context, optionally partially applying any
  	// arguments.
  	proxy: function( fn, context ) {
  		if ( typeof context === "string" ) {
  			var tmp = fn[ context ];
  			context = fn;
  			fn = tmp;
  		}
  
  		// Quick check to determine if target is callable, in the spec
  		// this throws a TypeError, but we will just return undefined.
  		if ( !jQuery.isFunction( fn ) ) {
  			return undefined;
  		}
  
  		// Simulated bind
  		var args = slice.call( arguments, 2 ),
  			proxy = function() {
  				return fn.apply( context, args.concat( slice.call( arguments ) ) );
  			};
  
  		// Set the guid of unique handler to the same of original handler, so it can be removed
  		proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++;
  
  		return proxy;
  	},
  
  	// Mutifunctional method to get and set values to a collection
  	// The value/s can be optionally by executed if its a function
  	access: function( elems, key, value, exec, fn, pass ) {
  		var length = elems.length;
  
  		// Setting many attributes
  		if ( typeof key === "object" ) {
  			for ( var k in key ) {
  				jQuery.access( elems, k, key[k], exec, fn, value );
  			}
  			return elems;
  		}
  
  		// Setting one attribute
  		if ( value !== undefined ) {
  			// Optionally, function values get executed if exec is true
  			exec = !pass && exec && jQuery.isFunction(value);
  
  			for ( var i = 0; i < length; i++ ) {
  				fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
  			}
  
  			return elems;
  		}
  
  		// Getting an attribute
  		return length ? fn( elems[0], key ) : undefined;
  	},
  
  	now: function() {
  		return (new Date()).getTime();
  	},
  
  	// Use of jQuery.browser is frowned upon.
  	// More details: http://docs.jquery.com/Utilities/jQuery.browser
  	uaMatch: function( ua ) {
  		ua = ua.toLowerCase();
  
  		var match = rwebkit.exec( ua ) ||
  			ropera.exec( ua ) ||
  			rmsie.exec( ua ) ||
  			ua.indexOf("compatible") < 0 && rmozilla.exec( ua ) ||
  			[];
  
  		return { browser: match[1] || "", version: match[2] || "0" };
  	},
  
  	sub: function() {
  		function jQuerySub( selector, context ) {
  			return new jQuerySub.fn.init( selector, context );
  		}
  		jQuery.extend( true, jQuerySub, this );
  		jQuerySub.superclass = this;
  		jQuerySub.fn = jQuerySub.prototype = this();
  		jQuerySub.fn.constructor = jQuerySub;
  		jQuerySub.sub = this.sub;
  		jQuerySub.fn.init = function init( selector, context ) {
  			if ( context && context instanceof jQuery && !(context instanceof jQuerySub) ) {
  				context = jQuerySub( context );
  			}
  
  			return jQuery.fn.init.call( this, selector, context, rootjQuerySub );
  		};
  		jQuerySub.fn.init.prototype = jQuerySub.fn;
  		var rootjQuerySub = jQuerySub(document);
  		return jQuerySub;
  	},
  
  	browser: {}
  });
  
  // Populate the class2type map
  jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {
  	class2type[ "[object " + name + "]" ] = name.toLowerCase();
  });
  
  browserMatch = jQuery.uaMatch( userAgent );
  if ( browserMatch.browser ) {
  	jQuery.browser[ browserMatch.browser ] = true;
  	jQuery.browser.version = browserMatch.version;
  }
  
  // Deprecated, use jQuery.browser.webkit instead
  if ( jQuery.browser.webkit ) {
  	jQuery.browser.safari = true;
  }
  
  // IE doesn't match non-breaking spaces with \s
  if ( rnotwhite.test( "\xA0" ) ) {
  	trimLeft = /^[\s\xA0]+/;
  	trimRight = /[\s\xA0]+$/;
  }
  
  // All jQuery objects should point back to these
  rootjQuery = jQuery(document);
  
  // Cleanup functions for the document ready method
  if ( document.addEventListener ) {
  	DOMContentLoaded = function() {
  		document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );
  		jQuery.ready();
  	};
  
  } else if ( document.attachEvent ) {
  	DOMContentLoaded = function() {
  		// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
  		if ( document.readyState === "complete" ) {
  			document.detachEvent( "onreadystatechange", DOMContentLoaded );
  			jQuery.ready();
  		}
  	};
  }
  
  // The DOM ready check for Internet Explorer
  function doScrollCheck() {
  	if ( jQuery.isReady ) {
  		return;
  	}
  
  	try {
  		// If IE is used, use the trick by Diego Perini
  		// http://javascript.nwbox.com/IEContentLoaded/
  		document.documentElement.doScroll("left");
  	} catch(e) {
  		setTimeout( doScrollCheck, 1 );
  		return;
  	}
  
  	// and execute any waiting functions
  	jQuery.ready();
  }
  
  // Expose jQuery to the global object
  return jQuery;
  
  })();
  
  
  var // Promise methods
  	promiseMethods = "done fail isResolved isRejected promise then always pipe".split( " " ),
  	// Static reference to slice
  	sliceDeferred = [].slice;
  
  jQuery.extend({
  	// Create a simple deferred (one callbacks list)
  	_Deferred: function() {
  		var // callbacks list
  			callbacks = [],
  			// stored [ context , args ]
  			fired,
  			// to avoid firing when already doing so
  			firing,
  			// flag to know if the deferred has been cancelled
  			cancelled,
  			// the deferred itself
  			deferred  = {
  
  				// done( f1, f2, ...)
  				done: function() {
  					if ( !cancelled ) {
  						var args = arguments,
  							i,
  							length,
  							elem,
  							type,
  							_fired;
  						if ( fired ) {
  							_fired = fired;
  							fired = 0;
  						}
  						for ( i = 0, length = args.length; i < length; i++ ) {
  							elem = args[ i ];
  							type = jQuery.type( elem );
  							if ( type === "array" ) {
  								deferred.done.apply( deferred, elem );
  							} else if ( type === "function" ) {
  								callbacks.push( elem );
  							}
  						}
  						if ( _fired ) {
  							deferred.resolveWith( _fired[ 0 ], _fired[ 1 ] );
  						}
  					}
  					return this;
  				},
  
  				// resolve with given context and args
  				resolveWith: function( context, args ) {
  					if ( !cancelled && !fired && !firing ) {
  						// make sure args are available (#8421)
  						args = args || [];
  						firing = 1;
  						try {
  							while( callbacks[ 0 ] ) {
  								callbacks.shift().apply( context, args );
  							}
  						}
  						finally {
  							fired = [ context, args ];
  							firing = 0;
  						}
  					}
  					return this;
  				},
  
  				// resolve with this as context and given arguments
  				resolve: function() {
  					deferred.resolveWith( this, arguments );
  					return this;
  				},
  
  				// Has this deferred been resolved?
  				isResolved: function() {
  					return !!( firing || fired );
  				},
  
  				// Cancel
  				cancel: function() {
  					cancelled = 1;
  					callbacks = [];
  					return this;
  				}
  			};
  
  		return deferred;
  	},
  
  	// Full fledged deferred (two callbacks list)
  	Deferred: function( func ) {
  		var deferred = jQuery._Deferred(),
  			failDeferred = jQuery._Deferred(),
  			promise;
  		// Add errorDeferred methods, then and promise
  		jQuery.extend( deferred, {
  			then: function( doneCallbacks, failCallbacks ) {
  				deferred.done( doneCallbacks ).fail( failCallbacks );
  				return this;
  			},
  			always: function() {
  				return deferred.done.apply( deferred, arguments ).fail.apply( this, arguments );
  			},
  			fail: failDeferred.done,
  			rejectWith: failDeferred.resolveWith,
  			reject: failDeferred.resolve,
  			isRejected: failDeferred.isResolved,
  			pipe: function( fnDone, fnFail ) {
  				return jQuery.Deferred(function( newDefer ) {
  					jQuery.each( {
  						done: [ fnDone, "resolve" ],
  						fail: [ fnFail, "reject" ]
  					}, function( handler, data ) {
  						var fn = data[ 0 ],
  							action = data[ 1 ],
  							returned;
  						if ( jQuery.isFunction( fn ) ) {
  							deferred[ handler ](function() {
  								returned = fn.apply( this, arguments );
  								if ( returned && jQuery.isFunction( returned.promise ) ) {
  									returned.promise().then( newDefer.resolve, newDefer.reject );
  								} else {
  									newDefer[ action ]( returned );
  								}
  							});
  						} else {
  							deferred[ handler ]( newDefer[ action ] );
  						}
  					});
  				}).promise();
  			},
  			// Get a promise for this deferred
  			// If obj is provided, the promise aspect is added to the object
  			promise: function( obj ) {
  				if ( obj == null ) {
  					if ( promise ) {
  						return promise;
  					}
  					promise = obj = {};
  				}
  				var i = promiseMethods.length;
  				while( i-- ) {
  					obj[ promiseMethods[i] ] = deferred[ promiseMethods[i] ];
  				}
  				return obj;
  			}
  		});
  		// Make sure only one callback list will be used
  		deferred.done( failDeferred.cancel ).fail( deferred.cancel );
  		// Unexpose cancel
  		delete deferred.cancel;
  		// Call given func if any
  		if ( func ) {
  			func.call( deferred, deferred );
  		}
  		return deferred;
  	},
  
  	// Deferred helper
  	when: function( firstParam ) {
  		var args = arguments,
  			i = 0,
  			length = args.length,
  			count = length,
  			deferred = length <= 1 && firstParam && jQuery.isFunction( firstParam.promise ) ?
  				firstParam :
  				jQuery.Deferred();
  		function resolveFunc( i ) {
  			return function( value ) {
  				args[ i ] = arguments.length > 1 ? sliceDeferred.call( arguments, 0 ) : value;
  				if ( !( --count ) ) {
  					// Strange bug in FF4:
  					// Values changed onto the arguments object sometimes end up as undefined values
  					// outside the $.when method. Cloning the object into a fresh array solves the issue
  					deferred.resolveWith( deferred, sliceDeferred.call( args, 0 ) );
  				}
  			};
  		}
  		if ( length > 1 ) {
  			for( ; i < length; i++ ) {
  				if ( args[ i ] && jQuery.isFunction( args[ i ].promise ) ) {
  					args[ i ].promise().then( resolveFunc(i), deferred.reject );
  				} else {
  					--count;
  				}
  			}
  			if ( !count ) {
  				deferred.resolveWith( deferred, args );
  			}
  		} else if ( deferred !== firstParam ) {
  			deferred.resolveWith( deferred, length ? [ firstParam ] : [] );
  		}
  		return deferred.promise();
  	}
  });
  
  
  
  jQuery.support = (function() {
  
  	var div = document.createElement( "div" ),
  		documentElement = document.documentElement,
  		all,
  		a,
  		select,
  		opt,
  		input,
  		marginDiv,
  		support,
  		fragment,
  		body,
  		bodyStyle,
  		tds,
  		events,
  		eventName,
  		i,
  		isSupported;
  
  	// Preliminary tests
  	div.setAttribute("className", "t");
  	div.innerHTML = "   <link/><table></table><a href='/a' style='top:1px;float:left;opacity:.55;'>a</a><input type='checkbox'/>";
  
  	all = div.getElementsByTagName( "*" );
  	a = div.getElementsByTagName( "a" )[ 0 ];
  
  	// Can't get basic test support
  	if ( !all || !all.length || !a ) {
  		return {};
  	}
  
  	// First batch of supports tests
  	select = document.createElement( "select" );
  	opt = select.appendChild( document.createElement("option") );
  	input = div.getElementsByTagName( "input" )[ 0 ];
  
  	support = {
  		// IE strips leading whitespace when .innerHTML is used
  		leadingWhitespace: ( div.firstChild.nodeType === 3 ),
  
  		// Make sure that tbody elements aren't automatically inserted
  		// IE will insert them into empty tables
  		tbody: !div.getElementsByTagName( "tbody" ).length,
  
  		// Make sure that link elements get serialized correctly by innerHTML
  		// This requires a wrapper element in IE
  		htmlSerialize: !!div.getElementsByTagName( "link" ).length,
  
  		// Get the style information from getAttribute
  		// (IE uses .cssText instead)
  		style: /top/.test( a.getAttribute("style") ),
  
  		// Make sure that URLs aren't manipulated
  		// (IE normalizes it by default)
  		hrefNormalized: ( a.getAttribute( "href" ) === "/a" ),
  
  		// Make sure that element opacity exists
  		// (IE uses filter instead)
  		// Use a regex to work around a WebKit issue. See #5145
  		opacity: /^0.55$/.test( a.style.opacity ),
  
  		// Verify style float existence
  		// (IE uses styleFloat instead of cssFloat)
  		cssFloat: !!a.style.cssFloat,
  
  		// Make sure that if no value is specified for a checkbox
  		// that it defaults to "on".
  		// (WebKit defaults to "" instead)
  		checkOn: ( input.value === "on" ),
  
  		// Make sure that a selected-by-default option has a working selected property.
  		// (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
  		optSelected: opt.selected,
  
  		// Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7)
  		getSetAttribute: div.className !== "t",
  
  		// Will be defined later
  		submitBubbles: true,
  		changeBubbles: true,
  		focusinBubbles: false,
  		deleteExpando: true,
  		noCloneEvent: true,
  		inlineBlockNeedsLayout: false,
  		shrinkWrapBlocks: false,
  		reliableMarginRight: true
  	};
  
  	// Make sure checked status is properly cloned
  	input.checked = true;
  	support.noCloneChecked = input.cloneNode( true ).checked;
  
  	// Make sure that the options inside disabled selects aren't marked as disabled
  	// (WebKit marks them as disabled)
  	select.disabled = true;
  	support.optDisabled = !opt.disabled;
  
  	// Test to see if it's possible to delete an expando from an element
  	// Fails in Internet Explorer
  	try {
  		delete div.test;
  	} catch( e ) {
  		support.deleteExpando = false;
  	}
  
  	if ( !div.addEventListener && div.attachEvent && div.fireEvent ) {
  		div.attachEvent( "onclick", function click() {
  			// Cloning a node shouldn't copy over any
  			// bound event handlers (IE does this)
  			support.noCloneEvent = false;
  			div.detachEvent( "onclick", click );
  		});
  		div.cloneNode( true ).fireEvent( "onclick" );
  	}
  
  	// Check if a radio maintains it's value
  	// after being appended to the DOM
  	input = document.createElement("input");
  	input.value = "t";
  	input.setAttribute("type", "radio");
  	support.radioValue = input.value === "t";
  
  	input.setAttribute("checked", "checked");
  	div.appendChild( input );
  	fragment = document.createDocumentFragment();
  	fragment.appendChild( div.firstChild );
  
  	// WebKit doesn't clone checked state correctly in fragments
  	support.checkClone = fragment.cloneNode( true ).cloneNode( true ).lastChild.checked;
  
  	div.innerHTML = "";
  
  	// Figure out if the W3C box model works as expected
  	div.style.width = div.style.paddingLeft = "1px";
  
  	// We use our own, invisible, body
  	body = document.createElement( "body" );
  	bodyStyle = {
  		visibility: "hidden",
  		width: 0,
  		height: 0,
  		border: 0,
  		margin: 0,
  		// Set background to avoid IE crashes when removing (#9028)
  		background: "none"
  	};
  	for ( i in bodyStyle ) {
  		body.style[ i ] = bodyStyle[ i ];
  	}
  	body.appendChild( div );
  	documentElement.insertBefore( body, documentElement.firstChild );
  
  	// Check if a disconnected checkbox will retain its checked
  	// value of true after appended to the DOM (IE6/7)
  	support.appendChecked = input.checked;
  
  	support.boxModel = div.offsetWidth === 2;
  
  	if ( "zoom" in div.style ) {
  		// Check if natively block-level elements act like inline-block
  		// elements when setting their display to 'inline' and giving
  		// them layout
  		// (IE < 8 does this)
  		div.style.display = "inline";
  		div.style.zoom = 1;
  		support.inlineBlockNeedsLayout = ( div.offsetWidth === 2 );
  
  		// Check if elements with layout shrink-wrap their children
  		// (IE 6 does this)
  		div.style.display = "";
  		div.innerHTML = "<div style='width:4px;'></div>";
  		support.shrinkWrapBlocks = ( div.offsetWidth !== 2 );
  	}
  
  	div.innerHTML = "<table><tr><td style='padding:0;border:0;display:none'></td><td>t</td></tr></table>";
  	tds = div.getElementsByTagName( "td" );
  
  	// Check if table cells still have offsetWidth/Height when they are set
  	// to display:none and there are still other visible table cells in a
  	// table row; if so, offsetWidth/Height are not reliable for use when
  	// determining if an element has been hidden directly using
  	// display:none (it is still safe to use offsets if a parent element is
  	// hidden; don safety goggles and see bug #4512 for more information).
  	// (only IE 8 fails this test)
  	isSupported = ( tds[ 0 ].offsetHeight === 0 );
  
  	tds[ 0 ].style.display = "";
  	tds[ 1 ].style.display = "none";
  
  	// Check if empty table cells still have offsetWidth/Height
  	// (IE < 8 fail this test)
  	support.reliableHiddenOffsets = isSupported && ( tds[ 0 ].offsetHeight === 0 );
  	div.innerHTML = "";
  
  	// Check if div with explicit width and no margin-right incorrectly
  	// gets computed margin-right based on width of container. For more
  	// info see bug #3333
  	// Fails in WebKit before Feb 2011 nightlies
  	// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
  	if ( document.defaultView && document.defaultView.getComputedStyle ) {
  		marginDiv = document.createElement( "div" );
  		marginDiv.style.width = "0";
  		marginDiv.style.marginRight = "0";
  		div.appendChild( marginDiv );
  		support.reliableMarginRight =
  			( parseInt( ( document.defaultView.getComputedStyle( marginDiv, null ) || { marginRight: 0 } ).marginRight, 10 ) || 0 ) === 0;
  	}
  
  	// Remove the body element we added
  	body.innerHTML = "";
  	documentElement.removeChild( body );
  
  	// Technique from Juriy Zaytsev
  	// http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/
  	// We only care about the case where non-standard event systems
  	// are used, namely in IE. Short-circuiting here helps us to
  	// avoid an eval call (in setAttribute) which can cause CSP
  	// to go haywire. See: https://developer.mozilla.org/en/Security/CSP
  	if ( div.attachEvent ) {
  		for( i in {
  			submit: 1,
  			change: 1,
  			focusin: 1
  		} ) {
  			eventName = "on" + i;
  			isSupported = ( eventName in div );
  			if ( !isSupported ) {
  				div.setAttribute( eventName, "return;" );
  				isSupported = ( typeof div[ eventName ] === "function" );
  			}
  			support[ i + "Bubbles" ] = isSupported;
  		}
  	}
  
  	return support;
  })();
  
  // Keep track of boxModel
  jQuery.boxModel = jQuery.support.boxModel;
  
  
  
  
  var rbrace = /^(?:\{.*\}|\[.*\])$/,
  	rmultiDash = /([a-z])([A-Z])/g;
  
  jQuery.extend({
  	cache: {},
  
  	// Please use with caution
  	uuid: 0,
  
  	// Unique for each copy of jQuery on the page
  	// Non-digits removed to match rinlinejQuery
  	expando: "jQuery" + ( jQuery.fn.jquery + Math.random() ).replace( /\D/g, "" ),
  
  	// The following elements throw uncatchable exceptions if you
  	// attempt to add expando properties to them.
  	noData: {
  		"embed": true,
  		// Ban all objects except for Flash (which handle expandos)
  		"object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
  		"applet": true
  	},
  
  	hasData: function( elem ) {
  		elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ];
  
  		return !!elem && !isEmptyDataObject( elem );
  	},
  
  	data: function( elem, name, data, pvt /* Internal Use Only */ ) {
  		if ( !jQuery.acceptData( elem ) ) {
  			return;
  		}
  
  		var internalKey = jQuery.expando, getByName = typeof name === "string", thisCache,
  
  			// We have to handle DOM nodes and JS objects differently because IE6-7
  			// can't GC object references properly across the DOM-JS boundary
  			isNode = elem.nodeType,
  
  			// Only DOM nodes need the global jQuery cache; JS object data is
  			// attached directly to the object so GC can occur automatically
  			cache = isNode ? jQuery.cache : elem,
  
  			// Only defining an ID for JS objects if its cache already exists allows
  			// the code to shortcut on the same path as a DOM node with no cache
  			id = isNode ? elem[ jQuery.expando ] : elem[ jQuery.expando ] && jQuery.expando;
  
  		// Avoid doing any more work than we need to when trying to get data on an
  		// object that has no data at all
  		if ( (!id || (pvt && id && !cache[ id ][ internalKey ])) && getByName && data === undefined ) {
  			return;
  		}
  
  		if ( !id ) {
  			// Only DOM nodes need a new unique ID for each element since their data
  			// ends up in the global cache
  			if ( isNode ) {
  				elem[ jQuery.expando ] = id = ++jQuery.uuid;
  			} else {
  				id = jQuery.expando;
  			}
  		}
  
  		if ( !cache[ id ] ) {
  			cache[ id ] = {};
  
  			// TODO: This is a hack for 1.5 ONLY. Avoids exposing jQuery
  			// metadata on plain JS objects when the object is serialized using
  			// JSON.stringify
  			if ( !isNode ) {
  				cache[ id ].toJSON = jQuery.noop;
  			}
  		}
  
  		// An object can be passed to jQuery.data instead of a key/value pair; this gets
  		// shallow copied over onto the existing cache
  		if ( typeof name === "object" || typeof name === "function" ) {
  			if ( pvt ) {
  				cache[ id ][ internalKey ] = jQuery.extend(cache[ id ][ internalKey ], name);
  			} else {
  				cache[ id ] = jQuery.extend(cache[ id ], name);
  			}
  		}
  
  		thisCache = cache[ id ];
  
  		// Internal jQuery data is stored in a separate object inside the object's data
  		// cache in order to avoid key collisions between internal data and user-defined
  		// data
  		if ( pvt ) {
  			if ( !thisCache[ internalKey ] ) {
  				thisCache[ internalKey ] = {};
  			}
  
  			thisCache = thisCache[ internalKey ];
  		}
  
  		if ( data !== undefined ) {
  			thisCache[ jQuery.camelCase( name ) ] = data;
  		}
  
  		// TODO: This is a hack for 1.5 ONLY. It will be removed in 1.6. Users should
  		// not attempt to inspect the internal events object using jQuery.data, as this
  		// internal data object is undocumented and subject to change.
  		if ( name === "events" && !thisCache[name] ) {
  			return thisCache[ internalKey ] && thisCache[ internalKey ].events;
  		}
  
  		return getByName ? thisCache[ jQuery.camelCase( name ) ] : thisCache;
  	},
  
  	removeData: function( elem, name, pvt /* Internal Use Only */ ) {
  		if ( !jQuery.acceptData( elem ) ) {
  			return;
  		}
  
  		var internalKey = jQuery.expando, isNode = elem.nodeType,
  
  			// See jQuery.data for more information
  			cache = isNode ? jQuery.cache : elem,
  
  			// See jQuery.data for more information
  			id = isNode ? elem[ jQuery.expando ] : jQuery.expando;
  
  		// If there is already no cache entry for this object, there is no
  		// purpose in continuing
  		if ( !cache[ id ] ) {
  			return;
  		}
  
  		if ( name ) {
  			var thisCache = pvt ? cache[ id ][ internalKey ] : cache[ id ];
  
  			if ( thisCache ) {
  				delete thisCache[ name ];
  
  				// If there is no data left in the cache, we want to continue
  				// and let the cache object itself get destroyed
  				if ( !isEmptyDataObject(thisCache) ) {
  					return;
  				}
  			}
  		}
  
  		// See jQuery.data for more information
  		if ( pvt ) {
  			delete cache[ id ][ internalKey ];
  
  			// Don't destroy the parent cache unless the internal data object
  			// had been the only thing left in it
  			if ( !isEmptyDataObject(cache[ id ]) ) {
  				return;
  			}
  		}
  
  		var internalCache = cache[ id ][ internalKey ];
  
  		// Browsers that fail expando deletion also refuse to delete expandos on
  		// the window, but it will allow it on all other JS objects; other browsers
  		// don't care
  		if ( jQuery.support.deleteExpando || cache != window ) {
  			delete cache[ id ];
  		} else {
  			cache[ id ] = null;
  		}
  
  		// We destroyed the entire user cache at once because it's faster than
  		// iterating through each key, but we need to continue to persist internal
  		// data if it existed
  		if ( internalCache ) {
  			cache[ id ] = {};
  			// TODO: This is a hack for 1.5 ONLY. Avoids exposing jQuery
  			// metadata on plain JS objects when the object is serialized using
  			// JSON.stringify
  			if ( !isNode ) {
  				cache[ id ].toJSON = jQuery.noop;
  			}
  
  			cache[ id ][ internalKey ] = internalCache;
  
  		// Otherwise, we need to eliminate the expando on the node to avoid
  		// false lookups in the cache for entries that no longer exist
  		} else if ( isNode ) {
  			// IE does not allow us to delete expando properties from nodes,
  			// nor does it have a removeAttribute function on Document nodes;
  			// we must handle all of these cases
  			if ( jQuery.support.deleteExpando ) {
  				delete elem[ jQuery.expando ];
  			} else if ( elem.removeAttribute ) {
  				elem.removeAttribute( jQuery.expando );
  			} else {
  				elem[ jQuery.expando ] = null;
  			}
  		}
  	},
  
  	// For internal use only.
  	_data: function( elem, name, data ) {
  		return jQuery.data( elem, name, data, true );
  	},
  
  	// A method for determining if a DOM node can handle the data expando
  	acceptData: function( elem ) {
  		if ( elem.nodeName ) {
  			var match = jQuery.noData[ elem.nodeName.toLowerCase() ];
  
  			if ( match ) {
  				return !(match === true || elem.getAttribute("classid") !== match);
  			}
  		}
  
  		return true;
  	}
  });
  
  jQuery.fn.extend({
  	data: function( key, value ) {
  		var data = null;
  
  		if ( typeof key === "undefined" ) {
  			if ( this.length ) {
  				data = jQuery.data( this[0] );
  
  				if ( this[0].nodeType === 1 ) {
  			    var attr = this[0].attributes, name;
  					for ( var i = 0, l = attr.length; i < l; i++ ) {
  						name = attr[i].name;
  
  						if ( name.indexOf( "data-" ) === 0 ) {
  							name = jQuery.camelCase( name.substring(5) );
  
  							dataAttr( this[0], name, data[ name ] );
  						}
  					}
  				}
  			}
  
  			return data;
  
  		} else if ( typeof key === "object" ) {
  			return this.each(function() {
  				jQuery.data( this, key );
  			});
  		}
  
  		var parts = key.split(".");
  		parts[1] = parts[1] ? "." + parts[1] : "";
  
  		if ( value === undefined ) {
  			data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
  
  			// Try to fetch any internally stored data first
  			if ( data === undefined && this.length ) {
  				data = jQuery.data( this[0], key );
  				data = dataAttr( this[0], key, data );
  			}
  
  			return data === undefined && parts[1] ?
  				this.data( parts[0] ) :
  				data;
  
  		} else {
  			return this.each(function() {
  				var $this = jQuery( this ),
  					args = [ parts[0], value ];
  
  				$this.triggerHandler( "setData" + parts[1] + "!", args );
  				jQuery.data( this, key, value );
  				$this.triggerHandler( "changeData" + parts[1] + "!", args );
  			});
  		}
  	},
  
  	removeData: function( key ) {
  		return this.each(function() {
  			jQuery.removeData( this, key );
  		});
  	}
  });
  
  function dataAttr( elem, key, data ) {
  	// If nothing was found internally, try to fetch any
  	// data from the HTML5 data-* attribute
  	if ( data === undefined && elem.nodeType === 1 ) {
  		var name = "data-" + key.replace( rmultiDash, "$1-$2" ).toLowerCase();
  
  		data = elem.getAttribute( name );
  
  		if ( typeof data === "string" ) {
  			try {
  				data = data === "true" ? true :
  				data === "false" ? false :
  				data === "null" ? null :
  				!jQuery.isNaN( data ) ? parseFloat( data ) :
  					rbrace.test( data ) ? jQuery.parseJSON( data ) :
  					data;
  			} catch( e ) {}
  
  			// Make sure we set the data so it isn't changed later
  			jQuery.data( elem, key, data );
  
  		} else {
  			data = undefined;
  		}
  	}
  
  	return data;
  }
  
  // TODO: This is a hack for 1.5 ONLY to allow objects with a single toJSON
  // property to be considered empty objects; this property always exists in
  // order to make sure JSON.stringify does not expose internal metadata
  function isEmptyDataObject( obj ) {
  	for ( var name in obj ) {
  		if ( name !== "toJSON" ) {
  			return false;
  		}
  	}
  
  	return true;
  }
  
  
  
  
  function handleQueueMarkDefer( elem, type, src ) {
  	var deferDataKey = type + "defer",
  		queueDataKey = type + "queue",
  		markDataKey = type + "mark",
  		defer = jQuery.data( elem, deferDataKey, undefined, true );
  	if ( defer &&
  		( src === "queue" || !jQuery.data( elem, queueDataKey, undefined, true ) ) &&
  		( src === "mark" || !jQuery.data( elem, markDataKey, undefined, true ) ) ) {
  		// Give room for hard-coded callbacks to fire first
  		// and eventually mark/queue something else on the element
  		setTimeout( function() {
  			if ( !jQuery.data( elem, queueDataKey, undefined, true ) &&
  				!jQuery.data( elem, markDataKey, undefined, true ) ) {
  				jQuery.removeData( elem, deferDataKey, true );
  				defer.resolve();
  			}
  		}, 0 );
  	}
  }
  
  jQuery.extend({
  
  	_mark: function( elem, type ) {
  		if ( elem ) {
  			type = (type || "fx") + "mark";
  			jQuery.data( elem, type, (jQuery.data(elem,type,undefined,true) || 0) + 1, true );
  		}
  	},
  
  	_unmark: function( force, elem, type ) {
  		if ( force !== true ) {
  			type = elem;
  			elem = force;
  			force = false;
  		}
  		if ( elem ) {
  			type = type || "fx";
  			var key = type + "mark",
  				count = force ? 0 : ( (jQuery.data( elem, key, undefined, true) || 1 ) - 1 );
  			if ( count ) {
  				jQuery.data( elem, key, count, true );
  			} else {
  				jQuery.removeData( elem, key, true );
  				handleQueueMarkDefer( elem, type, "mark" );
  			}
  		}
  	},
  
  	queue: function( elem, type, data ) {
  		if ( elem ) {
  			type = (type || "fx") + "queue";
  			var q = jQuery.data( elem, type, undefined, true );
  			// Speed up dequeue by getting out quickly if this is just a lookup
  			if ( data ) {
  				if ( !q || jQuery.isArray(data) ) {
  					q = jQuery.data( elem, type, jQuery.makeArray(data), true );
  				} else {
  					q.push( data );
  				}
  			}
  			return q || [];
  		}
  	},
  
  	dequeue: function( elem, type ) {
  		type = type || "fx";
  
  		var queue = jQuery.queue( elem, type ),
  			fn = queue.shift(),
  			defer;
  
  		// If the fx queue is dequeued, always remove the progress sentinel
  		if ( fn === "inprogress" ) {
  			fn = queue.shift();
  		}
  
  		if ( fn ) {
  			// Add a progress sentinel to prevent the fx queue from being
  			// automatically dequeued
  			if ( type === "fx" ) {
  				queue.unshift("inprogress");
  			}
  
  			fn.call(elem, function() {
  				jQuery.dequeue(elem, type);
  			});
  		}
  
  		if ( !queue.length ) {
  			jQuery.removeData( elem, type + "queue", true );
  			handleQueueMarkDefer( elem, type, "queue" );
  		}
  	}
  });
  
  jQuery.fn.extend({
  	queue: function( type, data ) {
  		if ( typeof type !== "string" ) {
  			data = type;
  			type = "fx";
  		}
  
  		if ( data === undefined ) {
  			return jQuery.queue( this[0], type );
  		}
  		return this.each(function() {
  			var queue = jQuery.queue( this, type, data );
  
  			if ( type === "fx" && queue[0] !== "inprogress" ) {
  				jQuery.dequeue( this, type );
  			}
  		});
  	},
  	dequeue: function( type ) {
  		return this.each(function() {
  			jQuery.dequeue( this, type );
  		});
  	},
  	// Based off of the plugin by Clint Helfers, with permission.
  	// http://blindsignals.com/index.php/2009/07/jquery-delay/
  	delay: function( time, type ) {
  		time = jQuery.fx ? jQuery.fx.speeds[time] || time : time;
  		type = type || "fx";
  
  		return this.queue( type, function() {
  			var elem = this;
  			setTimeout(function() {
  				jQuery.dequeue( elem, type );
  			}, time );
  		});
  	},
  	clearQueue: function( type ) {
  		return this.queue( type || "fx", [] );
  	},
  	// Get a promise resolved when queues of a certain type
  	// are emptied (fx is the type by default)
  	promise: function( type, object ) {
  		if ( typeof type !== "string" ) {
  			object = type;
  			type = undefined;
  		}
  		type = type || "fx";
  		var defer = jQuery.Deferred(),
  			elements = this,
  			i = elements.length,
  			count = 1,
  			deferDataKey = type + "defer",
  			queueDataKey = type + "queue",
  			markDataKey = type + "mark",
  			tmp;
  		function resolve() {
  			if ( !( --count ) ) {
  				defer.resolveWith( elements, [ elements ] );
  			}
  		}
  		while( i-- ) {
  			if (( tmp = jQuery.data( elements[ i ], deferDataKey, undefined, true ) ||
  					( jQuery.data( elements[ i ], queueDataKey, undefined, true ) ||
  						jQuery.data( elements[ i ], markDataKey, undefined, true ) ) &&
  					jQuery.data( elements[ i ], deferDataKey, jQuery._Deferred(), true ) )) {
  				count++;
  				tmp.done( resolve );
  			}
  		}
  		resolve();
  		return defer.promise();
  	}
  });
  
  
  
  
  var rclass = /[\n\t\r]/g,
  	rspace = /\s+/,
  	rreturn = /\r/g,
  	rtype = /^(?:button|input)$/i,
  	rfocusable = /^(?:button|input|object|select|textarea)$/i,
  	rclickable = /^a(?:rea)?$/i,
  	rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i,
  	rinvalidChar = /\:/,
  	formHook, boolHook;
  
  jQuery.fn.extend({
  	attr: function( name, value ) {
  		return jQuery.access( this, name, value, true, jQuery.attr );
  	},
  
  	removeAttr: function( name ) {
  		return this.each(function() {
  			jQuery.removeAttr( this, name );
  		});
  	},
  	
  	prop: function( name, value ) {
  		return jQuery.access( this, name, value, true, jQuery.prop );
  	},
  	
  	removeProp: function( name ) {
  		name = jQuery.propFix[ name ] || name;
  		return this.each(function() {
  			// try/catch handles cases where IE balks (such as removing a property on window)
  			try {
  				this[ name ] = undefined;
  				delete this[ name ];
  			} catch( e ) {}
  		});
  	},
  
  	addClass: function( value ) {
  		if ( jQuery.isFunction( value ) ) {
  			return this.each(function(i) {
  				var self = jQuery(this);
  				self.addClass( value.call(this, i, self.attr("class") || "") );
  			});
  		}
  
  		if ( value && typeof value === "string" ) {
  			var classNames = (value || "").split( rspace );
  
  			for ( var i = 0, l = this.length; i < l; i++ ) {
  				var elem = this[i];
  
  				if ( elem.nodeType === 1 ) {
  					if ( !elem.className ) {
  						elem.className = value;
  
  					} else {
  						var className = " " + elem.className + " ",
  							setClass = elem.className;
  
  						for ( var c = 0, cl = classNames.length; c < cl; c++ ) {
  							if ( className.indexOf( " " + classNames[c] + " " ) < 0 ) {
  								setClass += " " + classNames[c];
  							}
  						}
  						elem.className = jQuery.trim( setClass );
  					}
  				}
  			}
  		}
  
  		return this;
  	},
  
  	removeClass: function( value ) {
  		if ( jQuery.isFunction(value) ) {
  			return this.each(function(i) {
  				var self = jQuery(this);
  				self.removeClass( value.call(this, i, self.attr("class")) );
  			});
  		}
  
  		if ( (value && typeof value === "string") || value === undefined ) {
  			var classNames = (value || "").split( rspace );
  
  			for ( var i = 0, l = this.length; i < l; i++ ) {
  				var elem = this[i];
  
  				if ( elem.nodeType === 1 && elem.className ) {
  					if ( value ) {
  						var className = (" " + elem.className + " ").replace(rclass, " ");
  						for ( var c = 0, cl = classNames.length; c < cl; c++ ) {
  							className = className.replace(" " + classNames[c] + " ", " ");
  						}
  						elem.className = jQuery.trim( className );
  
  					} else {
  						elem.className = "";
  					}
  				}
  			}
  		}
  
  		return this;
  	},
  
  	toggleClass: function( value, stateVal ) {
  		var type = typeof value,
  			isBool = typeof stateVal === "boolean";
  
  		if ( jQuery.isFunction( value ) ) {
  			return this.each(function(i) {
  				var self = jQuery(this);
  				self.toggleClass( value.call(this, i, self.attr("class"), stateVal), stateVal );
  			});
  		}
  
  		return this.each(function() {
  			if ( type === "string" ) {
  				// toggle individual class names
  				var className,
  					i = 0,
  					self = jQuery( this ),
  					state = stateVal,
  					classNames = value.split( rspace );
  
  				while ( (className = classNames[ i++ ]) ) {
  					// check each className given, space seperated list
  					state = isBool ? state : !self.hasClass( className );
  					self[ state ? "addClass" : "removeClass" ]( className );
  				}
  
  			} else if ( type === "undefined" || type === "boolean" ) {
  				if ( this.className ) {
  					// store className if set
  					jQuery._data( this, "__className__", this.className );
  				}
  
  				// toggle whole className
  				this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || "";
  			}
  		});
  	},
  
  	hasClass: function( selector ) {
  		var className = " " + selector + " ";
  		for ( var i = 0, l = this.length; i < l; i++ ) {
  			if ( (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) {
  				return true;
  			}
  		}
  
  		return false;
  	},
  
  	val: function( value ) {
  		var hooks, ret,
  			elem = this[0];
  		
  		if ( !arguments.length ) {
  			if ( elem ) {
  				hooks = jQuery.valHooks[ elem.nodeName.toLowerCase() ] || jQuery.valHooks[ elem.type ];
  
  				if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) {
  					return ret;
  				}
  
  				return (elem.value || "").replace(rreturn, "");
  			}
  
  			return undefined;
  		}
  
  		var isFunction = jQuery.isFunction( value );
  
  		return this.each(function( i ) {
  			var self = jQuery(this), val;
  
  			if ( this.nodeType !== 1 ) {
  				return;
  			}
  
  			if ( isFunction ) {
  				val = value.call( this, i, self.val() );
  			} else {
  				val = value;
  			}
  
  			// Treat null/undefined as ""; convert numbers to string
  			if ( val == null ) {
  				val = "";
  			} else if ( typeof val === "number" ) {
  				val += "";
  			} else if ( jQuery.isArray( val ) ) {
  				val = jQuery.map(val, function ( value ) {
  					return value == null ? "" : value + "";
  				});
  			}
  
  			hooks = jQuery.valHooks[ this.nodeName.toLowerCase() ] || jQuery.valHooks[ this.type ];
  
  			// If set returns undefined, fall back to normal setting
  			if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) {
  				this.value = val;
  			}
  		});
  	}
  });
  
  jQuery.extend({
  	valHooks: {
  		option: {
  			get: function( elem ) {
  				// attributes.value is undefined in Blackberry 4.7 but
  				// uses .value. See #6932
  				var val = elem.attributes.value;
  				return !val || val.specified ? elem.value : elem.text;
  			}
  		},
  		select: {
  			get: function( elem ) {
  				var value,
  					index = elem.selectedIndex,
  					values = [],
  					options = elem.options,
  					one = elem.type === "select-one";
  
  				// Nothing was selected
  				if ( index < 0 ) {
  					return null;
  				}
  
  				// Loop through all the selected options
  				for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {
  					var option = options[ i ];
  
  					// Don't return options that are disabled or in a disabled optgroup
  					if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) &&
  							(!option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" )) ) {
  
  						// Get the specific value for the option
  						value = jQuery( option ).val();
  
  						// We don't need an array for one selects
  						if ( one ) {
  							return value;
  						}
  
  						// Multi-Selects return an array
  						values.push( value );
  					}
  				}
  
  				// Fixes Bug #2551 -- select.val() broken in IE after form.reset()
  				if ( one && !values.length && options.length ) {
  					return jQuery( options[ index ] ).val();
  				}
  
  				return values;
  			},
  
  			set: function( elem, value ) {
  				var values = jQuery.makeArray( value );
  
  				jQuery(elem).find("option").each(function() {
  					this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
  				});
  
  				if ( !values.length ) {
  					elem.selectedIndex = -1;
  				}
  				return values;
  			}
  		}
  	},
  
  	attrFn: {
  		val: true,
  		css: true,
  		html: true,
  		text: true,
  		data: true,
  		width: true,
  		height: true,
  		offset: true
  	},
  	
  	attrFix: {
  		// Always normalize to ensure hook usage
  		tabindex: "tabIndex"
  	},
  	
  	attr: function( elem, name, value, pass ) {
  		var nType = elem.nodeType;
  		
  		// don't get/set attributes on text, comment and attribute nodes
  		if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
  			return undefined;
  		}
  
  		if ( pass && name in jQuery.attrFn ) {
  			return jQuery( elem )[ name ]( value );
  		}
  
  		// Fallback to prop when attributes are not supported
  		if ( !("getAttribute" in elem) ) {
  			return jQuery.prop( elem, name, value );
  		}
  
  		var ret, hooks,
  			notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
  
  		// Normalize the name if needed
  		name = notxml && jQuery.attrFix[ name ] || name;
  
  		hooks = jQuery.attrHooks[ name ];
  
  		if ( !hooks ) {
  			// Use boolHook for boolean attributes
  			if ( rboolean.test( name ) &&
  				(typeof value === "boolean" || value === undefined || value.toLowerCase() === name.toLowerCase()) ) {
  
  				hooks = boolHook;
  
  			// Use formHook for forms and if the name contains certain characters
  			} else if ( formHook && (jQuery.nodeName( elem, "form" ) || rinvalidChar.test( name )) ) {
  				hooks = formHook;
  			}
  		}
  
  		if ( value !== undefined ) {
  
  			if ( value === null ) {
  				jQuery.removeAttr( elem, name );
  				return undefined;
  
  			} else if ( hooks && "set" in hooks && notxml && (ret = hooks.set( elem, value, name )) !== undefined ) {
  				return ret;
  
  			} else {
  				elem.setAttribute( name, "" + value );
  				return value;
  			}
  
  		} else if ( hooks && "get" in hooks && notxml ) {
  			return hooks.get( elem, name );
  
  		} else {
  
  			ret = elem.getAttribute( name );
  
  			// Non-existent attributes return null, we normalize to undefined
  			return ret === null ?
  				undefined :
  				ret;
  		}
  	},
  
  	removeAttr: function( elem, name ) {
  		var propName;
  		if ( elem.nodeType === 1 ) {
  			name = jQuery.attrFix[ name ] || name;
  		
  			if ( jQuery.support.getSetAttribute ) {
  				// Use removeAttribute in browsers that support it
  				elem.removeAttribute( name );
  			} else {
  				jQuery.attr( elem, name, "" );
  				elem.removeAttributeNode( elem.getAttributeNode( name ) );
  			}
  
  			// Set corresponding property to false for boolean attributes
  			if ( rboolean.test( name ) && (propName = jQuery.propFix[ name ] || name) in elem ) {
  				elem[ propName ] = false;
  			}
  		}
  	},
  
  	attrHooks: {
  		type: {
  			set: function( elem, value ) {
  				// We can't allow the type property to be changed (since it causes problems in IE)
  				if ( rtype.test( elem.nodeName ) && elem.parentNode ) {
  					jQuery.error( "type property can't be changed" );
  				} else if ( !jQuery.support.radioValue && value === "radio" && jQuery.nodeName(elem, "input") ) {
  					// Setting the type on a radio button after the value resets the value in IE6-9
  					// Reset value to it's default in case type is set after value
  					// This is for element creation
  					var val = elem.value;
  					elem.setAttribute( "type", value );
  					if ( val ) {
  						elem.value = val;
  					}
  					return value;
  				}
  			}
  		},
  		tabIndex: {
  			get: function( elem ) {
  				// elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
  				// http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
  				var attributeNode = elem.getAttributeNode("tabIndex");
  
  				return attributeNode && attributeNode.specified ?
  					parseInt( attributeNode.value, 10 ) :
  					rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
  						0 :
  						undefined;
  			}
  		}
  	},
  
  	propFix: {
  		tabindex: "tabIndex",
  		readonly: "readOnly",
  		"for": "htmlFor",
  		"class": "className",
  		maxlength: "maxLength",
  		cellspacing: "cellSpacing",
  		cellpadding: "cellPadding",
  		rowspan: "rowSpan",
  		colspan: "colSpan",
  		usemap: "useMap",
  		frameborder: "frameBorder",
  		contenteditable: "contentEditable"
  	},
  	
  	prop: function( elem, name, value ) {
  		var nType = elem.nodeType;
  
  		// don't get/set properties on text, comment and attribute nodes
  		if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
  			return undefined;
  		}
  
  		var ret, hooks,
  			notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
  
  		// Try to normalize/fix the name
  		name = notxml && jQuery.propFix[ name ] || name;
  		
  		hooks = jQuery.propHooks[ name ];
  
  		if ( value !== undefined ) {
  			if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {
  				return ret;
  
  			} else {
  				return (elem[ name ] = value);
  			}
  
  		} else {
  			if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== undefined ) {
  				return ret;
  
  			} else {
  				return elem[ name ];
  			}
  		}
  	},
  	
  	propHooks: {}
  });
  
  // Hook for boolean attributes
  boolHook = {
  	get: function( elem, name ) {
  		// Align boolean attributes with corresponding properties
  		return elem[ jQuery.propFix[ name ] || name ] ?
  			name.toLowerCase() :
  			undefined;
  	},
  	set: function( elem, value, name ) {
  		var propName;
  		if ( value === false ) {
  			// Remove boolean attributes when set to false
  			jQuery.removeAttr( elem, name );
  		} else {
  			// value is true since we know at this point it's type boolean and not false
  			// Set boolean attributes to the same name and set the DOM property
  			propName = jQuery.propFix[ name ] || name;
  			if ( propName in elem ) {
  				// Only set the IDL specifically if it already exists on the element
  				elem[ propName ] = value;
  			}
  
  			elem.setAttribute( name, name.toLowerCase() );
  		}
  		return name;
  	}
  };
  
  // Use the value property for back compat
  // Use the formHook for button elements in IE6/7 (#1954)
  jQuery.attrHooks.value = {
  	get: function( elem, name ) {
  		if ( formHook && jQuery.nodeName( elem, "button" ) ) {
  			return formHook.get( elem, name );
  		}
  		return elem.value;
  	},
  	set: function( elem, value, name ) {
  		if ( formHook && jQuery.nodeName( elem, "button" ) ) {
  			return formHook.set( elem, value, name );
  		}
  		// Does not return so that setAttribute is also used
  		elem.value = value;
  	}
  };
  
  // IE6/7 do not support getting/setting some attributes with get/setAttribute
  if ( !jQuery.support.getSetAttribute ) {
  
  	// propFix is more comprehensive and contains all fixes
  	jQuery.attrFix = jQuery.propFix;
  	
  	// Use this for any attribute on a form in IE6/7
  	formHook = jQuery.attrHooks.name = jQuery.valHooks.button = {
  		get: function( elem, name ) {
  			var ret;
  			ret = elem.getAttributeNode( name );
  			// Return undefined if nodeValue is empty string
  			return ret && ret.nodeValue !== "" ?
  				ret.nodeValue :
  				undefined;
  		},
  		set: function( elem, value, name ) {
  			// Check form objects in IE (multiple bugs related)
  			// Only use nodeValue if the attribute node exists on the form
  			var ret = elem.getAttributeNode( name );
  			if ( ret ) {
  				ret.nodeValue = value;
  				return value;
  			}
  		}
  	};
  
  	// Set width and height to auto instead of 0 on empty string( Bug #8150 )
  	// This is for removals
  	jQuery.each([ "width", "height" ], function( i, name ) {
  		jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
  			set: function( elem, value ) {
  				if ( value === "" ) {
  					elem.setAttribute( name, "auto" );
  					return value;
  				}
  			}
  		});
  	});
  }
  
  
  // Some attributes require a special call on IE
  if ( !jQuery.support.hrefNormalized ) {
  	jQuery.each([ "href", "src", "width", "height" ], function( i, name ) {
  		jQuery.attrHooks[ name ] = jQuery.extend( jQuery.attrHooks[ name ], {
  			get: function( elem ) {
  				var ret = elem.getAttribute( name, 2 );
  				return ret === null ? undefined : ret;
  			}
  		});
  	});
  }
  
  if ( !jQuery.support.style ) {
  	jQuery.attrHooks.style = {
  		get: function( elem ) {
  			// Return undefined in the case of empty string
  			// Normalize to lowercase since IE uppercases css property names
  			return elem.style.cssText.toLowerCase() || undefined;
  		},
  		set: function( elem, value ) {
  			return (elem.style.cssText = "" + value);
  		}
  	};
  }
  
  // Safari mis-reports the default selected property of an option
  // Accessing the parent's selectedIndex property fixes it
  if ( !jQuery.support.optSelected ) {
  	jQuery.propHooks.selected = jQuery.extend( jQuery.propHooks.selected, {
  		get: function( elem ) {
  			var parent = elem.parentNode;
  
  			if ( parent ) {
  				parent.selectedIndex;
  
  				// Make sure that it also works with optgroups, see #5701
  				if ( parent.parentNode ) {
  					parent.parentNode.selectedIndex;
  				}
  			}
  		}
  	});
  }
  
  // Radios and checkboxes getter/setter
  if ( !jQuery.support.checkOn ) {
  	jQuery.each([ "radio", "checkbox" ], function() {
  		jQuery.valHooks[ this ] = {
  			get: function( elem ) {
  				// Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
  				return elem.getAttribute("value") === null ? "on" : elem.value;
  			}
  		};
  	});
  }
  jQuery.each([ "radio", "checkbox" ], function() {
  	jQuery.valHooks[ this ] = jQuery.extend( jQuery.valHooks[ this ], {
  		set: function( elem, value ) {
  			if ( jQuery.isArray( value ) ) {
  				return (elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0);
  			}
  		}
  	});
  });
  
  
  
  
  var hasOwn = Object.prototype.hasOwnProperty,
  	rnamespaces = /\.(.*)$/,
  	rformElems = /^(?:textarea|input|select)$/i,
  	rperiod = /\./g,
  	rspaces = / /g,
  	rescape = /[^\w\s.|`]/g,
  	fcleanup = function( nm ) {
  		return nm.replace(rescape, "\\$&");
  	};
  
  /*
   * A number of helper functions used for managing events.
   * Many of the ideas behind this code originated from
   * Dean Edwards' addEvent library.
   */
  jQuery.event = {
  
  	// Bind an event to an element
  	// Original by Dean Edwards
  	add: function( elem, types, handler, data ) {
  		if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
  			return;
  		}
  
  		if ( handler === false ) {
  			handler = returnFalse;
  		} else if ( !handler ) {
  			// Fixes bug #7229. Fix recommended by jdalton
  			return;
  		}
  
  		var handleObjIn, handleObj;
  
  		if ( handler.handler ) {
  			handleObjIn = handler;
  			handler = handleObjIn.handler;
  		}
  
  		// Make sure that the function being executed has a unique ID
  		if ( !handler.guid ) {
  			handler.guid = jQuery.guid++;
  		}
  
  		// Init the element's event structure
  		var elemData = jQuery._data( elem );
  
  		// If no elemData is found then we must be trying to bind to one of the
  		// banned noData elements
  		if ( !elemData ) {
  			return;
  		}
  
  		var events = elemData.events,
  			eventHandle = elemData.handle;
  
  		if ( !events ) {
  			elemData.events = events = {};
  		}
  
  		if ( !eventHandle ) {
  			elemData.handle = eventHandle = function( e ) {
  				// Discard the second event of a jQuery.event.trigger() and
  				// when an event is called after a page has unloaded
  				return typeof jQuery !== "undefined" && (!e || jQuery.event.triggered !== e.type) ?
  					jQuery.event.handle.apply( eventHandle.elem, arguments ) :
  					undefined;
  			};
  		}
  
  		// Add elem as a property of the handle function
  		// This is to prevent a memory leak with non-native events in IE.
  		eventHandle.elem = elem;
  
  		// Handle multiple events separated by a space
  		// jQuery(...).bind("mouseover mouseout", fn);
  		types = types.split(" ");
  
  		var type, i = 0, namespaces;
  
  		while ( (type = types[ i++ ]) ) {
  			handleObj = handleObjIn ?
  				jQuery.extend({}, handleObjIn) :
  				{ handler: handler, data: data };
  
  			// Namespaced event handlers
  			if ( type.indexOf(".") > -1 ) {
  				namespaces = type.split(".");
  				type = namespaces.shift();
  				handleObj.namespace = namespaces.slice(0).sort().join(".");
  
  			} else {
  				namespaces = [];
  				handleObj.namespace = "";
  			}
  
  			handleObj.type = type;
  			if ( !handleObj.guid ) {
  				handleObj.guid = handler.guid;
  			}
  
  			// Get the current list of functions bound to this event
  			var handlers = events[ type ],
  				special = jQuery.event.special[ type ] || {};
  
  			// Init the event handler queue
  			if ( !handlers ) {
  				handlers = events[ type ] = [];
  
  				// Check for a special event handler
  				// Only use addEventListener/attachEvent if the special
  				// events handler returns false
  				if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
  					// Bind the global event handler to the element
  					if ( elem.addEventListener ) {
  						elem.addEventListener( type, eventHandle, false );
  
  					} else if ( elem.attachEvent ) {
  						elem.attachEvent( "on" + type, eventHandle );
  					}
  				}
  			}
  
  			if ( special.add ) {
  				special.add.call( elem, handleObj );
  
  				if ( !handleObj.handler.guid ) {
  					handleObj.handler.guid = handler.guid;
  				}
  			}
  
  			// Add the function to the element's handler list
  			handlers.push( handleObj );
  
  			// Keep track of which events have been used, for event optimization
  			jQuery.event.global[ type ] = true;
  		}
  
  		// Nullify elem to prevent memory leaks in IE
  		elem = null;
  	},
  
  	global: {},
  
  	// Detach an event or set of events from an element
  	remove: function( elem, types, handler, pos ) {
  		// don't do events on text and comment nodes
  		if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
  			return;
  		}
  
  		if ( handler === false ) {
  			handler = returnFalse;
  		}
  
  		var ret, type, fn, j, i = 0, all, namespaces, namespace, special, eventType, handleObj, origType,
  			elemData = jQuery.hasData( elem ) && jQuery._data( elem ),
  			events = elemData && elemData.events;
  
  		if ( !elemData || !events ) {
  			return;
  		}
  
  		// types is actually an event object here
  		if ( types && types.type ) {
  			handler = types.handler;
  			types = types.type;
  		}
  
  		// Unbind all events for the element
  		if ( !types || typeof types === "string" && types.charAt(0) === "." ) {
  			types = types || "";
  
  			for ( type in events ) {
  				jQuery.event.remove( elem, type + types );
  			}
  
  			return;
  		}
  
  		// Handle multiple events separated by a space
  		// jQuery(...).unbind("mouseover mouseout", fn);
  		types = types.split(" ");
  
  		while ( (type = types[ i++ ]) ) {
  			origType = type;
  			handleObj = null;
  			all = type.indexOf(".") < 0;
  			namespaces = [];
  
  			if ( !all ) {
  				// Namespaced event handlers
  				namespaces = type.split(".");
  				type = namespaces.shift();
  
  				namespace = new RegExp("(^|\\.)" +
  					jQuery.map( namespaces.slice(0).sort(), fcleanup ).join("\\.(?:.*\\.)?") + "(\\.|$)");
  			}
  
  			eventType = events[ type ];
  
  			if ( !eventType ) {
  				continue;
  			}
  
  			if ( !handler ) {
  				for ( j = 0; j < eventType.length; j++ ) {
  					handleObj = eventType[ j ];
  
  					if ( all || namespace.test( handleObj.namespace ) ) {
  						jQuery.event.remove( elem, origType, handleObj.handler, j );
  						eventType.splice( j--, 1 );
  					}
  				}
  
  				continue;
  			}
  
  			special = jQuery.event.special[ type ] || {};
  
  			for ( j = pos || 0; j < eventType.length; j++ ) {
  				handleObj = eventType[ j ];
  
  				if ( handler.guid === handleObj.guid ) {
  					// remove the given handler for the given type
  					if ( all || namespace.test( handleObj.namespace ) ) {
  						if ( pos == null ) {
  							eventType.splice( j--, 1 );
  						}
  
  						if ( special.remove ) {
  							special.remove.call( elem, handleObj );
  						}
  					}
  
  					if ( pos != null ) {
  						break;
  					}
  				}
  			}
  
  			// remove generic event handler if no more handlers exist
  			if ( eventType.length === 0 || pos != null && eventType.length === 1 ) {
  				if ( !special.teardown || special.teardown.call( elem, namespaces ) === false ) {
  					jQuery.removeEvent( elem, type, elemData.handle );
  				}
  
  				ret = null;
  				delete events[ type ];
  			}
  		}
  
  		// Remove the expando if it's no longer used
  		if ( jQuery.isEmptyObject( events ) ) {
  			var handle = elemData.handle;
  			if ( handle ) {
  				handle.elem = null;
  			}
  
  			delete elemData.events;
  			delete elemData.handle;
  
  			if ( jQuery.isEmptyObject( elemData ) ) {
  				jQuery.removeData( elem, undefined, true );
  			}
  		}
  	},
  	
  	// Events that are safe to short-circuit if no handlers are attached.
  	// Native DOM events should not be added, they may have inline handlers.
  	customEvent: {
  		"getData": true,
  		"setData": true,
  		"changeData": true
  	},
  
  	trigger: function( event, data, elem, onlyHandlers ) {
  		// Event object or event type
  		var type = event.type || event,
  			namespaces = [],
  			exclusive;
  
  		if ( type.indexOf("!") >= 0 ) {
  			// Exclusive events trigger only for the exact event (no namespaces)
  			type = type.slice(0, -1);
  			exclusive = true;
  		}
  
  		if ( type.indexOf(".") >= 0 ) {
  			// Namespaced trigger; create a regexp to match event type in handle()
  			namespaces = type.split(".");
  			type = namespaces.shift();
  			namespaces.sort();
  		}
  
  		if ( (!elem || jQuery.event.customEvent[ type ]) && !jQuery.event.global[ type ] ) {
  			// No jQuery handlers for this event type, and it can't have inline handlers
  			return;
  		}
  
  		// Caller can pass in an Event, Object, or just an event type string
  		event = typeof event === "object" ?
  			// jQuery.Event object
  			event[ jQuery.expando ] ? event :
  			// Object literal
  			new jQuery.Event( type, event ) :
  			// Just the event type (string)
  			new jQuery.Event( type );
  
  		event.type = type;
  		event.exclusive = exclusive;
  		event.namespace = namespaces.join(".");
  		event.namespace_re = new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.)?") + "(\\.|$)");
  		
  		// triggerHandler() and global events don't bubble or run the default action
  		if ( onlyHandlers || !elem ) {
  			event.preventDefault();
  			event.stopPropagation();
  		}
  
  		// Handle a global trigger
  		if ( !elem ) {
  			// TODO: Stop taunting the data cache; remove global events and always attach to document
  			jQuery.each( jQuery.cache, function() {
  				// internalKey variable is just used to make it easier to find
  				// and potentially change this stuff later; currently it just
  				// points to jQuery.expando
  				var internalKey = jQuery.expando,
  					internalCache = this[ internalKey ];
  				if ( internalCache && internalCache.events && internalCache.events[ type ] ) {
  					jQuery.event.trigger( event, data, internalCache.handle.elem );
  				}
  			});
  			return;
  		}
  
  		// Don't do events on text and comment nodes
  		if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
  			return;
  		}
  
  		// Clean up the event in case it is being reused
  		event.result = undefined;
  		event.target = elem;
  
  		// Clone any incoming data and prepend the event, creating the handler arg list
  		data = data ? jQuery.makeArray( data ) : [];
  		data.unshift( event );
  
  		var cur = elem,
  			// IE doesn't like method names with a colon (#3533, #8272)
  			ontype = type.indexOf(":") < 0 ? "on" + type : "";
  
  		// Fire event on the current element, then bubble up the DOM tree
  		do {
  			var handle = jQuery._data( cur, "handle" );
  
  			event.currentTarget = cur;
  			if ( handle ) {
  				handle.apply( cur, data );
  			}
  
  			// Trigger an inline bound script
  			if ( ontype && jQuery.acceptData( cur ) && cur[ ontype ] && cur[ ontype ].apply( cur, data ) === false ) {
  				event.result = false;
  				event.preventDefault();
  			}
  
  			// Bubble up to document, then to window
  			cur = cur.parentNode || cur.ownerDocument || cur === event.target.ownerDocument && window;
  		} while ( cur && !event.isPropagationStopped() );
  
  		// If nobody prevented the default action, do it now
  		if ( !event.isDefaultPrevented() ) {
  			var old,
  				special = jQuery.event.special[ type ] || {};
  
  			if ( (!special._default || special._default.call( elem.ownerDocument, event ) === false) &&
  				!(type === "click" && jQuery.nodeName( elem, "a" )) && jQuery.acceptData( elem ) ) {
  
  				// Call a native DOM method on the target with the same name name as the event.
  				// Can't use an .isFunction)() check here because IE6/7 fails that test.
  				// IE<9 dies on focus to hidden element (#1486), may want to revisit a try/catch.
  				try {
  					if ( ontype && elem[ type ] ) {
  						// Don't re-trigger an onFOO event when we call its FOO() method
  						old = elem[ ontype ];
  
  						if ( old ) {
  							elem[ ontype ] = null;
  						}
  
  						jQuery.event.triggered = type;
  						elem[ type ]();
  					}
  				} catch ( ieError ) {}
  
  				if ( old ) {
  					elem[ ontype ] = old;
  				}
  
  				jQuery.event.triggered = undefined;
  			}
  		}
  		
  		return event.result;
  	},
  
  	handle: function( event ) {
  		event = jQuery.event.fix( event || window.event );
  		// Snapshot the handlers list since a called handler may add/remove events.
  		var handlers = ((jQuery._data( this, "events" ) || {})[ event.type ] || []).slice(0),
  			run_all = !event.exclusive && !event.namespace,
  			args = Array.prototype.slice.call( arguments, 0 );
  
  		// Use the fix-ed Event rather than the (read-only) native event
  		args[0] = event;
  		event.currentTarget = this;
  
  		for ( var j = 0, l = handlers.length; j < l; j++ ) {
  			var handleObj = handlers[ j ];
  
  			// Triggered event must 1) be non-exclusive and have no namespace, or
  			// 2) have namespace(s) a subset or equal to those in the bound event.
  			if ( run_all || event.namespace_re.test( handleObj.namespace ) ) {
  				// Pass in a reference to the handler function itself
  				// So that we can later remove it
  				event.handler = handleObj.handler;
  				event.data = handleObj.data;
  				event.handleObj = handleObj;
  
  				var ret = handleObj.handler.apply( this, args );
  
  				if ( ret !== undefined ) {
  					event.result = ret;
  					if ( ret === false ) {
  						event.preventDefault();
  						event.stopPropagation();
  					}
  				}
  
  				if ( event.isImmediatePropagationStopped() ) {
  					break;
  				}
  			}
  		}
  		return event.result;
  	},
  
  	props: "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode layerX layerY metaKey newValue offsetX offsetY pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "),
  
  	fix: function( event ) {
  		if ( event[ jQuery.expando ] ) {
  			return event;
  		}
  
  		// store a copy of the original event object
  		// and "clone" to set read-only properties
  		var originalEvent = event;
  		event = jQuery.Event( originalEvent );
  
  		for ( var i = this.props.length, prop; i; ) {
  			prop = this.props[ --i ];
  			event[ prop ] = originalEvent[ prop ];
  		}
  
  		// Fix target property, if necessary
  		if ( !event.target ) {
  			// Fixes #1925 where srcElement might not be defined either
  			event.target = event.srcElement || document;
  		}
  
  		// check if target is a textnode (safari)
  		if ( event.target.nodeType === 3 ) {
  			event.target = event.target.parentNode;
  		}
  
  		// Add relatedTarget, if necessary
  		if ( !event.relatedTarget && event.fromElement ) {
  			event.relatedTarget = event.fromElement === event.target ? event.toElement : event.fromElement;
  		}
  
  		// Calculate pageX/Y if missing and clientX/Y available
  		if ( event.pageX == null && event.clientX != null ) {
  			var eventDocument = event.target.ownerDocument || document,
  				doc = eventDocument.documentElement,
  				body = eventDocument.body;
  
  			event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
  			event.pageY = event.clientY + (doc && doc.scrollTop  || body && body.scrollTop  || 0) - (doc && doc.clientTop  || body && body.clientTop  || 0);
  		}
  
  		// Add which for key events
  		if ( event.which == null && (event.charCode != null || event.keyCode != null) ) {
  			event.which = event.charCode != null ? event.charCode : event.keyCode;
  		}
  
  		// Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
  		if ( !event.metaKey && event.ctrlKey ) {
  			event.metaKey = event.ctrlKey;
  		}
  
  		// Add which for click: 1 === left; 2 === middle; 3 === right
  		// Note: button is not normalized, so don't use it
  		if ( !event.which && event.button !== undefined ) {
  			event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
  		}
  
  		return event;
  	},
  
  	// Deprecated, use jQuery.guid instead
  	guid: 1E8,
  
  	// Deprecated, use jQuery.proxy instead
  	proxy: jQuery.proxy,
  
  	special: {
  		ready: {
  			// Make sure the ready event is setup
  			setup: jQuery.bindReady,
  			teardown: jQuery.noop
  		},
  
  		live: {
  			add: function( handleObj ) {
  				jQuery.event.add( this,
  					liveConvert( handleObj.origType, handleObj.selector ),
  					jQuery.extend({}, handleObj, {handler: liveHandler, guid: handleObj.handler.guid}) );
  			},
  
  			remove: function( handleObj ) {
  				jQuery.event.remove( this, liveConvert( handleObj.origType, handleObj.selector ), handleObj );
  			}
  		},
  
  		beforeunload: {
  			setup: function( data, namespaces, eventHandle ) {
  				// We only want to do this special case on windows
  				if ( jQuery.isWindow( this ) ) {
  					this.onbeforeunload = eventHandle;
  				}
  			},
  
  			teardown: function( namespaces, eventHandle ) {
  				if ( this.onbeforeunload === eventHandle ) {
  					this.onbeforeunload = null;
  				}
  			}
  		}
  	}
  };
  
  jQuery.removeEvent = document.removeEventListener ?
  	function( elem, type, handle ) {
  		if ( elem.removeEventListener ) {
  			elem.removeEventListener( type, handle, false );
  		}
  	} :
  	function( elem, type, handle ) {
  		if ( elem.detachEvent ) {
  			elem.detachEvent( "on" + type, handle );
  		}
  	};
  
  jQuery.Event = function( src, props ) {
  	// Allow instantiation without the 'new' keyword
  	if ( !this.preventDefault ) {
  		return new jQuery.Event( src, props );
  	}
  
  	// Event object
  	if ( src && src.type ) {
  		this.originalEvent = src;
  		this.type = src.type;
  
  		// Events bubbling up the document may have been marked as prevented
  		// by a handler lower down the tree; reflect the correct value.
  		this.isDefaultPrevented = (src.defaultPrevented || src.returnValue === false ||
  			src.getPreventDefault && src.getPreventDefault()) ? returnTrue : returnFalse;
  
  	// Event type
  	} else {
  		this.type = src;
  	}
  
  	// Put explicitly provided properties onto the event object
  	if ( props ) {
  		jQuery.extend( this, props );
  	}
  
  	// timeStamp is buggy for some events on Firefox(#3843)
  	// So we won't rely on the native value
  	this.timeStamp = jQuery.now();
  
  	// Mark it as fixed
  	this[ jQuery.expando ] = true;
  };
  
  function returnFalse() {
  	return false;
  }
  function returnTrue() {
  	return true;
  }
  
  // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
  // http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
  jQuery.Event.prototype = {
  	preventDefault: function() {
  		this.isDefaultPrevented = returnTrue;
  
  		var e = this.originalEvent;
  		if ( !e ) {
  			return;
  		}
  
  		// if preventDefault exists run it on the original event
  		if ( e.preventDefault ) {
  			e.preventDefault();
  
  		// otherwise set the returnValue property of the original event to false (IE)
  		} else {
  			e.returnValue = false;
  		}
  	},
  	stopPropagation: function() {
  		this.isPropagationStopped = returnTrue;
  
  		var e = this.originalEvent;
  		if ( !e ) {
  			return;
  		}
  		// if stopPropagation exists run it on the original event
  		if ( e.stopPropagation ) {
  			e.stopPropagation();
  		}
  		// otherwise set the cancelBubble property of the original event to true (IE)
  		e.cancelBubble = true;
  	},
  	stopImmediatePropagation: function() {
  		this.isImmediatePropagationStopped = returnTrue;
  		this.stopPropagation();
  	},
  	isDefaultPrevented: returnFalse,
  	isPropagationStopped: returnFalse,
  	isImmediatePropagationStopped: returnFalse
  };
  
  // Checks if an event happened on an element within another element
  // Used in jQuery.event.special.mouseenter and mouseleave handlers
  var withinElement = function( event ) {
  	// Check if mouse(over|out) are still within the same parent element
  	var parent = event.relatedTarget;
  
  	// set the correct event type
  	event.type = event.data;
  
  	// Firefox sometimes assigns relatedTarget a XUL element
  	// which we cannot access the parentNode property of
  	try {
  
  		// Chrome does something similar, the parentNode property
  		// can be accessed but is null.
  		if ( parent && parent !== document && !parent.parentNode ) {
  			return;
  		}
  
  		// Traverse up the tree
  		while ( parent && parent !== this ) {
  			parent = parent.parentNode;
  		}
  
  		if ( parent !== this ) {
  			// handle event if we actually just moused on to a non sub-element
  			jQuery.event.handle.apply( this, arguments );
  		}
  
  	// assuming we've left the element since we most likely mousedover a xul element
  	} catch(e) { }
  },
  
  // In case of event delegation, we only need to rename the event.type,
  // liveHandler will take care of the rest.
  delegate = function( event ) {
  	event.type = event.data;
  	jQuery.event.handle.apply( this, arguments );
  };
  
  // Create mouseenter and mouseleave events
  jQuery.each({
  	mouseenter: "mouseover",
  	mouseleave: "mouseout"
  }, function( orig, fix ) {
  	jQuery.event.special[ orig ] = {
  		setup: function( data ) {
  			jQuery.event.add( this, fix, data && data.selector ? delegate : withinElement, orig );
  		},
  		teardown: function( data ) {
  			jQuery.event.remove( this, fix, data && data.selector ? delegate : withinElement );
  		}
  	};
  });
  
  // submit delegation
  if ( !jQuery.support.submitBubbles ) {
  
  	jQuery.event.special.submit = {
  		setup: function( data, namespaces ) {
  			if ( !jQuery.nodeName( this, "form" ) ) {
  				jQuery.event.add(this, "click.specialSubmit", function( e ) {
  					var elem = e.target,
  						type = elem.type;
  
  					if ( (type === "submit" || type === "image") && jQuery( elem ).closest("form").length ) {
  						trigger( "submit", this, arguments );
  					}
  				});
  
  				jQuery.event.add(this, "keypress.specialSubmit", function( e ) {
  					var elem = e.target,
  						type = elem.type;
  
  					if ( (type === "text" || type === "password") && jQuery( elem ).closest("form").length && e.keyCode === 13 ) {
  						trigger( "submit", this, arguments );
  					}
  				});
  
  			} else {
  				return false;
  			}
  		},
  
  		teardown: function( namespaces ) {
  			jQuery.event.remove( this, ".specialSubmit" );
  		}
  	};
  
  }
  
  // change delegation, happens here so we have bind.
  if ( !jQuery.support.changeBubbles ) {
  
  	var changeFilters,
  
  	getVal = function( elem ) {
  		var type = elem.type, val = elem.value;
  
  		if ( type === "radio" || type === "checkbox" ) {
  			val = elem.checked;
  
  		} else if ( type === "select-multiple" ) {
  			val = elem.selectedIndex > -1 ?
  				jQuery.map( elem.options, function( elem ) {
  					return elem.selected;
  				}).join("-") :
  				"";
  
  		} else if ( jQuery.nodeName( elem, "select" ) ) {
  			val = elem.selectedIndex;
  		}
  
  		return val;
  	},
  
  	testChange = function testChange( e ) {
  		var elem = e.target, data, val;
  
  		if ( !rformElems.test( elem.nodeName ) || elem.readOnly ) {
  			return;
  		}
  
  		data = jQuery._data( elem, "_change_data" );
  		val = getVal(elem);
  
  		// the current data will be also retrieved by beforeactivate
  		if ( e.type !== "focusout" || elem.type !== "radio" ) {
  			jQuery._data( elem, "_change_data", val );
  		}
  
  		if ( data === undefined || val === data ) {
  			return;
  		}
  
  		if ( data != null || val ) {
  			e.type = "change";
  			e.liveFired = undefined;
  			jQuery.event.trigger( e, arguments[1], elem );
  		}
  	};
  
  	jQuery.event.special.change = {
  		filters: {
  			focusout: testChange,
  
  			beforedeactivate: testChange,
  
  			click: function( e ) {
  				var elem = e.target, type = jQuery.nodeName( elem, "input" ) ? elem.type : "";
  
  				if ( type === "radio" || type === "checkbox" || jQuery.nodeName( elem, "select" ) ) {
  					testChange.call( this, e );
  				}
  			},
  
  			// Change has to be called before submit
  			// Keydown will be called before keypress, which is used in submit-event delegation
  			keydown: function( e ) {
  				var elem = e.target, type = jQuery.nodeName( elem, "input" ) ? elem.type : "";
  
  				if ( (e.keyCode === 13 && !jQuery.nodeName( elem, "textarea" ) ) ||
  					(e.keyCode === 32 && (type === "checkbox" || type === "radio")) ||
  					type === "select-multiple" ) {
  					testChange.call( this, e );
  				}
  			},
  
  			// Beforeactivate happens also before the previous element is blurred
  			// with this event you can't trigger a change event, but you can store
  			// information
  			beforeactivate: function( e ) {
  				var elem = e.target;
  				jQuery._data( elem, "_change_data", getVal(elem) );
  			}
  		},
  
  		setup: function( data, namespaces ) {
  			if ( this.type === "file" ) {
  				return false;
  			}
  
  			for ( var type in changeFilters ) {
  				jQuery.event.add( this, type + ".specialChange", changeFilters[type] );
  			}
  
  			return rformElems.test( this.nodeName );
  		},
  
  		teardown: function( namespaces ) {
  			jQuery.event.remove( this, ".specialChange" );
  
  			return rformElems.test( this.nodeName );
  		}
  	};
  
  	changeFilters = jQuery.event.special.change.filters;
  
  	// Handle when the input is .focus()'d
  	changeFilters.focus = changeFilters.beforeactivate;
  }
  
  function trigger( type, elem, args ) {
  	// Piggyback on a donor event to simulate a different one.
  	// Fake originalEvent to avoid donor's stopPropagation, but if the
  	// simulated event prevents default then we do the same on the donor.
  	// Don't pass args or remember liveFired; they apply to the donor event.
  	var event = jQuery.extend( {}, args[ 0 ] );
  	event.type = type;
  	event.originalEvent = {};
  	event.liveFired = undefined;
  	jQuery.event.handle.call( elem, event );
  	if ( event.isDefaultPrevented() ) {
  		args[ 0 ].preventDefault();
  	}
  }
  
  // Create "bubbling" focus and blur events
  if ( !jQuery.support.focusinBubbles ) {
  	jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
  
  		// Attach a single capturing handler while someone wants focusin/focusout
  		var attaches = 0;
  
  		jQuery.event.special[ fix ] = {
  			setup: function() {
  				if ( attaches++ === 0 ) {
  					document.addEventListener( orig, handler, true );
  				}
  			},
  			teardown: function() {
  				if ( --attaches === 0 ) {
  					document.removeEventListener( orig, handler, true );
  				}
  			}
  		};
  
  		function handler( donor ) {
  			// Donor event is always a native one; fix it and switch its type.
  			// Let focusin/out handler cancel the donor focus/blur event.
  			var e = jQuery.event.fix( donor );
  			e.type = fix;
  			e.originalEvent = {};
  			jQuery.event.trigger( e, null, e.target );
  			if ( e.isDefaultPrevented() ) {
  				donor.preventDefault();
  			}
  		}
  	});
  }
  
  jQuery.each(["bind", "one"], function( i, name ) {
  	jQuery.fn[ name ] = function( type, data, fn ) {
  		var handler;
  
  		// Handle object literals
  		if ( typeof type === "object" ) {
  			for ( var key in type ) {
  				this[ name ](key, data, type[key], fn);
  			}
  			return this;
  		}
  
  		if ( arguments.length === 2 || data === false ) {
  			fn = data;
  			data = undefined;
  		}
  
  		if ( name === "one" ) {
  			handler = function( event ) {
  				jQuery( this ).unbind( event, handler );
  				return fn.apply( this, arguments );
  			};
  			handler.guid = fn.guid || jQuery.guid++;
  		} else {
  			handler = fn;
  		}
  
  		if ( type === "unload" && name !== "one" ) {
  			this.one( type, data, fn );
  
  		} else {
  			for ( var i = 0, l = this.length; i < l; i++ ) {
  				jQuery.event.add( this[i], type, handler, data );
  			}
  		}
  
  		return this;
  	};
  });
  
  jQuery.fn.extend({
  	unbind: function( type, fn ) {
  		// Handle object literals
  		if ( typeof type === "object" && !type.preventDefault ) {
  			for ( var key in type ) {
  				this.unbind(key, type[key]);
  			}
  
  		} else {
  			for ( var i = 0, l = this.length; i < l; i++ ) {
  				jQuery.event.remove( this[i], type, fn );
  			}
  		}
  
  		return this;
  	},
  
  	delegate: function( selector, types, data, fn ) {
  		return this.live( types, data, fn, selector );
  	},
  
  	undelegate: function( selector, types, fn ) {
  		if ( arguments.length === 0 ) {
  			return this.unbind( "live" );
  
  		} else {
  			return this.die( types, null, fn, selector );
  		}
  	},
  
  	trigger: function( type, data ) {
  		return this.each(function() {
  			jQuery.event.trigger( type, data, this );
  		});
  	},
  
  	triggerHandler: function( type, data ) {
  		if ( this[0] ) {
  			return jQuery.event.trigger( type, data, this[0], true );
  		}
  	},
  
  	toggle: function( fn ) {
  		// Save reference to arguments for access in closure
  		var args = arguments,
  			guid = fn.guid || jQuery.guid++,
  			i = 0,
  			toggler = function( event ) {
  				// Figure out which function to execute
  				var lastToggle = ( jQuery.data( this, "lastToggle" + fn.guid ) || 0 ) % i;
  				jQuery.data( this, "lastToggle" + fn.guid, lastToggle + 1 );
  
  				// Make sure that clicks stop
  				event.preventDefault();
  
  				// and execute the function
  				return args[ lastToggle ].apply( this, arguments ) || false;
  			};
  
  		// link all the functions, so any of them can unbind this click handler
  		toggler.guid = guid;
  		while ( i < args.length ) {
  			args[ i++ ].guid = guid;
  		}
  
  		return this.click( toggler );
  	},
  
  	hover: function( fnOver, fnOut ) {
  		return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
  	}
  });
  
  var liveMap = {
  	focus: "focusin",
  	blur: "focusout",
  	mouseenter: "mouseover",
  	mouseleave: "mouseout"
  };
  
  jQuery.each(["live", "die"], function( i, name ) {
  	jQuery.fn[ name ] = function( types, data, fn, origSelector /* Internal Use Only */ ) {
  		var type, i = 0, match, namespaces, preType,
  			selector = origSelector || this.selector,
  			context = origSelector ? this : jQuery( this.context );
  
  		if ( typeof types === "object" && !types.preventDefault ) {
  			for ( var key in types ) {
  				context[ name ]( key, data, types[key], selector );
  			}
  
  			return this;
  		}
  
  		if ( name === "die" && !types &&
  					origSelector && origSelector.charAt(0) === "." ) {
  
  			context.unbind( origSelector );
  
  			return this;
  		}
  
  		if ( data === false || jQuery.isFunction( data ) ) {
  			fn = data || returnFalse;
  			data = undefined;
  		}
  
  		types = (types || "").split(" ");
  
  		while ( (type = types[ i++ ]) != null ) {
  			match = rnamespaces.exec( type );
  			namespaces = "";
  
  			if ( match )  {
  				namespaces = match[0];
  				type = type.replace( rnamespaces, "" );
  			}
  
  			if ( type === "hover" ) {
  				types.push( "mouseenter" + namespaces, "mouseleave" + namespaces );
  				continue;
  			}
  
  			preType = type;
  
  			if ( liveMap[ type ] ) {
  				types.push( liveMap[ type ] + namespaces );
  				type = type + namespaces;
  
  			} else {
  				type = (liveMap[ type ] || type) + namespaces;
  			}
  
  			if ( name === "live" ) {
  				// bind live handler
  				for ( var j = 0, l = context.length; j < l; j++ ) {
  					jQuery.event.add( context[j], "live." + liveConvert( type, selector ),
  						{ data: data, selector: selector, handler: fn, origType: type, origHandler: fn, preType: preType } );
  				}
  
  			} else {
  				// unbind live handler
  				context.unbind( "live." + liveConvert( type, selector ), fn );
  			}
  		}
  
  		return this;
  	};
  });
  
  function liveHandler( event ) {
  	var stop, maxLevel, related, match, handleObj, elem, j, i, l, data, close, namespace, ret,
  		elems = [],
  		selectors = [],
  		events = jQuery._data( this, "events" );
  
  	// Make sure we avoid non-left-click bubbling in Firefox (#3861) and disabled elements in IE (#6911)
  	if ( event.liveFired === this || !events || !events.live || event.target.disabled || event.button && event.type === "click" ) {
  		return;
  	}
  
  	if ( event.namespace ) {
  		namespace = new RegExp("(^|\\.)" + event.namespace.split(".").join("\\.(?:.*\\.)?") + "(\\.|$)");
  	}
  
  	event.liveFired = this;
  
  	var live = events.live.slice(0);
  
  	for ( j = 0; j < live.length; j++ ) {
  		handleObj = live[j];
  
  		if ( handleObj.origType.replace( rnamespaces, "" ) === event.type ) {
  			selectors.push( handleObj.selector );
  
  		} else {
  			live.splice( j--, 1 );
  		}
  	}
  
  	match = jQuery( event.target ).closest( selectors, event.currentTarget );
  
  	for ( i = 0, l = match.length; i < l; i++ ) {
  		close = match[i];
  
  		for ( j = 0; j < live.length; j++ ) {
  			handleObj = live[j];
  
  			if ( close.selector === handleObj.selector && (!namespace || namespace.test( handleObj.namespace )) && !close.elem.disabled ) {
  				elem = close.elem;
  				related = null;
  
  				// Those two events require additional checking
  				if ( handleObj.preType === "mouseenter" || handleObj.preType === "mouseleave" ) {
  					event.type = handleObj.preType;
  					related = jQuery( event.relatedTarget ).closest( handleObj.selector )[0];
  
  					// Make sure not to accidentally match a child element with the same selector
  					if ( related && jQuery.contains( elem, related ) ) {
  						related = elem;
  					}
  				}
  
  				if ( !related || related !== elem ) {
  					elems.push({ elem: elem, handleObj: handleObj, level: close.level });
  				}
  			}
  		}
  	}
  
  	for ( i = 0, l = elems.length; i < l; i++ ) {
  		match = elems[i];
  
  		if ( maxLevel && match.level > maxLevel ) {
  			break;
  		}
  
  		event.currentTarget = match.elem;
  		event.data = match.handleObj.data;
  		event.handleObj = match.handleObj;
  
  		ret = match.handleObj.origHandler.apply( match.elem, arguments );
  
  		if ( ret === false || event.isPropagationStopped() ) {
  			maxLevel = match.level;
  
  			if ( ret === false ) {
  				stop = false;
  			}
  			if ( event.isImmediatePropagationStopped() ) {
  				break;
  			}
  		}
  	}
  
  	return stop;
  }
  
  function liveConvert( type, selector ) {
  	return (type && type !== "*" ? type + "." : "") + selector.replace(rperiod, "`").replace(rspaces, "&");
  }
  
  jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
  	"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
  	"change select submit keydown keypress keyup error").split(" "), function( i, name ) {
  
  	// Handle event binding
  	jQuery.fn[ name ] = function( data, fn ) {
  		if ( fn == null ) {
  			fn = data;
  			data = null;
  		}
  
  		return arguments.length > 0 ?
  			this.bind( name, data, fn ) :
  			this.trigger( name );
  	};
  
  	if ( jQuery.attrFn ) {
  		jQuery.attrFn[ name ] = true;
  	}
  });
  
  
  
  /*!
   * Sizzle CSS Selector Engine
   *  Copyright 2011, The Dojo Foundation
   *  Released under the MIT, BSD, and GPL Licenses.
   *  More information: http://sizzlejs.com/
   */
  (function(){
  
  var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,
  	done = 0,
  	toString = Object.prototype.toString,
  	hasDuplicate = false,
  	baseHasDuplicate = true,
  	rBackslash = /\\/g,
  	rNonWord = /\W/;
  
  // Here we check if the JavaScript engine is using some sort of
  // optimization where it does not always call our comparision
  // function. If that is the case, discard the hasDuplicate value.
  //   Thus far that includes Google Chrome.
  [0, 0].sort(function() {
  	baseHasDuplicate = false;
  	return 0;
  });
  
  var Sizzle = function( selector, context, results, seed ) {
  	results = results || [];
  	context = context || document;
  
  	var origContext = context;
  
  	if ( context.nodeType !== 1 && context.nodeType !== 9 ) {
  		return [];
  	}
  	
  	if ( !selector || typeof selector !== "string" ) {
  		return results;
  	}
  
  	var m, set, checkSet, extra, ret, cur, pop, i,
  		prune = true,
  		contextXML = Sizzle.isXML( context ),
  		parts = [],
  		soFar = selector;
  	
  	// Reset the position of the chunker regexp (start from head)
  	do {
  		chunker.exec( "" );
  		m = chunker.exec( soFar );
  
  		if ( m ) {
  			soFar = m[3];
  		
  			parts.push( m[1] );
  		
  			if ( m[2] ) {
  				extra = m[3];
  				break;
  			}
  		}
  	} while ( m );
  
  	if ( parts.length > 1 && origPOS.exec( selector ) ) {
  
  		if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
  			set = posProcess( parts[0] + parts[1], context );
  
  		} else {
  			set = Expr.relative[ parts[0] ] ?
  				[ context ] :
  				Sizzle( parts.shift(), context );
  
  			while ( parts.length ) {
  				selector = parts.shift();
  
  				if ( Expr.relative[ selector ] ) {
  					selector += parts.shift();
  				}
  				
  				set = posProcess( selector, set );
  			}
  		}
  
  	} else {
  		// Take a shortcut and set the context if the root selector is an ID
  		// (but not if it'll be faster if the inner selector is an ID)
  		if ( !seed && parts.length > 1 && context.nodeType === 9 && !contextXML &&
  				Expr.match.ID.test(parts[0]) && !Expr.match.ID.test(parts[parts.length - 1]) ) {
  
  			ret = Sizzle.find( parts.shift(), context, contextXML );
  			context = ret.expr ?
  				Sizzle.filter( ret.expr, ret.set )[0] :
  				ret.set[0];
  		}
  
  		if ( context ) {
  			ret = seed ?
  				{ expr: parts.pop(), set: makeArray(seed) } :
  				Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" || parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML );
  
  			set = ret.expr ?
  				Sizzle.filter( ret.expr, ret.set ) :
  				ret.set;
  
  			if ( parts.length > 0 ) {
  				checkSet = makeArray( set );
  
  			} else {
  				prune = false;
  			}
  
  			while ( parts.length ) {
  				cur = parts.pop();
  				pop = cur;
  
  				if ( !Expr.relative[ cur ] ) {
  					cur = "";
  				} else {
  					pop = parts.pop();
  				}
  
  				if ( pop == null ) {
  					pop = context;
  				}
  
  				Expr.relative[ cur ]( checkSet, pop, contextXML );
  			}
  
  		} else {
  			checkSet = parts = [];
  		}
  	}
  
  	if ( !checkSet ) {
  		checkSet = set;
  	}
  
  	if ( !checkSet ) {
  		Sizzle.error( cur || selector );
  	}
  
  	if ( toString.call(checkSet) === "[object Array]" ) {
  		if ( !prune ) {
  			results.push.apply( results, checkSet );
  
  		} else if ( context && context.nodeType === 1 ) {
  			for ( i = 0; checkSet[i] != null; i++ ) {
  				if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && Sizzle.contains(context, checkSet[i])) ) {
  					results.push( set[i] );
  				}
  			}
  
  		} else {
  			for ( i = 0; checkSet[i] != null; i++ ) {
  				if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
  					results.push( set[i] );
  				}
  			}
  		}
  
  	} else {
  		makeArray( checkSet, results );
  	}
  
  	if ( extra ) {
  		Sizzle( extra, origContext, results, seed );
  		Sizzle.uniqueSort( results );
  	}
  
  	return results;
  };
  
  Sizzle.uniqueSort = function( results ) {
  	if ( sortOrder ) {
  		hasDuplicate = baseHasDuplicate;
  		results.sort( sortOrder );
  
  		if ( hasDuplicate ) {
  			for ( var i = 1; i < results.length; i++ ) {
  				if ( results[i] === results[ i - 1 ] ) {
  					results.splice( i--, 1 );
  				}
  			}
  		}
  	}
  
  	return results;
  };
  
  Sizzle.matches = function( expr, set ) {
  	return Sizzle( expr, null, null, set );
  };
  
  Sizzle.matchesSelector = function( node, expr ) {
  	return Sizzle( expr, null, null, [node] ).length > 0;
  };
  
  Sizzle.find = function( expr, context, isXML ) {
  	var set;
  
  	if ( !expr ) {
  		return [];
  	}
  
  	for ( var i = 0, l = Expr.order.length; i < l; i++ ) {
  		var match,
  			type = Expr.order[i];
  		
  		if ( (match = Expr.leftMatch[ type ].exec( expr )) ) {
  			var left = match[1];
  			match.splice( 1, 1 );
  
  			if ( left.substr( left.length - 1 ) !== "\\" ) {
  				match[1] = (match[1] || "").replace( rBackslash, "" );
  				set = Expr.find[ type ]( match, context, isXML );
  
  				if ( set != null ) {
  					expr = expr.replace( Expr.match[ type ], "" );
  					break;
  				}
  			}
  		}
  	}
  
  	if ( !set ) {
  		set = typeof context.getElementsByTagName !== "undefined" ?
  			context.getElementsByTagName( "*" ) :
  			[];
  	}
  
  	return { set: set, expr: expr };
  };
  
  Sizzle.filter = function( expr, set, inplace, not ) {
  	var match, anyFound,
  		old = expr,
  		result = [],
  		curLoop = set,
  		isXMLFilter = set && set[0] && Sizzle.isXML( set[0] );
  
  	while ( expr && set.length ) {
  		for ( var type in Expr.filter ) {
  			if ( (match = Expr.leftMatch[ type ].exec( expr )) != null && match[2] ) {
  				var found, item,
  					filter = Expr.filter[ type ],
  					left = match[1];
  
  				anyFound = false;
  
  				match.splice(1,1);
  
  				if ( left.substr( left.length - 1 ) === "\\" ) {
  					continue;
  				}
  
  				if ( curLoop === result ) {
  					result = [];
  				}
  
  				if ( Expr.preFilter[ type ] ) {
  					match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter );
  
  					if ( !match ) {
  						anyFound = found = true;
  
  					} else if ( match === true ) {
  						continue;
  					}
  				}
  
  				if ( match ) {
  					for ( var i = 0; (item = curLoop[i]) != null; i++ ) {
  						if ( item ) {
  							found = filter( item, match, i, curLoop );
  							var pass = not ^ !!found;
  
  							if ( inplace && found != null ) {
  								if ( pass ) {
  									anyFound = true;
  
  								} else {
  									curLoop[i] = false;
  								}
  
  							} else if ( pass ) {
  								result.push( item );
  								anyFound = true;
  							}
  						}
  					}
  				}
  
  				if ( found !== undefined ) {
  					if ( !inplace ) {
  						curLoop = result;
  					}
  
  					expr = expr.replace( Expr.match[ type ], "" );
  
  					if ( !anyFound ) {
  						return [];
  					}
  
  					break;
  				}
  			}
  		}
  
  		// Improper expression
  		if ( expr === old ) {
  			if ( anyFound == null ) {
  				Sizzle.error( expr );
  
  			} else {
  				break;
  			}
  		}
  
  		old = expr;
  	}
  
  	return curLoop;
  };
  
  Sizzle.error = function( msg ) {
  	throw "Syntax error, unrecognized expression: " + msg;
  };
  
  var Expr = Sizzle.selectors = {
  	order: [ "ID", "NAME", "TAG" ],
  
  	match: {
  		ID: /#((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
  		CLASS: /\.((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
  		NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF\-]|\\.)+)['"]*\]/,
  		ATTR: /\[\s*((?:[\w\u00c0-\uFFFF\-]|\\.)+)\s*(?:(\S?=)\s*(?:(['"])(.*?)\3|(#?(?:[\w\u00c0-\uFFFF\-]|\\.)*)|)|)\s*\]/,
  		TAG: /^((?:[\w\u00c0-\uFFFF\*\-]|\\.)+)/,
  		CHILD: /:(only|nth|last|first)-child(?:\(\s*(even|odd|(?:[+\-]?\d+|(?:[+\-]?\d*)?n\s*(?:[+\-]\s*\d+)?))\s*\))?/,
  		POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^\-]|$)/,
  		PSEUDO: /:((?:[\w\u00c0-\uFFFF\-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/
  	},
  
  	leftMatch: {},
  
  	attrMap: {
  		"class": "className",
  		"for": "htmlFor"
  	},
  
  	attrHandle: {
  		href: function( elem ) {
  			return elem.getAttribute( "href" );
  		},
  		type: function( elem ) {
  			return elem.getAttribute( "type" );
  		}
  	},
  
  	relative: {
  		"+": function(checkSet, part){
  			var isPartStr = typeof part === "string",
  				isTag = isPartStr && !rNonWord.test( part ),
  				isPartStrNotTag = isPartStr && !isTag;
  
  			if ( isTag ) {
  				part = part.toLowerCase();
  			}
  
  			for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) {
  				if ( (elem = checkSet[i]) ) {
  					while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {}
  
  					checkSet[i] = isPartStrNotTag || elem && elem.nodeName.toLowerCase() === part ?
  						elem || false :
  						elem === part;
  				}
  			}
  
  			if ( isPartStrNotTag ) {
  				Sizzle.filter( part, checkSet, true );
  			}
  		},
  
  		">": function( checkSet, part ) {
  			var elem,
  				isPartStr = typeof part === "string",
  				i = 0,
  				l = checkSet.length;
  
  			if ( isPartStr && !rNonWord.test( part ) ) {
  				part = part.toLowerCase();
  
  				for ( ; i < l; i++ ) {
  					elem = checkSet[i];
  
  					if ( elem ) {
  						var parent = elem.parentNode;
  						checkSet[i] = parent.nodeName.toLowerCase() === part ? parent : false;
  					}
  				}
  
  			} else {
  				for ( ; i < l; i++ ) {
  					elem = checkSet[i];
  
  					if ( elem ) {
  						checkSet[i] = isPartStr ?
  							elem.parentNode :
  							elem.parentNode === part;
  					}
  				}
  
  				if ( isPartStr ) {
  					Sizzle.filter( part, checkSet, true );
  				}
  			}
  		},
  
  		"": function(checkSet, part, isXML){
  			var nodeCheck,
  				doneName = done++,
  				checkFn = dirCheck;
  
  			if ( typeof part === "string" && !rNonWord.test( part ) ) {
  				part = part.toLowerCase();
  				nodeCheck = part;
  				checkFn = dirNodeCheck;
  			}
  
  			checkFn( "parentNode", part, doneName, checkSet, nodeCheck, isXML );
  		},
  
  		"~": function( checkSet, part, isXML ) {
  			var nodeCheck,
  				doneName = done++,
  				checkFn = dirCheck;
  
  			if ( typeof part === "string" && !rNonWord.test( part ) ) {
  				part = part.toLowerCase();
  				nodeCheck = part;
  				checkFn = dirNodeCheck;
  			}
  
  			checkFn( "previousSibling", part, doneName, checkSet, nodeCheck, isXML );
  		}
  	},
  
  	find: {
  		ID: function( match, context, isXML ) {
  			if ( typeof context.getElementById !== "undefined" && !isXML ) {
  				var m = context.getElementById(match[1]);
  				// Check parentNode to catch when Blackberry 4.6 returns
  				// nodes that are no longer in the document #6963
  				return m && m.parentNode ? [m] : [];
  			}
  		},
  
  		NAME: function( match, context ) {
  			if ( typeof context.getElementsByName !== "undefined" ) {
  				var ret = [],
  					results = context.getElementsByName( match[1] );
  
  				for ( var i = 0, l = results.length; i < l; i++ ) {
  					if ( results[i].getAttribute("name") === match[1] ) {
  						ret.push( results[i] );
  					}
  				}
  
  				return ret.length === 0 ? null : ret;
  			}
  		},
  
  		TAG: function( match, context ) {
  			if ( typeof context.getElementsByTagName !== "undefined" ) {
  				return context.getElementsByTagName( match[1] );
  			}
  		}
  	},
  	preFilter: {
  		CLASS: function( match, curLoop, inplace, result, not, isXML ) {
  			match = " " + match[1].replace( rBackslash, "" ) + " ";
  
  			if ( isXML ) {
  				return match;
  			}
  
  			for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) {
  				if ( elem ) {
  					if ( not ^ (elem.className && (" " + elem.className + " ").replace(/[\t\n\r]/g, " ").indexOf(match) >= 0) ) {
  						if ( !inplace ) {
  							result.push( elem );
  						}
  
  					} else if ( inplace ) {
  						curLoop[i] = false;
  					}
  				}
  			}
  
  			return false;
  		},
  
  		ID: function( match ) {
  			return match[1].replace( rBackslash, "" );
  		},
  
  		TAG: function( match, curLoop ) {
  			return match[1].replace( rBackslash, "" ).toLowerCase();
  		},
  
  		CHILD: function( match ) {
  			if ( match[1] === "nth" ) {
  				if ( !match[2] ) {
  					Sizzle.error( match[0] );
  				}
  
  				match[2] = match[2].replace(/^\+|\s*/g, '');
  
  				// parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
  				var test = /(-?)(\d*)(?:n([+\-]?\d*))?/.exec(
  					match[2] === "even" && "2n" || match[2] === "odd" && "2n+1" ||
  					!/\D/.test( match[2] ) && "0n+" + match[2] || match[2]);
  
  				// calculate the numbers (first)n+(last) including if they are negative
  				match[2] = (test[1] + (test[2] || 1)) - 0;
  				match[3] = test[3] - 0;
  			}
  			else if ( match[2] ) {
  				Sizzle.error( match[0] );
  			}
  
  			// TODO: Move to normal caching system
  			match[0] = done++;
  
  			return match;
  		},
  
  		ATTR: function( match, curLoop, inplace, result, not, isXML ) {
  			var name = match[1] = match[1].replace( rBackslash, "" );
  			
  			if ( !isXML && Expr.attrMap[name] ) {
  				match[1] = Expr.attrMap[name];
  			}
  
  			// Handle if an un-quoted value was used
  			match[4] = ( match[4] || match[5] || "" ).replace( rBackslash, "" );
  
  			if ( match[2] === "~=" ) {
  				match[4] = " " + match[4] + " ";
  			}
  
  			return match;
  		},
  
  		PSEUDO: function( match, curLoop, inplace, result, not ) {
  			if ( match[1] === "not" ) {
  				// If we're dealing with a complex expression, or a simple one
  				if ( ( chunker.exec(match[3]) || "" ).length > 1 || /^\w/.test(match[3]) ) {
  					match[3] = Sizzle(match[3], null, null, curLoop);
  
  				} else {
  					var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not);
  
  					if ( !inplace ) {
  						result.push.apply( result, ret );
  					}
  
  					return false;
  				}
  
  			} else if ( Expr.match.POS.test( match[0] ) || Expr.match.CHILD.test( match[0] ) ) {
  				return true;
  			}
  			
  			return match;
  		},
  
  		POS: function( match ) {
  			match.unshift( true );
  
  			return match;
  		}
  	},
  	
  	filters: {
  		enabled: function( elem ) {
  			return elem.disabled === false && elem.type !== "hidden";
  		},
  
  		disabled: function( elem ) {
  			return elem.disabled === true;
  		},
  
  		checked: function( elem ) {
  			return elem.checked === true;
  		},
  		
  		selected: function( elem ) {
  			// Accessing this property makes selected-by-default
  			// options in Safari work properly
  			if ( elem.parentNode ) {
  				elem.parentNode.selectedIndex;
  			}
  			
  			return elem.selected === true;
  		},
  
  		parent: function( elem ) {
  			return !!elem.firstChild;
  		},
  
  		empty: function( elem ) {
  			return !elem.firstChild;
  		},
  
  		has: function( elem, i, match ) {
  			return !!Sizzle( match[3], elem ).length;
  		},
  
  		header: function( elem ) {
  			return (/h\d/i).test( elem.nodeName );
  		},
  
  		text: function( elem ) {
  			var attr = elem.getAttribute( "type" ), type = elem.type;
  			// IE6 and 7 will map elem.type to 'text' for new HTML5 types (search, etc) 
  			// use getAttribute instead to test this case
  			return elem.nodeName.toLowerCase() === "input" && "text" === type && ( attr === type || attr === null );
  		},
  
  		radio: function( elem ) {
  			return elem.nodeName.toLowerCase() === "input" && "radio" === elem.type;
  		},
  
  		checkbox: function( elem ) {
  			return elem.nodeName.toLowerCase() === "input" && "checkbox" === elem.type;
  		},
  
  		file: function( elem ) {
  			return elem.nodeName.toLowerCase() === "input" && "file" === elem.type;
  		},
  
  		password: function( elem ) {
  			return elem.nodeName.toLowerCase() === "input" && "password" === elem.type;
  		},
  
  		submit: function( elem ) {
  			var name = elem.nodeName.toLowerCase();
  			return (name === "input" || name === "button") && "submit" === elem.type;
  		},
  
  		image: function( elem ) {
  			return elem.nodeName.toLowerCase() === "input" && "image" === elem.type;
  		},
  
  		reset: function( elem ) {
  			var name = elem.nodeName.toLowerCase();
  			return (name === "input" || name === "button") && "reset" === elem.type;
  		},
  
  		button: function( elem ) {
  			var name = elem.nodeName.toLowerCase();
  			return name === "input" && "button" === elem.type || name === "button";
  		},
  
  		input: function( elem ) {
  			return (/input|select|textarea|button/i).test( elem.nodeName );
  		},
  
  		focus: function( elem ) {
  			return elem === elem.ownerDocument.activeElement;
  		}
  	},
  	setFilters: {
  		first: function( elem, i ) {
  			return i === 0;
  		},
  
  		last: function( elem, i, match, array ) {
  			return i === array.length - 1;
  		},
  
  		even: function( elem, i ) {
  			return i % 2 === 0;
  		},
  
  		odd: function( elem, i ) {
  			return i % 2 === 1;
  		},
  
  		lt: function( elem, i, match ) {
  			return i < match[3] - 0;
  		},
  
  		gt: function( elem, i, match ) {
  			return i > match[3] - 0;
  		},
  
  		nth: function( elem, i, match ) {
  			return match[3] - 0 === i;
  		},
  
  		eq: function( elem, i, match ) {
  			return match[3] - 0 === i;
  		}
  	},
  	filter: {
  		PSEUDO: function( elem, match, i, array ) {
  			var name = match[1],
  				filter = Expr.filters[ name ];
  
  			if ( filter ) {
  				return filter( elem, i, match, array );
  
  			} else if ( name === "contains" ) {
  				return (elem.textContent || elem.innerText || Sizzle.getText([ elem ]) || "").indexOf(match[3]) >= 0;
  
  			} else if ( name === "not" ) {
  				var not = match[3];
  
  				for ( var j = 0, l = not.length; j < l; j++ ) {
  					if ( not[j] === elem ) {
  						return false;
  					}
  				}
  
  				return true;
  
  			} else {
  				Sizzle.error( name );
  			}
  		},
  
  		CHILD: function( elem, match ) {
  			var type = match[1],
  				node = elem;
  
  			switch ( type ) {
  				case "only":
  				case "first":
  					while ( (node = node.previousSibling) )	 {
  						if ( node.nodeType === 1 ) { 
  							return false; 
  						}
  					}
  
  					if ( type === "first" ) { 
  						return true; 
  					}
  
  					node = elem;
  
  				case "last":
  					while ( (node = node.nextSibling) )	 {
  						if ( node.nodeType === 1 ) { 
  							return false; 
  						}
  					}
  
  					return true;
  
  				case "nth":
  					var first = match[2],
  						last = match[3];
  
  					if ( first === 1 && last === 0 ) {
  						return true;
  					}
  					
  					var doneName = match[0],
  						parent = elem.parentNode;
  	
  					if ( parent && (parent.sizcache !== doneName || !elem.nodeIndex) ) {
  						var count = 0;
  						
  						for ( node = parent.firstChild; node; node = node.nextSibling ) {
  							if ( node.nodeType === 1 ) {
  								node.nodeIndex = ++count;
  							}
  						} 
  
  						parent.sizcache = doneName;
  					}
  					
  					var diff = elem.nodeIndex - last;
  
  					if ( first === 0 ) {
  						return diff === 0;
  
  					} else {
  						return ( diff % first === 0 && diff / first >= 0 );
  					}
  			}
  		},
  
  		ID: function( elem, match ) {
  			return elem.nodeType === 1 && elem.getAttribute("id") === match;
  		},
  
  		TAG: function( elem, match ) {
  			return (match === "*" && elem.nodeType === 1) || elem.nodeName.toLowerCase() === match;
  		},
  		
  		CLASS: function( elem, match ) {
  			return (" " + (elem.className || elem.getAttribute("class")) + " ")
  				.indexOf( match ) > -1;
  		},
  
  		ATTR: function( elem, match ) {
  			var name = match[1],
  				result = Expr.attrHandle[ name ] ?
  					Expr.attrHandle[ name ]( elem ) :
  					elem[ name ] != null ?
  						elem[ name ] :
  						elem.getAttribute( name ),
  				value = result + "",
  				type = match[2],
  				check = match[4];
  
  			return result == null ?
  				type === "!=" :
  				type === "=" ?
  				value === check :
  				type === "*=" ?
  				value.indexOf(check) >= 0 :
  				type === "~=" ?
  				(" " + value + " ").indexOf(check) >= 0 :
  				!check ?
  				value && result !== false :
  				type === "!=" ?
  				value !== check :
  				type === "^=" ?
  				value.indexOf(check) === 0 :
  				type === "$=" ?
  				value.substr(value.length - check.length) === check :
  				type === "|=" ?
  				value === check || value.substr(0, check.length + 1) === check + "-" :
  				false;
  		},
  
  		POS: function( elem, match, i, array ) {
  			var name = match[2],
  				filter = Expr.setFilters[ name ];
  
  			if ( filter ) {
  				return filter( elem, i, match, array );
  			}
  		}
  	}
  };
  
  var origPOS = Expr.match.POS,
  	fescape = function(all, num){
  		return "\\" + (num - 0 + 1);
  	};
  
  for ( var type in Expr.match ) {
  	Expr.match[ type ] = new RegExp( Expr.match[ type ].source + (/(?![^\[]*\])(?![^\(]*\))/.source) );
  	Expr.leftMatch[ type ] = new RegExp( /(^(?:.|\r|\n)*?)/.source + Expr.match[ type ].source.replace(/\\(\d+)/g, fescape) );
  }
  
  var makeArray = function( array, results ) {
  	array = Array.prototype.slice.call( array, 0 );
  
  	if ( results ) {
  		results.push.apply( results, array );
  		return results;
  	}
  	
  	return array;
  };
  
  // Perform a simple check to determine if the browser is capable of
  // converting a NodeList to an array using builtin methods.
  // Also verifies that the returned array holds DOM nodes
  // (which is not the case in the Blackberry browser)
  try {
  	Array.prototype.slice.call( document.documentElement.childNodes, 0 )[0].nodeType;
  
  // Provide a fallback method if it does not work
  } catch( e ) {
  	makeArray = function( array, results ) {
  		var i = 0,
  			ret = results || [];
  
  		if ( toString.call(array) === "[object Array]" ) {
  			Array.prototype.push.apply( ret, array );
  
  		} else {
  			if ( typeof array.length === "number" ) {
  				for ( var l = array.length; i < l; i++ ) {
  					ret.push( array[i] );
  				}
  
  			} else {
  				for ( ; array[i]; i++ ) {
  					ret.push( array[i] );
  				}
  			}
  		}
  
  		return ret;
  	};
  }
  
  var sortOrder, siblingCheck;
  
  if ( document.documentElement.compareDocumentPosition ) {
  	sortOrder = function( a, b ) {
  		if ( a === b ) {
  			hasDuplicate = true;
  			return 0;
  		}
  
  		if ( !a.compareDocumentPosition || !b.compareDocumentPosition ) {
  			return a.compareDocumentPosition ? -1 : 1;
  		}
  
  		return a.compareDocumentPosition(b) & 4 ? -1 : 1;
  	};
  
  } else {
  	sortOrder = function( a, b ) {
  		// The nodes are identical, we can exit early
  		if ( a === b ) {
  			hasDuplicate = true;
  			return 0;
  
  		// Fallback to using sourceIndex (in IE) if it's available on both nodes
  		} else if ( a.sourceIndex && b.sourceIndex ) {
  			return a.sourceIndex - b.sourceIndex;
  		}
  
  		var al, bl,
  			ap = [],
  			bp = [],
  			aup = a.parentNode,
  			bup = b.parentNode,
  			cur = aup;
  
  		// If the nodes are siblings (or identical) we can do a quick check
  		if ( aup === bup ) {
  			return siblingCheck( a, b );
  
  		// If no parents were found then the nodes are disconnected
  		} else if ( !aup ) {
  			return -1;
  
  		} else if ( !bup ) {
  			return 1;
  		}
  
  		// Otherwise they're somewhere else in the tree so we need
  		// to build up a full list of the parentNodes for comparison
  		while ( cur ) {
  			ap.unshift( cur );
  			cur = cur.parentNode;
  		}
  
  		cur = bup;
  
  		while ( cur ) {
  			bp.unshift( cur );
  			cur = cur.parentNode;
  		}
  
  		al = ap.length;
  		bl = bp.length;
  
  		// Start walking down the tree looking for a discrepancy
  		for ( var i = 0; i < al && i < bl; i++ ) {
  			if ( ap[i] !== bp[i] ) {
  				return siblingCheck( ap[i], bp[i] );
  			}
  		}
  
  		// We ended someplace up the tree so do a sibling check
  		return i === al ?
  			siblingCheck( a, bp[i], -1 ) :
  			siblingCheck( ap[i], b, 1 );
  	};
  
  	siblingCheck = function( a, b, ret ) {
  		if ( a === b ) {
  			return ret;
  		}
  
  		var cur = a.nextSibling;
  
  		while ( cur ) {
  			if ( cur === b ) {
  				return -1;
  			}
  
  			cur = cur.nextSibling;
  		}
  
  		return 1;
  	};
  }
  
  // Utility function for retreiving the text value of an array of DOM nodes
  Sizzle.getText = function( elems ) {
  	var ret = "", elem;
  
  	for ( var i = 0; elems[i]; i++ ) {
  		elem = elems[i];
  
  		// Get the text from text nodes and CDATA nodes
  		if ( elem.nodeType === 3 || elem.nodeType === 4 ) {
  			ret += elem.nodeValue;
  
  		// Traverse everything else, except comment nodes
  		} else if ( elem.nodeType !== 8 ) {
  			ret += Sizzle.getText( elem.childNodes );
  		}
  	}
  
  	return ret;
  };
  
  // Check to see if the browser returns elements by name when
  // querying by getElementById (and provide a workaround)
  (function(){
  	// We're going to inject a fake input element with a specified name
  	var form = document.createElement("div"),
  		id = "script" + (new Date()).getTime(),
  		root = document.documentElement;
  
  	form.innerHTML = "<a name='" + id + "'/>";
  
  	// Inject it into the root element, check its status, and remove it quickly
  	root.insertBefore( form, root.firstChild );
  
  	// The workaround has to do additional checks after a getElementById
  	// Which slows things down for other browsers (hence the branching)
  	if ( document.getElementById( id ) ) {
  		Expr.find.ID = function( match, context, isXML ) {
  			if ( typeof context.getElementById !== "undefined" && !isXML ) {
  				var m = context.getElementById(match[1]);
  
  				return m ?
  					m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ?
  						[m] :
  						undefined :
  					[];
  			}
  		};
  
  		Expr.filter.ID = function( elem, match ) {
  			var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
  
  			return elem.nodeType === 1 && node && node.nodeValue === match;
  		};
  	}
  
  	root.removeChild( form );
  
  	// release memory in IE
  	root = form = null;
  })();
  
  (function(){
  	// Check to see if the browser returns only elements
  	// when doing getElementsByTagName("*")
  
  	// Create a fake element
  	var div = document.createElement("div");
  	div.appendChild( document.createComment("") );
  
  	// Make sure no comments are found
  	if ( div.getElementsByTagName("*").length > 0 ) {
  		Expr.find.TAG = function( match, context ) {
  			var results = context.getElementsByTagName( match[1] );
  
  			// Filter out possible comments
  			if ( match[1] === "*" ) {
  				var tmp = [];
  
  				for ( var i = 0; results[i]; i++ ) {
  					if ( results[i].nodeType === 1 ) {
  						tmp.push( results[i] );
  					}
  				}
  
  				results = tmp;
  			}
  
  			return results;
  		};
  	}
  
  	// Check to see if an attribute returns normalized href attributes
  	div.innerHTML = "<a href='#'></a>";
  
  	if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined" &&
  			div.firstChild.getAttribute("href") !== "#" ) {
  
  		Expr.attrHandle.href = function( elem ) {
  			return elem.getAttribute( "href", 2 );
  		};
  	}
  
  	// release memory in IE
  	div = null;
  })();
  
  if ( document.querySelectorAll ) {
  	(function(){
  		var oldSizzle = Sizzle,
  			div = document.createElement("div"),
  			id = "__sizzle__";
  
  		div.innerHTML = "<p class='TEST'></p>";
  
  		// Safari can't handle uppercase or unicode characters when
  		// in quirks mode.
  		if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) {
  			return;
  		}
  	
  		Sizzle = function( query, context, extra, seed ) {
  			context = context || document;
  
  			// Only use querySelectorAll on non-XML documents
  			// (ID selectors don't work in non-HTML documents)
  			if ( !seed && !Sizzle.isXML(context) ) {
  				// See if we find a selector to speed up
  				var match = /^(\w+$)|^\.([\w\-]+$)|^#([\w\-]+$)/.exec( query );
  				
  				if ( match && (context.nodeType === 1 || context.nodeType === 9) ) {
  					// Speed-up: Sizzle("TAG")
  					if ( match[1] ) {
  						return makeArray( context.getElementsByTagName( query ), extra );
  					
  					// Speed-up: Sizzle(".CLASS")
  					} else if ( match[2] && Expr.find.CLASS && context.getElementsByClassName ) {
  						return makeArray( context.getElementsByClassName( match[2] ), extra );
  					}
  				}
  				
  				if ( context.nodeType === 9 ) {
  					// Speed-up: Sizzle("body")
  					// The body element only exists once, optimize finding it
  					if ( query === "body" && context.body ) {
  						return makeArray( [ context.body ], extra );
  						
  					// Speed-up: Sizzle("#ID")
  					} else if ( match && match[3] ) {
  						var elem = context.getElementById( match[3] );
  
  						// Check parentNode to catch when Blackberry 4.6 returns
  						// nodes that are no longer in the document #6963
  						if ( elem && elem.parentNode ) {
  							// Handle the case where IE and Opera return items
  							// by name instead of ID
  							if ( elem.id === match[3] ) {
  								return makeArray( [ elem ], extra );
  							}
  							
  						} else {
  							return makeArray( [], extra );
  						}
  					}
  					
  					try {
  						return makeArray( context.querySelectorAll(query), extra );
  					} catch(qsaError) {}
  
  				// qSA works strangely on Element-rooted queries
  				// We can work around this by specifying an extra ID on the root
  				// and working up from there (Thanks to Andrew Dupont for the technique)
  				// IE 8 doesn't work on object elements
  				} else if ( context.nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) {
  					var oldContext = context,
  						old = context.getAttribute( "id" ),
  						nid = old || id,
  						hasParent = context.parentNode,
  						relativeHierarchySelector = /^\s*[+~]/.test( query );
  
  					if ( !old ) {
  						context.setAttribute( "id", nid );
  					} else {
  						nid = nid.replace( /'/g, "\\$&" );
  					}
  					if ( relativeHierarchySelector && hasParent ) {
  						context = context.parentNode;
  					}
  
  					try {
  						if ( !relativeHierarchySelector || hasParent ) {
  							return makeArray( context.querySelectorAll( "[id='" + nid + "'] " + query ), extra );
  						}
  
  					} catch(pseudoError) {
  					} finally {
  						if ( !old ) {
  							oldContext.removeAttribute( "id" );
  						}
  					}
  				}
  			}
  		
  			return oldSizzle(query, context, extra, seed);
  		};
  
  		for ( var prop in oldSizzle ) {
  			Sizzle[ prop ] = oldSizzle[ prop ];
  		}
  
  		// release memory in IE
  		div = null;
  	})();
  }
  
  (function(){
  	var html = document.documentElement,
  		matches = html.matchesSelector || html.mozMatchesSelector || html.webkitMatchesSelector || html.msMatchesSelector;
  
  	if ( matches ) {
  		// Check to see if it's possible to do matchesSelector
  		// on a disconnected node (IE 9 fails this)
  		var disconnectedMatch = !matches.call( document.createElement( "div" ), "div" ),
  			pseudoWorks = false;
  
  		try {
  			// This should fail with an exception
  			// Gecko does not error, returns false instead
  			matches.call( document.documentElement, "[test!='']:sizzle" );
  	
  		} catch( pseudoError ) {
  			pseudoWorks = true;
  		}
  
  		Sizzle.matchesSelector = function( node, expr ) {
  			// Make sure that attribute selectors are quoted
  			expr = expr.replace(/\=\s*([^'"\]]*)\s*\]/g, "='$1']");
  
  			if ( !Sizzle.isXML( node ) ) {
  				try { 
  					if ( pseudoWorks || !Expr.match.PSEUDO.test( expr ) && !/!=/.test( expr ) ) {
  						var ret = matches.call( node, expr );
  
  						// IE 9's matchesSelector returns false on disconnected nodes
  						if ( ret || !disconnectedMatch ||
  								// As well, disconnected nodes are said to be in a document
  								// fragment in IE 9, so check for that
  								node.document && node.document.nodeType !== 11 ) {
  							return ret;
  						}
  					}
  				} catch(e) {}
  			}
  
  			return Sizzle(expr, null, null, [node]).length > 0;
  		};
  	}
  })();
  
  (function(){
  	var div = document.createElement("div");
  
  	div.innerHTML = "<div class='test e'></div><div class='test'></div>";
  
  	// Opera can't find a second classname (in 9.6)
  	// Also, make sure that getElementsByClassName actually exists
  	if ( !div.getElementsByClassName || div.getElementsByClassName("e").length === 0 ) {
  		return;
  	}
  
  	// Safari caches class attributes, doesn't catch changes (in 3.2)
  	div.lastChild.className = "e";
  
  	if ( div.getElementsByClassName("e").length === 1 ) {
  		return;
  	}
  	
  	Expr.order.splice(1, 0, "CLASS");
  	Expr.find.CLASS = function( match, context, isXML ) {
  		if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) {
  			return context.getElementsByClassName(match[1]);
  		}
  	};
  
  	// release memory in IE
  	div = null;
  })();
  
  function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
  	for ( var i = 0, l = checkSet.length; i < l; i++ ) {
  		var elem = checkSet[i];
  
  		if ( elem ) {
  			var match = false;
  
  			elem = elem[dir];
  
  			while ( elem ) {
  				if ( elem.sizcache === doneName ) {
  					match = checkSet[elem.sizset];
  					break;
  				}
  
  				if ( elem.nodeType === 1 && !isXML ){
  					elem.sizcache = doneName;
  					elem.sizset = i;
  				}
  
  				if ( elem.nodeName.toLowerCase() === cur ) {
  					match = elem;
  					break;
  				}
  
  				elem = elem[dir];
  			}
  
  			checkSet[i] = match;
  		}
  	}
  }
  
  function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
  	for ( var i = 0, l = checkSet.length; i < l; i++ ) {
  		var elem = checkSet[i];
  
  		if ( elem ) {
  			var match = false;
  			
  			elem = elem[dir];
  
  			while ( elem ) {
  				if ( elem.sizcache === doneName ) {
  					match = checkSet[elem.sizset];
  					break;
  				}
  
  				if ( elem.nodeType === 1 ) {
  					if ( !isXML ) {
  						elem.sizcache = doneName;
  						elem.sizset = i;
  					}
  
  					if ( typeof cur !== "string" ) {
  						if ( elem === cur ) {
  							match = true;
  							break;
  						}
  
  					} else if ( Sizzle.filter( cur, [elem] ).length > 0 ) {
  						match = elem;
  						break;
  					}
  				}
  
  				elem = elem[dir];
  			}
  
  			checkSet[i] = match;
  		}
  	}
  }
  
  if ( document.documentElement.contains ) {
  	Sizzle.contains = function( a, b ) {
  		return a !== b && (a.contains ? a.contains(b) : true);
  	};
  
  } else if ( document.documentElement.compareDocumentPosition ) {
  	Sizzle.contains = function( a, b ) {
  		return !!(a.compareDocumentPosition(b) & 16);
  	};
  
  } else {
  	Sizzle.contains = function() {
  		return false;
  	};
  }
  
  Sizzle.isXML = function( elem ) {
  	// documentElement is verified for cases where it doesn't yet exist
  	// (such as loading iframes in IE - #4833) 
  	var documentElement = (elem ? elem.ownerDocument || elem : 0).documentElement;
  
  	return documentElement ? documentElement.nodeName !== "HTML" : false;
  };
  
  var posProcess = function( selector, context ) {
  	var match,
  		tmpSet = [],
  		later = "",
  		root = context.nodeType ? [context] : context;
  
  	// Position selectors must be done after the filter
  	// And so must :not(positional) so we move all PSEUDOs to the end
  	while ( (match = Expr.match.PSEUDO.exec( selector )) ) {
  		later += match[0];
  		selector = selector.replace( Expr.match.PSEUDO, "" );
  	}
  
  	selector = Expr.relative[selector] ? selector + "*" : selector;
  
  	for ( var i = 0, l = root.length; i < l; i++ ) {
  		Sizzle( selector, root[i], tmpSet );
  	}
  
  	return Sizzle.filter( later, tmpSet );
  };
  
  // EXPOSE
  jQuery.find = Sizzle;
  jQuery.expr = Sizzle.selectors;
  jQuery.expr[":"] = jQuery.expr.filters;
  jQuery.unique = Sizzle.uniqueSort;
  jQuery.text = Sizzle.getText;
  jQuery.isXMLDoc = Sizzle.isXML;
  jQuery.contains = Sizzle.contains;
  
  
  })();
  
  
  var runtil = /Until$/,
  	rparentsprev = /^(?:parents|prevUntil|prevAll)/,
  	// Note: This RegExp should be improved, or likely pulled from Sizzle
  	rmultiselector = /,/,
  	isSimple = /^.[^:#\[\.,]*$/,
  	slice = Array.prototype.slice,
  	POS = jQuery.expr.match.POS,
  	// methods guaranteed to produce a unique set when starting from a unique set
  	guaranteedUnique = {
  		children: true,
  		contents: true,
  		next: true,
  		prev: true
  	};
  
  jQuery.fn.extend({
  	find: function( selector ) {
  		var self = this,
  			i, l;
  
  		if ( typeof selector !== "string" ) {
  			return jQuery( selector ).filter(function() {
  				for ( i = 0, l = self.length; i < l; i++ ) {
  					if ( jQuery.contains( self[ i ], this ) ) {
  						return true;
  					}
  				}
  			});
  		}
  
  		var ret = this.pushStack( "", "find", selector ),
  			length, n, r;
  
  		for ( i = 0, l = this.length; i < l; i++ ) {
  			length = ret.length;
  			jQuery.find( selector, this[i], ret );
  
  			if ( i > 0 ) {
  				// Make sure that the results are unique
  				for ( n = length; n < ret.length; n++ ) {
  					for ( r = 0; r < length; r++ ) {
  						if ( ret[r] === ret[n] ) {
  							ret.splice(n--, 1);
  							break;
  						}
  					}
  				}
  			}
  		}
  
  		return ret;
  	},
  
  	has: function( target ) {
  		var targets = jQuery( target );
  		return this.filter(function() {
  			for ( var i = 0, l = targets.length; i < l; i++ ) {
  				if ( jQuery.contains( this, targets[i] ) ) {
  					return true;
  				}
  			}
  		});
  	},
  
  	not: function( selector ) {
  		return this.pushStack( winnow(this, selector, false), "not", selector);
  	},
  
  	filter: function( selector ) {
  		return this.pushStack( winnow(this, selector, true), "filter", selector );
  	},
  
  	is: function( selector ) {
  		return !!selector && ( typeof selector === "string" ?
  			jQuery.filter( selector, this ).length > 0 :
  			this.filter( selector ).length > 0 );
  	},
  
  	closest: function( selectors, context ) {
  		var ret = [], i, l, cur = this[0];
  		
  		// Array
  		if ( jQuery.isArray( selectors ) ) {
  			var match, selector,
  				matches = {},
  				level = 1;
  
  			if ( cur && selectors.length ) {
  				for ( i = 0, l = selectors.length; i < l; i++ ) {
  					selector = selectors[i];
  
  					if ( !matches[ selector ] ) {
  						matches[ selector ] = POS.test( selector ) ?
  							jQuery( selector, context || this.context ) :
  							selector;
  					}
  				}
  
  				while ( cur && cur.ownerDocument && cur !== context ) {
  					for ( selector in matches ) {
  						match = matches[ selector ];
  
  						if ( match.jquery ? match.index( cur ) > -1 : jQuery( cur ).is( match ) ) {
  							ret.push({ selector: selector, elem: cur, level: level });
  						}
  					}
  
  					cur = cur.parentNode;
  					level++;
  				}
  			}
  
  			return ret;
  		}
  
  		// String
  		var pos = POS.test( selectors ) || typeof selectors !== "string" ?
  				jQuery( selectors, context || this.context ) :
  				0;
  
  		for ( i = 0, l = this.length; i < l; i++ ) {
  			cur = this[i];
  
  			while ( cur ) {
  				if ( pos ? pos.index(cur) > -1 : jQuery.find.matchesSelector(cur, selectors) ) {
  					ret.push( cur );
  					break;
  
  				} else {
  					cur = cur.parentNode;
  					if ( !cur || !cur.ownerDocument || cur === context || cur.nodeType === 11 ) {
  						break;
  					}
  				}
  			}
  		}
  
  		ret = ret.length > 1 ? jQuery.unique( ret ) : ret;
  
  		return this.pushStack( ret, "closest", selectors );
  	},
  
  	// Determine the position of an element within
  	// the matched set of elements
  	index: function( elem ) {
  		if ( !elem || typeof elem === "string" ) {
  			return jQuery.inArray( this[0],
  				// If it receives a string, the selector is used
  				// If it receives nothing, the siblings are used
  				elem ? jQuery( elem ) : this.parent().children() );
  		}
  		// Locate the position of the desired element
  		return jQuery.inArray(
  			// If it receives a jQuery object, the first element is used
  			elem.jquery ? elem[0] : elem, this );
  	},
  
  	add: function( selector, context ) {
  		var set = typeof selector === "string" ?
  				jQuery( selector, context ) :
  				jQuery.makeArray( selector && selector.nodeType ? [ selector ] : selector ),
  			all = jQuery.merge( this.get(), set );
  
  		return this.pushStack( isDisconnected( set[0] ) || isDisconnected( all[0] ) ?
  			all :
  			jQuery.unique( all ) );
  	},
  
  	andSelf: function() {
  		return this.add( this.prevObject );
  	}
  });
  
  // A painfully simple check to see if an element is disconnected
  // from a document (should be improved, where feasible).
  function isDisconnected( node ) {
  	return !node || !node.parentNode || node.parentNode.nodeType === 11;
  }
  
  jQuery.each({
  	parent: function( elem ) {
  		var parent = elem.parentNode;
  		return parent && parent.nodeType !== 11 ? parent : null;
  	},
  	parents: function( elem ) {
  		return jQuery.dir( elem, "parentNode" );
  	},
  	parentsUntil: function( elem, i, until ) {
  		return jQuery.dir( elem, "parentNode", until );
  	},
  	next: function( elem ) {
  		return jQuery.nth( elem, 2, "nextSibling" );
  	},
  	prev: function( elem ) {
  		return jQuery.nth( elem, 2, "previousSibling" );
  	},
  	nextAll: function( elem ) {
  		return jQuery.dir( elem, "nextSibling" );
  	},
  	prevAll: function( elem ) {
  		return jQuery.dir( elem, "previousSibling" );
  	},
  	nextUntil: function( elem, i, until ) {
  		return jQuery.dir( elem, "nextSibling", until );
  	},
  	prevUntil: function( elem, i, until ) {
  		return jQuery.dir( elem, "previousSibling", until );
  	},
  	siblings: function( elem ) {
  		return jQuery.sibling( elem.parentNode.firstChild, elem );
  	},
  	children: function( elem ) {
  		return jQuery.sibling( elem.firstChild );
  	},
  	contents: function( elem ) {
  		return jQuery.nodeName( elem, "iframe" ) ?
  			elem.contentDocument || elem.contentWindow.document :
  			jQuery.makeArray( elem.childNodes );
  	}
  }, function( name, fn ) {
  	jQuery.fn[ name ] = function( until, selector ) {
  		var ret = jQuery.map( this, fn, until ),
  			// The variable 'args' was introduced in
  			// https://github.com/jquery/jquery/commit/52a0238
  			// to work around a bug in Chrome 10 (Dev) and should be removed when the bug is fixed.
  			// http://code.google.com/p/v8/issues/detail?id=1050
  			args = slice.call(arguments);
  
  		if ( !runtil.test( name ) ) {
  			selector = until;
  		}
  
  		if ( selector && typeof selector === "string" ) {
  			ret = jQuery.filter( selector, ret );
  		}
  
  		ret = this.length > 1 && !guaranteedUnique[ name ] ? jQuery.unique( ret ) : ret;
  
  		if ( (this.length > 1 || rmultiselector.test( selector )) && rparentsprev.test( name ) ) {
  			ret = ret.reverse();
  		}
  
  		return this.pushStack( ret, name, args.join(",") );
  	};
  });
  
  jQuery.extend({
  	filter: function( expr, elems, not ) {
  		if ( not ) {
  			expr = ":not(" + expr + ")";
  		}
  
  		return elems.length === 1 ?
  			jQuery.find.matchesSelector(elems[0], expr) ? [ elems[0] ] : [] :
  			jQuery.find.matches(expr, elems);
  	},
  
  	dir: function( elem, dir, until ) {
  		var matched = [],
  			cur = elem[ dir ];
  
  		while ( cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery( cur ).is( until )) ) {
  			if ( cur.nodeType === 1 ) {
  				matched.push( cur );
  			}
  			cur = cur[dir];
  		}
  		return matched;
  	},
  
  	nth: function( cur, result, dir, elem ) {
  		result = result || 1;
  		var num = 0;
  
  		for ( ; cur; cur = cur[dir] ) {
  			if ( cur.nodeType === 1 && ++num === result ) {
  				break;
  			}
  		}
  
  		return cur;
  	},
  
  	sibling: function( n, elem ) {
  		var r = [];
  
  		for ( ; n; n = n.nextSibling ) {
  			if ( n.nodeType === 1 && n !== elem ) {
  				r.push( n );
  			}
  		}
  
  		return r;
  	}
  });
  
  // Implement the identical functionality for filter and not
  function winnow( elements, qualifier, keep ) {
  
  	// Can't pass null or undefined to indexOf in Firefox 4
  	// Set to 0 to skip string check
  	qualifier = qualifier || 0;
  
  	if ( jQuery.isFunction( qualifier ) ) {
  		return jQuery.grep(elements, function( elem, i ) {
  			var retVal = !!qualifier.call( elem, i, elem );
  			return retVal === keep;
  		});
  
  	} else if ( qualifier.nodeType ) {
  		return jQuery.grep(elements, function( elem, i ) {
  			return (elem === qualifier) === keep;
  		});
  
  	} else if ( typeof qualifier === "string" ) {
  		var filtered = jQuery.grep(elements, function( elem ) {
  			return elem.nodeType === 1;
  		});
  
  		if ( isSimple.test( qualifier ) ) {
  			return jQuery.filter(qualifier, filtered, !keep);
  		} else {
  			qualifier = jQuery.filter( qualifier, filtered );
  		}
  	}
  
  	return jQuery.grep(elements, function( elem, i ) {
  		return (jQuery.inArray( elem, qualifier ) >= 0) === keep;
  	});
  }
  
  
  
  
  var rinlinejQuery = / jQuery\d+="(?:\d+|null)"/g,
  	rleadingWhitespace = /^\s+/,
  	rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig,
  	rtagName = /<([\w:]+)/,
  	rtbody = /<tbody/i,
  	rhtml = /<|&#?\w+;/,
  	rnocache = /<(?:script|object|embed|option|style)/i,
  	// checked="checked" or checked
  	rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
  	rscriptType = /\/(java|ecma)script/i,
  	rcleanScript = /^\s*<!(?:\[CDATA\[|\-\-)/,
  	wrapMap = {
  		option: [ 1, "<select multiple='multiple'>", "</select>" ],
  		legend: [ 1, "<fieldset>", "</fieldset>" ],
  		thead: [ 1, "<table>", "</table>" ],
  		tr: [ 2, "<table><tbody>", "</tbody></table>" ],
  		td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
  		col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ],
  		area: [ 1, "<map>", "</map>" ],
  		_default: [ 0, "", "" ]
  	};
  
  wrapMap.optgroup = wrapMap.option;
  wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
  wrapMap.th = wrapMap.td;
  
  // IE can't serialize <link> and <script> tags normally
  if ( !jQuery.support.htmlSerialize ) {
  	wrapMap._default = [ 1, "div<div>", "</div>" ];
  }
  
  jQuery.fn.extend({
  	text: function( text ) {
  		if ( jQuery.isFunction(text) ) {
  			return this.each(function(i) {
  				var self = jQuery( this );
  
  				self.text( text.call(this, i, self.text()) );
  			});
  		}
  
  		if ( typeof text !== "object" && text !== undefined ) {
  			return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );
  		}
  
  		return jQuery.text( this );
  	},
  
  	wrapAll: function( html ) {
  		if ( jQuery.isFunction( html ) ) {
  			return this.each(function(i) {
  				jQuery(this).wrapAll( html.call(this, i) );
  			});
  		}
  
  		if ( this[0] ) {
  			// The elements to wrap the target around
  			var wrap = jQuery( html, this[0].ownerDocument ).eq(0).clone(true);
  
  			if ( this[0].parentNode ) {
  				wrap.insertBefore( this[0] );
  			}
  
  			wrap.map(function() {
  				var elem = this;
  
  				while ( elem.firstChild && elem.firstChild.nodeType === 1 ) {
  					elem = elem.firstChild;
  				}
  
  				return elem;
  			}).append( this );
  		}
  
  		return this;
  	},
  
  	wrapInner: function( html ) {
  		if ( jQuery.isFunction( html ) ) {
  			return this.each(function(i) {
  				jQuery(this).wrapInner( html.call(this, i) );
  			});
  		}
  
  		return this.each(function() {
  			var self = jQuery( this ),
  				contents = self.contents();
  
  			if ( contents.length ) {
  				contents.wrapAll( html );
  
  			} else {
  				self.append( html );
  			}
  		});
  	},
  
  	wrap: function( html ) {
  		return this.each(function() {
  			jQuery( this ).wrapAll( html );
  		});
  	},
  
  	unwrap: function() {
  		return this.parent().each(function() {
  			if ( !jQuery.nodeName( this, "body" ) ) {
  				jQuery( this ).replaceWith( this.childNodes );
  			}
  		}).end();
  	},
  
  	append: function() {
  		return this.domManip(arguments, true, function( elem ) {
  			if ( this.nodeType === 1 ) {
  				this.appendChild( elem );
  			}
  		});
  	},
  
  	prepend: function() {
  		return this.domManip(arguments, true, function( elem ) {
  			if ( this.nodeType === 1 ) {
  				this.insertBefore( elem, this.firstChild );
  			}
  		});
  	},
  
  	before: function() {
  		if ( this[0] && this[0].parentNode ) {
  			return this.domManip(arguments, false, function( elem ) {
  				this.parentNode.insertBefore( elem, this );
  			});
  		} else if ( arguments.length ) {
  			var set = jQuery(arguments[0]);
  			set.push.apply( set, this.toArray() );
  			return this.pushStack( set, "before", arguments );
  		}
  	},
  
  	after: function() {
  		if ( this[0] && this[0].parentNode ) {
  			return this.domManip(arguments, false, function( elem ) {
  				this.parentNode.insertBefore( elem, this.nextSibling );
  			});
  		} else if ( arguments.length ) {
  			var set = this.pushStack( this, "after", arguments );
  			set.push.apply( set, jQuery(arguments[0]).toArray() );
  			return set;
  		}
  	},
  
  	// keepData is for internal use only--do not document
  	remove: function( selector, keepData ) {
  		for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
  			if ( !selector || jQuery.filter( selector, [ elem ] ).length ) {
  				if ( !keepData && elem.nodeType === 1 ) {
  					jQuery.cleanData( elem.getElementsByTagName("*") );
  					jQuery.cleanData( [ elem ] );
  				}
  
  				if ( elem.parentNode ) {
  					elem.parentNode.removeChild( elem );
  				}
  			}
  		}
  
  		return this;
  	},
  
  	empty: function() {
  		for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
  			// Remove element nodes and prevent memory leaks
  			if ( elem.nodeType === 1 ) {
  				jQuery.cleanData( elem.getElementsByTagName("*") );
  			}
  
  			// Remove any remaining nodes
  			while ( elem.firstChild ) {
  				elem.removeChild( elem.firstChild );
  			}
  		}
  
  		return this;
  	},
  
  	clone: function( dataAndEvents, deepDataAndEvents ) {
  		dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
  		deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
  
  		return this.map( function () {
  			return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
  		});
  	},
  
  	html: function( value ) {
  		if ( value === undefined ) {
  			return this[0] && this[0].nodeType === 1 ?
  				this[0].innerHTML.replace(rinlinejQuery, "") :
  				null;
  
  		// See if we can take a shortcut and just use innerHTML
  		} else if ( typeof value === "string" && !rnocache.test( value ) &&
  			(jQuery.support.leadingWhitespace || !rleadingWhitespace.test( value )) &&
  			!wrapMap[ (rtagName.exec( value ) || ["", ""])[1].toLowerCase() ] ) {
  
  			value = value.replace(rxhtmlTag, "<$1></$2>");
  
  			try {
  				for ( var i = 0, l = this.length; i < l; i++ ) {
  					// Remove element nodes and prevent memory leaks
  					if ( this[i].nodeType === 1 ) {
  						jQuery.cleanData( this[i].getElementsByTagName("*") );
  						this[i].innerHTML = value;
  					}
  				}
  
  			// If using innerHTML throws an exception, use the fallback method
  			} catch(e) {
  				this.empty().append( value );
  			}
  
  		} else if ( jQuery.isFunction( value ) ) {
  			this.each(function(i){
  				var self = jQuery( this );
  
  				self.html( value.call(this, i, self.html()) );
  			});
  
  		} else {
  			this.empty().append( value );
  		}
  
  		return this;
  	},
  
  	replaceWith: function( value ) {
  		if ( this[0] && this[0].parentNode ) {
  			// Make sure that the elements are removed from the DOM before they are inserted
  			// this can help fix replacing a parent with child elements
  			if ( jQuery.isFunction( value ) ) {
  				return this.each(function(i) {
  					var self = jQuery(this), old = self.html();
  					self.replaceWith( value.call( this, i, old ) );
  				});
  			}
  
  			if ( typeof value !== "string" ) {
  				value = jQuery( value ).detach();
  			}
  
  			return this.each(function() {
  				var next = this.nextSibling,
  					parent = this.parentNode;
  
  				jQuery( this ).remove();
  
  				if ( next ) {
  					jQuery(next).before( value );
  				} else {
  					jQuery(parent).append( value );
  				}
  			});
  		} else {
  			return this.length ?
  				this.pushStack( jQuery(jQuery.isFunction(value) ? value() : value), "replaceWith", value ) :
  				this;
  		}
  	},
  
  	detach: function( selector ) {
  		return this.remove( selector, true );
  	},
  
  	domManip: function( args, table, callback ) {
  		var results, first, fragment, parent,
  			value = args[0],
  			scripts = [];
  
  		// We can't cloneNode fragments that contain checked, in WebKit
  		if ( !jQuery.support.checkClone && arguments.length === 3 && typeof value === "string" && rchecked.test( value ) ) {
  			return this.each(function() {
  				jQuery(this).domManip( args, table, callback, true );
  			});
  		}
  
  		if ( jQuery.isFunction(value) ) {
  			return this.each(function(i) {
  				var self = jQuery(this);
  				args[0] = value.call(this, i, table ? self.html() : undefined);
  				self.domManip( args, table, callback );
  			});
  		}
  
  		if ( this[0] ) {
  			parent = value && value.parentNode;
  
  			// If we're in a fragment, just use that instead of building a new one
  			if ( jQuery.support.parentNode && parent && parent.nodeType === 11 && parent.childNodes.length === this.length ) {
  				results = { fragment: parent };
  
  			} else {
  				results = jQuery.buildFragment( args, this, scripts );
  			}
  
  			fragment = results.fragment;
  
  			if ( fragment.childNodes.length === 1 ) {
  				first = fragment = fragment.firstChild;
  			} else {
  				first = fragment.firstChild;
  			}
  
  			if ( first ) {
  				table = table && jQuery.nodeName( first, "tr" );
  
  				for ( var i = 0, l = this.length, lastIndex = l - 1; i < l; i++ ) {
  					callback.call(
  						table ?
  							root(this[i], first) :
  							this[i],
  						// Make sure that we do not leak memory by inadvertently discarding
  						// the original fragment (which might have attached data) instead of
  						// using it; in addition, use the original fragment object for the last
  						// item instead of first because it can end up being emptied incorrectly
  						// in certain situations (Bug #8070).
  						// Fragments from the fragment cache must always be cloned and never used
  						// in place.
  						results.cacheable || (l > 1 && i < lastIndex) ?
  							jQuery.clone( fragment, true, true ) :
  							fragment
  					);
  				}
  			}
  
  			if ( scripts.length ) {
  				jQuery.each( scripts, evalScript );
  			}
  		}
  
  		return this;
  	}
  });
  
  function root( elem, cur ) {
  	return jQuery.nodeName(elem, "table") ?
  		(elem.getElementsByTagName("tbody")[0] ||
  		elem.appendChild(elem.ownerDocument.createElement("tbody"))) :
  		elem;
  }
  
  function cloneCopyEvent( src, dest ) {
  
  	if ( dest.nodeType !== 1 || !jQuery.hasData( src ) ) {
  		return;
  	}
  
  	var internalKey = jQuery.expando,
  		oldData = jQuery.data( src ),
  		curData = jQuery.data( dest, oldData );
  
  	// Switch to use the internal data object, if it exists, for the next
  	// stage of data copying
  	if ( (oldData = oldData[ internalKey ]) ) {
  		var events = oldData.events;
  				curData = curData[ internalKey ] = jQuery.extend({}, oldData);
  
  		if ( events ) {
  			delete curData.handle;
  			curData.events = {};
  
  			for ( var type in events ) {
  				for ( var i = 0, l = events[ type ].length; i < l; i++ ) {
  					jQuery.event.add( dest, type + ( events[ type ][ i ].namespace ? "." : "" ) + events[ type ][ i ].namespace, events[ type ][ i ], events[ type ][ i ].data );
  				}
  			}
  		}
  	}
  }
  
  function cloneFixAttributes( src, dest ) {
  	var nodeName;
  
  	// We do not need to do anything for non-Elements
  	if ( dest.nodeType !== 1 ) {
  		return;
  	}
  
  	// clearAttributes removes the attributes, which we don't want,
  	// but also removes the attachEvent events, which we *do* want
  	if ( dest.clearAttributes ) {
  		dest.clearAttributes();
  	}
  
  	// mergeAttributes, in contrast, only merges back on the
  	// original attributes, not the events
  	if ( dest.mergeAttributes ) {
  		dest.mergeAttributes( src );
  	}
  
  	nodeName = dest.nodeName.toLowerCase();
  
  	// IE6-8 fail to clone children inside object elements that use
  	// the proprietary classid attribute value (rather than the type
  	// attribute) to identify the type of content to display
  	if ( nodeName === "object" ) {
  		dest.outerHTML = src.outerHTML;
  
  	} else if ( nodeName === "input" && (src.type === "checkbox" || src.type === "radio") ) {
  		// IE6-8 fails to persist the checked state of a cloned checkbox
  		// or radio button. Worse, IE6-7 fail to give the cloned element
  		// a checked appearance if the defaultChecked value isn't also set
  		if ( src.checked ) {
  			dest.defaultChecked = dest.checked = src.checked;
  		}
  
  		// IE6-7 get confused and end up setting the value of a cloned
  		// checkbox/radio button to an empty string instead of "on"
  		if ( dest.value !== src.value ) {
  			dest.value = src.value;
  		}
  
  	// IE6-8 fails to return the selected option to the default selected
  	// state when cloning options
  	} else if ( nodeName === "option" ) {
  		dest.selected = src.defaultSelected;
  
  	// IE6-8 fails to set the defaultValue to the correct value when
  	// cloning other types of input fields
  	} else if ( nodeName === "input" || nodeName === "textarea" ) {
  		dest.defaultValue = src.defaultValue;
  	}
  
  	// Event data gets referenced instead of copied if the expando
  	// gets copied too
  	dest.removeAttribute( jQuery.expando );
  }
  
  jQuery.buildFragment = function( args, nodes, scripts ) {
  	var fragment, cacheable, cacheresults,
  		doc = (nodes && nodes[0] ? nodes[0].ownerDocument || nodes[0] : document);
  
  	// Only cache "small" (1/2 KB) HTML strings that are associated with the main document
  	// Cloning options loses the selected state, so don't cache them
  	// IE 6 doesn't like it when you put <object> or <embed> elements in a fragment
  	// Also, WebKit does not clone 'checked' attributes on cloneNode, so don't cache
  	if ( args.length === 1 && typeof args[0] === "string" && args[0].length < 512 && doc === document &&
  		args[0].charAt(0) === "<" && !rnocache.test( args[0] ) && (jQuery.support.checkClone || !rchecked.test( args[0] )) ) {
  
  		cacheable = true;
  
  		cacheresults = jQuery.fragments[ args[0] ];
  		if ( cacheresults && cacheresults !== 1 ) {
  			fragment = cacheresults;
  		}
  	}
  
  	if ( !fragment ) {
  		fragment = doc.createDocumentFragment();
  		jQuery.clean( args, doc, fragment, scripts );
  	}
  
  	if ( cacheable ) {
  		jQuery.fragments[ args[0] ] = cacheresults ? fragment : 1;
  	}
  
  	return { fragment: fragment, cacheable: cacheable };
  };
  
  jQuery.fragments = {};
  
  jQuery.each({
  	appendTo: "append",
  	prependTo: "prepend",
  	insertBefore: "before",
  	insertAfter: "after",
  	replaceAll: "replaceWith"
  }, function( name, original ) {
  	jQuery.fn[ name ] = function( selector ) {
  		var ret = [],
  			insert = jQuery( selector ),
  			parent = this.length === 1 && this[0].parentNode;
  
  		if ( parent && parent.nodeType === 11 && parent.childNodes.length === 1 && insert.length === 1 ) {
  			insert[ original ]( this[0] );
  			return this;
  
  		} else {
  			for ( var i = 0, l = insert.length; i < l; i++ ) {
  				var elems = (i > 0 ? this.clone(true) : this).get();
  				jQuery( insert[i] )[ original ]( elems );
  				ret = ret.concat( elems );
  			}
  
  			return this.pushStack( ret, name, insert.selector );
  		}
  	};
  });
  
  function getAll( elem ) {
  	if ( "getElementsByTagName" in elem ) {
  		return elem.getElementsByTagName( "*" );
  
  	} else if ( "querySelectorAll" in elem ) {
  		return elem.querySelectorAll( "*" );
  
  	} else {
  		return [];
  	}
  }
  
  // Used in clean, fixes the defaultChecked property
  function fixDefaultChecked( elem ) {
  	if ( elem.type === "checkbox" || elem.type === "radio" ) {
  		elem.defaultChecked = elem.checked;
  	}
  }
  // Finds all inputs and passes them to fixDefaultChecked
  function findInputs( elem ) {
  	if ( jQuery.nodeName( elem, "input" ) ) {
  		fixDefaultChecked( elem );
  	} else if ( elem.getElementsByTagName ) {
  		jQuery.grep( elem.getElementsByTagName("input"), fixDefaultChecked );
  	}
  }
  
  jQuery.extend({
  	clone: function( elem, dataAndEvents, deepDataAndEvents ) {
  		var clone = elem.cloneNode(true),
  				srcElements,
  				destElements,
  				i;
  
  		if ( (!jQuery.support.noCloneEvent || !jQuery.support.noCloneChecked) &&
  				(elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem) ) {
  			// IE copies events bound via attachEvent when using cloneNode.
  			// Calling detachEvent on the clone will also remove the events
  			// from the original. In order to get around this, we use some
  			// proprietary methods to clear the events. Thanks to MooTools
  			// guys for this hotness.
  
  			cloneFixAttributes( elem, clone );
  
  			// Using Sizzle here is crazy slow, so we use getElementsByTagName
  			// instead
  			srcElements = getAll( elem );
  			destElements = getAll( clone );
  
  			// Weird iteration because IE will replace the length property
  			// with an element if you are cloning the body and one of the
  			// elements on the page has a name or id of "length"
  			for ( i = 0; srcElements[i]; ++i ) {
  				cloneFixAttributes( srcElements[i], destElements[i] );
  			}
  		}
  
  		// Copy the events from the original to the clone
  		if ( dataAndEvents ) {
  			cloneCopyEvent( elem, clone );
  
  			if ( deepDataAndEvents ) {
  				srcElements = getAll( elem );
  				destElements = getAll( clone );
  
  				for ( i = 0; srcElements[i]; ++i ) {
  					cloneCopyEvent( srcElements[i], destElements[i] );
  				}
  			}
  		}
  
  		// Return the cloned set
  		return clone;
  	},
  
  	clean: function( elems, context, fragment, scripts ) {
  		var checkScriptType;
  
  		context = context || document;
  
  		// !context.createElement fails in IE with an error but returns typeof 'object'
  		if ( typeof context.createElement === "undefined" ) {
  			context = context.ownerDocument || context[0] && context[0].ownerDocument || document;
  		}
  
  		var ret = [], j;
  
  		for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
  			if ( typeof elem === "number" ) {
  				elem += "";
  			}
  
  			if ( !elem ) {
  				continue;
  			}
  
  			// Convert html string into DOM nodes
  			if ( typeof elem === "string" ) {
  				if ( !rhtml.test( elem ) ) {
  					elem = context.createTextNode( elem );
  				} else {
  					// Fix "XHTML"-style tags in all browsers
  					elem = elem.replace(rxhtmlTag, "<$1></$2>");
  
  					// Trim whitespace, otherwise indexOf won't work as expected
  					var tag = (rtagName.exec( elem ) || ["", ""])[1].toLowerCase(),
  						wrap = wrapMap[ tag ] || wrapMap._default,
  						depth = wrap[0],
  						div = context.createElement("div");
  
  					// Go to html and back, then peel off extra wrappers
  					div.innerHTML = wrap[1] + elem + wrap[2];
  
  					// Move to the right depth
  					while ( depth-- ) {
  						div = div.lastChild;
  					}
  
  					// Remove IE's autoinserted <tbody> from table fragments
  					if ( !jQuery.support.tbody ) {
  
  						// String was a <table>, *may* have spurious <tbody>
  						var hasBody = rtbody.test(elem),
  							tbody = tag === "table" && !hasBody ?
  								div.firstChild && div.firstChild.childNodes :
  
  								// String was a bare <thead> or <tfoot>
  								wrap[1] === "<table>" && !hasBody ?
  									div.childNodes :
  									[];
  
  						for ( j = tbody.length - 1; j >= 0 ; --j ) {
  							if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length ) {
  								tbody[ j ].parentNode.removeChild( tbody[ j ] );
  							}
  						}
  					}
  
  					// IE completely kills leading whitespace when innerHTML is used
  					if ( !jQuery.support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {
  						div.insertBefore( context.createTextNode( rleadingWhitespace.exec(elem)[0] ), div.firstChild );
  					}
  
  					elem = div.childNodes;
  				}
  			}
  
  			// Resets defaultChecked for any radios and checkboxes
  			// about to be appended to the DOM in IE 6/7 (#8060)
  			var len;
  			if ( !jQuery.support.appendChecked ) {
  				if ( elem[0] && typeof (len = elem.length) === "number" ) {
  					for ( j = 0; j < len; j++ ) {
  						findInputs( elem[j] );
  					}
  				} else {
  					findInputs( elem );
  				}
  			}
  
  			if ( elem.nodeType ) {
  				ret.push( elem );
  			} else {
  				ret = jQuery.merge( ret, elem );
  			}
  		}
  
  		if ( fragment ) {
  			checkScriptType = function( elem ) {
  				return !elem.type || rscriptType.test( elem.type );
  			};
  			for ( i = 0; ret[i]; i++ ) {
  				if ( scripts && jQuery.nodeName( ret[i], "script" ) && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript") ) {
  					scripts.push( ret[i].parentNode ? ret[i].parentNode.removeChild( ret[i] ) : ret[i] );
  
  				} else {
  					if ( ret[i].nodeType === 1 ) {
  						var jsTags = jQuery.grep( ret[i].getElementsByTagName( "script" ), checkScriptType );
  
  						ret.splice.apply( ret, [i + 1, 0].concat( jsTags ) );
  					}
  					fragment.appendChild( ret[i] );
  				}
  			}
  		}
  
  		return ret;
  	},
  
  	cleanData: function( elems ) {
  		var data, id, cache = jQuery.cache, internalKey = jQuery.expando, special = jQuery.event.special,
  			deleteExpando = jQuery.support.deleteExpando;
  
  		for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
  			if ( elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()] ) {
  				continue;
  			}
  
  			id = elem[ jQuery.expando ];
  
  			if ( id ) {
  				data = cache[ id ] && cache[ id ][ internalKey ];
  
  				if ( data && data.events ) {
  					for ( var type in data.events ) {
  						if ( special[ type ] ) {
  							jQuery.event.remove( elem, type );
  
  						// This is a shortcut to avoid jQuery.event.remove's overhead
  						} else {
  							jQuery.removeEvent( elem, type, data.handle );
  						}
  					}
  
  					// Null the DOM reference to avoid IE6/7/8 leak (#7054)
  					if ( data.handle ) {
  						data.handle.elem = null;
  					}
  				}
  
  				if ( deleteExpando ) {
  					delete elem[ jQuery.expando ];
  
  				} else if ( elem.removeAttribute ) {
  					elem.removeAttribute( jQuery.expando );
  				}
  
  				delete cache[ id ];
  			}
  		}
  	}
  });
  
  function evalScript( i, elem ) {
  	if ( elem.src ) {
  		jQuery.ajax({
  			url: elem.src,
  			async: false,
  			dataType: "script"
  		});
  	} else {
  		jQuery.globalEval( ( elem.text || elem.textContent || elem.innerHTML || "" ).replace( rcleanScript, "/*$0*/" ) );
  	}
  
  	if ( elem.parentNode ) {
  		elem.parentNode.removeChild( elem );
  	}
  }
  
  
  
  
  var ralpha = /alpha\([^)]*\)/i,
  	ropacity = /opacity=([^)]*)/,
  	rdashAlpha = /-([a-z])/ig,
  	// fixed for IE9, see #8346
  	rupper = /([A-Z]|^ms)/g,
  	rnumpx = /^-?\d+(?:px)?$/i,
  	rnum = /^-?\d/,
  	rrelNum = /^[+\-]=/,
  	rrelNumFilter = /[^+\-\.\de]+/g,
  
  	cssShow = { position: "absolute", visibility: "hidden", display: "block" },
  	cssWidth = [ "Left", "Right" ],
  	cssHeight = [ "Top", "Bottom" ],
  	curCSS,
  
  	getComputedStyle,
  	currentStyle,
  
  	fcamelCase = function( all, letter ) {
  		return letter.toUpperCase();
  	};
  
  jQuery.fn.css = function( name, value ) {
  	// Setting 'undefined' is a no-op
  	if ( arguments.length === 2 && value === undefined ) {
  		return this;
  	}
  
  	return jQuery.access( this, name, value, true, function( elem, name, value ) {
  		return value !== undefined ?
  			jQuery.style( elem, name, value ) :
  			jQuery.css( elem, name );
  	});
  };
  
  jQuery.extend({
  	// Add in style property hooks for overriding the default
  	// behavior of getting and setting a style property
  	cssHooks: {
  		opacity: {
  			get: function( elem, computed ) {
  				if ( computed ) {
  					// We should always get a number back from opacity
  					var ret = curCSS( elem, "opacity", "opacity" );
  					return ret === "" ? "1" : ret;
  
  				} else {
  					return elem.style.opacity;
  				}
  			}
  		}
  	},
  
  	// Exclude the following css properties to add px
  	cssNumber: {
  		"zIndex": true,
  		"fontWeight": true,
  		"opacity": true,
  		"zoom": true,
  		"lineHeight": true,
  		"widows": true,
  		"orphans": true
  	},
  
  	// Add in properties whose names you wish to fix before
  	// setting or getting the value
  	cssProps: {
  		// normalize float css property
  		"float": jQuery.support.cssFloat ? "cssFloat" : "styleFloat"
  	},
  
  	// Get and set the style property on a DOM Node
  	style: function( elem, name, value, extra ) {
  		// Don't set styles on text and comment nodes
  		if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
  			return;
  		}
  
  		// Make sure that we're working with the right name
  		var ret, type, origName = jQuery.camelCase( name ),
  			style = elem.style, hooks = jQuery.cssHooks[ origName ];
  
  		name = jQuery.cssProps[ origName ] || origName;
  
  		// Check if we're setting a value
  		if ( value !== undefined ) {
  			type = typeof value;
  
  			// Make sure that NaN and null values aren't set. See: #7116
  			if ( type === "number" && isNaN( value ) || value == null ) {
  				return;
  			}
  
  			// convert relative number strings (+= or -=) to relative numbers. #7345
  			if ( type === "string" && rrelNum.test( value ) ) {
  				value = +value.replace( rrelNumFilter, "" ) + parseFloat( jQuery.css( elem, name ) );
  			}
  
  			// If a number was passed in, add 'px' to the (except for certain CSS properties)
  			if ( type === "number" && !jQuery.cssNumber[ origName ] ) {
  				value += "px";
  			}
  
  			// If a hook was provided, use that value, otherwise just set the specified value
  			if ( !hooks || !("set" in hooks) || (value = hooks.set( elem, value )) !== undefined ) {
  				// Wrapped to prevent IE from throwing errors when 'invalid' values are provided
  				// Fixes bug #5509
  				try {
  					style[ name ] = value;
  				} catch(e) {}
  			}
  
  		} else {
  			// If a hook was provided get the non-computed value from there
  			if ( hooks && "get" in hooks && (ret = hooks.get( elem, false, extra )) !== undefined ) {
  				return ret;
  			}
  
  			// Otherwise just get the value from the style object
  			return style[ name ];
  		}
  	},
  
  	css: function( elem, name, extra ) {
  		var ret, hooks;
  
  		// Make sure that we're working with the right name
  		name = jQuery.camelCase( name );
  		hooks = jQuery.cssHooks[ name ];
  		name = jQuery.cssProps[ name ] || name;
  
  		// cssFloat needs a special treatment
  		if ( name === "cssFloat" ) {
  			name = "float";
  		}
  
  		// If a hook was provided get the computed value from there
  		if ( hooks && "get" in hooks && (ret = hooks.get( elem, true, extra )) !== undefined ) {
  			return ret;
  
  		// Otherwise, if a way to get the computed value exists, use that
  		} else if ( curCSS ) {
  			return curCSS( elem, name );
  		}
  	},
  
  	// A method for quickly swapping in/out CSS properties to get correct calculations
  	swap: function( elem, options, callback ) {
  		var old = {};
  
  		// Remember the old values, and insert the new ones
  		for ( var name in options ) {
  			old[ name ] = elem.style[ name ];
  			elem.style[ name ] = options[ name ];
  		}
  
  		callback.call( elem );
  
  		// Revert the old values
  		for ( name in options ) {
  			elem.style[ name ] = old[ name ];
  		}
  	},
  
  	camelCase: function( string ) {
  		return string.replace( rdashAlpha, fcamelCase );
  	}
  });
  
  // DEPRECATED, Use jQuery.css() instead
  jQuery.curCSS = jQuery.css;
  
  jQuery.each(["height", "width"], function( i, name ) {
  	jQuery.cssHooks[ name ] = {
  		get: function( elem, computed, extra ) {
  			var val;
  
  			if ( computed ) {
  				if ( elem.offsetWidth !== 0 ) {
  					val = getWH( elem, name, extra );
  
  				} else {
  					jQuery.swap( elem, cssShow, function() {
  						val = getWH( elem, name, extra );
  					});
  				}
  
  				if ( val <= 0 ) {
  					val = curCSS( elem, name, name );
  
  					if ( val === "0px" && currentStyle ) {
  						val = currentStyle( elem, name, name );
  					}
  
  					if ( val != null ) {
  						// Should return "auto" instead of 0, use 0 for
  						// temporary backwards-compat
  						return val === "" || val === "auto" ? "0px" : val;
  					}
  				}
  
  				if ( val < 0 || val == null ) {
  					val = elem.style[ name ];
  
  					// Should return "auto" instead of 0, use 0 for
  					// temporary backwards-compat
  					return val === "" || val === "auto" ? "0px" : val;
  				}
  
  				return typeof val === "string" ? val : val + "px";
  			}
  		},
  
  		set: function( elem, value ) {
  			if ( rnumpx.test( value ) ) {
  				// ignore negative width and height values #1599
  				value = parseFloat(value);
  
  				if ( value >= 0 ) {
  					return value + "px";
  				}
  
  			} else {
  				return value;
  			}
  		}
  	};
  });
  
  if ( !jQuery.support.opacity ) {
  	jQuery.cssHooks.opacity = {
  		get: function( elem, computed ) {
  			// IE uses filters for opacity
  			return ropacity.test( (computed && elem.currentStyle ? elem.currentStyle.filter : elem.style.filter) || "" ) ?
  				( parseFloat( RegExp.$1 ) / 100 ) + "" :
  				computed ? "1" : "";
  		},
  
  		set: function( elem, value ) {
  			var style = elem.style,
  				currentStyle = elem.currentStyle;
  
  			// IE has trouble with opacity if it does not have layout
  			// Force it by setting the zoom level
  			style.zoom = 1;
  
  			// Set the alpha filter to set the opacity
  			var opacity = jQuery.isNaN( value ) ?
  				"" :
  				"alpha(opacity=" + value * 100 + ")",
  				filter = currentStyle && currentStyle.filter || style.filter || "";
  
  			style.filter = ralpha.test( filter ) ?
  				filter.replace( ralpha, opacity ) :
  				filter + " " + opacity;
  		}
  	};
  }
  
  jQuery(function() {
  	// This hook cannot be added until DOM ready because the support test
  	// for it is not run until after DOM ready
  	if ( !jQuery.support.reliableMarginRight ) {
  		jQuery.cssHooks.marginRight = {
  			get: function( elem, computed ) {
  				// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
  				// Work around by temporarily setting element display to inline-block
  				var ret;
  				jQuery.swap( elem, { "display": "inline-block" }, function() {
  					if ( computed ) {
  						ret = curCSS( elem, "margin-right", "marginRight" );
  					} else {
  						ret = elem.style.marginRight;
  					}
  				});
  				return ret;
  			}
  		};
  	}
  });
  
  if ( document.defaultView && document.defaultView.getComputedStyle ) {
  	getComputedStyle = function( elem, name ) {
  		var ret, defaultView, computedStyle;
  
  		name = name.replace( rupper, "-$1" ).toLowerCase();
  
  		if ( !(defaultView = elem.ownerDocument.defaultView) ) {
  			return undefined;
  		}
  
  		if ( (computedStyle = defaultView.getComputedStyle( elem, null )) ) {
  			ret = computedStyle.getPropertyValue( name );
  			if ( ret === "" && !jQuery.contains( elem.ownerDocument.documentElement, elem ) ) {
  				ret = jQuery.style( elem, name );
  			}
  		}
  
  		return ret;
  	};
  }
  
  if ( document.documentElement.currentStyle ) {
  	currentStyle = function( elem, name ) {
  		var left,
  			ret = elem.currentStyle && elem.currentStyle[ name ],
  			rsLeft = elem.runtimeStyle && elem.runtimeStyle[ name ],
  			style = elem.style;
  
  		// From the awesome hack by Dean Edwards
  		// http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
  
  		// If we're not dealing with a regular pixel number
  		// but a number that has a weird ending, we need to convert it to pixels
  		if ( !rnumpx.test( ret ) && rnum.test( ret ) ) {
  			// Remember the original values
  			left = style.left;
  
  			// Put in the new values to get a computed value out
  			if ( rsLeft ) {
  				elem.runtimeStyle.left = elem.currentStyle.left;
  			}
  			style.left = name === "fontSize" ? "1em" : (ret || 0);
  			ret = style.pixelLeft + "px";
  
  			// Revert the changed values
  			style.left = left;
  			if ( rsLeft ) {
  				elem.runtimeStyle.left = rsLeft;
  			}
  		}
  
  		return ret === "" ? "auto" : ret;
  	};
  }
  
  curCSS = getComputedStyle || currentStyle;
  
  function getWH( elem, name, extra ) {
  	var which = name === "width" ? cssWidth : cssHeight,
  		val = name === "width" ? elem.offsetWidth : elem.offsetHeight;
  
  	if ( extra === "border" ) {
  		return val;
  	}
  
  	jQuery.each( which, function() {
  		if ( !extra ) {
  			val -= parseFloat(jQuery.css( elem, "padding" + this )) || 0;
  		}
  
  		if ( extra === "margin" ) {
  			val += parseFloat(jQuery.css( elem, "margin" + this )) || 0;
  
  		} else {
  			val -= parseFloat(jQuery.css( elem, "border" + this + "Width" )) || 0;
  		}
  	});
  
  	return val;
  }
  
  if ( jQuery.expr && jQuery.expr.filters ) {
  	jQuery.expr.filters.hidden = function( elem ) {
  		var width = elem.offsetWidth,
  			height = elem.offsetHeight;
  
  		return (width === 0 && height === 0) || (!jQuery.support.reliableHiddenOffsets && (elem.style.display || jQuery.css( elem, "display" )) === "none");
  	};
  
  	jQuery.expr.filters.visible = function( elem ) {
  		return !jQuery.expr.filters.hidden( elem );
  	};
  }
  
  
  
  
  var r20 = /%20/g,
  	rbracket = /\[\]$/,
  	rCRLF = /\r?\n/g,
  	rhash = /#.*$/,
  	rheaders = /^(.*?):[ \t]*([^\r\n]*)\r?$/mg, // IE leaves an \r character at EOL
  	rinput = /^(?:color|date|datetime|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i,
  	// #7653, #8125, #8152: local protocol detection
  	rlocalProtocol = /^(?:about|app|app\-storage|.+\-extension|file|widget):$/,
  	rnoContent = /^(?:GET|HEAD)$/,
  	rprotocol = /^\/\//,
  	rquery = /\?/,
  	rscript = /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,
  	rselectTextarea = /^(?:select|textarea)/i,
  	rspacesAjax = /\s+/,
  	rts = /([?&])_=[^&]*/,
  	rurl = /^([\w\+\.\-]+:)(?:\/\/([^\/?#:]*)(?::(\d+))?)?/,
  
  	// Keep a copy of the old load method
  	_load = jQuery.fn.load,
  
  	/* Prefilters
  	 * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
  	 * 2) These are called:
  	 *    - BEFORE asking for a transport
  	 *    - AFTER param serialization (s.data is a string if s.processData is true)
  	 * 3) key is the dataType
  	 * 4) the catchall symbol "*" can be used
  	 * 5) execution will start with transport dataType and THEN continue down to "*" if needed
  	 */
  	prefilters = {},
  
  	/* Transports bindings
  	 * 1) key is the dataType
  	 * 2) the catchall symbol "*" can be used
  	 * 3) selection will start with transport dataType and THEN go to "*" if needed
  	 */
  	transports = {},
  
  	// Document location
  	ajaxLocation,
  
  	// Document location segments
  	ajaxLocParts;
  
  // #8138, IE may throw an exception when accessing
  // a field from window.location if document.domain has been set
  try {
  	ajaxLocation = location.href;
  } catch( e ) {
  	// Use the href attribute of an A element
  	// since IE will modify it given document.location
  	ajaxLocation = document.createElement( "a" );
  	ajaxLocation.href = "";
  	ajaxLocation = ajaxLocation.href;
  }
  
  // Segment location into parts
  ajaxLocParts = rurl.exec( ajaxLocation.toLowerCase() ) || [];
  
  // Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
  function addToPrefiltersOrTransports( structure ) {
  
  	// dataTypeExpression is optional and defaults to "*"
  	return function( dataTypeExpression, func ) {
  
  		if ( typeof dataTypeExpression !== "string" ) {
  			func = dataTypeExpression;
  			dataTypeExpression = "*";
  		}
  
  		if ( jQuery.isFunction( func ) ) {
  			var dataTypes = dataTypeExpression.toLowerCase().split( rspacesAjax ),
  				i = 0,
  				length = dataTypes.length,
  				dataType,
  				list,
  				placeBefore;
  
  			// For each dataType in the dataTypeExpression
  			for(; i < length; i++ ) {
  				dataType = dataTypes[ i ];
  				// We control if we're asked to add before
  				// any existing element
  				placeBefore = /^\+/.test( dataType );
  				if ( placeBefore ) {
  					dataType = dataType.substr( 1 ) || "*";
  				}
  				list = structure[ dataType ] = structure[ dataType ] || [];
  				// then we add to the structure accordingly
  				list[ placeBefore ? "unshift" : "push" ]( func );
  			}
  		}
  	};
  }
  
  // Base inspection function for prefilters and transports
  function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR,
  		dataType /* internal */, inspected /* internal */ ) {
  
  	dataType = dataType || options.dataTypes[ 0 ];
  	inspected = inspected || {};
  
  	inspected[ dataType ] = true;
  
  	var list = structure[ dataType ],
  		i = 0,
  		length = list ? list.length : 0,
  		executeOnly = ( structure === prefilters ),
  		selection;
  
  	for(; i < length && ( executeOnly || !selection ); i++ ) {
  		selection = list[ i ]( options, originalOptions, jqXHR );
  		// If we got redirected to another dataType
  		// we try there if executing only and not done already
  		if ( typeof selection === "string" ) {
  			if ( !executeOnly || inspected[ selection ] ) {
  				selection = undefined;
  			} else {
  				options.dataTypes.unshift( selection );
  				selection = inspectPrefiltersOrTransports(
  						structure, options, originalOptions, jqXHR, selection, inspected );
  			}
  		}
  	}
  	// If we're only executing or nothing was selected
  	// we try the catchall dataType if not done already
  	if ( ( executeOnly || !selection ) && !inspected[ "*" ] ) {
  		selection = inspectPrefiltersOrTransports(
  				structure, options, originalOptions, jqXHR, "*", inspected );
  	}
  	// unnecessary when only executing (prefilters)
  	// but it'll be ignored by the caller in that case
  	return selection;
  }
  
  jQuery.fn.extend({
  	load: function( url, params, callback ) {
  		if ( typeof url !== "string" && _load ) {
  			return _load.apply( this, arguments );
  
  		// Don't do a request if no elements are being requested
  		} else if ( !this.length ) {
  			return this;
  		}
  
  		var off = url.indexOf( " " );
  		if ( off >= 0 ) {
  			var selector = url.slice( off, url.length );
  			url = url.slice( 0, off );
  		}
  
  		// Default to a GET request
  		var type = "GET";
  
  		// If the second parameter was provided
  		if ( params ) {
  			// If it's a function
  			if ( jQuery.isFunction( params ) ) {
  				// We assume that it's the callback
  				callback = params;
  				params = undefined;
  
  			// Otherwise, build a param string
  			} else if ( typeof params === "object" ) {
  				params = jQuery.param( params, jQuery.ajaxSettings.traditional );
  				type = "POST";
  			}
  		}
  
  		var self = this;
  
  		// Request the remote document
  		jQuery.ajax({
  			url: url,
  			type: type,
  			dataType: "html",
  			data: params,
  			// Complete callback (responseText is used internally)
  			complete: function( jqXHR, status, responseText ) {
  				// Store the response as specified by the jqXHR object
  				responseText = jqXHR.responseText;
  				// If successful, inject the HTML into all the matched elements
  				if ( jqXHR.isResolved() ) {
  					// #4825: Get the actual response in case
  					// a dataFilter is present in ajaxSettings
  					jqXHR.done(function( r ) {
  						responseText = r;
  					});
  					// See if a selector was specified
  					self.html( selector ?
  						// Create a dummy div to hold the results
  						jQuery("<div>")
  							// inject the contents of the document in, removing the scripts
  							// to avoid any 'Permission Denied' errors in IE
  							.append(responseText.replace(rscript, ""))
  
  							// Locate the specified elements
  							.find(selector) :
  
  						// If not, just inject the full result
  						responseText );
  				}
  
  				if ( callback ) {
  					self.each( callback, [ responseText, status, jqXHR ] );
  				}
  			}
  		});
  
  		return this;
  	},
  
  	serialize: function() {
  		return jQuery.param( this.serializeArray() );
  	},
  
  	serializeArray: function() {
  		return this.map(function(){
  			return this.elements ? jQuery.makeArray( this.elements ) : this;
  		})
  		.filter(function(){
  			return this.name && !this.disabled &&
  				( this.checked || rselectTextarea.test( this.nodeName ) ||
  					rinput.test( this.type ) );
  		})
  		.map(function( i, elem ){
  			var val = jQuery( this ).val();
  
  			return val == null ?
  				null :
  				jQuery.isArray( val ) ?
  					jQuery.map( val, function( val, i ){
  						return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
  					}) :
  					{ name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
  		}).get();
  	}
  });
  
  // Attach a bunch of functions for handling common AJAX events
  jQuery.each( "ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split( " " ), function( i, o ){
  	jQuery.fn[ o ] = function( f ){
  		return this.bind( o, f );
  	};
  });
  
  jQuery.each( [ "get", "post" ], function( i, method ) {
  	jQuery[ method ] = function( url, data, callback, type ) {
  		// shift arguments if data argument was omitted
  		if ( jQuery.isFunction( data ) ) {
  			type = type || callback;
  			callback = data;
  			data = undefined;
  		}
  
  		return jQuery.ajax({
  			type: method,
  			url: url,
  			data: data,
  			success: callback,
  			dataType: type
  		});
  	};
  });
  
  jQuery.extend({
  
  	getScript: function( url, callback ) {
  		return jQuery.get( url, undefined, callback, "script" );
  	},
  
  	getJSON: function( url, data, callback ) {
  		return jQuery.get( url, data, callback, "json" );
  	},
  
  	// Creates a full fledged settings object into target
  	// with both ajaxSettings and settings fields.
  	// If target is omitted, writes into ajaxSettings.
  	ajaxSetup: function ( target, settings ) {
  		if ( !settings ) {
  			// Only one parameter, we extend ajaxSettings
  			settings = target;
  			target = jQuery.extend( true, jQuery.ajaxSettings, settings );
  		} else {
  			// target was provided, we extend into it
  			jQuery.extend( true, target, jQuery.ajaxSettings, settings );
  		}
  		// Flatten fields we don't want deep extended
  		for( var field in { context: 1, url: 1 } ) {
  			if ( field in settings ) {
  				target[ field ] = settings[ field ];
  			} else if( field in jQuery.ajaxSettings ) {
  				target[ field ] = jQuery.ajaxSettings[ field ];
  			}
  		}
  		return target;
  	},
  
  	ajaxSettings: {
  		url: ajaxLocation,
  		isLocal: rlocalProtocol.test( ajaxLocParts[ 1 ] ),
  		global: true,
  		type: "GET",
  		contentType: "application/x-www-form-urlencoded",
  		processData: true,
  		async: true,
  		/*
  		timeout: 0,
  		data: null,
  		dataType: null,
  		username: null,
  		password: null,
  		cache: null,
  		traditional: false,
  		headers: {},
  		*/
  
  		accepts: {
  			xml: "application/xml, text/xml",
  			html: "text/html",
  			text: "text/plain",
  			json: "application/json, text/javascript",
  			"*": "*/*"
  		},
  
  		contents: {
  			xml: /xml/,
  			html: /html/,
  			json: /json/
  		},
  
  		responseFields: {
  			xml: "responseXML",
  			text: "responseText"
  		},
  
  		// List of data converters
  		// 1) key format is "source_type destination_type" (a single space in-between)
  		// 2) the catchall symbol "*" can be used for source_type
  		converters: {
  
  			// Convert anything to text
  			"* text": window.String,
  
  			// Text to html (true = no transformation)
  			"text html": true,
  
  			// Evaluate text as a json expression
  			"text json": jQuery.parseJSON,
  
  			// Parse text as xml
  			"text xml": jQuery.parseXML
  		}
  	},
  
  	ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
  	ajaxTransport: addToPrefiltersOrTransports( transports ),
  
  	// Main method
  	ajax: function( url, options ) {
  
  		// If url is an object, simulate pre-1.5 signature
  		if ( typeof url === "object" ) {
  			options = url;
  			url = undefined;
  		}
  
  		// Force options to be an object
  		options = options || {};
  
  		var // Create the final options object
  			s = jQuery.ajaxSetup( {}, options ),
  			// Callbacks context
  			callbackContext = s.context || s,
  			// Context for global events
  			// It's the callbackContext if one was provided in the options
  			// and if it's a DOM node or a jQuery collection
  			globalEventContext = callbackContext !== s &&
  				( callbackContext.nodeType || callbackContext instanceof jQuery ) ?
  						jQuery( callbackContext ) : jQuery.event,
  			// Deferreds
  			deferred = jQuery.Deferred(),
  			completeDeferred = jQuery._Deferred(),
  			// Status-dependent callbacks
  			statusCode = s.statusCode || {},
  			// ifModified key
  			ifModifiedKey,
  			// Headers (they are sent all at once)
  			requestHeaders = {},
  			requestHeadersNames = {},
  			// Response headers
  			responseHeadersString,
  			responseHeaders,
  			// transport
  			transport,
  			// timeout handle
  			timeoutTimer,
  			// Cross-domain detection vars
  			parts,
  			// The jqXHR state
  			state = 0,
  			// To know if global events are to be dispatched
  			fireGlobals,
  			// Loop variable
  			i,
  			// Fake xhr
  			jqXHR = {
  
  				readyState: 0,
  
  				// Caches the header
  				setRequestHeader: function( name, value ) {
  					if ( !state ) {
  						var lname = name.toLowerCase();
  						name = requestHeadersNames[ lname ] = requestHeadersNames[ lname ] || name;
  						requestHeaders[ name ] = value;
  					}
  					return this;
  				},
  
  				// Raw string
  				getAllResponseHeaders: function() {
  					return state === 2 ? responseHeadersString : null;
  				},
  
  				// Builds headers hashtable if needed
  				getResponseHeader: function( key ) {
  					var match;
  					if ( state === 2 ) {
  						if ( !responseHeaders ) {
  							responseHeaders = {};
  							while( ( match = rheaders.exec( responseHeadersString ) ) ) {
  								responseHeaders[ match[1].toLowerCase() ] = match[ 2 ];
  							}
  						}
  						match = responseHeaders[ key.toLowerCase() ];
  					}
  					return match === undefined ? null : match;
  				},
  
  				// Overrides response content-type header
  				overrideMimeType: function( type ) {
  					if ( !state ) {
  						s.mimeType = type;
  					}
  					return this;
  				},
  
  				// Cancel the request
  				abort: function( statusText ) {
  					statusText = statusText || "abort";
  					if ( transport ) {
  						transport.abort( statusText );
  					}
  					done( 0, statusText );
  					return this;
  				}
  			};
  
  		// Callback for when everything is done
  		// It is defined here because jslint complains if it is declared
  		// at the end of the function (which would be more logical and readable)
  		function done( status, statusText, responses, headers ) {
  
  			// Called once
  			if ( state === 2 ) {
  				return;
  			}
  
  			// State is "done" now
  			state = 2;
  
  			// Clear timeout if it exists
  			if ( timeoutTimer ) {
  				clearTimeout( timeoutTimer );
  			}
  
  			// Dereference transport for early garbage collection
  			// (no matter how long the jqXHR object will be used)
  			transport = undefined;
  
  			// Cache response headers
  			responseHeadersString = headers || "";
  
  			// Set readyState
  			jqXHR.readyState = status ? 4 : 0;
  
  			var isSuccess,
  				success,
  				error,
  				response = responses ? ajaxHandleResponses( s, jqXHR, responses ) : undefined,
  				lastModified,
  				etag;
  
  			// If successful, handle type chaining
  			if ( status >= 200 && status < 300 || status === 304 ) {
  
  				// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
  				if ( s.ifModified ) {
  
  					if ( ( lastModified = jqXHR.getResponseHeader( "Last-Modified" ) ) ) {
  						jQuery.lastModified[ ifModifiedKey ] = lastModified;
  					}
  					if ( ( etag = jqXHR.getResponseHeader( "Etag" ) ) ) {
  						jQuery.etag[ ifModifiedKey ] = etag;
  					}
  				}
  
  				// If not modified
  				if ( status === 304 ) {
  
  					statusText = "notmodified";
  					isSuccess = true;
  
  				// If we have data
  				} else {
  
  					try {
  						success = ajaxConvert( s, response );
  						statusText = "success";
  						isSuccess = true;
  					} catch(e) {
  						// We have a parsererror
  						statusText = "parsererror";
  						error = e;
  					}
  				}
  			} else {
  				// We extract error from statusText
  				// then normalize statusText and status for non-aborts
  				error = statusText;
  				if( !statusText || status ) {
  					statusText = "error";
  					if ( status < 0 ) {
  						status = 0;
  					}
  				}
  			}
  
  			// Set data for the fake xhr object
  			jqXHR.status = status;
  			jqXHR.statusText = statusText;
  
  			// Success/Error
  			if ( isSuccess ) {
  				deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
  			} else {
  				deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
  			}
  
  			// Status-dependent callbacks
  			jqXHR.statusCode( statusCode );
  			statusCode = undefined;
  
  			if ( fireGlobals ) {
  				globalEventContext.trigger( "ajax" + ( isSuccess ? "Success" : "Error" ),
  						[ jqXHR, s, isSuccess ? success : error ] );
  			}
  
  			// Complete
  			completeDeferred.resolveWith( callbackContext, [ jqXHR, statusText ] );
  
  			if ( fireGlobals ) {
  				globalEventContext.trigger( "ajaxComplete", [ jqXHR, s] );
  				// Handle the global AJAX counter
  				if ( !( --jQuery.active ) ) {
  					jQuery.event.trigger( "ajaxStop" );
  				}
  			}
  		}
  
  		// Attach deferreds
  		deferred.promise( jqXHR );
  		jqXHR.success = jqXHR.done;
  		jqXHR.error = jqXHR.fail;
  		jqXHR.complete = completeDeferred.done;
  
  		// Status-dependent callbacks
  		jqXHR.statusCode = function( map ) {
  			if ( map ) {
  				var tmp;
  				if ( state < 2 ) {
  					for( tmp in map ) {
  						statusCode[ tmp ] = [ statusCode[tmp], map[tmp] ];
  					}
  				} else {
  					tmp = map[ jqXHR.status ];
  					jqXHR.then( tmp, tmp );
  				}
  			}
  			return this;
  		};
  
  		// Remove hash character (#7531: and string promotion)
  		// Add protocol if not provided (#5866: IE7 issue with protocol-less urls)
  		// We also use the url parameter if available
  		s.url = ( ( url || s.url ) + "" ).replace( rhash, "" ).replace( rprotocol, ajaxLocParts[ 1 ] + "//" );
  
  		// Extract dataTypes list
  		s.dataTypes = jQuery.trim( s.dataType || "*" ).toLowerCase().split( rspacesAjax );
  
  		// Determine if a cross-domain request is in order
  		if ( s.crossDomain == null ) {
  			parts = rurl.exec( s.url.toLowerCase() );
  			s.crossDomain = !!( parts &&
  				( parts[ 1 ] != ajaxLocParts[ 1 ] || parts[ 2 ] != ajaxLocParts[ 2 ] ||
  					( parts[ 3 ] || ( parts[ 1 ] === "http:" ? 80 : 443 ) ) !=
  						( ajaxLocParts[ 3 ] || ( ajaxLocParts[ 1 ] === "http:" ? 80 : 443 ) ) )
  			);
  		}
  
  		// Convert data if not already a string
  		if ( s.data && s.processData && typeof s.data !== "string" ) {
  			s.data = jQuery.param( s.data, s.traditional );
  		}
  
  		// Apply prefilters
  		inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
  
  		// If request was aborted inside a prefiler, stop there
  		if ( state === 2 ) {
  			return false;
  		}
  
  		// We can fire global events as of now if asked to
  		fireGlobals = s.global;
  
  		// Uppercase the type
  		s.type = s.type.toUpperCase();
  
  		// Determine if request has content
  		s.hasContent = !rnoContent.test( s.type );
  
  		// Watch for a new set of requests
  		if ( fireGlobals && jQuery.active++ === 0 ) {
  			jQuery.event.trigger( "ajaxStart" );
  		}
  
  		// More options handling for requests with no content
  		if ( !s.hasContent ) {
  
  			// If data is available, append data to url
  			if ( s.data ) {
  				s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.data;
  			}
  
  			// Get ifModifiedKey before adding the anti-cache parameter
  			ifModifiedKey = s.url;
  
  			// Add anti-cache in url if needed
  			if ( s.cache === false ) {
  
  				var ts = jQuery.now(),
  					// try replacing _= if it is there
  					ret = s.url.replace( rts, "$1_=" + ts );
  
  				// if nothing was replaced, add timestamp to the end
  				s.url = ret + ( (ret === s.url ) ? ( rquery.test( s.url ) ? "&" : "?" ) + "_=" + ts : "" );
  			}
  		}
  
  		// Set the correct header, if data is being sent
  		if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
  			jqXHR.setRequestHeader( "Content-Type", s.contentType );
  		}
  
  		// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
  		if ( s.ifModified ) {
  			ifModifiedKey = ifModifiedKey || s.url;
  			if ( jQuery.lastModified[ ifModifiedKey ] ) {
  				jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ ifModifiedKey ] );
  			}
  			if ( jQuery.etag[ ifModifiedKey ] ) {
  				jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ ifModifiedKey ] );
  			}
  		}
  
  		// Set the Accepts header for the server, depending on the dataType
  		jqXHR.setRequestHeader(
  			"Accept",
  			s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[0] ] ?
  				s.accepts[ s.dataTypes[0] ] + ( s.dataTypes[ 0 ] !== "*" ? ", */*; q=0.01" : "" ) :
  				s.accepts[ "*" ]
  		);
  
  		// Check for headers option
  		for ( i in s.headers ) {
  			jqXHR.setRequestHeader( i, s.headers[ i ] );
  		}
  
  		// Allow custom headers/mimetypes and early abort
  		if ( s.beforeSend && ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || state === 2 ) ) {
  				// Abort if not done already
  				jqXHR.abort();
  				return false;
  
  		}
  
  		// Install callbacks on deferreds
  		for ( i in { success: 1, error: 1, complete: 1 } ) {
  			jqXHR[ i ]( s[ i ] );
  		}
  
  		// Get transport
  		transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );
  
  		// If no transport, we auto-abort
  		if ( !transport ) {
  			done( -1, "No Transport" );
  		} else {
  			jqXHR.readyState = 1;
  			// Send global event
  			if ( fireGlobals ) {
  				globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
  			}
  			// Timeout
  			if ( s.async && s.timeout > 0 ) {
  				timeoutTimer = setTimeout( function(){
  					jqXHR.abort( "timeout" );
  				}, s.timeout );
  			}
  
  			try {
  				state = 1;
  				transport.send( requestHeaders, done );
  			} catch (e) {
  				// Propagate exception as error if not done
  				if ( status < 2 ) {
  					done( -1, e );
  				// Simply rethrow otherwise
  				} else {
  					jQuery.error( e );
  				}
  			}
  		}
  
  		return jqXHR;
  	},
  
  	// Serialize an array of form elements or a set of
  	// key/values into a query string
  	param: function( a, traditional ) {
  		var s = [],
  			add = function( key, value ) {
  				// If value is a function, invoke it and return its value
  				value = jQuery.isFunction( value ) ? value() : value;
  				s[ s.length ] = encodeURIComponent( key ) + "=" + encodeURIComponent( value );
  			};
  
  		// Set traditional to true for jQuery <= 1.3.2 behavior.
  		if ( traditional === undefined ) {
  			traditional = jQuery.ajaxSettings.traditional;
  		}
  
  		// If an array was passed in, assume that it is an array of form elements.
  		if ( jQuery.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {
  			// Serialize the form elements
  			jQuery.each( a, function() {
  				add( this.name, this.value );
  			});
  
  		} else {
  			// If traditional, encode the "old" way (the way 1.3.2 or older
  			// did it), otherwise encode params recursively.
  			for ( var prefix in a ) {
  				buildParams( prefix, a[ prefix ], traditional, add );
  			}
  		}
  
  		// Return the resulting serialization
  		return s.join( "&" ).replace( r20, "+" );
  	}
  });
  
  function buildParams( prefix, obj, traditional, add ) {
  	if ( jQuery.isArray( obj ) ) {
  		// Serialize array item.
  		jQuery.each( obj, function( i, v ) {
  			if ( traditional || rbracket.test( prefix ) ) {
  				// Treat each array item as a scalar.
  				add( prefix, v );
  
  			} else {
  				// If array item is non-scalar (array or object), encode its
  				// numeric index to resolve deserialization ambiguity issues.
  				// Note that rack (as of 1.0.0) can't currently deserialize
  				// nested arrays properly, and attempting to do so may cause
  				// a server error. Possible fixes are to modify rack's
  				// deserialization algorithm or to provide an option or flag
  				// to force array serialization to be shallow.
  				buildParams( prefix + "[" + ( typeof v === "object" || jQuery.isArray(v) ? i : "" ) + "]", v, traditional, add );
  			}
  		});
  
  	} else if ( !traditional && obj != null && typeof obj === "object" ) {
  		// Serialize object item.
  		for ( var name in obj ) {
  			buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add );
  		}
  
  	} else {
  		// Serialize scalar item.
  		add( prefix, obj );
  	}
  }
  
  // This is still on the jQuery object... for now
  // Want to move this to jQuery.ajax some day
  jQuery.extend({
  
  	// Counter for holding the number of active queries
  	active: 0,
  
  	// Last-Modified header cache for next request
  	lastModified: {},
  	etag: {}
  
  });
  
  /* Handles responses to an ajax request:
   * - sets all responseXXX fields accordingly
   * - finds the right dataType (mediates between content-type and expected dataType)
   * - returns the corresponding response
   */
  function ajaxHandleResponses( s, jqXHR, responses ) {
  
  	var contents = s.contents,
  		dataTypes = s.dataTypes,
  		responseFields = s.responseFields,
  		ct,
  		type,
  		finalDataType,
  		firstDataType;
  
  	// Fill responseXXX fields
  	for( type in responseFields ) {
  		if ( type in responses ) {
  			jqXHR[ responseFields[type] ] = responses[ type ];
  		}
  	}
  
  	// Remove auto dataType and get content-type in the process
  	while( dataTypes[ 0 ] === "*" ) {
  		dataTypes.shift();
  		if ( ct === undefined ) {
  			ct = s.mimeType || jqXHR.getResponseHeader( "content-type" );
  		}
  	}
  
  	// Check if we're dealing with a known content-type
  	if ( ct ) {
  		for ( type in contents ) {
  			if ( contents[ type ] && contents[ type ].test( ct ) ) {
  				dataTypes.unshift( type );
  				break;
  			}
  		}
  	}
  
  	// Check to see if we have a response for the expected dataType
  	if ( dataTypes[ 0 ] in responses ) {
  		finalDataType = dataTypes[ 0 ];
  	} else {
  		// Try convertible dataTypes
  		for ( type in responses ) {
  			if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[0] ] ) {
  				finalDataType = type;
  				break;
  			}
  			if ( !firstDataType ) {
  				firstDataType = type;
  			}
  		}
  		// Or just use first one
  		finalDataType = finalDataType || firstDataType;
  	}
  
  	// If we found a dataType
  	// We add the dataType to the list if needed
  	// and return the corresponding response
  	if ( finalDataType ) {
  		if ( finalDataType !== dataTypes[ 0 ] ) {
  			dataTypes.unshift( finalDataType );
  		}
  		return responses[ finalDataType ];
  	}
  }
  
  // Chain conversions given the request and the original response
  function ajaxConvert( s, response ) {
  
  	// Apply the dataFilter if provided
  	if ( s.dataFilter ) {
  		response = s.dataFilter( response, s.dataType );
  	}
  
  	var dataTypes = s.dataTypes,
  		converters = {},
  		i,
  		key,
  		length = dataTypes.length,
  		tmp,
  		// Current and previous dataTypes
  		current = dataTypes[ 0 ],
  		prev,
  		// Conversion expression
  		conversion,
  		// Conversion function
  		conv,
  		// Conversion functions (transitive conversion)
  		conv1,
  		conv2;
  
  	// For each dataType in the chain
  	for( i = 1; i < length; i++ ) {
  
  		// Create converters map
  		// with lowercased keys
  		if ( i === 1 ) {
  			for( key in s.converters ) {
  				if( typeof key === "string" ) {
  					converters[ key.toLowerCase() ] = s.converters[ key ];
  				}
  			}
  		}
  
  		// Get the dataTypes
  		prev = current;
  		current = dataTypes[ i ];
  
  		// If current is auto dataType, update it to prev
  		if( current === "*" ) {
  			current = prev;
  		// If no auto and dataTypes are actually different
  		} else if ( prev !== "*" && prev !== current ) {
  
  			// Get the converter
  			conversion = prev + " " + current;
  			conv = converters[ conversion ] || converters[ "* " + current ];
  
  			// If there is no direct converter, search transitively
  			if ( !conv ) {
  				conv2 = undefined;
  				for( conv1 in converters ) {
  					tmp = conv1.split( " " );
  					if ( tmp[ 0 ] === prev || tmp[ 0 ] === "*" ) {
  						conv2 = converters[ tmp[1] + " " + current ];
  						if ( conv2 ) {
  							conv1 = converters[ conv1 ];
  							if ( conv1 === true ) {
  								conv = conv2;
  							} else if ( conv2 === true ) {
  								conv = conv1;
  							}
  							break;
  						}
  					}
  				}
  			}
  			// If we found no converter, dispatch an error
  			if ( !( conv || conv2 ) ) {
  				jQuery.error( "No conversion from " + conversion.replace(" "," to ") );
  			}
  			// If found converter is not an equivalence
  			if ( conv !== true ) {
  				// Convert with 1 or 2 converters accordingly
  				response = conv ? conv( response ) : conv2( conv1(response) );
  			}
  		}
  	}
  	return response;
  }
  
  
  
  
  var jsc = jQuery.now(),
  	jsre = /(\=)\?(&|$)|\?\?/i;
  
  // Default jsonp settings
  jQuery.ajaxSetup({
  	jsonp: "callback",
  	jsonpCallback: function() {
  		return jQuery.expando + "_" + ( jsc++ );
  	}
  });
  
  // Detect, normalize options and install callbacks for jsonp requests
  jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
  
  	var inspectData = s.contentType === "application/x-www-form-urlencoded" &&
  		( typeof s.data === "string" );
  
  	if ( s.dataTypes[ 0 ] === "jsonp" ||
  		s.jsonp !== false && ( jsre.test( s.url ) ||
  				inspectData && jsre.test( s.data ) ) ) {
  
  		var responseContainer,
  			jsonpCallback = s.jsonpCallback =
  				jQuery.isFunction( s.jsonpCallback ) ? s.jsonpCallback() : s.jsonpCallback,
  			previous = window[ jsonpCallback ],
  			url = s.url,
  			data = s.data,
  			replace = "$1" + jsonpCallback + "$2";
  
  		if ( s.jsonp !== false ) {
  			url = url.replace( jsre, replace );
  			if ( s.url === url ) {
  				if ( inspectData ) {
  					data = data.replace( jsre, replace );
  				}
  				if ( s.data === data ) {
  					// Add callback manually
  					url += (/\?/.test( url ) ? "&" : "?") + s.jsonp + "=" + jsonpCallback;
  				}
  			}
  		}
  
  		s.url = url;
  		s.data = data;
  
  		// Install callback
  		window[ jsonpCallback ] = function( response ) {
  			responseContainer = [ response ];
  		};
  
  		// Clean-up function
  		jqXHR.always(function() {
  			// Set callback back to previous value
  			window[ jsonpCallback ] = previous;
  			// Call if it was a function and we have a response
  			if ( responseContainer && jQuery.isFunction( previous ) ) {
  				window[ jsonpCallback ]( responseContainer[ 0 ] );
  			}
  		});
  
  		// Use data converter to retrieve json after script execution
  		s.converters["script json"] = function() {
  			if ( !responseContainer ) {
  				jQuery.error( jsonpCallback + " was not called" );
  			}
  			return responseContainer[ 0 ];
  		};
  
  		// force json dataType
  		s.dataTypes[ 0 ] = "json";
  
  		// Delegate to script
  		return "script";
  	}
  });
  
  
  
  
  // Install script dataType
  jQuery.ajaxSetup({
  	accepts: {
  		script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
  	},
  	contents: {
  		script: /javascript|ecmascript/
  	},
  	converters: {
  		"text script": function( text ) {
  			jQuery.globalEval( text );
  			return text;
  		}
  	}
  });
  
  // Handle cache's special case and global
  jQuery.ajaxPrefilter( "script", function( s ) {
  	if ( s.cache === undefined ) {
  		s.cache = false;
  	}
  	if ( s.crossDomain ) {
  		s.type = "GET";
  		s.global = false;
  	}
  });
  
  // Bind script tag hack transport
  jQuery.ajaxTransport( "script", function(s) {
  
  	// This transport only deals with cross domain requests
  	if ( s.crossDomain ) {
  
  		var script,
  			head = document.head || document.getElementsByTagName( "head" )[0] || document.documentElement;
  
  		return {
  
  			send: function( _, callback ) {
  
  				script = document.createElement( "script" );
  
  				script.async = "async";
  
  				if ( s.scriptCharset ) {
  					script.charset = s.scriptCharset;
  				}
  
  				script.src = s.url;
  
  				// Attach handlers for all browsers
  				script.onload = script.onreadystatechange = function( _, isAbort ) {
  
  					if ( isAbort || !script.readyState || /loaded|complete/.test( script.readyState ) ) {
  
  						// Handle memory leak in IE
  						script.onload = script.onreadystatechange = null;
  
  						// Remove the script
  						if ( head && script.parentNode ) {
  							head.removeChild( script );
  						}
  
  						// Dereference the script
  						script = undefined;
  
  						// Callback if not abort
  						if ( !isAbort ) {
  							callback( 200, "success" );
  						}
  					}
  				};
  				// Use insertBefore instead of appendChild  to circumvent an IE6 bug.
  				// This arises when a base node is used (#2709 and #4378).
  				head.insertBefore( script, head.firstChild );
  			},
  
  			abort: function() {
  				if ( script ) {
  					script.onload( 0, 1 );
  				}
  			}
  		};
  	}
  });
  
  
  
  
  var // #5280: Internet Explorer will keep connections alive if we don't abort on unload
  	xhrOnUnloadAbort = window.ActiveXObject ? function() {
  		// Abort all pending requests
  		for ( var key in xhrCallbacks ) {
  			xhrCallbacks[ key ]( 0, 1 );
  		}
  	} : false,
  	xhrId = 0,
  	xhrCallbacks;
  
  // Functions to create xhrs
  function createStandardXHR() {
  	try {
  		return new window.XMLHttpRequest();
  	} catch( e ) {}
  }
  
  function createActiveXHR() {
  	try {
  		return new window.ActiveXObject( "Microsoft.XMLHTTP" );
  	} catch( e ) {}
  }
  
  // Create the request object
  // (This is still attached to ajaxSettings for backward compatibility)
  jQuery.ajaxSettings.xhr = window.ActiveXObject ?
  	/* Microsoft failed to properly
  	 * implement the XMLHttpRequest in IE7 (can't request local files),
  	 * so we use the ActiveXObject when it is available
  	 * Additionally XMLHttpRequest can be disabled in IE7/IE8 so
  	 * we need a fallback.
  	 */
  	function() {
  		return !this.isLocal && createStandardXHR() || createActiveXHR();
  	} :
  	// For all other browsers, use the standard XMLHttpRequest object
  	createStandardXHR;
  
  // Determine support properties
  (function( xhr ) {
  	jQuery.extend( jQuery.support, {
  		ajax: !!xhr,
  		cors: !!xhr && ( "withCredentials" in xhr )
  	});
  })( jQuery.ajaxSettings.xhr() );
  
  // Create transport if the browser can provide an xhr
  if ( jQuery.support.ajax ) {
  
  	jQuery.ajaxTransport(function( s ) {
  		// Cross domain only allowed if supported through XMLHttpRequest
  		if ( !s.crossDomain || jQuery.support.cors ) {
  
  			var callback;
  
  			return {
  				send: function( headers, complete ) {
  
  					// Get a new xhr
  					var xhr = s.xhr(),
  						handle,
  						i;
  
  					// Open the socket
  					// Passing null username, generates a login popup on Opera (#2865)
  					if ( s.username ) {
  						xhr.open( s.type, s.url, s.async, s.username, s.password );
  					} else {
  						xhr.open( s.type, s.url, s.async );
  					}
  
  					// Apply custom fields if provided
  					if ( s.xhrFields ) {
  						for ( i in s.xhrFields ) {
  							xhr[ i ] = s.xhrFields[ i ];
  						}
  					}
  
  					// Override mime type if needed
  					if ( s.mimeType && xhr.overrideMimeType ) {
  						xhr.overrideMimeType( s.mimeType );
  					}
  
  					// X-Requested-With header
  					// For cross-domain requests, seeing as conditions for a preflight are
  					// akin to a jigsaw puzzle, we simply never set it to be sure.
  					// (it can always be set on a per-request basis or even using ajaxSetup)
  					// For same-domain requests, won't change header if already provided.
  					if ( !s.crossDomain && !headers["X-Requested-With"] ) {
  						headers[ "X-Requested-With" ] = "XMLHttpRequest";
  					}
  
  					// Need an extra try/catch for cross domain requests in Firefox 3
  					try {
  						for ( i in headers ) {
  							xhr.setRequestHeader( i, headers[ i ] );
  						}
  					} catch( _ ) {}
  
  					// Do send the request
  					// This may raise an exception which is actually
  					// handled in jQuery.ajax (so no try/catch here)
  					xhr.send( ( s.hasContent && s.data ) || null );
  
  					// Listener
  					callback = function( _, isAbort ) {
  
  						var status,
  							statusText,
  							responseHeaders,
  							responses,
  							xml;
  
  						// Firefox throws exceptions when accessing properties
  						// of an xhr when a network error occured
  						// http://helpful.knobs-dials.com/index.php/Component_returned_failure_code:_0x80040111_(NS_ERROR_NOT_AVAILABLE)
  						try {
  
  							// Was never called and is aborted or complete
  							if ( callback && ( isAbort || xhr.readyState === 4 ) ) {
  
  								// Only called once
  								callback = undefined;
  
  								// Do not keep as active anymore
  								if ( handle ) {
  									xhr.onreadystatechange = jQuery.noop;
  									if ( xhrOnUnloadAbort ) {
  										delete xhrCallbacks[ handle ];
  									}
  								}
  
  								// If it's an abort
  								if ( isAbort ) {
  									// Abort it manually if needed
  									if ( xhr.readyState !== 4 ) {
  										xhr.abort();
  									}
  								} else {
  									status = xhr.status;
  									responseHeaders = xhr.getAllResponseHeaders();
  									responses = {};
  									xml = xhr.responseXML;
  
  									// Construct response list
  									if ( xml && xml.documentElement /* #4958 */ ) {
  										responses.xml = xml;
  									}
  									responses.text = xhr.responseText;
  
  									// Firefox throws an exception when accessing
  									// statusText for faulty cross-domain requests
  									try {
  										statusText = xhr.statusText;
  									} catch( e ) {
  										// We normalize with Webkit giving an empty statusText
  										statusText = "";
  									}
  
  									// Filter status for non standard behaviors
  
  									// If the request is local and we have data: assume a success
  									// (success with no data won't get notified, that's the best we
  									// can do given current implementations)
  									if ( !status && s.isLocal && !s.crossDomain ) {
  										status = responses.text ? 200 : 404;
  									// IE - #1450: sometimes returns 1223 when it should be 204
  									} else if ( status === 1223 ) {
  										status = 204;
  									}
  								}
  							}
  						} catch( firefoxAccessException ) {
  							if ( !isAbort ) {
  								complete( -1, firefoxAccessException );
  							}
  						}
  
  						// Call complete if needed
  						if ( responses ) {
  							complete( status, statusText, responses, responseHeaders );
  						}
  					};
  
  					// if we're in sync mode or it's in cache
  					// and has been retrieved directly (IE6 & IE7)
  					// we need to manually fire the callback
  					if ( !s.async || xhr.readyState === 4 ) {
  						callback();
  					} else {
  						handle = ++xhrId;
  						if ( xhrOnUnloadAbort ) {
  							// Create the active xhrs callbacks list if needed
  							// and attach the unload handler
  							if ( !xhrCallbacks ) {
  								xhrCallbacks = {};
  								jQuery( window ).unload( xhrOnUnloadAbort );
  							}
  							// Add to list of active xhrs callbacks
  							xhrCallbacks[ handle ] = callback;
  						}
  						xhr.onreadystatechange = callback;
  					}
  				},
  
  				abort: function() {
  					if ( callback ) {
  						callback(0,1);
  					}
  				}
  			};
  		}
  	});
  }
  
  
  
  
  var elemdisplay = {},
  	iframe, iframeDoc,
  	rfxtypes = /^(?:toggle|show|hide)$/,
  	rfxnum = /^([+\-]=)?([\d+.\-]+)([a-z%]*)$/i,
  	timerId,
  	fxAttrs = [
  		// height animations
  		[ "height", "marginTop", "marginBottom", "paddingTop", "paddingBottom" ],
  		// width animations
  		[ "width", "marginLeft", "marginRight", "paddingLeft", "paddingRight" ],
  		// opacity animations
  		[ "opacity" ]
  	],
  	fxNow,
  	requestAnimationFrame = window.webkitRequestAnimationFrame ||
  	    window.mozRequestAnimationFrame ||
  	    window.oRequestAnimationFrame;
  
  jQuery.fn.extend({
  	show: function( speed, easing, callback ) {
  		var elem, display;
  
  		if ( speed || speed === 0 ) {
  			return this.animate( genFx("show", 3), speed, easing, callback);
  
  		} else {
  			for ( var i = 0, j = this.length; i < j; i++ ) {
  				elem = this[i];
  
  				if ( elem.style ) {
  					display = elem.style.display;
  
  					// Reset the inline display of this element to learn if it is
  					// being hidden by cascaded rules or not
  					if ( !jQuery._data(elem, "olddisplay") && display === "none" ) {
  						display = elem.style.display = "";
  					}
  
  					// Set elements which have been overridden with display: none
  					// in a stylesheet to whatever the default browser style is
  					// for such an element
  					if ( display === "" && jQuery.css( elem, "display" ) === "none" ) {
  						jQuery._data(elem, "olddisplay", defaultDisplay(elem.nodeName));
  					}
  				}
  			}
  
  			// Set the display of most of the elements in a second loop
  			// to avoid the constant reflow
  			for ( i = 0; i < j; i++ ) {
  				elem = this[i];
  
  				if ( elem.style ) {
  					display = elem.style.display;
  
  					if ( display === "" || display === "none" ) {
  						elem.style.display = jQuery._data(elem, "olddisplay") || "";
  					}
  				}
  			}
  
  			return this;
  		}
  	},
  
  	hide: function( speed, easing, callback ) {
  		if ( speed || speed === 0 ) {
  			return this.animate( genFx("hide", 3), speed, easing, callback);
  
  		} else {
  			for ( var i = 0, j = this.length; i < j; i++ ) {
  				if ( this[i].style ) {
  					var display = jQuery.css( this[i], "display" );
  
  					if ( display !== "none" && !jQuery._data( this[i], "olddisplay" ) ) {
  						jQuery._data( this[i], "olddisplay", display );
  					}
  				}
  			}
  
  			// Set the display of the elements in a second loop
  			// to avoid the constant reflow
  			for ( i = 0; i < j; i++ ) {
  				if ( this[i].style ) {
  					this[i].style.display = "none";
  				}
  			}
  
  			return this;
  		}
  	},
  
  	// Save the old toggle function
  	_toggle: jQuery.fn.toggle,
  
  	toggle: function( fn, fn2, callback ) {
  		var bool = typeof fn === "boolean";
  
  		if ( jQuery.isFunction(fn) && jQuery.isFunction(fn2) ) {
  			this._toggle.apply( this, arguments );
  
  		} else if ( fn == null || bool ) {
  			this.each(function() {
  				var state = bool ? fn : jQuery(this).is(":hidden");
  				jQuery(this)[ state ? "show" : "hide" ]();
  			});
  
  		} else {
  			this.animate(genFx("toggle", 3), fn, fn2, callback);
  		}
  
  		return this;
  	},
  
  	fadeTo: function( speed, to, easing, callback ) {
  		return this.filter(":hidden").css("opacity", 0).show().end()
  					.animate({opacity: to}, speed, easing, callback);
  	},
  
  	animate: function( prop, speed, easing, callback ) {
  		var optall = jQuery.speed(speed, easing, callback);
  
  		if ( jQuery.isEmptyObject( prop ) ) {
  			return this.each( optall.complete, [ false ] );
  		}
  
  		// Do not change referenced properties as per-property easing will be lost
  		prop = jQuery.extend( {}, prop );
  
  		return this[ optall.queue === false ? "each" : "queue" ](function() {
  			// XXX 'this' does not always have a nodeName when running the
  			// test suite
  
  			if ( optall.queue === false ) {
  				jQuery._mark( this );
  			}
  
  			var opt = jQuery.extend( {}, optall ),
  				isElement = this.nodeType === 1,
  				hidden = isElement && jQuery(this).is(":hidden"),
  				name, val, p,
  				display, e,
  				parts, start, end, unit;
  
  			// will store per property easing and be used to determine when an animation is complete
  			opt.animatedProperties = {};
  
  			for ( p in prop ) {
  
  				// property name normalization
  				name = jQuery.camelCase( p );
  				if ( p !== name ) {
  					prop[ name ] = prop[ p ];
  					delete prop[ p ];
  				}
  
  				val = prop[ name ];
  
  				// easing resolution: per property > opt.specialEasing > opt.easing > 'swing' (default)
  				if ( jQuery.isArray( val ) ) {
  					opt.animatedProperties[ name ] = val[ 1 ];
  					val = prop[ name ] = val[ 0 ];
  				} else {
  					opt.animatedProperties[ name ] = opt.specialEasing && opt.specialEasing[ name ] || opt.easing || 'swing';
  				}
  
  				if ( val === "hide" && hidden || val === "show" && !hidden ) {
  					return opt.complete.call( this );
  				}
  
  				if ( isElement && ( name === "height" || name === "width" ) ) {
  					// Make sure that nothing sneaks out
  					// Record all 3 overflow attributes because IE does not
  					// change the overflow attribute when overflowX and
  					// overflowY are set to the same value
  					opt.overflow = [ this.style.overflow, this.style.overflowX, this.style.overflowY ];
  
  					// Set display property to inline-block for height/width
  					// animations on inline elements that are having width/height
  					// animated
  					if ( jQuery.css( this, "display" ) === "inline" &&
  							jQuery.css( this, "float" ) === "none" ) {
  						if ( !jQuery.support.inlineBlockNeedsLayout ) {
  							this.style.display = "inline-block";
  
  						} else {
  							display = defaultDisplay( this.nodeName );
  
  							// inline-level elements accept inline-block;
  							// block-level elements need to be inline with layout
  							if ( display === "inline" ) {
  								this.style.display = "inline-block";
  
  							} else {
  								this.style.display = "inline";
  								this.style.zoom = 1;
  							}
  						}
  					}
  				}
  			}
  
  			if ( opt.overflow != null ) {
  				this.style.overflow = "hidden";
  			}
  
  			for ( p in prop ) {
  				e = new jQuery.fx( this, opt, p );
  				val = prop[ p ];
  
  				if ( rfxtypes.test(val) ) {
  					e[ val === "toggle" ? hidden ? "show" : "hide" : val ]();
  
  				} else {
  					parts = rfxnum.exec( val );
  					start = e.cur();
  
  					if ( parts ) {
  						end = parseFloat( parts[2] );
  						unit = parts[3] || ( jQuery.cssNumber[ p ] ? "" : "px" );
  
  						// We need to compute starting value
  						if ( unit !== "px" ) {
  							jQuery.style( this, p, (end || 1) + unit);
  							start = ((end || 1) / e.cur()) * start;
  							jQuery.style( this, p, start + unit);
  						}
  
  						// If a +=/-= token was provided, we're doing a relative animation
  						if ( parts[1] ) {
  							end = ( (parts[ 1 ] === "-=" ? -1 : 1) * end ) + start;
  						}
  
  						e.custom( start, end, unit );
  
  					} else {
  						e.custom( start, val, "" );
  					}
  				}
  			}
  
  			// For JS strict compliance
  			return true;
  		});
  	},
  
  	stop: function( clearQueue, gotoEnd ) {
  		if ( clearQueue ) {
  			this.queue([]);
  		}
  
  		this.each(function() {
  			var timers = jQuery.timers,
  				i = timers.length;
  			// clear marker counters if we know they won't be
  			if ( !gotoEnd ) {
  				jQuery._unmark( true, this );
  			}
  			while ( i-- ) {
  				if ( timers[i].elem === this ) {
  					if (gotoEnd) {
  						// force the next step to be the last
  						timers[i](true);
  					}
  
  					timers.splice(i, 1);
  				}
  			}
  		});
  
  		// start the next in the queue if the last step wasn't forced
  		if ( !gotoEnd ) {
  			this.dequeue();
  		}
  
  		return this;
  	}
  
  });
  
  // Animations created synchronously will run synchronously
  function createFxNow() {
  	setTimeout( clearFxNow, 0 );
  	return ( fxNow = jQuery.now() );
  }
  
  function clearFxNow() {
  	fxNow = undefined;
  }
  
  // Generate parameters to create a standard animation
  function genFx( type, num ) {
  	var obj = {};
  
  	jQuery.each( fxAttrs.concat.apply([], fxAttrs.slice(0,num)), function() {
  		obj[ this ] = type;
  	});
  
  	return obj;
  }
  
  // Generate shortcuts for custom animations
  jQuery.each({
  	slideDown: genFx("show", 1),
  	slideUp: genFx("hide", 1),
  	slideToggle: genFx("toggle", 1),
  	fadeIn: { opacity: "show" },
  	fadeOut: { opacity: "hide" },
  	fadeToggle: { opacity: "toggle" }
  }, function( name, props ) {
  	jQuery.fn[ name ] = function( speed, easing, callback ) {
  		return this.animate( props, speed, easing, callback );
  	};
  });
  
  jQuery.extend({
  	speed: function( speed, easing, fn ) {
  		var opt = speed && typeof speed === "object" ? jQuery.extend({}, speed) : {
  			complete: fn || !fn && easing ||
  				jQuery.isFunction( speed ) && speed,
  			duration: speed,
  			easing: fn && easing || easing && !jQuery.isFunction(easing) && easing
  		};
  
  		opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
  			opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[opt.duration] : jQuery.fx.speeds._default;
  
  		// Queueing
  		opt.old = opt.complete;
  		opt.complete = function( noUnmark ) {
  			if ( opt.queue !== false ) {
  				jQuery.dequeue( this );
  			} else if ( noUnmark !== false ) {
  				jQuery._unmark( this );
  			}
  
  			if ( jQuery.isFunction( opt.old ) ) {
  				opt.old.call( this );
  			}
  		};
  
  		return opt;
  	},
  
  	easing: {
  		linear: function( p, n, firstNum, diff ) {
  			return firstNum + diff * p;
  		},
  		swing: function( p, n, firstNum, diff ) {
  			return ((-Math.cos(p*Math.PI)/2) + 0.5) * diff + firstNum;
  		}
  	},
  
  	timers: [],
  
  	fx: function( elem, options, prop ) {
  		this.options = options;
  		this.elem = elem;
  		this.prop = prop;
  
  		options.orig = options.orig || {};
  	}
  
  });
  
  jQuery.fx.prototype = {
  	// Simple function for setting a style value
  	update: function() {
  		if ( this.options.step ) {
  			this.options.step.call( this.elem, this.now, this );
  		}
  
  		(jQuery.fx.step[this.prop] || jQuery.fx.step._default)( this );
  	},
  
  	// Get the current size
  	cur: function() {
  		if ( this.elem[this.prop] != null && (!this.elem.style || this.elem.style[this.prop] == null) ) {
  			return this.elem[ this.prop ];
  		}
  
  		var parsed,
  			r = jQuery.css( this.elem, this.prop );
  		// Empty strings, null, undefined and "auto" are converted to 0,
  		// complex values such as "rotate(1rad)" are returned as is,
  		// simple values such as "10px" are parsed to Float.
  		return isNaN( parsed = parseFloat( r ) ) ? !r || r === "auto" ? 0 : r : parsed;
  	},
  
  	// Start an animation from one number to another
  	custom: function( from, to, unit ) {
  		var self = this,
  			fx = jQuery.fx,
  			raf;
  
  		this.startTime = fxNow || createFxNow();
  		this.start = from;
  		this.end = to;
  		this.unit = unit || this.unit || ( jQuery.cssNumber[ this.prop ] ? "" : "px" );
  		this.now = this.start;
  		this.pos = this.state = 0;
  
  		function t( gotoEnd ) {
  			return self.step(gotoEnd);
  		}
  
  		t.elem = this.elem;
  
  		if ( t() && jQuery.timers.push(t) && !timerId ) {
  			// Use requestAnimationFrame instead of setInterval if available
  			if ( requestAnimationFrame ) {
  				timerId = 1;
  				raf = function() {
  					// When timerId gets set to null at any point, this stops
  					if ( timerId ) {
  						requestAnimationFrame( raf );
  						fx.tick();
  					}
  				};
  				requestAnimationFrame( raf );
  			} else {
  				timerId = setInterval( fx.tick, fx.interval );
  			}
  		}
  	},
  
  	// Simple 'show' function
  	show: function() {
  		// Remember where we started, so that we can go back to it later
  		this.options.orig[this.prop] = jQuery.style( this.elem, this.prop );
  		this.options.show = true;
  
  		// Begin the animation
  		// Make sure that we start at a small width/height to avoid any
  		// flash of content
  		this.custom(this.prop === "width" || this.prop === "height" ? 1 : 0, this.cur());
  
  		// Start by showing the element
  		jQuery( this.elem ).show();
  	},
  
  	// Simple 'hide' function
  	hide: function() {
  		// Remember where we started, so that we can go back to it later
  		this.options.orig[this.prop] = jQuery.style( this.elem, this.prop );
  		this.options.hide = true;
  
  		// Begin the animation
  		this.custom(this.cur(), 0);
  	},
  
  	// Each step of an animation
  	step: function( gotoEnd ) {
  		var t = fxNow || createFxNow(),
  			done = true,
  			elem = this.elem,
  			options = this.options,
  			i, n;
  
  		if ( gotoEnd || t >= options.duration + this.startTime ) {
  			this.now = this.end;
  			this.pos = this.state = 1;
  			this.update();
  
  			options.animatedProperties[ this.prop ] = true;
  
  			for ( i in options.animatedProperties ) {
  				if ( options.animatedProperties[i] !== true ) {
  					done = false;
  				}
  			}
  
  			if ( done ) {
  				// Reset the overflow
  				if ( options.overflow != null && !jQuery.support.shrinkWrapBlocks ) {
  
  					jQuery.each( [ "", "X", "Y" ], function (index, value) {
  						elem.style[ "overflow" + value ] = options.overflow[index];
  					});
  				}
  
  				// Hide the element if the "hide" operation was done
  				if ( options.hide ) {
  					jQuery(elem).hide();
  				}
  
  				// Reset the properties, if the item has been hidden or shown
  				if ( options.hide || options.show ) {
  					for ( var p in options.animatedProperties ) {
  						jQuery.style( elem, p, options.orig[p] );
  					}
  				}
  
  				// Execute the complete function
  				options.complete.call( elem );
  			}
  
  			return false;
  
  		} else {
  			// classical easing cannot be used with an Infinity duration
  			if ( options.duration == Infinity ) {
  				this.now = t;
  			} else {
  				n = t - this.startTime;
  				this.state = n / options.duration;
  
  				// Perform the easing function, defaults to swing
  				this.pos = jQuery.easing[ options.animatedProperties[ this.prop ] ]( this.state, n, 0, 1, options.duration );
  				this.now = this.start + ((this.end - this.start) * this.pos);
  			}
  			// Perform the next step of the animation
  			this.update();
  		}
  
  		return true;
  	}
  };
  
  jQuery.extend( jQuery.fx, {
  	tick: function() {
  		for ( var timers = jQuery.timers, i = 0 ; i < timers.length ; ++i ) {
  			if ( !timers[i]() ) {
  				timers.splice(i--, 1);
  			}
  		}
  
  		if ( !timers.length ) {
  			jQuery.fx.stop();
  		}
  	},
  
  	interval: 13,
  
  	stop: function() {
  		clearInterval( timerId );
  		timerId = null;
  	},
  
  	speeds: {
  		slow: 600,
  		fast: 200,
  		// Default speed
  		_default: 400
  	},
  
  	step: {
  		opacity: function( fx ) {
  			jQuery.style( fx.elem, "opacity", fx.now );
  		},
  
  		_default: function( fx ) {
  			if ( fx.elem.style && fx.elem.style[ fx.prop ] != null ) {
  				fx.elem.style[ fx.prop ] = (fx.prop === "width" || fx.prop === "height" ? Math.max(0, fx.now) : fx.now) + fx.unit;
  			} else {
  				fx.elem[ fx.prop ] = fx.now;
  			}
  		}
  	}
  });
  
  if ( jQuery.expr && jQuery.expr.filters ) {
  	jQuery.expr.filters.animated = function( elem ) {
  		return jQuery.grep(jQuery.timers, function( fn ) {
  			return elem === fn.elem;
  		}).length;
  	};
  }
  
  // Try to restore the default display value of an element
  function defaultDisplay( nodeName ) {
  
  	if ( !elemdisplay[ nodeName ] ) {
  
  		var elem = jQuery( "<" + nodeName + ">" ).appendTo( "body" ),
  			display = elem.css( "display" );
  
  		elem.remove();
  
  		// If the simple way fails,
  		// get element's real default display by attaching it to a temp iframe
  		if ( display === "none" || display === "" ) {
  			// No iframe to use yet, so create it
  			if ( !iframe ) {
  				iframe = document.createElement( "iframe" );
  				iframe.frameBorder = iframe.width = iframe.height = 0;
  			}
  
  			document.body.appendChild( iframe );
  
  			// Create a cacheable copy of the iframe document on first call.
  			// IE and Opera will allow us to reuse the iframeDoc without re-writing the fake html
  			// document to it, Webkit & Firefox won't allow reusing the iframe document
  			if ( !iframeDoc || !iframe.createElement ) {
  				iframeDoc = ( iframe.contentWindow || iframe.contentDocument ).document;
  				iframeDoc.write( "<!doctype><html><body></body></html>" );
  			}
  
  			elem = iframeDoc.createElement( nodeName );
  
  			iframeDoc.body.appendChild( elem );
  
  			display = jQuery.css( elem, "display" );
  
  			document.body.removeChild( iframe );
  		}
  
  		// Store the correct default display
  		elemdisplay[ nodeName ] = display;
  	}
  
  	return elemdisplay[ nodeName ];
  }
  
  
  
  
  var rtable = /^t(?:able|d|h)$/i,
  	rroot = /^(?:body|html)$/i;
  
  if ( "getBoundingClientRect" in document.documentElement ) {
  	jQuery.fn.offset = function( options ) {
  		var elem = this[0], box;
  
  		if ( options ) {
  			return this.each(function( i ) {
  				jQuery.offset.setOffset( this, options, i );
  			});
  		}
  
  		if ( !elem || !elem.ownerDocument ) {
  			return null;
  		}
  
  		if ( elem === elem.ownerDocument.body ) {
  			return jQuery.offset.bodyOffset( elem );
  		}
  
  		try {
  			box = elem.getBoundingClientRect();
  		} catch(e) {}
  
  		var doc = elem.ownerDocument,
  			docElem = doc.documentElement;
  
  		// Make sure we're not dealing with a disconnected DOM node
  		if ( !box || !jQuery.contains( docElem, elem ) ) {
  			return box ? { top: box.top, left: box.left } : { top: 0, left: 0 };
  		}
  
  		var body = doc.body,
  			win = getWindow(doc),
  			clientTop  = docElem.clientTop  || body.clientTop  || 0,
  			clientLeft = docElem.clientLeft || body.clientLeft || 0,
  			scrollTop  = win.pageYOffset || jQuery.support.boxModel && docElem.scrollTop  || body.scrollTop,
  			scrollLeft = win.pageXOffset || jQuery.support.boxModel && docElem.scrollLeft || body.scrollLeft,
  			top  = box.top  + scrollTop  - clientTop,
  			left = box.left + scrollLeft - clientLeft;
  
  		return { top: top, left: left };
  	};
  
  } else {
  	jQuery.fn.offset = function( options ) {
  		var elem = this[0];
  
  		if ( options ) {
  			return this.each(function( i ) {
  				jQuery.offset.setOffset( this, options, i );
  			});
  		}
  
  		if ( !elem || !elem.ownerDocument ) {
  			return null;
  		}
  
  		if ( elem === elem.ownerDocument.body ) {
  			return jQuery.offset.bodyOffset( elem );
  		}
  
  		jQuery.offset.initialize();
  
  		var computedStyle,
  			offsetParent = elem.offsetParent,
  			prevOffsetParent = elem,
  			doc = elem.ownerDocument,
  			docElem = doc.documentElement,
  			body = doc.body,
  			defaultView = doc.defaultView,
  			prevComputedStyle = defaultView ? defaultView.getComputedStyle( elem, null ) : elem.currentStyle,
  			top = elem.offsetTop,
  			left = elem.offsetLeft;
  
  		while ( (elem = elem.parentNode) && elem !== body && elem !== docElem ) {
  			if ( jQuery.offset.supportsFixedPosition && prevComputedStyle.position === "fixed" ) {
  				break;
  			}
  
  			computedStyle = defaultView ? defaultView.getComputedStyle(elem, null) : elem.currentStyle;
  			top  -= elem.scrollTop;
  			left -= elem.scrollLeft;
  
  			if ( elem === offsetParent ) {
  				top  += elem.offsetTop;
  				left += elem.offsetLeft;
  
  				if ( jQuery.offset.doesNotAddBorder && !(jQuery.offset.doesAddBorderForTableAndCells && rtable.test(elem.nodeName)) ) {
  					top  += parseFloat( computedStyle.borderTopWidth  ) || 0;
  					left += parseFloat( computedStyle.borderLeftWidth ) || 0;
  				}
  
  				prevOffsetParent = offsetParent;
  				offsetParent = elem.offsetParent;
  			}
  
  			if ( jQuery.offset.subtractsBorderForOverflowNotVisible && computedStyle.overflow !== "visible" ) {
  				top  += parseFloat( computedStyle.borderTopWidth  ) || 0;
  				left += parseFloat( computedStyle.borderLeftWidth ) || 0;
  			}
  
  			prevComputedStyle = computedStyle;
  		}
  
  		if ( prevComputedStyle.position === "relative" || prevComputedStyle.position === "static" ) {
  			top  += body.offsetTop;
  			left += body.offsetLeft;
  		}
  
  		if ( jQuery.offset.supportsFixedPosition && prevComputedStyle.position === "fixed" ) {
  			top  += Math.max( docElem.scrollTop, body.scrollTop );
  			left += Math.max( docElem.scrollLeft, body.scrollLeft );
  		}
  
  		return { top: top, left: left };
  	};
  }
  
  jQuery.offset = {
  	initialize: function() {
  		var body = document.body, container = document.createElement("div"), innerDiv, checkDiv, table, td, bodyMarginTop = parseFloat( jQuery.css(body, "marginTop") ) || 0,
  			html = "<div style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;'><div></div></div><table style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;' cellpadding='0' cellspacing='0'><tr><td></td></tr></table>";
  
  		jQuery.extend( container.style, { position: "absolute", top: 0, left: 0, margin: 0, border: 0, width: "1px", height: "1px", visibility: "hidden" } );
  
  		container.innerHTML = html;
  		body.insertBefore( container, body.firstChild );
  		innerDiv = container.firstChild;
  		checkDiv = innerDiv.firstChild;
  		td = innerDiv.nextSibling.firstChild.firstChild;
  
  		this.doesNotAddBorder = (checkDiv.offsetTop !== 5);
  		this.doesAddBorderForTableAndCells = (td.offsetTop === 5);
  
  		checkDiv.style.position = "fixed";
  		checkDiv.style.top = "20px";
  
  		// safari subtracts parent border width here which is 5px
  		this.supportsFixedPosition = (checkDiv.offsetTop === 20 || checkDiv.offsetTop === 15);
  		checkDiv.style.position = checkDiv.style.top = "";
  
  		innerDiv.style.overflow = "hidden";
  		innerDiv.style.position = "relative";
  
  		this.subtractsBorderForOverflowNotVisible = (checkDiv.offsetTop === -5);
  
  		this.doesNotIncludeMarginInBodyOffset = (body.offsetTop !== bodyMarginTop);
  
  		body.removeChild( container );
  		jQuery.offset.initialize = jQuery.noop;
  	},
  
  	bodyOffset: function( body ) {
  		var top = body.offsetTop,
  			left = body.offsetLeft;
  
  		jQuery.offset.initialize();
  
  		if ( jQuery.offset.doesNotIncludeMarginInBodyOffset ) {
  			top  += parseFloat( jQuery.css(body, "marginTop") ) || 0;
  			left += parseFloat( jQuery.css(body, "marginLeft") ) || 0;
  		}
  
  		return { top: top, left: left };
  	},
  
  	setOffset: function( elem, options, i ) {
  		var position = jQuery.css( elem, "position" );
  
  		// set position first, in-case top/left are set even on static elem
  		if ( position === "static" ) {
  			elem.style.position = "relative";
  		}
  
  		var curElem = jQuery( elem ),
  			curOffset = curElem.offset(),
  			curCSSTop = jQuery.css( elem, "top" ),
  			curCSSLeft = jQuery.css( elem, "left" ),
  			calculatePosition = (position === "absolute" || position === "fixed") && jQuery.inArray("auto", [curCSSTop, curCSSLeft]) > -1,
  			props = {}, curPosition = {}, curTop, curLeft;
  
  		// need to be able to calculate position if either top or left is auto and position is either absolute or fixed
  		if ( calculatePosition ) {
  			curPosition = curElem.position();
  			curTop = curPosition.top;
  			curLeft = curPosition.left;
  		} else {
  			curTop = parseFloat( curCSSTop ) || 0;
  			curLeft = parseFloat( curCSSLeft ) || 0;
  		}
  
  		if ( jQuery.isFunction( options ) ) {
  			options = options.call( elem, i, curOffset );
  		}
  
  		if (options.top != null) {
  			props.top = (options.top - curOffset.top) + curTop;
  		}
  		if (options.left != null) {
  			props.left = (options.left - curOffset.left) + curLeft;
  		}
  
  		if ( "using" in options ) {
  			options.using.call( elem, props );
  		} else {
  			curElem.css( props );
  		}
  	}
  };
  
  
  jQuery.fn.extend({
  	position: function() {
  		if ( !this[0] ) {
  			return null;
  		}
  
  		var elem = this[0],
  
  		// Get *real* offsetParent
  		offsetParent = this.offsetParent(),
  
  		// Get correct offsets
  		offset       = this.offset(),
  		parentOffset = rroot.test(offsetParent[0].nodeName) ? { top: 0, left: 0 } : offsetParent.offset();
  
  		// Subtract element margins
  		// note: when an element has margin: auto the offsetLeft and marginLeft
  		// are the same in Safari causing offset.left to incorrectly be 0
  		offset.top  -= parseFloat( jQuery.css(elem, "marginTop") ) || 0;
  		offset.left -= parseFloat( jQuery.css(elem, "marginLeft") ) || 0;
  
  		// Add offsetParent borders
  		parentOffset.top  += parseFloat( jQuery.css(offsetParent[0], "borderTopWidth") ) || 0;
  		parentOffset.left += parseFloat( jQuery.css(offsetParent[0], "borderLeftWidth") ) || 0;
  
  		// Subtract the two offsets
  		return {
  			top:  offset.top  - parentOffset.top,
  			left: offset.left - parentOffset.left
  		};
  	},
  
  	offsetParent: function() {
  		return this.map(function() {
  			var offsetParent = this.offsetParent || document.body;
  			while ( offsetParent && (!rroot.test(offsetParent.nodeName) && jQuery.css(offsetParent, "position") === "static") ) {
  				offsetParent = offsetParent.offsetParent;
  			}
  			return offsetParent;
  		});
  	}
  });
  
  
  // Create scrollLeft and scrollTop methods
  jQuery.each( ["Left", "Top"], function( i, name ) {
  	var method = "scroll" + name;
  
  	jQuery.fn[ method ] = function( val ) {
  		var elem, win;
  
  		if ( val === undefined ) {
  			elem = this[ 0 ];
  
  			if ( !elem ) {
  				return null;
  			}
  
  			win = getWindow( elem );
  
  			// Return the scroll offset
  			return win ? ("pageXOffset" in win) ? win[ i ? "pageYOffset" : "pageXOffset" ] :
  				jQuery.support.boxModel && win.document.documentElement[ method ] ||
  					win.document.body[ method ] :
  				elem[ method ];
  		}
  
  		// Set the scroll offset
  		return this.each(function() {
  			win = getWindow( this );
  
  			if ( win ) {
  				win.scrollTo(
  					!i ? val : jQuery( win ).scrollLeft(),
  					 i ? val : jQuery( win ).scrollTop()
  				);
  
  			} else {
  				this[ method ] = val;
  			}
  		});
  	};
  });
  
  function getWindow( elem ) {
  	return jQuery.isWindow( elem ) ?
  		elem :
  		elem.nodeType === 9 ?
  			elem.defaultView || elem.parentWindow :
  			false;
  }
  
  
  
  
  // Create innerHeight, innerWidth, outerHeight and outerWidth methods
  jQuery.each([ "Height", "Width" ], function( i, name ) {
  
  	var type = name.toLowerCase();
  
  	// innerHeight and innerWidth
  	jQuery.fn["inner" + name] = function() {
  		return this[0] ?
  			parseFloat( jQuery.css( this[0], type, "padding" ) ) :
  			null;
  	};
  
  	// outerHeight and outerWidth
  	jQuery.fn["outer" + name] = function( margin ) {
  		return this[0] ?
  			parseFloat( jQuery.css( this[0], type, margin ? "margin" : "border" ) ) :
  			null;
  	};
  
  	jQuery.fn[ type ] = function( size ) {
  		// Get window width or height
  		var elem = this[0];
  		if ( !elem ) {
  			return size == null ? null : this;
  		}
  
  		if ( jQuery.isFunction( size ) ) {
  			return this.each(function( i ) {
  				var self = jQuery( this );
  				self[ type ]( size.call( this, i, self[ type ]() ) );
  			});
  		}
  
  		if ( jQuery.isWindow( elem ) ) {
  			// Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
  			// 3rd condition allows Nokia support, as it supports the docElem prop but not CSS1Compat
  			var docElemProp = elem.document.documentElement[ "client" + name ];
  			return elem.document.compatMode === "CSS1Compat" && docElemProp ||
  				elem.document.body[ "client" + name ] || docElemProp;
  
  		// Get document width or height
  		} else if ( elem.nodeType === 9 ) {
  			// Either scroll[Width/Height] or offset[Width/Height], whichever is greater
  			return Math.max(
  				elem.documentElement["client" + name],
  				elem.body["scroll" + name], elem.documentElement["scroll" + name],
  				elem.body["offset" + name], elem.documentElement["offset" + name]
  			);
  
  		// Get or set width or height on the element
  		} else if ( size === undefined ) {
  			var orig = jQuery.css( elem, type ),
  				ret = parseFloat( orig );
  
  			return jQuery.isNaN( ret ) ? orig : ret;
  
  		// Set the width or height on the element (default to pixels if value is unitless)
  		} else {
  			return this.css( type, typeof size === "string" ? size : size + "px" );
  		}
  	};
  
  });
  
  
  window.jQuery = window.$ = jQuery;
  })(window);
  /*!
   * jQuery UI 1.8.12
   *
   * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
   * Dual licensed under the MIT or GPL Version 2 licenses.
   * http://jquery.org/license
   *
   * http://docs.jquery.com/UI
   */
  (function( $, undefined ) {
  
  // prevent duplicate loading
  // this is only a problem because we proxy existing functions
  // and we don't want to double proxy them
  $.ui = $.ui || {};
  if ( $.ui.version ) {
  	return;
  }
  
  $.extend( $.ui, {
  	version: "1.8.12",
  
  	keyCode: {
  		ALT: 18,
  		BACKSPACE: 8,
  		CAPS_LOCK: 20,
  		COMMA: 188,
  		COMMAND: 91,
  		COMMAND_LEFT: 91, // COMMAND
  		COMMAND_RIGHT: 93,
  		CONTROL: 17,
  		DELETE: 46,
  		DOWN: 40,
  		END: 35,
  		ENTER: 13,
  		ESCAPE: 27,
  		HOME: 36,
  		INSERT: 45,
  		LEFT: 37,
  		MENU: 93, // COMMAND_RIGHT
  		NUMPAD_ADD: 107,
  		NUMPAD_DECIMAL: 110,
  		NUMPAD_DIVIDE: 111,
  		NUMPAD_ENTER: 108,
  		NUMPAD_MULTIPLY: 106,
  		NUMPAD_SUBTRACT: 109,
  		PAGE_DOWN: 34,
  		PAGE_UP: 33,
  		PERIOD: 190,
  		RIGHT: 39,
  		SHIFT: 16,
  		SPACE: 32,
  		TAB: 9,
  		UP: 38,
  		WINDOWS: 91 // COMMAND
  	}
  });
  
  // plugins
  $.fn.extend({
  	_focus: $.fn.focus,
  	focus: function( delay, fn ) {
  		return typeof delay === "number" ?
  			this.each(function() {
  				var elem = this;
  				setTimeout(function() {
  					$( elem ).focus();
  					if ( fn ) {
  						fn.call( elem );
  					}
  				}, delay );
  			}) :
  			this._focus.apply( this, arguments );
  	},
  
  	scrollParent: function() {
  		var scrollParent;
  		if (($.browser.msie && (/(static|relative)/).test(this.css('position'))) || (/absolute/).test(this.css('position'))) {
  			scrollParent = this.parents().filter(function() {
  				return (/(relative|absolute|fixed)/).test($.curCSS(this,'position',1)) && (/(auto|scroll)/).test($.curCSS(this,'overflow',1)+$.curCSS(this,'overflow-y',1)+$.curCSS(this,'overflow-x',1));
  			}).eq(0);
  		} else {
  			scrollParent = this.parents().filter(function() {
  				return (/(auto|scroll)/).test($.curCSS(this,'overflow',1)+$.curCSS(this,'overflow-y',1)+$.curCSS(this,'overflow-x',1));
  			}).eq(0);
  		}
  
  		return (/fixed/).test(this.css('position')) || !scrollParent.length ? $(document) : scrollParent;
  	},
  
  	zIndex: function( zIndex ) {
  		if ( zIndex !== undefined ) {
  			return this.css( "zIndex", zIndex );
  		}
  
  		if ( this.length ) {
  			var elem = $( this[ 0 ] ), position, value;
  			while ( elem.length && elem[ 0 ] !== document ) {
  				// Ignore z-index if position is set to a value where z-index is ignored by the browser
  				// This makes behavior of this function consistent across browsers
  				// WebKit always returns auto if the element is positioned
  				position = elem.css( "position" );
  				if ( position === "absolute" || position === "relative" || position === "fixed" ) {
  					// IE returns 0 when zIndex is not specified
  					// other browsers return a string
  					// we ignore the case of nested elements with an explicit value of 0
  					// <div style="z-index: -10;"><div style="z-index: 0;"></div></div>
  					value = parseInt( elem.css( "zIndex" ), 10 );
  					if ( !isNaN( value ) && value !== 0 ) {
  						return value;
  					}
  				}
  				elem = elem.parent();
  			}
  		}
  
  		return 0;
  	},
  
  	disableSelection: function() {
  		return this.bind( ( $.support.selectstart ? "selectstart" : "mousedown" ) +
  			".ui-disableSelection", function( event ) {
  				event.preventDefault();
  			});
  	},
  
  	enableSelection: function() {
  		return this.unbind( ".ui-disableSelection" );
  	}
  });
  
  $.each( [ "Width", "Height" ], function( i, name ) {
  	var side = name === "Width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ],
  		type = name.toLowerCase(),
  		orig = {
  			innerWidth: $.fn.innerWidth,
  			innerHeight: $.fn.innerHeight,
  			outerWidth: $.fn.outerWidth,
  			outerHeight: $.fn.outerHeight
  		};
  
  	function reduce( elem, size, border, margin ) {
  		$.each( side, function() {
  			size -= parseFloat( $.curCSS( elem, "padding" + this, true) ) || 0;
  			if ( border ) {
  				size -= parseFloat( $.curCSS( elem, "border" + this + "Width", true) ) || 0;
  			}
  			if ( margin ) {
  				size -= parseFloat( $.curCSS( elem, "margin" + this, true) ) || 0;
  			}
  		});
  		return size;
  	}
  
  	$.fn[ "inner" + name ] = function( size ) {
  		if ( size === undefined ) {
  			return orig[ "inner" + name ].call( this );
  		}
  
  		return this.each(function() {
  			$( this ).css( type, reduce( this, size ) + "px" );
  		});
  	};
  
  	$.fn[ "outer" + name] = function( size, margin ) {
  		if ( typeof size !== "number" ) {
  			return orig[ "outer" + name ].call( this, size );
  		}
  
  		return this.each(function() {
  			$( this).css( type, reduce( this, size, true, margin ) + "px" );
  		});
  	};
  });
  
  // selectors
  function visible( element ) {
  	return !$( element ).parents().andSelf().filter(function() {
  		return $.curCSS( this, "visibility" ) === "hidden" ||
  			$.expr.filters.hidden( this );
  	}).length;
  }
  
  $.extend( $.expr[ ":" ], {
  	data: function( elem, i, match ) {
  		return !!$.data( elem, match[ 3 ] );
  	},
  
  	focusable: function( element ) {
  		var nodeName = element.nodeName.toLowerCase(),
  			tabIndex = $.attr( element, "tabindex" );
  		if ( "area" === nodeName ) {
  			var map = element.parentNode,
  				mapName = map.name,
  				img;
  			if ( !element.href || !mapName || map.nodeName.toLowerCase() !== "map" ) {
  				return false;
  			}
  			img = $( "img[usemap=#" + mapName + "]" )[0];
  			return !!img && visible( img );
  		}
  		return ( /input|select|textarea|button|object/.test( nodeName )
  			? !element.disabled
  			: "a" == nodeName
  				? element.href || !isNaN( tabIndex )
  				: !isNaN( tabIndex ))
  			// the element and all of its ancestors must be visible
  			&& visible( element );
  	},
  
  	tabbable: function( element ) {
  		var tabIndex = $.attr( element, "tabindex" );
  		return ( isNaN( tabIndex ) || tabIndex >= 0 ) && $( element ).is( ":focusable" );
  	}
  });
  
  // support
  $(function() {
  	var body = document.body,
  		div = body.appendChild( div = document.createElement( "div" ) );
  
  	$.extend( div.style, {
  		minHeight: "100px",
  		height: "auto",
  		padding: 0,
  		borderWidth: 0
  	});
  
  	$.support.minHeight = div.offsetHeight === 100;
  	$.support.selectstart = "onselectstart" in div;
  
  	// set display to none to avoid a layout bug in IE
  	// http://dev.jquery.com/ticket/4014
  	body.removeChild( div ).style.display = "none";
  });
  
  
  
  
  
  // deprecated
  $.extend( $.ui, {
  	// $.ui.plugin is deprecated.  Use the proxy pattern instead.
  	plugin: {
  		add: function( module, option, set ) {
  			var proto = $.ui[ module ].prototype;
  			for ( var i in set ) {
  				proto.plugins[ i ] = proto.plugins[ i ] || [];
  				proto.plugins[ i ].push( [ option, set[ i ] ] );
  			}
  		},
  		call: function( instance, name, args ) {
  			var set = instance.plugins[ name ];
  			if ( !set || !instance.element[ 0 ].parentNode ) {
  				return;
  			}
  	
  			for ( var i = 0; i < set.length; i++ ) {
  				if ( instance.options[ set[ i ][ 0 ] ] ) {
  					set[ i ][ 1 ].apply( instance.element, args );
  				}
  			}
  		}
  	},
  	
  	// will be deprecated when we switch to jQuery 1.4 - use jQuery.contains()
  	contains: function( a, b ) {
  		return document.compareDocumentPosition ?
  			a.compareDocumentPosition( b ) & 16 :
  			a !== b && a.contains( b );
  	},
  	
  	// only used by resizable
  	hasScroll: function( el, a ) {
  	
  		//If overflow is hidden, the element might have extra content, but the user wants to hide it
  		if ( $( el ).css( "overflow" ) === "hidden") {
  			return false;
  		}
  	
  		var scroll = ( a && a === "left" ) ? "scrollLeft" : "scrollTop",
  			has = false;
  	
  		if ( el[ scroll ] > 0 ) {
  			return true;
  		}
  	
  		// TODO: determine which cases actually cause this to happen
  		// if the element doesn't have the scroll set, see if it's possible to
  		// set the scroll
  		el[ scroll ] = 1;
  		has = ( el[ scroll ] > 0 );
  		el[ scroll ] = 0;
  		return has;
  	},
  	
  	// these are odd functions, fix the API or move into individual plugins
  	isOverAxis: function( x, reference, size ) {
  		//Determines when x coordinate is over "b" element axis
  		return ( x > reference ) && ( x < ( reference + size ) );
  	},
  	isOver: function( y, x, top, left, height, width ) {
  		//Determines when x, y coordinates is over "b" element
  		return $.ui.isOverAxis( y, top, height ) && $.ui.isOverAxis( x, left, width );
  	}
  });
  
  })( jQuery );
  /*!
   * jQuery UI Widget 1.8.12
   *
   * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
   * Dual licensed under the MIT or GPL Version 2 licenses.
   * http://jquery.org/license
   *
   * http://docs.jquery.com/UI/Widget
   */
  (function( $, undefined ) {
  
  // jQuery 1.4+
  if ( $.cleanData ) {
  	var _cleanData = $.cleanData;
  	$.cleanData = function( elems ) {
  		for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
  			$( elem ).triggerHandler( "remove" );
  		}
  		_cleanData( elems );
  	};
  } else {
  	var _remove = $.fn.remove;
  	$.fn.remove = function( selector, keepData ) {
  		return this.each(function() {
  			if ( !keepData ) {
  				if ( !selector || $.filter( selector, [ this ] ).length ) {
  					$( "*", this ).add( [ this ] ).each(function() {
  						$( this ).triggerHandler( "remove" );
  					});
  				}
  			}
  			return _remove.call( $(this), selector, keepData );
  		});
  	};
  }
  
  $.widget = function( name, base, prototype ) {
  	var namespace = name.split( "." )[ 0 ],
  		fullName;
  	name = name.split( "." )[ 1 ];
  	fullName = namespace + "-" + name;
  
  	if ( !prototype ) {
  		prototype = base;
  		base = $.Widget;
  	}
  
  	// create selector for plugin
  	$.expr[ ":" ][ fullName ] = function( elem ) {
  		return !!$.data( elem, name );
  	};
  
  	$[ namespace ] = $[ namespace ] || {};
  	$[ namespace ][ name ] = function( options, element ) {
  		// allow instantiation without initializing for simple inheritance
  		if ( arguments.length ) {
  			this._createWidget( options, element );
  		}
  	};
  
  	var basePrototype = new base();
  	// we need to make the options hash a property directly on the new instance
  	// otherwise we'll modify the options hash on the prototype that we're
  	// inheriting from
  //	$.each( basePrototype, function( key, val ) {
  //		if ( $.isPlainObject(val) ) {
  //			basePrototype[ key ] = $.extend( {}, val );
  //		}
  //	});
  	basePrototype.options = $.extend( true, {}, basePrototype.options );
  	$[ namespace ][ name ].prototype = $.extend( true, basePrototype, {
  		namespace: namespace,
  		widgetName: name,
  		widgetEventPrefix: $[ namespace ][ name ].prototype.widgetEventPrefix || name,
  		widgetBaseClass: fullName
  	}, prototype );
  
  	$.widget.bridge( name, $[ namespace ][ name ] );
  };
  
  $.widget.bridge = function( name, object ) {
  	$.fn[ name ] = function( options ) {
  		var isMethodCall = typeof options === "string",
  			args = Array.prototype.slice.call( arguments, 1 ),
  			returnValue = this;
  
  		// allow multiple hashes to be passed on init
  		options = !isMethodCall && args.length ?
  			$.extend.apply( null, [ true, options ].concat(args) ) :
  			options;
  
  		// prevent calls to internal methods
  		if ( isMethodCall && options.charAt( 0 ) === "_" ) {
  			return returnValue;
  		}
  
  		if ( isMethodCall ) {
  			this.each(function() {
  				var instance = $.data( this, name ),
  					methodValue = instance && $.isFunction( instance[options] ) ?
  						instance[ options ].apply( instance, args ) :
  						instance;
  				// TODO: add this back in 1.9 and use $.error() (see #5972)
  //				if ( !instance ) {
  //					throw "cannot call methods on " + name + " prior to initialization; " +
  //						"attempted to call method '" + options + "'";
  //				}
  //				if ( !$.isFunction( instance[options] ) ) {
  //					throw "no such method '" + options + "' for " + name + " widget instance";
  //				}
  //				var methodValue = instance[ options ].apply( instance, args );
  				if ( methodValue !== instance && methodValue !== undefined ) {
  					returnValue = methodValue;
  					return false;
  				}
  			});
  		} else {
  			this.each(function() {
  				var instance = $.data( this, name );
  				if ( instance ) {
  					instance.option( options || {} )._init();
  				} else {
  					$.data( this, name, new object( options, this ) );
  				}
  			});
  		}
  
  		return returnValue;
  	};
  };
  
  $.Widget = function( options, element ) {
  	// allow instantiation without initializing for simple inheritance
  	if ( arguments.length ) {
  		this._createWidget( options, element );
  	}
  };
  
  $.Widget.prototype = {
  	widgetName: "widget",
  	widgetEventPrefix: "",
  	options: {
  		disabled: false
  	},
  	_createWidget: function( options, element ) {
  		// $.widget.bridge stores the plugin instance, but we do it anyway
  		// so that it's stored even before the _create function runs
  		$.data( element, this.widgetName, this );
  		this.element = $( element );
  		this.options = $.extend( true, {},
  			this.options,
  			this._getCreateOptions(),
  			options );
  
  		var self = this;
  		this.element.bind( "remove." + this.widgetName, function() {
  			self.destroy();
  		});
  
  		this._create();
  		this._trigger( "create" );
  		this._init();
  	},
  	_getCreateOptions: function() {
  		return $.metadata && $.metadata.get( this.element[0] )[ this.widgetName ];
  	},
  	_create: function() {},
  	_init: function() {},
  
  	destroy: function() {
  		this.element
  			.unbind( "." + this.widgetName )
  			.removeData( this.widgetName );
  		this.widget()
  			.unbind( "." + this.widgetName )
  			.removeAttr( "aria-disabled" )
  			.removeClass(
  				this.widgetBaseClass + "-disabled " +
  				"ui-state-disabled" );
  	},
  
  	widget: function() {
  		return this.element;
  	},
  
  	option: function( key, value ) {
  		var options = key;
  
  		if ( arguments.length === 0 ) {
  			// don't return a reference to the internal hash
  			return $.extend( {}, this.options );
  		}
  
  		if  (typeof key === "string" ) {
  			if ( value === undefined ) {
  				return this.options[ key ];
  			}
  			options = {};
  			options[ key ] = value;
  		}
  
  		this._setOptions( options );
  
  		return this;
  	},
  	_setOptions: function( options ) {
  		var self = this;
  		$.each( options, function( key, value ) {
  			self._setOption( key, value );
  		});
  
  		return this;
  	},
  	_setOption: function( key, value ) {
  		this.options[ key ] = value;
  
  		if ( key === "disabled" ) {
  			this.widget()
  				[ value ? "addClass" : "removeClass"](
  					this.widgetBaseClass + "-disabled" + " " +
  					"ui-state-disabled" )
  				.attr( "aria-disabled", value );
  		}
  
  		return this;
  	},
  
  	enable: function() {
  		return this._setOption( "disabled", false );
  	},
  	disable: function() {
  		return this._setOption( "disabled", true );
  	},
  
  	_trigger: function( type, event, data ) {
  		var callback = this.options[ type ];
  
  		event = $.Event( event );
  		event.type = ( type === this.widgetEventPrefix ?
  			type :
  			this.widgetEventPrefix + type ).toLowerCase();
  		data = data || {};
  
  		// copy original event properties over to the new event
  		// this would happen if we could call $.event.fix instead of $.Event
  		// but we don't have a way to force an event to be fixed multiple times
  		if ( event.originalEvent ) {
  			for ( var i = $.event.props.length, prop; i; ) {
  				prop = $.event.props[ --i ];
  				event[ prop ] = event.originalEvent[ prop ];
  			}
  		}
  
  		this.element.trigger( event, data );
  
  		return !( $.isFunction(callback) &&
  			callback.call( this.element[0], event, data ) === false ||
  			event.isDefaultPrevented() );
  	}
  };
  
  })( jQuery );
  /*!
   * jQuery UI Mouse 1.8.12
   *
   * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
   * Dual licensed under the MIT or GPL Version 2 licenses.
   * http://jquery.org/license
   *
   * http://docs.jquery.com/UI/Mouse
   *
   * Depends:
   *	jquery.ui.widget.js
   */
  (function( $, undefined ) {
  
  $.widget("ui.mouse", {
  	options: {
  		cancel: ':input,option',
  		distance: 1,
  		delay: 0
  	},
  	_mouseInit: function() {
  		var self = this;
  
  		this.element
  			.bind('mousedown.'+this.widgetName, function(event) {
  				return self._mouseDown(event);
  			})
  			.bind('click.'+this.widgetName, function(event) {
  				if (true === $.data(event.target, self.widgetName + '.preventClickEvent')) {
  				    $.removeData(event.target, self.widgetName + '.preventClickEvent');
  					event.stopImmediatePropagation();
  					return false;
  				}
  			});
  
  		this.started = false;
  	},
  
  	// TODO: make sure destroying one instance of mouse doesn't mess with
  	// other instances of mouse
  	_mouseDestroy: function() {
  		this.element.unbind('.'+this.widgetName);
  	},
  
  	_mouseDown: function(event) {
  		// don't let more than one widget handle mouseStart
  		// TODO: figure out why we have to use originalEvent
  		event.originalEvent = event.originalEvent || {};
  		if (event.originalEvent.mouseHandled) { return; }
  
  		// we may have missed mouseup (out of window)
  		(this._mouseStarted && this._mouseUp(event));
  
  		this._mouseDownEvent = event;
  
  		var self = this,
  			btnIsLeft = (event.which == 1),
  			elIsCancel = (typeof this.options.cancel == "string" ? $(event.target).parents().add(event.target).filter(this.options.cancel).length : false);
  		if (!btnIsLeft || elIsCancel || !this._mouseCapture(event)) {
  			return true;
  		}
  
  		this.mouseDelayMet = !this.options.delay;
  		if (!this.mouseDelayMet) {
  			this._mouseDelayTimer = setTimeout(function() {
  				self.mouseDelayMet = true;
  			}, this.options.delay);
  		}
  
  		if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
  			this._mouseStarted = (this._mouseStart(event) !== false);
  			if (!this._mouseStarted) {
  				event.preventDefault();
  				return true;
  			}
  		}
  
  		// Click event may never have fired (Gecko & Opera)
  		if (true === $.data(event.target, this.widgetName + '.preventClickEvent')) {
  			$.removeData(event.target, this.widgetName + '.preventClickEvent');
  		}
  
  		// these delegates are required to keep context
  		this._mouseMoveDelegate = function(event) {
  			return self._mouseMove(event);
  		};
  		this._mouseUpDelegate = function(event) {
  			return self._mouseUp(event);
  		};
  		$(document)
  			.bind('mousemove.'+this.widgetName, this._mouseMoveDelegate)
  			.bind('mouseup.'+this.widgetName, this._mouseUpDelegate);
  
  		event.preventDefault();
  		event.originalEvent.mouseHandled = true;
  		return true;
  	},
  
  	_mouseMove: function(event) {
  		// IE mouseup check - mouseup happened when mouse was out of window
  		if ($.browser.msie && !(document.documentMode >= 9) && !event.button) {
  			return this._mouseUp(event);
  		}
  
  		if (this._mouseStarted) {
  			this._mouseDrag(event);
  			return event.preventDefault();
  		}
  
  		if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
  			this._mouseStarted =
  				(this._mouseStart(this._mouseDownEvent, event) !== false);
  			(this._mouseStarted ? this._mouseDrag(event) : this._mouseUp(event));
  		}
  
  		return !this._mouseStarted;
  	},
  
  	_mouseUp: function(event) {
  		$(document)
  			.unbind('mousemove.'+this.widgetName, this._mouseMoveDelegate)
  			.unbind('mouseup.'+this.widgetName, this._mouseUpDelegate);
  
  		if (this._mouseStarted) {
  			this._mouseStarted = false;
  
  			if (event.target == this._mouseDownEvent.target) {
  			    $.data(event.target, this.widgetName + '.preventClickEvent', true);
  			}
  
  			this._mouseStop(event);
  		}
  
  		return false;
  	},
  
  	_mouseDistanceMet: function(event) {
  		return (Math.max(
  				Math.abs(this._mouseDownEvent.pageX - event.pageX),
  				Math.abs(this._mouseDownEvent.pageY - event.pageY)
  			) >= this.options.distance
  		);
  	},
  
  	_mouseDelayMet: function(event) {
  		return this.mouseDelayMet;
  	},
  
  	// These are placeholder methods, to be overriden by extending plugin
  	_mouseStart: function(event) {},
  	_mouseDrag: function(event) {},
  	_mouseStop: function(event) {},
  	_mouseCapture: function(event) { return true; }
  });
  
  })(jQuery);
  /*
   * jQuery UI Position 1.8.12
   *
   * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
   * Dual licensed under the MIT or GPL Version 2 licenses.
   * http://jquery.org/license
   *
   * http://docs.jquery.com/UI/Position
   */
  (function( $, undefined ) {
  
  $.ui = $.ui || {};
  
  var horizontalPositions = /left|center|right/,
  	verticalPositions = /top|center|bottom/,
  	center = "center",
  	_position = $.fn.position,
  	_offset = $.fn.offset;
  
  $.fn.position = function( options ) {
  	if ( !options || !options.of ) {
  		return _position.apply( this, arguments );
  	}
  
  	// make a copy, we don't want to modify arguments
  	options = $.extend( {}, options );
  
  	var target = $( options.of ),
  		targetElem = target[0],
  		collision = ( options.collision || "flip" ).split( " " ),
  		offset = options.offset ? options.offset.split( " " ) : [ 0, 0 ],
  		targetWidth,
  		targetHeight,
  		basePosition;
  
  	if ( targetElem.nodeType === 9 ) {
  		targetWidth = target.width();
  		targetHeight = target.height();
  		basePosition = { top: 0, left: 0 };
  	// TODO: use $.isWindow() in 1.9
  	} else if ( targetElem.setTimeout ) {
  		targetWidth = target.width();
  		targetHeight = target.height();
  		basePosition = { top: target.scrollTop(), left: target.scrollLeft() };
  	} else if ( targetElem.preventDefault ) {
  		// force left top to allow flipping
  		options.at = "left top";
  		targetWidth = targetHeight = 0;
  		basePosition = { top: options.of.pageY, left: options.of.pageX };
  	} else {
  		targetWidth = target.outerWidth();
  		targetHeight = target.outerHeight();
  		basePosition = target.offset();
  	}
  
  	// force my and at to have valid horizontal and veritcal positions
  	// if a value is missing or invalid, it will be converted to center 
  	$.each( [ "my", "at" ], function() {
  		var pos = ( options[this] || "" ).split( " " );
  		if ( pos.length === 1) {
  			pos = horizontalPositions.test( pos[0] ) ?
  				pos.concat( [center] ) :
  				verticalPositions.test( pos[0] ) ?
  					[ center ].concat( pos ) :
  					[ center, center ];
  		}
  		pos[ 0 ] = horizontalPositions.test( pos[0] ) ? pos[ 0 ] : center;
  		pos[ 1 ] = verticalPositions.test( pos[1] ) ? pos[ 1 ] : center;
  		options[ this ] = pos;
  	});
  
  	// normalize collision option
  	if ( collision.length === 1 ) {
  		collision[ 1 ] = collision[ 0 ];
  	}
  
  	// normalize offset option
  	offset[ 0 ] = parseInt( offset[0], 10 ) || 0;
  	if ( offset.length === 1 ) {
  		offset[ 1 ] = offset[ 0 ];
  	}
  	offset[ 1 ] = parseInt( offset[1], 10 ) || 0;
  
  	if ( options.at[0] === "right" ) {
  		basePosition.left += targetWidth;
  	} else if ( options.at[0] === center ) {
  		basePosition.left += targetWidth / 2;
  	}
  
  	if ( options.at[1] === "bottom" ) {
  		basePosition.top += targetHeight;
  	} else if ( options.at[1] === center ) {
  		basePosition.top += targetHeight / 2;
  	}
  
  	basePosition.left += offset[ 0 ];
  	basePosition.top += offset[ 1 ];
  
  	return this.each(function() {
  		var elem = $( this ),
  			elemWidth = elem.outerWidth(),
  			elemHeight = elem.outerHeight(),
  			marginLeft = parseInt( $.curCSS( this, "marginLeft", true ) ) || 0,
  			marginTop = parseInt( $.curCSS( this, "marginTop", true ) ) || 0,
  			collisionWidth = elemWidth + marginLeft +
  				( parseInt( $.curCSS( this, "marginRight", true ) ) || 0 ),
  			collisionHeight = elemHeight + marginTop +
  				( parseInt( $.curCSS( this, "marginBottom", true ) ) || 0 ),
  			position = $.extend( {}, basePosition ),
  			collisionPosition;
  
  		if ( options.my[0] === "right" ) {
  			position.left -= elemWidth;
  		} else if ( options.my[0] === center ) {
  			position.left -= elemWidth / 2;
  		}
  
  		if ( options.my[1] === "bottom" ) {
  			position.top -= elemHeight;
  		} else if ( options.my[1] === center ) {
  			position.top -= elemHeight / 2;
  		}
  
  		// prevent fractions (see #5280)
  		position.left = Math.round( position.left );
  		position.top = Math.round( position.top );
  
  		collisionPosition = {
  			left: position.left - marginLeft,
  			top: position.top - marginTop
  		};
  
  		$.each( [ "left", "top" ], function( i, dir ) {
  			if ( $.ui.position[ collision[i] ] ) {
  				$.ui.position[ collision[i] ][ dir ]( position, {
  					targetWidth: targetWidth,
  					targetHeight: targetHeight,
  					elemWidth: elemWidth,
  					elemHeight: elemHeight,
  					collisionPosition: collisionPosition,
  					collisionWidth: collisionWidth,
  					collisionHeight: collisionHeight,
  					offset: offset,
  					my: options.my,
  					at: options.at
  				});
  			}
  		});
  
  		if ( $.fn.bgiframe ) {
  			elem.bgiframe();
  		}
  		elem.offset( $.extend( position, { using: options.using } ) );
  	});
  };
  
  $.ui.position = {
  	fit: {
  		left: function( position, data ) {
  			var win = $( window ),
  				over = data.collisionPosition.left + data.collisionWidth - win.width() - win.scrollLeft();
  			position.left = over > 0 ? position.left - over : Math.max( position.left - data.collisionPosition.left, position.left );
  		},
  		top: function( position, data ) {
  			var win = $( window ),
  				over = data.collisionPosition.top + data.collisionHeight - win.height() - win.scrollTop();
  			position.top = over > 0 ? position.top - over : Math.max( position.top - data.collisionPosition.top, position.top );
  		}
  	},
  
  	flip: {
  		left: function( position, data ) {
  			if ( data.at[0] === center ) {
  				return;
  			}
  			var win = $( window ),
  				over = data.collisionPosition.left + data.collisionWidth - win.width() - win.scrollLeft(),
  				myOffset = data.my[ 0 ] === "left" ?
  					-data.elemWidth :
  					data.my[ 0 ] === "right" ?
  						data.elemWidth :
  						0,
  				atOffset = data.at[ 0 ] === "left" ?
  					data.targetWidth :
  					-data.targetWidth,
  				offset = -2 * data.offset[ 0 ];
  			position.left += data.collisionPosition.left < 0 ?
  				myOffset + atOffset + offset :
  				over > 0 ?
  					myOffset + atOffset + offset :
  					0;
  		},
  		top: function( position, data ) {
  			if ( data.at[1] === center ) {
  				return;
  			}
  			var win = $( window ),
  				over = data.collisionPosition.top + data.collisionHeight - win.height() - win.scrollTop(),
  				myOffset = data.my[ 1 ] === "top" ?
  					-data.elemHeight :
  					data.my[ 1 ] === "bottom" ?
  						data.elemHeight :
  						0,
  				atOffset = data.at[ 1 ] === "top" ?
  					data.targetHeight :
  					-data.targetHeight,
  				offset = -2 * data.offset[ 1 ];
  			position.top += data.collisionPosition.top < 0 ?
  				myOffset + atOffset + offset :
  				over > 0 ?
  					myOffset + atOffset + offset :
  					0;
  		}
  	}
  };
  
  // offset setter from jQuery 1.4
  if ( !$.offset.setOffset ) {
  	$.offset.setOffset = function( elem, options ) {
  		// set position first, in-case top/left are set even on static elem
  		if ( /static/.test( $.curCSS( elem, "position" ) ) ) {
  			elem.style.position = "relative";
  		}
  		var curElem   = $( elem ),
  			curOffset = curElem.offset(),
  			curTop    = parseInt( $.curCSS( elem, "top",  true ), 10 ) || 0,
  			curLeft   = parseInt( $.curCSS( elem, "left", true ), 10)  || 0,
  			props     = {
  				top:  (options.top  - curOffset.top)  + curTop,
  				left: (options.left - curOffset.left) + curLeft
  			};
  		
  		if ( 'using' in options ) {
  			options.using.call( elem, props );
  		} else {
  			curElem.css( props );
  		}
  	};
  
  	$.fn.offset = function( options ) {
  		var elem = this[ 0 ];
  		if ( !elem || !elem.ownerDocument ) { return null; }
  		if ( options ) { 
  			return this.each(function() {
  				$.offset.setOffset( this, options );
  			});
  		}
  		return _offset.call( this );
  	};
  }
  
  }( jQuery ));
  /*!
   * Fluid Infusion v1.5
   *
   * Infusion is distributed under the Educational Community License 2.0 and new BSD licenses: 
   * http://wiki.fluidproject.org/display/fluid/Fluid+Licensing
   *
   * For information on copyright, see the individual Infusion source code files: 
   * https://github.com/fluid-project/infusion/
   */
  
  /*
  Copyright 2007-2010 University of Cambridge
  Copyright 2007-2009 University of Toronto
  Copyright 2007-2009 University of California, Berkeley
  Copyright 2010-2011 Lucendo Development Ltd.
  Copyright 2010 OCAD University
  Copyright 2011 Charly Molter
  
  Licensed under the Educational Community License (ECL), Version 2.0 or the New
  BSD license. You may not use this file except in compliance with one these
  Licenses.
  
  You may obtain a copy of the ECL 2.0 License and BSD License at
  https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
  */
  
  // Declare dependencies
  /*global console, window, fluid:true, fluid_1_5:true, jQuery, opera, YAHOO*/
  
  // JSLint options 
  /*jslint white: true, funcinvoke: true, continue: true, jslintok: true, undef: true, newcap: true, nomen: true, regexp: true, bitwise: true, browser: true, forin: true, maxerr: 100, indent: 4 */
  
  var fluid_1_5 = fluid_1_5 || {};
  var fluid = fluid || fluid_1_5;
  
  (function ($, fluid) {
      
      fluid.version = "Infusion 1.5";
      
      // Export this for use in environments like node.js, where it is useful for
      // configuring stack trace behaviour
      fluid.Error = Error;
      
      fluid.environment = {
          fluid: fluid
      };
      
      var globalObject = window || {};
      
      fluid.singleThreadLocal = function(initFunc) {
          var value = initFunc();
          return function() {
              return value;
          };
      };
      
      // Return to the old strategy of monkey-patching this, since this is a most frequently used function within IoC    
      fluid.threadLocal = fluid.singleThreadLocal;
      
      var softFailure = [false];
      
      // This function will be patched from FluidIoC.js in order to describe complex activities
      fluid.describeActivity = function () {
          return [];
      };
      
      /**
       * Causes an error message to be logged to the console and a real runtime error to be thrown.
       * 
       * @param {String|Error} message the error message to log
       * @param ... Additional arguments
       */
      fluid.fail = function (message /*, ... */) { // jslint:ok - whitespace in arg list
          fluid.setLogging(true);
          fluid.log.apply(null, ["ASSERTION FAILED: "].concat(fluid.makeArray(arguments)).concat(fluid.describeActivity()));
          if (softFailure[0]) {
              throw new Error(message);
          } else {
              message.fail(); // Intentionally cause a browser error by invoking a nonexistent function.
          }
      };
      
      fluid.pushSoftFailure = function (condition) {
          if (typeof (condition) === "boolean") {
              softFailure.unshift(condition);
          } else if (condition === -1) {
              softFailure.shift();
          }
      };
      
      fluid.notrycatch = false;
      
      // A wrapper for the try/catch/finally language feature, to aid debugging on environments
      // such as IE, where any try will destroy stack information for errors
      fluid.tryCatch = function (tryfun, catchfun, finallyfun) {
          finallyfun = finallyfun || fluid.identity;
          if (fluid.notrycatch) {
              var togo = tryfun();
              finallyfun();
              return togo;
          } else {
              try {
                  return tryfun();  
              } catch (e) {
                  if (catchfun) {
                      catchfun(e);
                  } else { 
                      throw (e);
                  }
              } finally {
                  finallyfun();
              }
          }
      };
      
      // TODO: rescued from kettleCouchDB.js - clean up in time
      fluid.expect = function (name, members, target) {
          fluid.transform(fluid.makeArray(members), function (key) {
              if (typeof target[key] === "undefined") {
                  fluid.fail(name + " missing required parameter " + key);
              }
          });
      };
  
      // Logging
  
      var logging;
          
      /** Returns whether logging is enabled **/
      fluid.isLogging = function () {
          return logging;
      };
  
      /** method to allow user to enable logging (off by default) */
      fluid.setLogging = function (enabled) {
          if (typeof enabled === "boolean") {
              logging = enabled;
          } else {
              logging = false;
          }
      };
  
      // On some dodgy environments (notably IE9 and recent alphas of Firebug 1.8), 
      // console.log/debug are incomplete function objects and need to be operated via
      // this trick: http://stackoverflow.com/questions/5472938/does-ie9-support-console-log-and-is-it-a-real-function
      fluid.applyHostFunction = function (obj, func, args) {
          if (func.apply) {
              func.apply(obj, args);
          } else {
              var applier = Function.prototype.bind.call(func, obj);
              applier.apply(obj, args);
          }
      };
  
      /** Log a message to a suitable environmental console. If the standard "console" 
       * stream is available, the message will be sent there - otherwise either the
       * YAHOO logger or the Opera "postError" stream will be used. Logging must first
       * be enabled with a call to the fluid.setLogging(true) function.
       */
      fluid.log = function (message /*, ... */) { // jslint:ok - whitespace in arg list
          if (logging) {
              var arg0 = fluid.renderTimestamp(new Date()) + ":  "; 
              var args = [arg0].concat(fluid.makeArray(arguments));
              var str = args.join("");
              if (typeof (console) !== "undefined") {
                  if (console.debug) {
                      fluid.applyHostFunction(console, console.debug, args);
                  } else if (typeof (console.log) === "function") {
                      fluid.applyHostFunction(console, console.log, args);
                  } else {
                      console.log(str); // this branch executes on old IE, fully synthetic console.log
                  }
              } else if (typeof (YAHOO) !== "undefined") {
                  YAHOO.log(str);
              } else if (typeof (opera) !== "undefined") {
                  opera.postError(str);
              }
          }
      };
       
      // Functional programming utilities.
                 
      /** A basic utility that returns its argument unchanged */
      
      fluid.identity = function (arg) {
          return arg;
      };
      
      // Framework and instantiation functions.
  
      
      /** Returns true if the argument is a value other than null or undefined **/
      fluid.isValue = function (value) {
          return value !== undefined && value !== null;
      };
      
      /** Returns true if the argument is a primitive type **/
      fluid.isPrimitive = function (value) {
          var valueType = typeof (value);
          return !value || valueType === "string" || valueType === "boolean" || valueType === "number" || valueType === "function";
      };
      
      /** Determines whether the supplied object is an array. The strategy used is an optimised
       * approach taken from an earlier version of jQuery - detecting whether the toString() version
       * of the object agrees with the textual form [object Array], or else whether the object is a 
       * jQuery object (the most common source of "fake arrays").
       */
      fluid.isArrayable = function (totest) {
          return totest && (totest.jquery || Object.prototype.toString.call(totest) === "[object Array]");
      };
      
      fluid.isDOMNode = function (obj) {
        // This could be more sound, but messy: 
        // http://stackoverflow.com/questions/384286/javascript-isdom-how-do-you-check-if-a-javascript-object-is-a-dom-object
          return obj && typeof (obj.nodeType) === "number";  
      };
      
      /** Return an empty container as the same type as the argument (either an
       * array or hash */
      fluid.freshContainer = function (tocopy) {
          return fluid.isArrayable(tocopy) ? [] : {};   
      };
      
      /** Performs a deep copy (clone) of its argument **/
      
      fluid.copy = function (tocopy) {
          if (fluid.isPrimitive(tocopy)) {
              return tocopy;
          }
          return $.extend(true, fluid.freshContainer(tocopy), tocopy);
      };
              
      /** Corrected version of jQuery makeArray that returns an empty array on undefined rather than crashing.
        * We don't deal with as many pathological cases as jQuery **/
      fluid.makeArray = function (arg) {
          var togo = [];
          if (arg !== null && arg !== undefined) {
              if (fluid.isPrimitive(arg) || typeof(arg.length) !== "number") {
                  togo.push(arg); 
              }
              else {
                  for (var i = 0; i < arg.length; ++ i) {
                      togo[i] = arg[i];
                  }
              }
          }
          return togo;
      };
      
      function transformInternal(source, togo, key, args) {
          var transit = source[key];
          for (var j = 0; j < args.length - 1; ++j) {
              transit = args[j + 1](transit, key);
          }
          togo[key] = transit; 
      }
      
      /** Return a list or hash of objects, transformed by one or more functions. Similar to
       * jQuery.map, only will accept an arbitrary list of transformation functions and also
       * works on non-arrays.
       * @param source {Array or Object} The initial container of objects to be transformed.
       * @param fn1, fn2, etc. {Function} An arbitrary number of optional further arguments,
       * all of type Function, accepting the signature (object, index), where object is the
       * list member to be transformed, and index is its list index. Each function will be
       * applied in turn to each list member, which will be replaced by the return value
       * from the function.
       * @return The finally transformed list, where each member has been replaced by the
       * original member acted on by the function or functions.
       */
      fluid.transform = function (source) {
          var togo = fluid.freshContainer(source);
          if (fluid.isArrayable(source)) {
              for (var i = 0; i < source.length; ++i) {
                  transformInternal(source, togo, i, arguments);
              }
          } else {
              for (var key in source) {
                  transformInternal(source, togo, key, arguments);
              }
          }  
          return togo;
      };
      
      /** Better jQuery.each which works on hashes as well as having the arguments
       * the right way round. 
       * @param source {Arrayable or Object} The container to be iterated over
       * @param func {Function} A function accepting (value, key) for each iterated
       * object. This function may return a value to terminate the iteration
       */
      fluid.each = function (source, func) {
          if (fluid.isArrayable(source)) {
              for (var i = 0; i < source.length; ++i) {
                  func(source[i], i);
              }
          } else {
              for (var key in source) {
                  func(source[key], key);
              }
          }
      };
      
      /** Scan through a list or hash of objects, terminating on the first member which
       * matches a predicate function.
       * @param source {Arrayable or Object} The list or hash of objects to be searched.
       * @param func {Function} A predicate function, acting on a member. A predicate which
       * returns any value which is not <code>undefined</code> will terminate
       * the search. The function accepts (object, index).
       * @param deflt {Object} A value to be returned in the case no predicate function matches
       * a list member. The default will be the natural value of <code>undefined</code>
       * @return The first return value from the predicate function which is not <code>undefined</code>
       */
      fluid.find = function (source, func, deflt) {
          var disp;
          if (fluid.isArrayable(source)) {
              for (var i = 0; i < source.length; ++i) {
                  disp = func(source[i], i);
                  if (disp !== undefined) {
                      return disp;
                  }
              }
          } else {
              for (var key in source) {
                  disp = func(source[key], key);
                  if (disp !== undefined) {
                      return disp;
                  }
              }
          }
          return deflt;
      };
      
      /** Scan through a list of objects, "accumulating" a value over them 
       * (may be a straightforward "sum" or some other chained computation).
       * @param list {Array} The list of objects to be accumulated over.
       * @param fn {Function} An "accumulation function" accepting the signature (object, total, index) where
       * object is the list member, total is the "running total" object (which is the return value from the previous function),
       * and index is the index number.
       * @param arg {Object} The initial value for the "running total" object.
       * @return {Object} the final running total object as returned from the final invocation of the function on the last list member.
       */
      fluid.accumulate = function (list, fn, arg) {
          for (var i = 0; i < list.length; ++i) {
              arg = fn(list[i], arg, i);
          }
          return arg;
      };
      
      /** Can through a list of objects, removing those which match a predicate. Similar to
       * jQuery.grep, only acts on the list in-place by removal, rather than by creating
       * a new list by inclusion.
       * @param source {Array|Object} The list of objects to be scanned over.
       * @param fn {Function} A predicate function determining whether an element should be
       * removed. This accepts the standard signature (object, index) and returns a "truthy"
       * result in order to determine that the supplied object should be removed from the list.
       * @return The list, transformed by the operation of removing the matched elements. The
       * supplied list is modified by this operation.
       */
      fluid.remove_if = function (source, fn) {
          if (fluid.isArrayable(source)) {
              for (var i = 0; i < source.length; ++i) {
                  if (fn(source[i], i)) {
                      source.splice(i, 1);
                      --i;
                  }
              }
          } else {
              for (var key in source) {
                  if (fn(source[key], key)) {
                      delete source[key];
                  }
              }
          }
          return source;
      };
      
      /** Accepts an object to be filtered, and a list of keys. Either all keys not present in
       * the list are removed, or only keys present in the list are returned.
       * @param toFilter {Array|Object} The object to be filtered - this will be modified by the operation
       * @param keys {Array of String} The list of keys to operate with
       * @param exclude {boolean} If <code>true</code>, the keys listed are removed rather than included
       * @return the filtered object (the same object that was supplied as <code>toFilter</code>
       */
      
      fluid.filterKeys = function (toFilter, keys, exclude) {
          return fluid.remove_if($.extend({}, toFilter), function (value, key) {
              return exclude ^ ($.inArray(key, keys) === -1);
          });
      };
      
      /** A convenience wrapper for <code>fluid.filterKeys</code> with the parameter <code>exclude</code> set to <code>true</code>
       *  Returns the supplied object with listed keys removed */
  
      fluid.censorKeys = function (toCensor, keys) {
          return fluid.filterKeys(toCensor, keys, true);
      };
      
      fluid.makeFlatten = function (index) {
          return function (obj) {
              var togo = [];
              fluid.each(obj, function (value, key) {
                  togo.push(arguments[index]);
              });
              return togo;
          }; 
      };
      
      /** Return the keys in the supplied object as an array **/
      fluid.keys = fluid.makeFlatten(1); 
      
      /** Return the values in the supplied object as an array **/
      fluid.values = fluid.makeFlatten(0);
      
      /** 
       * Searches through the supplied object, and returns <code>true</code> if the supplied value
       * can be found 
       */
      fluid.contains = function (obj, value) {
          return obj ? fluid.find(obj, function (thisValue, key) {
              if (value === thisValue) {
                  return true;
              }
          }) : undefined;
      };
      
      /** 
       * Searches through the supplied object for the first value which matches the one supplied.
       * @param obj {Object} the Object to be searched through
       * @param value {Object} the value to be found. This will be compared against the object's
       * member using === equality.
       * @return {String} The first key whose value matches the one supplied, or <code>null</code> if no
       * such key is found.
       */
      fluid.keyForValue = function (obj, value) {
          return fluid.find(obj, function (thisValue, key) {
              if (value === thisValue) {
                  return key;
              }
          });
      };
      
      /**
       * This method is now deprecated and will be removed in a future release of Infusion. 
       * See fluid.keyForValue instead.
       */
      fluid.findKeyInObject = fluid.keyForValue;
      
      /** Converts an array into an object whose keys are the elements of the array, each with the value "true"
       */ 
      
      fluid.arrayToHash = function (array) {
          var togo = {};
          fluid.each(array, function (el) {
              togo[el] = true;
          });
          return togo;
      };
      
      /** 
       * Clears an object or array of its contents. For objects, each property is deleted.
       * 
       * @param {Object|Array} target the target to be cleared
       */
      fluid.clear = function (target) {
          if (fluid.isArrayable(target)) {
              target.length = 0;
          } else {
              for (var i in target) {
                  delete target[i];
              }
          }
      };
      
     /**
      * @param boolean ascending <code>true</code> if a comparator is to be returned which 
      * sorts strings in descending order of length
      */
      fluid.compareStringLength = function (ascending) {
          return ascending ? function (a, b) {
              return a.length - b.length;
          } : function (a, b) {
              return b.length - a.length;
          };
      };
          
      // Model functions
      fluid.model = {}; // cannot call registerNamespace yet since it depends on fluid.model
         
      /** Another special "marker object" representing that a distinguished 
       * (probably context-dependent) value should be substituted.
       */
      fluid.VALUE = {type: "fluid.marker", value: "VALUE"};
      
      /** Another special "marker object" representing that no value is present (where
       * signalling using the value "undefined" is not possible) */
      fluid.NO_VALUE = {type: "fluid.marker", value: "NO_VALUE"};
      
      /** A marker indicating that a value requires to be expanded after component construction begins **/
      fluid.EXPAND = {type: "fluid.marker", value: "EXPAND"};
      /** A marker indicating that a value requires to be expanded immediately**/
      fluid.EXPAND_NOW = {type: "fluid.marker", value: "EXPAND_NOW"};
      
      /** Determine whether an object is any marker, or a particular marker - omit the
       * 2nd argument to detect any marker
       */
      fluid.isMarker = function (totest, type) {
          if (!totest || typeof (totest) !== 'object' || totest.type !== "fluid.marker") {
              return false;
          }
          if (!type) {
              return true;
          }
          return totest === type;
      };
     
      /** Copy a source "model" onto a target **/
      fluid.model.copyModel = function (target, source) {
          fluid.clear(target);
          $.extend(true, target, source);
      };
      
      /** Parse an EL expression separated by periods (.) into its component segments.
       * @param {String} EL The EL expression to be split
       * @return {Array of String} the component path expressions.
       * TODO: This needs to be upgraded to handle (the same) escaping rules (as RSF), so that
       * path segments containing periods and backslashes etc. can be processed, and be harmonised
       * with the more complex implementations in fluid.pathUtil(data binding).
       */
      fluid.model.parseEL = function (EL) {
          return EL === "" ? [] : String(EL).split('.');
      };
      
      /** Compose an EL expression from two separate EL expressions. The returned 
       * expression will be the one that will navigate the first expression, and then
       * the second, from the value reached by the first. Either prefix or suffix may be
       * the empty string **/
      
      fluid.model.composePath = function (prefix, suffix) {
          return prefix === "" ? suffix : (suffix === "" ? prefix : prefix + "." + suffix);
      };
      
      /** Compose any number of path segments, none of which may be empty **/
      fluid.model.composeSegments = function () {
          return fluid.makeArray(arguments).join(".");
      };
      
      /** Helpful alias for old-style API **/
      fluid.path = fluid.model.composeSegments;
      fluid.composePath = fluid.model.composePath;
  
  
      // unsupported, NON-API function
      fluid.requireDataBinding = function () {
          fluid.fail("Please include DataBinding.js in order to operate complex model accessor configuration");  
      };
      
      fluid.model.trundle = fluid.model.getPenultimate = fluid.requireDataBinding;
      
      // unsupported, NON-API function
      fluid.model.resolvePathSegment = function (root, segment, create, origEnv) {
          if (!origEnv && root.resolvePathSegment) {
              return root.resolvePathSegment(segment);
          }
          if (create && root[segment] === undefined) {
              // This optimisation in this heavily used function has a fair effect
              return root[segment] = {};
          }
          return root[segment];
      };
      
      // unsupported, NON-API function
      fluid.model.getPenultimateSimple = function (root, EL, environment, create) {
          var origEnv = environment;
          var segs = fluid.model.parseEL(EL);
          for (var i = 0; i < segs.length - 1; ++i) {
              if (!root) {
                  return {root: root };
              }
              var segment = segs[i];
              if (environment && environment[segment]) {
                  root = environment[segment];
                  environment = null;
              } else {
                  root = fluid.model.resolvePathSegment(root, segment, create, origEnv);
              }
          }
          return {root: root, last: segs[segs.length - 1]};
      };
      
      fluid.model.setSimple = function (root, EL, newValue, environment) {
          var pen = fluid.model.getPenultimateSimple(root, EL, environment, true);
          pen.root[pen.last] = newValue;
      };
      
      /** Evaluates an EL expression by fetching a dot-separated list of members
       * recursively from a provided root.
       * @param root The root data structure in which the EL expression is to be evaluated
       * @param {string} EL The EL expression to be evaluated
       * @param environment An optional "environment" which, if it contains any members
       * at top level, will take priority over the root data structure.
       * @return The fetched data value.
       */
      
      fluid.model.getSimple = function (root, EL, environment) {
          if (EL === "" || EL === null || EL === undefined) {
              return root;
          }
          var pen = fluid.model.getPenultimateSimple(root, EL, environment);
          return pen.root ? pen.root[pen.last] : pen.root;
      };
      
      // unsupported, NON-API function
      // Returns undefined to signal complex configuration which needs to be farmed out to DataBinding.js
      // any other return represents an environment value AND a simple configuration we can handle here
      fluid.decodeAccessorArg = function (arg3) {
          return (!arg3 || arg3 === fluid.model.defaultGetConfig || arg3 === fluid.model.defaultSetConfig) ? 
              null : (arg3.type === "environment" ? arg3.value : undefined);
      };
      
      fluid.set = function (root, EL, newValue, config) {
          var env = fluid.decodeAccessorArg(config);
          if (env === undefined) {
              var trundler = fluid.model.getPenultimate(root, EL, config);
              trundler.root[trundler.last] = newValue;
          } else {
              fluid.model.setSimple(root, EL, newValue, env);
          }
      };
      
      /** Evaluates an EL expression by fetching a dot-separated list of members
       * recursively from a provided root.
       * @param root The root data structure in which the EL expression is to be evaluated
       * @param {string} EL The EL expression to be evaluated
       * @param environment An optional "environment" which, if it contains any members
       * at top level, will take priority over the root data structure.
       * @return The fetched data value.
       */
      
      fluid.get = function (root, EL, config) {
          var env = fluid.decodeAccessorArg(config);
          return env === undefined ? 
              fluid.model.trundle(root, EL, config).root 
              : fluid.model.getSimple(root, EL, env);
      };
  
      // This backward compatibility will be maintained for a number of releases, probably until Fluid 2.0
      fluid.model.setBeanValue = fluid.set;
      fluid.model.getBeanValue = fluid.get;
      
      fluid.getGlobalValue = function (path, env) {
          if (path) {
              env = env || fluid.environment;
              return fluid.get(globalObject, path, {type: "environment", value: env});
          }
      };
      
      /**
       * Allows for the calling of a function from an EL expression "functionPath", with the arguments "args", scoped to an framework version "environment".
       * @param {Object} functionPath - An EL expression
       * @param {Object} args - An array of arguments to be applied to the function, specified in functionPath
       * @param {Object} environment - (optional) The object to scope the functionPath to  (typically the framework root for version control)
       */
      fluid.invokeGlobalFunction = function (functionPath, args, environment) {
          var func = fluid.getGlobalValue(functionPath, environment);
          if (!func) {
              fluid.fail("Error invoking global function: " + functionPath + " could not be located");
          } else {
              return func.apply(null, args);
          }
      };
      
      /** Registers a new global function at a given path (currently assumes that
       * it lies within the fluid namespace)
       */
      
      fluid.registerGlobalFunction = function (functionPath, func, env) {
          env = env || fluid.environment;
          fluid.set(globalObject, functionPath, func, {type: "environment", value: env});
      };
      
      fluid.setGlobalValue = fluid.registerGlobalFunction;
      
      /** Ensures that an entry in the global namespace exists **/
      fluid.registerNamespace = function (naimspace, env) {
          env = env || fluid.environment;
          var existing = fluid.getGlobalValue(naimspace, env);
          if (!existing) {
              existing = {};
              fluid.setGlobalValue(naimspace, existing, env);
          }
          return existing;
      };
      
      // stubs for two functions in FluidDebugging.js
      fluid.dumpEl = fluid.identity;
      fluid.renderTimestamp = fluid.identity;
      
      
      /*** The Model Events system. ***/
      
      fluid.registerNamespace("fluid.event");
      
      fluid.generateUniquePrefix = function () {
          return (Math.floor(Math.random() * 1e12)).toString(36) + "-";
      };
      
      var fluid_prefix = fluid.generateUniquePrefix(); 
      
      var fluid_guid = 1;
      
      /** Allocate an string value that will be very likely unique within this (browser) process **/
      
      fluid.allocateGuid = function () {
          return fluid_prefix + (fluid_guid++);
      };
      
      fluid.event.identifyListener = function (listener) {
          if (typeof (listener) === "string") {
              return listener; 
          }
          if (!listener.$$guid) {
              listener.$$guid = fluid.allocateGuid();
          }
          return listener.$$guid;
      };
      
      // unsupported, NON-API function
      fluid.event.mapPriority = function (priority, count) {
          return (priority === null || priority === undefined ? -count : 
             (priority === "last" ? -Number.MAX_VALUE :
                (priority === "first" ? Number.MAX_VALUE : priority)));
      };
      
      // unsupported, NON-API function
      fluid.event.listenerComparator = function (recA, recB) {
          return recB.priority - recA.priority;
      };
      
      // unsupported, NON-API function
      fluid.event.sortListeners = function (listeners) {
          var togo = [];
          fluid.each(listeners, function (listener) {
              togo.push(listener);
          });
          return togo.sort(fluid.event.listenerComparator);
      };
      
      // unsupported, NON-API function
      fluid.event.resolveListener = function (listener) {
          if (typeof (listener) === "string") {
              var listenerFunc = fluid.getGlobalValue(listener);
              if (!listenerFunc) {
                  fluid.fail("Unable to look up name " + listener + " as a global function"); 
              } else {
                  listener = listenerFunc;
              }
          }
          return listener;
      };
      
      fluid.event.nameEvent = function (that, eventName) {
          return eventName + " of " + fluid.nameComponent(that);
      };
      
      /** Construct an "event firer" object which can be used to register and deregister 
       * listeners, to which "events" can be fired. These events consist of an arbitrary
       * function signature. General documentation on the Fluid events system is at
       * http://wiki.fluidproject.org/display/fluid/The+Fluid+Event+System .
       * @param {Boolean} unicast If <code>true</code>, this is a "unicast" event which may only accept
       * a single listener.
       * @param {Boolean} preventable If <code>true</code> the return value of each handler will 
       * be checked for <code>false</code> in which case further listeners will be shortcircuited, and this
       * will be the return value of fire()
       */
      // This name will be deprecated in Fluid 2.0 for fluid.makeEventFirer (or fluid.eventFirer)
      fluid.event.getEventFirer = function (unicast, preventable, name) {
          var listeners = {};
          var sortedListeners = [];
          
          function fireToListeners(listeners, args, wrapper) {
              fluid.log("Firing event " + name + " to list of " + listeners.length + " listeners");
              for (var i = 0; i < listeners.length; ++i) {
                  var lisrec = listeners[i];
                  lisrec.listener = fluid.event.resolveListener(lisrec.listener);
                  var listener = lisrec.listener;
  
                  if (lisrec.predicate && !lisrec.predicate(listener, args)) {
                      continue;
                  }
                  var value = fluid.tryCatch(function () {
                      var ret = (wrapper ? wrapper(listener) : listener).apply(null, args);
                      if (preventable && ret === false) {
                          return false;
                      }
                      if (unicast) {
                          return ret;
                      }
                  }, function (e) { // jslint:ok - function within a loop, only invoked synchronously
                      fluid.log("FireEvent received exception " + e.message + " e " + e + " firing to listener " + i);
                      throw (e);       
                  }); // jslint:ok - function within loop
                  if (value !== undefined) {
                      return value;
                  }
              }
          }
          
          return {
              name: name,
              typeName: "fluid.event.firer", 
              addListener: function (listener, namespace, predicate, priority) {
                  if (!listener) {
                      return;
                  }
                  if (unicast) {
                      namespace = "unicast";
                  }
                  if (!namespace) {
                      namespace = fluid.event.identifyListener(listener);
                  }
  
                  listeners[namespace] = {listener: listener, predicate: predicate, priority: 
                      fluid.event.mapPriority(priority, sortedListeners.length)};
                  sortedListeners = fluid.event.sortListeners(listeners);
              },
  
              removeListener: function (listener) {
                  if (typeof (listener) === 'string') {
                      delete listeners[listener];
                  } else if (listener.$$guid) {
                      delete listeners[listener.$$guid];
                  }
                  sortedListeners = fluid.event.sortListeners(listeners);
              },
              // NB - this method exists currently solely for the convenience of the new,
              // transactional changeApplier. As it exists it is hard to imagine the function
              // being helpful to any other client. We need to get more experience on the kinds
              // of listeners that are useful, and ultimately factor this method away.
              fireToListeners: function (listeners, args, wrapper) {
                  return fireToListeners(listeners, args, wrapper);
              },
              fire: function () {
                  return fireToListeners(sortedListeners, arguments);
              }
          };
      };
      
      fluid.makeEventFirer = fluid.event.getEventFirer;
      
      /** Fire the specified event with supplied arguments. This call is an optimisation utility
       * which handles the case where the firer has not been instantiated (presumably as a result
       * of having no listeners registered 
       */
       
      fluid.fireEvent = function (firer, args) {
          if (firer) {
              firer.fire.apply(null, fluid.makeArray(args));
          }  
      };
      
      // unsupported, NON-API function
      fluid.event.addListenerToFirer = function (firer, value, namespace) {
          if (fluid.isArrayable(value)) {
              for (var i = 0; i < value.length; ++i) {
                  fluid.event.addListenerToFirer(firer, value[i], namespace); 
              }
          } else if (typeof (value) === "function" || typeof (value) === "string") {
              firer.addListener(value, namespace);
          } else if (value && typeof (value) === "object") {
              firer.addListener(value.listener, namespace || value.namespace, value.predicate, value.priority);
          }
      };
      
      fluid.event.resolveListenerRecord = fluid.identity; // non-IOC passthrough
      
      // unsupported, NON-API function
      fluid.mergeListeners = function (that, events, listeners) {
          fluid.each(listeners, function (value, key) {
              var firer, namespace;
              if (key.charAt(0) === "{") {
                  if (!fluid.expandOptions) {
                      fluid.fail("fluid.expandOptions could not be loaded - please include FluidIoC.js in order to operate IoC-driven event with descriptor " + 
                          key);
                  }
                  firer = fluid.expandOptions(key, that);
              } else {
                  var keydot = key.indexOf(".");
              
                  if (keydot !== -1) {
                      namespace = key.substring(keydot + 1);
                      key = key.substring(0, keydot);
                  }
                  if (!events[key]) {
                      fluid.fail("Listener registered for event " + key + " which is not defined for this component");
                      events[key] = fluid.makeEventFirer(null, null, fluid.event.nameEvent(that, key));
                  }
                  firer = events[key];
              }
              value = fluid.event.resolveListenerRecord(value, that, key);
              fluid.event.addListenerToFirer(firer, value, namespace);
          });
      };
      
      function initEvents(that, events, pass) {
          fluid.each(events, function (eventSpec, eventKey) { 
              var isIoCEvent = eventSpec && (typeof (eventSpec) !== "string" || eventSpec.charAt(0) === "{");
              var event;
              if (isIoCEvent && pass === "IoC") {
                  if (!fluid.event.resolveEvent) {
                      fluid.fail("fluid.event.resolveEvent could not be loaded - please include FluidIoC.js in order to operate IoC-driven event with descriptor ", 
                          eventSpec);
                  } else {
                      event = fluid.event.resolveEvent(that, eventKey, eventSpec);
                  }
              } else if (pass === "flat") {
                  event = fluid.makeEventFirer(eventSpec === "unicast", eventSpec === "preventable", fluid.event.nameEvent(that, eventKey));
              }
              if (event) {
                  that.events[eventKey] = event;
              } 
          });
      }
      
      // unsupported, NON-API function
      fluid.instantiateFirers = function (that, options) {
          that.events = {};
          // TODO: manual 2-phase instantiation since we have no GINGER WORLD
          initEvents(that, options.events, "flat"); 
          initEvents(that, options.events, "IoC");
          // TODO: manually expand these late so that members attached to ourselves with preInitFunction can be detected
          //var listeners = fluid.expandOptions ? fluid.expandOptions(options.listeners, that) : options.listeners;
          fluid.mergeListeners(that, that.events, options.listeners);
      };
      
      fluid.mergeListenerPolicy = function (target, source, key) {
          // cf. triage in mergeListeners
          var hasNamespace = key.charAt(0) !== "{" && key.indexOf(".") !== -1; 
          return hasNamespace ? (source ? source : target) 
              : fluid.makeArray(target).concat(fluid.makeArray(source));
      };
      
      fluid.mergeListenersPolicy = function (target, source) {
          target = target || {};
          fluid.each(source, function (listeners, key) {
              target[key] = fluid.mergeListenerPolicy(target[key], listeners, key);
          });
          return target;
      };
      
      /*** DEFAULTS AND OPTIONS MERGING SYSTEM ***/
      
      var defaultsStore = {};
          
      var resolveGradesImpl = function (gs, gradeNames) {
          gradeNames = fluid.makeArray(gradeNames);
          fluid.each(gradeNames, function (gradeName) {
              var options = fluid.rawDefaults(gradeName) || {};
              gs.gradeHash[gradeName] = true;
              gs.gradeChain.push(gradeName);
              gs.optionsChain.push(options);
              fluid.each(options.gradeNames, function (parent) {
                  if (!gs.gradeHash[parent]) {
                      resolveGradesImpl(gs, parent);
                  }
              });
          });
          return gs;
      };
      
      // unsupported, NON-API function
      fluid.resolveGradeStructure = function (gradeNames) {
          var gradeStruct = {
              gradeChain: [],
              gradeHash: {},
              optionsChain: []
          };
          return resolveGradesImpl(gradeStruct, gradeNames);
      };
      
      fluid.lifecycleFunctions = {
          preInitFunction: true,
          postInitFunction: true,
          finalInitFunction: true,
          clearFunction: false
      };
      
      fluid.rootMergePolicy = fluid.transform(fluid.lifecycleFunctions, function () {
          return fluid.mergeListenerPolicy;
      });
      
      var mergedDefaultsCache = {};
      
      fluid.gradeNamesToKey = function (gradeNames, defaultName) {
          return defaultName + "|" + fluid.makeArray(gradeNames).sort().join("|");
      };
      
      // unsupported, NON-API function
      fluid.resolveGrade = function (defaults, defaultName, gradeNames) {
          var mergeArgs = [defaults];
          if (gradeNames) {
              var gradeStruct = fluid.resolveGradeStructure(gradeNames);
              mergeArgs = gradeStruct.optionsChain.reverse().concat(mergeArgs).concat({gradeNames: gradeStruct.gradeChain});
          }
          mergeArgs = [fluid.rootMergePolicy, {}].concat(mergeArgs);
          var mergedDefaults = fluid.merge.apply(null, mergeArgs);
          return mergedDefaults;  
      };
      
      fluid.getGradedDefaults = function (defaults, defaultName, gradeNames) {
          var key = fluid.gradeNamesToKey(gradeNames, defaultName);
          var mergedDefaults = mergedDefaultsCache[key];
          if (!mergedDefaults) {
              mergedDefaults = mergedDefaultsCache[key] = fluid.resolveGrade(defaults, defaultName, gradeNames);
          }
          return mergedDefaults;
      };
  
      // unsupported, NON-API function
      fluid.resolveGradedOptions = function (componentName) {
          var defaults = fluid.rawDefaults(componentName);
          if (!defaults) {
              return defaults;
          } else {
              return fluid.getGradedDefaults(defaults, componentName, defaults.gradeNames);
          }
      };
      
      // unsupported, NON-API function
      fluid.rawDefaults = function (componentName, options) {
          if (options === undefined) {
              return defaultsStore[componentName];
          } else {
              defaultsStore[componentName] = options;
          }
      };
      
          
      fluid.hasGrade = function (options, gradeName) {
          return !options || !options.gradeNames ? false : fluid.contains(options.gradeNames, gradeName);
      };
      
       /**
       * Retrieves and stores a component's default settings centrally.
       * @param {boolean} (options) if true, manipulate a global option (for the head
       *   component) rather than instance options. NB - the use of "global options" 
       *   is deprecated and will be removed from the framework in release 1.5 
       * @param {String} componentName the name of the component
       * @param {Object} (optional) an container of key/value pairs to set
       */
       
      fluid.defaults = function () {
          var offset = 0;
          if (typeof arguments[0] === "boolean") {
              offset = 1;
          }
          var componentName = (offset === 0 ? "" : "*.global-") + arguments[offset];
          var options = arguments[offset + 1];
          if (options === undefined) {
              return fluid.resolveGradedOptions(componentName);
          } else {
              if (options && options.options) {
                  fluid.fail("Probable error in options structure with option named \"options\" - perhaps you meant to write these options at top level in fluid.defaults?");  
              }
              fluid.rawDefaults(componentName, options);
              if (fluid.hasGrade(options, "autoInit")) {
                  fluid.makeComponent(componentName, fluid.resolveGradedOptions(componentName));
              }
          }
      };
      
      fluid.makeComponent = function (componentName, options) {
          if (!options.initFunction || !options.gradeNames) {
              fluid.fail("Cannot autoInit component " + componentName + " which does not have an initFunction and gradeName defined");
          }
          var creator = function () {
              return fluid.initComponent(componentName, arguments);
          };
          var existing = fluid.getGlobalValue(componentName);
          if (existing) {
              $.extend(creator, existing);
          }
          fluid.setGlobalValue(componentName, creator);
      };
          
      fluid.makeComponents = function (components, env) {
          fluid.each(components, function (value, key) {
              var options = {
                  gradeNames: fluid.makeArray(value).concat(["autoInit"])
              };
              fluid.defaults(key, options);
          });
      };
      
      // The base system grade definitions
      
      fluid.defaults("fluid.littleComponent", {
          initFunction: "fluid.initLittleComponent",
          argumentMap: {
              options: 0
          }
      });
  
      fluid.clearEventedComponent = function (that) {
          // Remove all declaratively attached event listeners that have a namespace.
          fluid.each(that.options.listeners, function (listener, eventName) {
              var namespace = listener.namespace;
              if (!namespace) {
                  return;
              }
              that.events[eventName].removeListener(namespace);
          });
      };
      
      fluid.defaults("fluid.eventedComponent", {
          gradeNames: ["fluid.littleComponent"],
          mergePolicy: {
              listeners: fluid.mergeListenersPolicy
          },
          clearFunction: {
              namespace: "clearEventedComponent",
              listener: "fluid.clearEventedComponent"
          }
      });
      
          
      fluid.preInitModelComponent = function (that) {
          that.model = that.options.model || {};
          that.applier = that.options.applier || (fluid.makeChangeApplier ? fluid.makeChangeApplier(that.model, that.options.changeApplierOptions) : null);
      };
      
      fluid.defaults("fluid.modelComponent", {
          gradeNames: ["fluid.littleComponent"],
          preInitFunction: {
              namespace: "preInitModelComponent",
              listener: "fluid.preInitModelComponent"
          },
          mergePolicy: {
              model: "preserve",
              applier: "nomerge"
          }
      });
  
      /** Generate a name for a component for debugging purposes */    
      fluid.nameComponent = function (that) {
          return that ? "component with typename " + that.typeName + " and id " + that.id : "[unknown component]";
      };
      
      // unsupported, NON-API function
      fluid.guardCircularity = function (seenIds, source, message1, message2) {
          if (source && source.id) {
              if (!seenIds[source.id]) {
                  seenIds[source.id] = source;
              } else if (seenIds[source.id] === source) {
                  fluid.fail("Circularity in options " + message1 + " - " + fluid.nameComponent(source)
                      + " has already been seen" + message2);  
              }
          }      
      };
                  
      fluid.mergePolicyIs = function (policy, test) {
          return typeof (policy) === "string" && $.inArray(test, policy.split(/\s*,\s*/)) !== -1;
      };
  
      // Cheapskate implementation which avoids dependency on DataBinding.js    
      fluid.model.mergeModel = function (target, source, applier) {
          if (!fluid.isPrimitive(target)) {
              var copySource = fluid.copy(source);
              $.extend(true, source, target);
              $.extend(true, source, copySource);
          }
          return source; 
      };
  
      function mergeImpl(policy, basePath, target, source, thisPolicy, rec) {
          if (fluid.isTracing) {
              fluid.tracing.pathCount.push(basePath);
          }
          if (fluid.mergePolicyIs(thisPolicy, "replace")) {
              fluid.clear(target);
          }
          fluid.guardCircularity(rec.seenIds, source, "merging", " when evaluating path " + basePath + " - please protect components from merging using the \"nomerge\" merge policy");
        
          for (var name in source) {
              var path = (basePath ? basePath + "." : "") + name;
              var newPolicy = policy && typeof (policy) !== "string" ? policy[path] : policy;
              var funcPolicy = typeof (newPolicy) === "function";
              var thisTarget = target[name];
              var thisSource = source[name];
              var primitiveTarget = fluid.isPrimitive(thisTarget);
      
              if (thisSource !== undefined) {
                  if (!funcPolicy && thisSource !== null && typeof (thisSource) === "object" &&
                          !fluid.isDOMNode(thisSource) && !thisSource.jquery && thisSource !== fluid.VALUE &&
                          !fluid.mergePolicyIs(newPolicy, "preserve") && !fluid.mergePolicyIs(newPolicy, "nomerge") && !fluid.mergePolicyIs(newPolicy, "noexpand")) {
                      if (primitiveTarget) {
                          target[name] = thisTarget = fluid.freshContainer(thisSource);
                      }
                      mergeImpl(policy, path, thisTarget, thisSource, newPolicy, rec);
                  } else {
                      if (funcPolicy) {
                          target[name] = newPolicy.call(null, thisTarget, thisSource, name);
                      } else if (!fluid.isValue(thisTarget) || !fluid.mergePolicyIs(newPolicy, "reverse")) {
                          // TODO: When "grades" are implemented, grandfather in any paired applier to perform these operations
                          // NB: mergePolicy of "preserve" now creates dependency on DataBinding.js
                          target[name] = fluid.isValue(thisTarget) && fluid.mergePolicyIs(newPolicy, "preserve") ? fluid.model.mergeModel(thisTarget, thisSource) : thisSource;
                      }
                  }
              }
          }
          return target;
      }
      
      /** Merge a collection of options structures onto a target, following an optional policy.
       * This function is typically called automatically, as a result of an invocation of
       * <code>fluid.initLittleComponent</code>. The behaviour of this function is explained more fully on
       * the page http://wiki.fluidproject.org/display/fluid/Options+Merging+for+Fluid+Components .
       * @param policy {Object/String} A "policy object" specifiying the type of merge to be performed.
       * If policy is of type {String} it should take on the value "reverse" or "replace" representing
       * a static policy. If it is an
       * Object, it should contain a mapping of EL paths onto these String values, representing a
       * fine-grained policy. If it is an Object, the values may also themselves be EL paths 
       * representing that a default value is to be taken from that path.
       * @param target {Object} The options structure which is to be modified by receiving the merge results.
       * @param options1, options2, .... {Object} an arbitrary list of options structure which are to
       * be merged "on top of" the <code>target</code>. These will not be modified.    
       */
      
      fluid.merge = function (policy, target) {
          var path = "";
          
          for (var i = 2; i < arguments.length; ++i) {
              var source = arguments[i];
              if (source !== null && source !== undefined) {
                  mergeImpl(policy, path, target, source, policy ? policy[""] : null, {seenIds: {}});
              }
          }
          if (policy && typeof (policy) !== "string") {
              for (var key in policy) {
                  var elrh = policy[key];
                  if (typeof (elrh) === "string" && elrh !== "replace" && elrh !== "preserve") {
                      var oldValue = fluid.get(target, key);
                      if (oldValue === null || oldValue === undefined) {
                          var value = fluid.get(target, elrh);
                          fluid.set(target, key, value);
                      }
                  }
              }
          }
          return target;     
      };
  
      // unsupported, NON-API function
      fluid.transformOptions = function (mergeArgs, transRec) {
          fluid.expect("Options transformation record", ["transformer", "config"], transRec);
          var transFunc = fluid.getGlobalValue(transRec.transformer);
          var togo = fluid.transform(mergeArgs, function (value, key) {
              return key === 0 ? value : transFunc.call(null, value, transRec.config);
          });
          return togo;
      };
      
      // unsupporter, NON-API function
      fluid.lastTransformationRecord = function (extraArgs) {
          for (var i = extraArgs.length - 1; i >= 0; --i) {
              if (extraArgs[i] && extraArgs[i].transformOptions) {
                  return extraArgs[i].transformOptions;
              } 
          }
      };
  
      /**
       * Merges the component's declared defaults, as obtained from fluid.defaults(),
       * with the user's specified overrides.
       * 
       * @param {Object} that the instance to attach the options to
       * @param {String} componentName the unique "name" of the component, which will be used
       * to fetch the default options from store. By recommendation, this should be the global
       * name of the component's creator function.
       * @param {Object} userOptions the user-specified configuration options for this component
       */
      // unsupported, NON-API function
      fluid.mergeComponentOptions = function (that, componentName, userOptions, localOptions) {
          var defaults = fluid.defaults(componentName) || {};
          var mergePolicy = $.extend({}, fluid.rootMergePolicy, defaults.mergePolicy);
          var defaultGrades = defaults.gradeNames;
  
          localOptions = defaultGrades ? {} : fluid.copy(fluid.getGradedDefaults({}, "", localOptions.gradeNames));
          var mergeArgs = [mergePolicy, localOptions];
          
          var extraArgs;
          if (fluid.expandComponentOptions) {
              extraArgs = fluid.expandComponentOptions(defaults, userOptions, that);
          } else {
              extraArgs = [defaults, userOptions];
          }
          var transRec = fluid.lastTransformationRecord(extraArgs);
          if (transRec) {
              extraArgs = fluid.transformOptions(extraArgs, transRec);
          }
          mergeArgs = mergeArgs.concat(extraArgs);
          that.options = fluid.merge.apply(null, mergeArgs);
      };
      
      // The Fluid Component System proper   
              
      /** A special "marker object" which is recognised as one of the arguments to 
       * fluid.initSubcomponents. This object is recognised by reference equality - 
       * where it is found, it is replaced in the actual argument position supplied
       * to the specific subcomponent instance, with the particular options block
       * for that instance attached to the overall "that" object.
       * NOTE: The use of this marker has been deprecated as of the Fluid 1.4 release in 
       * favour of the contextual EL path "{options}" - it will be removed in a future
       * release of the framework.
       */
      fluid.COMPONENT_OPTIONS = {type: "fluid.marker", value: "COMPONENT_OPTIONS"};
      
      /** Construct a dummy or "placeholder" subcomponent, that optionally provides empty
       * implementations for a set of methods.
       */
      fluid.emptySubcomponent = function (options) {
          var that = {};
          options = $.makeArray(options);
          var empty = function () {};
          for (var i = 0; i < options.length; ++i) {
              that[options[i]] = empty;
          }
          return that;
      };
      
      /** Compute a "nickname" given a fully qualified typename, by returning the last path
       * segment.
       */
      
      fluid.computeNickName = function (typeName) {
          var segs = fluid.model.parseEL(typeName);
          return segs[segs.length - 1];
      };
          
      /** Create a "type tag" component with no state but simply a type name and id. The most 
       *  minimal form of Fluid component */
         
      fluid.typeTag = function (name) {
          return name ? {
              typeName: name,
              id: fluid.allocateGuid()
          } : null;
      };
      
      /** A combined "component and grade name" which allows type tags to be declaratively constructed
       * from options material */
      
      fluid.typeFount = function (options) {
          var that = fluid.initLittleComponent("fluid.typeFount", options);
          return fluid.typeTag(that.options.targetTypeName);
      };
      
      /**
       * Creates a new "little component": a that-ist object with options merged into it by the framework.
       * This method is a convenience for creating small objects that have options but don't require full
       * View-like features such as the DOM Binder or events
       * 
       * @param {Object} name the name of the little component to create
       * @param {Object} options user-supplied options to merge with the defaults
       */
      // NOTE: the 3rd argument localOptions is NOT to be advertised as part of the stable API, it is present
      // just to allow backward compatibility whilst grade specifications are not mandatory
      fluid.initLittleComponent = function (name, options, localOptions) {
          var that = fluid.typeTag(name);
          // TODO: nickName must be available earlier than other merged options so that component may resolve to itself
          that.nickName = options && options.nickName ? options.nickName : fluid.computeNickName(that.typeName);
          localOptions = localOptions || {gradeNames: "fluid.littleComponent"};
          
          fluid.mergeComponentOptions(that, name, options, localOptions);
          fluid.initLifecycleFunctions(that);
          fluid.fireEvent(that.options.preInitFunction, that);
  
          if (fluid.hasGrade(that.options, "fluid.eventedComponent")) {
              fluid.instantiateFirers(that, that.options);
          }
          if (!fluid.hasGrade(that.options, "autoInit")) {
              fluid.clearLifecycleFunctions(that.options);
          }
          return that;
      };
      
      fluid.initLifecycleFunctions = function (that) {
          fluid.each(fluid.lifecycleFunctions, function (func, key) {
              var value = that.options[key];
              if (value) {
                  that.options[key] = fluid.makeEventFirer(null, null, key);
                  fluid.event.addListenerToFirer(that.options[key], value);
              }  
          }); 
      };
      
      fluid.clearLifecycleFunctions = function (options) {
          fluid.each(fluid.lifecycleFunctions, function (value, key) {
              if (!value) {
                  return;
              }
              delete options[key];
          });
          delete options.initFunction; 
      };
  
      fluid.diagnoseFailedView = fluid.identity;    
      
      fluid.initComponent = function (componentName, initArgs) {
          var options = fluid.defaults(componentName);
          if (!options.gradeNames) {
              fluid.fail("Cannot initialise component " + componentName + " which has no gradeName registered");
          }
          var args = [componentName].concat(fluid.makeArray(initArgs)); // TODO: support different initFunction variants
          var that = fluid.invokeGlobalFunction(options.initFunction, args);
          fluid.diagnoseFailedView(componentName, that, options, args);
          fluid.fireEvent(that.options.postInitFunction, that);
          if (fluid.initDependents) {
              fluid.initDependents(that);
          }
          fluid.fireEvent(that.options.finalInitFunction, that);
          fluid.clearLifecycleFunctions(that.options);
          return that.options.returnedPath ? fluid.get(that, that.options.returnedPath) : that;
      };
  
      // unsupported, NON-API function
      fluid.initSubcomponentImpl = function (that, entry, args) {
          var togo;
          if (typeof (entry) !== "function") {
              var entryType = typeof (entry) === "string" ? entry : entry.type;
              var globDef = fluid.defaults(true, entryType);
              fluid.merge("reverse", that.options, globDef);
              togo = entryType === "fluid.emptySubcomponent" ?
                  fluid.emptySubcomponent(entry.options) : 
                  fluid.invokeGlobalFunction(entryType, args);
          } else {
              togo = entry.apply(null, args);
          }
  
          var returnedOptions = togo ? togo.returnedOptions : null;
          if (returnedOptions) {
              fluid.merge(that.options.mergePolicy, that.options, returnedOptions);
              if (returnedOptions.listeners) {
                  fluid.mergeListeners(that, that.events, returnedOptions.listeners);
              }
          }
          return togo;
      };
      
      /** Initialise all the "subcomponents" which are configured to be attached to 
       * the supplied top-level component, which share a particular "class name".
       * @param {Component} that The top-level component for which sub-components are
       * to be instantiated. It contains specifications for these subcomponents in its
       * <code>options</code> structure.
       * @param {String} className The "class name" or "category" for the subcomponents to
       * be instantiated. A class name specifies an overall "function" for a class of 
       * subcomponents and represents a category which accept the same signature of
       * instantiation arguments.
       * @param {Array of Object} args The instantiation arguments to be passed to each 
       * constructed subcomponent. These will typically be members derived from the
       * top-level <code>that</code> or perhaps globally discovered from elsewhere. One
       * of these arguments may be <code>fluid.COMPONENT_OPTIONS</code> in which case this
       * placeholder argument will be replaced by instance-specific options configured
       * into the member of the top-level <code>options</code> structure named for the
       * <code>className</code>
       * @return {Array of Object} The instantiated subcomponents, one for each member
       * of <code>that.options[className]</code>.
       */
      
      fluid.initSubcomponents = function (that, className, args) {
          var entry = that.options[className];
          if (!entry) {
              return;
          }
          var entries = $.makeArray(entry);
          var optindex = -1;
          var togo = [];
          args = $.makeArray(args);
          for (var i = 0; i < args.length; ++i) {
              if (args[i] === fluid.COMPONENT_OPTIONS) {
                  optindex = i;
              }
          }
          for (i = 0; i < entries.length; ++i) {
              entry = entries[i];
              if (optindex !== -1) {
                  args[optindex] = entry.options;
              }
              togo[i] = fluid.initSubcomponentImpl(that, entry, args);
          }
          return togo;
      };
          
      fluid.initSubcomponent = function (that, className, args) {
          return fluid.initSubcomponents(that, className, args)[0];
      };
  
  
      // Message resolution and templating
     
     
     /**
      * Converts a string to a regexp with the specified flags given in parameters
      * @param {String} a string that has to be turned into a regular expression
      * @param {String} the flags to provide to the reg exp 
      */
      fluid.stringToRegExp = function (str, flags) {
          return new RegExp(str.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&"), flags);
      };
      
      /**
       * Simple string template system. 
       * Takes a template string containing tokens in the form of "%value".
       * Returns a new string with the tokens replaced by the specified values.
       * Keys and values can be of any data type that can be coerced into a string. Arrays will work here as well.
       * 
       * @param {String}    template    a string (can be HTML) that contains tokens embedded into it
       * @param {object}    values      a collection of token keys and values
       */
      fluid.stringTemplate = function (template, values) {
          var keys = fluid.keys(values);
          keys = keys.sort(fluid.compareStringLength());
          for (var i = 0; i < keys.length; ++i) {
              var key = keys[i];
              var re = fluid.stringToRegExp("%" + key, "g");
              template = template.replace(re, values[key]);
          }
          return template;
      };
      
  
      fluid.messageResolver = function (options) {
          var that = fluid.initLittleComponent("fluid.messageResolver", options);
          that.messageBase = that.options.parseFunc(that.options.messageBase);
          
          that.lookup = function (messagecodes) {
              var resolved = fluid.messageResolver.resolveOne(that.messageBase, messagecodes);
              if (resolved === undefined) {
                  return fluid.find(that.options.parents, function (parent) {
                      return parent.lookup(messagecodes);
                  });
              } else {
                  return {template: resolved, resolveFunc: that.options.resolveFunc};
              }
          };
          that.resolve = function (messagecodes, args) {
              if (!messagecodes) {
                  return "[No messagecodes provided]";
              }
              messagecodes = fluid.makeArray(messagecodes);
              var looked = that.lookup(messagecodes);
              return looked ? looked.resolveFunc(looked.template, args) :
                  "[Message string for key " + messagecodes[0] + " not found]";
          };
          
          return that;  
      };
      
      fluid.defaults("fluid.messageResolver", {
          mergePolicy: {
              messageBase: "preserve",
              parents: "nomerge"
          },
          resolveFunc: fluid.stringTemplate,
          parseFunc: fluid.identity,
          messageBase: {},
          parents: []
      });
      
      fluid.messageResolver.resolveOne = function (messageBase, messagecodes) {
          for (var i = 0; i < messagecodes.length; ++i) {
              var code = messagecodes[i];
              var message = messageBase[code];
              if (message !== undefined) {
                  return message;
              }
          }
      };
            
      /** Converts a data structure consisting of a mapping of keys to message strings,
       * into a "messageLocator" function which maps an array of message codes, to be 
       * tried in sequence until a key is found, and an array of substitution arguments,
       * into a substituted message string.
       */
      fluid.messageLocator = function (messageBase, resolveFunc) {
          var resolver = fluid.messageResolver({messageBase: messageBase, resolveFunc: resolveFunc});
          return function (messagecodes, args) {
              return resolver.resolve(messagecodes, args);
          };
      };
  
  })(jQuery, fluid_1_5);
  /*
  Copyright 2007-2010 University of Cambridge
  Copyright 2007-2009 University of Toronto
  Copyright 2010-2011 Lucendo Development Ltd.
  Copyright 2010 OCAD University
  
  Licensed under the Educational Community License (ECL), Version 2.0 or the New
  BSD license. You may not use this file except in compliance with one these
  Licenses.
  
  You may obtain a copy of the ECL 2.0 License and BSD License at
  https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
  */
  
  /** This file contains functions which depend on the presence of a DOM document
   * but which do not depend on the contents of Fluid.js **/
  
  // Declare dependencies
  /*global fluid_1_5:true, jQuery*/
  
  // JSLint options 
  /*jslint white: true, funcinvoke: true, undef: true, newcap: true, nomen: true, regexp: true, bitwise: true, browser: true, forin: true, maxerr: 100, indent: 4 */
  
  var fluid_1_5 = fluid_1_5 || {};
  
  (function ($, fluid) {
  
      // Private constants.
      var NAMESPACE_KEY = "fluid-scoped-data";
  
      /**
       * Gets stored state from the jQuery instance's data map.
       * This function is unsupported: It is not really intended for use by implementors.
       */
      fluid.getScopedData = function(target, key) {
          var data = $(target).data(NAMESPACE_KEY);
          return data ? data[key] : undefined;
      };
  
      /**
       * Stores state in the jQuery instance's data map. Unlike jQuery's version,
       * accepts multiple-element jQueries.
       * This function is unsupported: It is not really intended for use by implementors.
       */
      fluid.setScopedData = function(target, key, value) {
          $(target).each(function() {
              var data = $.data(this, NAMESPACE_KEY) || {};
              data[key] = value;
  
              $.data(this, NAMESPACE_KEY, data);
          });
      };
  
      /** Global focus manager - makes use of "focusin" event supported in jquery 1.4.2 or later.
       */
  
      var lastFocusedElement = null;
      
      $(document).bind("focusin", function(event){
          lastFocusedElement = event.target;
      });
      
      fluid.getLastFocusedElement = function() {
          return lastFocusedElement;
      }
  
  
      var ENABLEMENT_KEY = "enablement";
  
      /** Queries or sets the enabled status of a control. An activatable node
       * may be "disabled" in which case its keyboard bindings will be inoperable
       * (but still stored) until it is reenabled again.
       * This function is unsupported: It is not really intended for use by implementors.
       */
       
      fluid.enabled = function(target, state) {
          target = $(target);
          if (state === undefined) {
              return fluid.getScopedData(target, ENABLEMENT_KEY) !== false;
          }
          else {
              $("*", target).add(target).each(function() {
                  if (fluid.getScopedData(this, ENABLEMENT_KEY) !== undefined) {
                      fluid.setScopedData(this, ENABLEMENT_KEY, state);
                  }
                  else if (/select|textarea|input/i.test(this.nodeName)) {
                      $(this).prop("disabled", !state);
                  }
              });
              fluid.setScopedData(target, ENABLEMENT_KEY, state);
          }
      };
      
      fluid.initEnablement = function(target) {
          fluid.setScopedData(target, ENABLEMENT_KEY, true);
      };
      
      // This function is necessary since simulation of focus events by jQuery under IE
      // is not sufficiently good to intercept the "focusin" binding. Any code which triggers
      // focus or blur synthetically throughout the framework and client code must use this function,
      // especially if correct cross-platform interaction is required with the "deadMansBlur" function.
      
      function applyOp(node, func) {
          node = $(node);
          node.trigger("fluid-"+func);
          node[func]();
      }
      
      $.each(["focus", "blur"], function(i, name) {
          fluid[name] = function(elem) {
              applyOp(elem, name);
          }
      });
      
  })(jQuery, fluid_1_5);
  /*
  Copyright 2008-2010 University of Cambridge
  Copyright 2008-2009 University of Toronto
  
  Licensed under the Educational Community License (ECL), Version 2.0 or the New
  BSD license. You may not use this file except in compliance with one these
  Licenses.
  
  You may obtain a copy of the ECL 2.0 License and BSD License at
  https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
  */
  
  // Declare dependencies
  /*global fluid_1_5:true, jQuery */
  
  // JSLint options 
  /*jslint white: true, funcinvoke: true, undef: true, newcap: true, nomen: true, regexp: true, bitwise: true, browser: true, forin: true, maxerr: 100, indent: 4 */
  
  var fluid_1_5 = fluid_1_5 || {};
  
  (function ($, fluid) {
      
      fluid.dom = fluid.dom || {};
      
      // Node walker function for iterateDom.
      var getNextNode = function (iterator) {
          if (iterator.node.firstChild) {
              iterator.node = iterator.node.firstChild;
              iterator.depth += 1;
              return iterator;
          }
          while (iterator.node) {
              if (iterator.node.nextSibling) {
                  iterator.node = iterator.node.nextSibling;
                  return iterator;
              }
              iterator.node = iterator.node.parentNode;
              iterator.depth -= 1;
          }
          return iterator;
      };
      
      /**
       * Walks the DOM, applying the specified acceptor function to each element.
       * There is a special case for the acceptor, allowing for quick deletion of elements and their children.
       * Return "delete" from your acceptor function if you want to delete the element in question.
       * Return "stop" to terminate iteration. 
       
       * Implementation note - this utility exists mainly for performance reasons. It was last tested
       * carefully some time ago (around jQuery 1.2) but at that time was around 3-4x faster at raw DOM
       * filtration tasks than the jQuery equivalents, which was an important source of performance loss in the
       * Reorderer component. General clients of the framework should use this method with caution if at all, and
       * the performance issues should be reassessed when we have time. 
       * 
       * @param {Element} node the node to start walking from
       * @param {Function} acceptor the function to invoke with each DOM element
       * @param {Boolean} allnodes Use <code>true</code> to call acceptor on all nodes, 
       * rather than just element nodes (type 1)
       */
      fluid.dom.iterateDom = function (node, acceptor, allNodes) {
          var currentNode = {node: node, depth: 0};
          var prevNode = node;
          var condition;
          while (currentNode.node !== null && currentNode.depth >= 0 && currentNode.depth < fluid.dom.iterateDom.DOM_BAIL_DEPTH) {
              condition = null;
              if (currentNode.node.nodeType === 1 || allNodes) {
                  condition = acceptor(currentNode.node, currentNode.depth);
              }
              if (condition) {
                  if (condition === "delete") {
                      currentNode.node.parentNode.removeChild(currentNode.node);
                      currentNode.node = prevNode;
                  }
                  else if (condition === "stop") {
                      return currentNode.node;
                  }
              }
              prevNode = currentNode.node;
              currentNode = getNextNode(currentNode);
          }
      };
      
      // Work around IE circular DOM issue. This is the default max DOM depth on IE.
      // http://msdn2.microsoft.com/en-us/library/ms761392(VS.85).aspx
      fluid.dom.iterateDom.DOM_BAIL_DEPTH = 256;
      
      /**
       * Checks if the specified container is actually the parent of containee.
       * 
       * @param {Element} container the potential parent
       * @param {Element} containee the child in question
       */
      fluid.dom.isContainer = function (container, containee) {
          for (; containee; containee = containee.parentNode) {
              if (container === containee) {
                  return true;
              }
          }
          return false;
      };
         
      /** Return the element text from the supplied DOM node as a single String.
       * Implementation note - this is a special-purpose utility used in the framework in just one
       * position in the Reorderer. It only performs a "shallow" traversal of the text and was intended
       * as a quick and dirty means of extracting element labels where the user had not explicitly provided one.
       * It should not be used by general users of the framework and its presence here needs to be 
       * reassessed.
       */
      fluid.dom.getElementText = function (element) {
          var nodes = element.childNodes;
          var text = "";
          for (var i = 0; i < nodes.length; ++i) {
              var child = nodes[i];
              if (child.nodeType === 3) {
                  text = text + child.nodeValue;
              }
          }
          return text; 
      };
      
  })(jQuery, fluid_1_5);
  /*
  Copyright 2008-2010 University of Cambridge
  Copyright 2008-2009 University of Toronto
  Copyright 2010 Lucendo Development Ltd.
  
  Licensed under the Educational Community License (ECL), Version 2.0 or the New
  BSD license. You may not use this file except in compliance with one these
  Licenses.
  
  You may obtain a copy of the ECL 2.0 License and BSD License at
  https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
  */
  
  // Declare dependencies
  /*global fluid_1_5:true, jQuery*/
  
  // JSLint options 
  /*jslint white: true, funcinvoke: true, undef: true, newcap: true, nomen: true, regexp: true, bitwise: true, browser: true, forin: true, maxerr: 100, indent: 4 */
  
  fluid_1_5 = fluid_1_5 || {};
  
  (function ($, fluid) {
        
    var unUnicode = /(\\u[\dabcdef]{4}|\\x[\dabcdef]{2})/g;
    
    fluid.unescapeProperties = function (string) {
      string = string.replace(unUnicode, function(match) {
        var code = match.substring(2);
        var parsed = parseInt(code, 16);
        return String.fromCharCode(parsed);
        }
      );
      var pos = 0;
      while (true) {
          var backpos = string.indexOf("\\", pos);
          if (backpos === -1) {
              break;
          }
          if (backpos === string.length - 1) {
            return [string.substring(0, string.length - 1), true];
          }
          var replace = string.charAt(backpos + 1);
          if (replace === "n") replace = "\n";
          if (replace === "r") replace = "\r";
          if (replace === "t") replace = "\t";
          string = string.substring(0, backpos) + replace + string.substring(backpos + 2);
          pos = backpos + 1;
      }
      return [string, false];
    };
    
    var breakPos = /[^\\][\s:=]/;
    
    fluid.parseJavaProperties = function(text) {
      // File format described at http://java.sun.com/javase/6/docs/api/java/util/Properties.html#load(java.io.Reader)
      var togo = {};
      text = text.replace(/\r\n/g, "\n");
      text = text.replace(/\r/g, "\n");
      lines = text.split("\n");
      var contin, key, valueComp, valueRaw, valueEsc;
      for (var i = 0; i < lines.length; ++ i) {
        var line = $.trim(lines[i]);
        if (!line || line.charAt(0) === "#" || line.charAt(0) === '!') {
            continue;
        }
        if (!contin) {
          valueComp = "";
          var breakpos = line.search(breakPos);
          if (breakpos === -1) {
            key = line;
            valueRaw = "";
            }
          else {
            key = $.trim(line.substring(0, breakpos + 1)); // +1 since first char is escape exclusion
            valueRaw = $.trim(line.substring(breakpos + 2));
            if (valueRaw.charAt(0) === ":" || valueRaw.charAt(0) === "=") {
              valueRaw = $.trim(valueRaw.substring(1));
            }
          }
        
          key = fluid.unescapeProperties(key)[0];
          valueEsc = fluid.unescapeProperties(valueRaw);
        }
        else {
          valueEsc = fluid.unescapeProperties(line);
        }
  
        contin = valueEsc[1];
        if (!valueEsc[1]) { // this line was not a continuation line - store the value
          togo[key] = valueComp + valueEsc[0];
        }
        else {
          valueComp += valueEsc[0];
        }
      }
      return togo;
    };
        
      /** 
       * Expand a message string with respect to a set of arguments, following a basic
       * subset of the Java MessageFormat rules. 
       * http://java.sun.com/j2se/1.4.2/docs/api/java/text/MessageFormat.html
       * 
       * The message string is expected to contain replacement specifications such
       * as {0}, {1}, {2}, etc.
       * @param messageString {String} The message key to be expanded
       * @param args {String/Array of String} An array of arguments to be substituted into the message.
       * @return The expanded message string. 
       */
      fluid.formatMessage = function (messageString, args) {
          if (!args) {
              return messageString;
          } 
          if (typeof(args) === "string") {
              args = [args];
          }
          for (var i = 0; i < args.length; ++ i) {
              messageString = messageString.replace("{" + i + "}", args[i]);
          }
          return messageString;
      };
        
  })(jQuery, fluid_1_5);
  /*
  Copyright 2007-2010 University of Cambridge
  Copyright 2007-2009 University of Toronto
  Copyright 2007-2009 University of California, Berkeley
  Copyright 2010 OCAD University
  Copyright 2010-2011 Lucendo Development Ltd.
  
  Licensed under the Educational Community License (ECL), Version 2.0 or the New
  BSD license. You may not use this file except in compliance with one these
  Licenses.
  
  You may obtain a copy of the ECL 2.0 License and BSD License at
  https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
  */
  
  // Declare dependencies
  /*global fluid:true, fluid_1_5:true, jQuery*/
  
  // JSLint options 
  /*jslint white: true, funcinvoke: true, undef: true, newcap: true, nomen: true, regexp: true, bitwise: true, browser: true, forin: true, maxerr: 100, indent: 4 */
  
  var fluid_1_5 = fluid_1_5 || {};
  var fluid = fluid || fluid_1_5;
  
  (function ($, fluid) {
         
      fluid.renderTimestamp = function (date) {
          var zeropad = function (num, width) {
               if (!width) width = 2;
               var numstr = (num == undefined? "" : num.toString());
               return "00000".substring(5 - width + numstr.length) + numstr;
               }
          return zeropad(date.getHours()) + ":" + zeropad(date.getMinutes()) + ":" + zeropad(date.getSeconds()) + "." + zeropad(date.getMilliseconds(), 3);
      };
  
      fluid.isTracing = false;
  
      fluid.registerNamespace("fluid.tracing");
  
      fluid.tracing.pathCount = [];
      
      fluid.tracing.summarisePathCount = function (pathCount) {
          pathCount = pathCount || fluid.tracing.pathCount;
          var togo = {};
          for (var i = 0; i < pathCount.length; ++ i) {
              var path = pathCount[i];
              if (!togo[path]) {
                  togo[path] = 1;
              }
              else {
                  ++togo[path];
              }
          }
          var toReallyGo = [];
          fluid.each(togo, function(el, path) {
              toReallyGo.push({path: path, count: el});
          });
          toReallyGo.sort(function(a, b) {return b.count - a.count});
          return toReallyGo;
      };
      
      fluid.tracing.condensePathCount = function (prefixes, pathCount) {
          prefixes = fluid.makeArray(prefixes);
          var prefixCount = {};
          fluid.each(prefixes, function(prefix) {
              prefixCount[prefix] = 0;
          });
          var togo = [];
          fluid.each(pathCount, function(el) {
              var path = el.path;
              if (!fluid.find(prefixes, function(prefix) {
                  if (path.indexOf(prefix) === 0) {
                      prefixCount[prefix] += el.count;
                      return true;
                  }
              })) {
              togo.push(el);
              }
          });
          fluid.each(prefixCount, function(count, path) {
              togo.unshift({path: path, count: count});
          });
          return togo;
      };
  
      // Exception stripping code taken from https://github.com/emwendelin/javascript-stacktrace/blob/master/stacktrace.js
      // BSD licence, see header
      
      fluid.detectStackStyle = function (e) {
          var style = "other";
          var stackStyle = {
              offset: 0  
          };
          if (e["arguments"]) {
              style = "chrome";
          } else if (typeof window !== "undefined" && window.opera && e.stacktrace) {
              style = "opera10";
          } else if (e.stack) {
              style = "firefox";
              // Detect FireFox 4-style stacks which are 1 level less deep
              stackStyle.offset = e.stack.indexOf("Trace exception") === -1? 1 : 0;
          } else if (typeof window !== 'undefined' && window.opera && !('stacktrace' in e)) { //Opera 9-
              style = "opera";
          }
          stackStyle.style = style;
          return stackStyle;
      };
      
      fluid.obtainException = function() {
          try {
              throw new Error("Trace exception");
          }
          catch (e) {
              return e;
          }
      };
      
      var stackStyle = fluid.detectStackStyle(fluid.obtainException());
  
      fluid.registerNamespace("fluid.exceptionDecoders");
      
      fluid.decodeStack = function() {
          if (stackStyle.style !== "firefox") {
              return null;
          }
          var e = fluid.obtainException();
          return fluid.exceptionDecoders[stackStyle.style](e);
      };
  
      fluid.exceptionDecoders.firefox = function(e) {
          var lines = e.stack.replace(/(?:\n@:0)?\s+$/m, '').replace(/^\(/gm, '{anonymous}(').split('\n');
          return fluid.transform(lines, function(line) {
              var atind = line.indexOf("@");
              return atind === -1? [line] : [line.substring(atind + 1), line.substring(0, atind)];  
          });
      };
      
      fluid.getCallerInfo = function(atDepth) {
          atDepth = (atDepth || 3) - stackStyle.offset;
          var stack = fluid.decodeStack();
          return stack? stack[atDepth][0] : null;
      };
      
      function generate(c, count) {
          var togo = "";
          for (var i = 0; i < count; ++ i) {
              togo += c;
          }
          return togo;
      }
      
      function printImpl(obj, small, options) {
          var big = small + options.indentChars;
          if (obj === null) {
              return "null";
          }
          else if (fluid.isPrimitive(obj)) {
              return JSON.stringify(obj);
          }
          else {
              var j = [];
              if (fluid.isArrayable(obj)) {
                  if (obj.length === 0) {
                      return "[]";
                  }
                  for (var i = 0; i < obj.length; ++ i) {
                      j[i] = printImpl(obj[i], big, options);
                  }
                  return "[\n" + big + j.join(",\n" + big) + "\n" + small + "]";
                  }
              else {
                  var i = 0;
                  fluid.each(obj, function(value, key) {
                      j[i++] = JSON.stringify(key) + ": " + printImpl(value, big, options);
                  });
                  return "{\n" + big + j.join(",\n" + big) + "\n" + small + "}"; 
              }
          }
      }
      
      fluid.prettyPrintJSON = function(obj, options) {
          options = $.extend({indent: 4}, options);
          options.indentChars = generate(" ", options.indent);
          return printImpl(obj, "", options);
      }
          
      /** 
       * Dumps a DOM element into a readily recognisable form for debugging - produces a
       * "semi-selector" summarising its tag name, class and id, whichever are set.
       * 
       * @param {jQueryable} element The element to be dumped
       * @return A string representing the element.
       */
      fluid.dumpEl = function (element) {
          var togo;
          
          if (!element) {
              return "null";
          }
          if (element.nodeType === 3 || element.nodeType === 8) {
              return "[data: " + element.data + "]";
          } 
          if (element.nodeType === 9) {
              return "[document: location " + element.location + "]";
          }
          if (!element.nodeType && fluid.isArrayable(element)) {
              togo = "[";
              for (var i = 0; i < element.length; ++ i) {
                  togo += fluid.dumpEl(element[i]);
                  if (i < element.length - 1) {
                      togo += ", ";
                  }
              }
              return togo + "]";
          }
          element = $(element);
          togo = element.get(0).tagName;
          if (element.id) {
              togo += "#" + element.id;
          }
          if (element.attr("class")) {
              togo += "." + element.attr("class");
          }
          return togo;
      };
          
  })(jQuery, fluid_1_5);
      /*
  Copyright 2008-2010 University of Cambridge
  Copyright 2008-2009 University of Toronto
  Copyright 2010-2011 Lucendo Development Ltd.
  Copyright 2010 OCAD University
  
  Licensed under the Educational Community License (ECL), Version 2.0 or the New
  BSD license. You may not use this file except in compliance with one these
  Licenses.
  
  You may obtain a copy of the ECL 2.0 License and BSD License at
  https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
  */
  
  // Declare dependencies
  /*global fluid_1_5:true, jQuery*/
  
  // JSLint options 
  /*jslint white: true, funcinvoke: true, continue: true, elsecatch: true, operator: true, jslintok:true, undef: true, newcap: true, regexp: true, bitwise: true, browser: true, forin: true, maxerr: 100, indent: 4 */
  
  var fluid_1_5 = fluid_1_5 || {};
  
  (function ($, fluid) {
      
      fluid.BINDING_ROOT_KEY = "fluid-binding-root";
      
      /** Recursively find any data stored under a given name from a node upwards
       * in its DOM hierarchy **/
       
      fluid.findData = function (elem, name) {
          while (elem) {
              var data = $.data(elem, name);
              if (data) {
                  return data;
              }
              elem = elem.parentNode;
          }
      };
    
      fluid.bindFossils = function (node, data, fossils) {
          $.data(node, fluid.BINDING_ROOT_KEY, {data: data, fossils: fossils});
      };
          
      fluid.boundPathForNode = function (node, fossils) {
          node = fluid.unwrap(node);
          var key = node.name || node.id;
          var record = fossils[key];
          return record ? record.EL : null;
      };
    
      fluid.findForm = function (node) {
          return fluid.findAncestor(node, function (element) {
              return element.nodeName.toLowerCase() === "form";
          });
      };
      
      /** A generalisation of jQuery.val to correctly handle the case of acquiring and
       * setting the value of clustered radio button/checkbox sets, potentially, given
       * a node corresponding to just one element.
       */
      fluid.value = function (nodeIn, newValue) {
          var node = fluid.unwrap(nodeIn);
          var multiple = false;
          if (node.nodeType === undefined && node.length > 1) {
              node = node[0];
              multiple = true;
          }
          if ("input" !== node.nodeName.toLowerCase() || !/radio|checkbox/.test(node.type)) {
              // resist changes to contract of jQuery.val() in jQuery 1.5.1 (see FLUID-4113)
              return newValue === undefined ? $(node).val() : $(node).val(newValue);
          }
          var name = node.name;
          if (name === undefined) {
              fluid.fail("Cannot acquire value from node " + fluid.dumpEl(node) + " which does not have name attribute set");
          }
          var elements;
          if (multiple) {
              elements = nodeIn;
          } else {
              elements = node.ownerDocument.getElementsByName(name);
              var scope = fluid.findForm(node);
              elements = $.grep(elements, function (element) {
                  if (element.name !== name) {
                      return false;
                  }
                  return !scope || fluid.dom.isContainer(scope, element);
              });
          }
          if (newValue !== undefined) {
              if (typeof(newValue) === "boolean") {
                  newValue = (newValue ? "true" : "false");
              }
            // jQuery gets this partially right, but when dealing with radio button array will
            // set all of their values to "newValue" rather than setting the checked property
            // of the corresponding control. 
              $.each(elements, function () {
                  this.checked = (newValue instanceof Array ? 
                      $.inArray(this.value, newValue) !== -1 : newValue === this.value);
              });
          } else { // this part jQuery will not do - extracting value from <input> array
              var checked = $.map(elements, function (element) {
                  return element.checked ? element.value : null;
              });
              return node.type === "radio" ? checked[0] : checked;
          }
      };
      
     /** "Automatically" apply to whatever part of the data model is
       * relevant, the changed value received at the given DOM node*/
      fluid.applyBoundChange = function (node, newValue, applier) {
          node = fluid.unwrap(node);
          if (newValue === undefined) {
              newValue = fluid.value(node);
          }
          if (node.nodeType === undefined && node.length > 0) {
              node = node[0];
          } // assume here that they share name and parent
          var root = fluid.findData(node, fluid.BINDING_ROOT_KEY);
          if (!root) {
              fluid.fail("Bound data could not be discovered in any node above " + fluid.dumpEl(node));
          }
          var name = node.name;
          var fossil = root.fossils[name];
          if (!fossil) {
              fluid.fail("No fossil discovered for name " + name + " in fossil record above " + fluid.dumpEl(node));
          }
          if (typeof(fossil.oldvalue) === "boolean") { // deal with the case of an "isolated checkbox"
              newValue = newValue[0] ? true : false;
          }
          var EL = root.fossils[name].EL;
          if (applier) {
              applier.fireChangeRequest({path: EL, value: newValue, source: node.id});
          } else {
              fluid.set(root.data, EL, newValue);
          }    
      };
      
      /** MODEL ACCESSOR ENGINE (trundler) **/
      
      /** Standard strategies for resolving path segments **/
      fluid.model.environmentStrategy = function (initEnvironment) {
          return {
              init: function () {
                  var environment = initEnvironment;
                  return function (root, segment, index) {
                      var togo;
                      if (environment && environment[segment]) {
                          togo = environment[segment];
                      }
                      environment = null;
                      return togo; 
                  };
              }
          };
      };
  
      fluid.model.defaultCreatorStrategy = function (root, segment) {
          if (root[segment] === undefined) {
              root[segment] = {};
              return root[segment];
          }
      };
      
      fluid.model.defaultFetchStrategy = function (root, segment) {
          return segment === "" ? root : root[segment];
      };
          
      fluid.model.funcResolverStrategy = function (root, segment) {
          if (root.resolvePathSegment) {
              return root.resolvePathSegment(segment);
          }
      };
      
          
      fluid.model.defaultGetConfig = {
          strategies: [fluid.model.funcResolverStrategy, fluid.model.defaultFetchStrategy]
      };
  
      fluid.model.defaultSetConfig = {
          strategies: [fluid.model.funcResolverStrategy, fluid.model.defaultFetchStrategy, fluid.model.defaultCreatorStrategy]
      };
      
      
      // unsupported, NON-API function
      fluid.model.applyStrategy = function (strategy, root, segment, index) {
          if (typeof (strategy) === "function") { 
              return strategy(root, segment, index);
          } else if (strategy && strategy.next) {
              return strategy.next(root, segment, index);
          }
      };
      
      // unsupported, NON-API function
      fluid.model.initStrategy = function (baseStrategy, index, oldStrategies) {
          return baseStrategy.init ? baseStrategy.init(oldStrategies ? oldStrategies[index] : undefined) : baseStrategy;
      };
      
      // unsupported, NON-API function
      fluid.model.makeTrundler = function (root, config, oldStrategies) {
          var that = {
              root: root,
              strategies: fluid.isArrayable(config) ? config : 
                  fluid.transform(config.strategies, function (strategy, index) {
                      return fluid.model.initStrategy(strategy, index, oldStrategies); 
                  })
          };
          that.trundle = function (EL, uncess) {
              uncess = uncess || 0;
              var newThat = fluid.model.makeTrundler(that.root, config, that.strategies);
              newThat.segs = fluid.model.parseEL(EL);
              newThat.index = 0;
              newThat.step(newThat.segs.length - uncess);
              return newThat;
          };
          that.next = function () {
              if (!that.root) {
                  return;
              }
              var accepted;
              for (var i = 0; i < that.strategies.length; ++i) {
                  var value = fluid.model.applyStrategy(that.strategies[i], that.root, that.segs[that.index], that.index);
                  if (accepted === undefined) {
                      accepted = value;
                  }
              }
              if (accepted === fluid.NO_VALUE) {
                  accepted = undefined;
              }
              that.root = accepted;
              ++that.index;
          };
          that.step = function (limit) {
              for (var i = 0; i < limit; ++i) {
                  that.next();
              }
              that.last = that.segs[that.index];
          };
          return that;
      };
      
      // unsupported, NON-API function
      // core trundling recursion point
      fluid.model.trundleImpl = function (trundler, EL, config, uncess) {
          if (typeof (EL) === "string") {
              trundler = trundler.trundle(EL, uncess);
          } else {
              var key = EL.type || "default";
              var resolver = config.resolvers[key];
              if (!resolver) {
                  fluid.fail("Unable to find resolver of type " + key);
              }
              trundler = resolver(EL, trundler) || {};
              if (EL.path && trundler.trundle && trundler.root !== undefined) {
                  trundler = fluid.model.trundleImpl(trundler, EL.path, config, uncess);
              }
          }
          return trundler;  
      };
          
      // unsupported, NON-API function
      // entry point for initially unbased trundling
      fluid.model.trundle = function (root, EL, config, uncess) {
          EL = EL || "";
          config = config || fluid.model.defaultGetConfig;
          var trundler = fluid.model.makeTrundler(root, config);
          return fluid.model.trundleImpl(trundler, EL, config, uncess);
      };
      
      fluid.model.getPenultimate = function (root, EL, config) {
          return fluid.model.trundle(root, EL, config, 1);
      };  
     
      // Implementation notes: The EL path manipulation utilities here are somewhat more thorough
      // and expensive versions of those provided in Fluid.js - there is some duplication of 
      // functionality. This is a tradeoff between stability and performance - the versions in
      // Fluid.js are the most frequently used and do not implement escaping of characters .
      // as \. and \ as \\ as the versions here. The implementations here are not quite complete
      // or very performant and are left here partially as an implementation note. Problems will
      // arise if clients manipulate JSON structures containing "." characters in keys as if they
      // are models, treating these is best left until the cases where they occur. The now standard
      // utilities fluid.path(), fluid.parseEL and fluid.composePath are the ones recommended for
      // general users and their implementation can be upgraded if required.
     
      fluid.pathUtil = {};
     
      var getPathSegmentImpl = function (accept, path, i) {
          var segment = null; // TODO: rewrite this with regexes and replaces
          if (accept) {
              segment = "";
          }
          var escaped = false;
          var limit = path.length;
          for (; i < limit; ++i) {
              var c = path.charAt(i);
              if (!escaped) {
                  if (c === '.') {
                      break;
                  }
                  else if (c === '\\') {
                      escaped = true;
                  }
                  else if (segment !== null) {
                      segment += c;
                  }
              }
              else {
                  escaped = false;
                  if (segment !== null) {
                      accept += c;
                  }
              }
          }
          if (segment !== null) {
              accept[0] = segment;
          }
          return i;
      };
      
      var globalAccept = []; // TODO: serious reentrancy risk here, why is this impl like this?
      
      fluid.pathUtil.getPathSegment = function (path, i) {
          getPathSegmentImpl(globalAccept, path, i);
          return globalAccept[0];
      }; 
    
      fluid.pathUtil.getHeadPath = function (path) {
          return fluid.pathUtil.getPathSegment(path, 0);
      };
    
      fluid.pathUtil.getFromHeadPath = function (path) {
          var firstdot = getPathSegmentImpl(null, path, 0);
          return firstdot === path.length ? null
              : path.substring(firstdot + 1);
      };
      
      function lastDotIndex(path) {
          // TODO: proper escaping rules
          return path.lastIndexOf(".");
      }
      
      fluid.pathUtil.getToTailPath = function (path) {
          var lastdot = lastDotIndex(path);
          return lastdot === -1 ? null : path.substring(0, lastdot);
      };
  
    /** Returns the very last path component of a bean path */
      fluid.pathUtil.getTailPath = function (path) {
          var lastdot = lastDotIndex(path);
          return fluid.pathUtil.getPathSegment(path, lastdot + 1);
      };
      
      var composeSegment = function (prefix, toappend) {
          for (var i = 0; i < toappend.length; ++i) {
              var c = toappend.charAt(i);
              if (c === '.' || c === '\\' || c === '}') {
                  prefix += '\\';
              }
              prefix += c;
          }
          return prefix;
      };
      
      /**
       * Compose a prefix and suffix EL path, where the prefix is already escaped.
       * Prefix may be empty, but not null. The suffix will become escaped.
       */
      fluid.pathUtil.composePath = function (prefix, suffix) {
          if (prefix.length !== 0) {
              prefix += '.';
          }
          return composeSegment(prefix, suffix);
      };    
     
      fluid.pathUtil.matchPath = function (spec, path) {
          var togo = "";
          while (true) {
              // FLUID-4625 - symmetry on spec and path is actually undesirable, but this
              // quickly avoids at least missed notifications - improved (but slower) 
              // implementation should explode composite changes
              if (!spec || !path) {
                  break;
              }
              var spechead = fluid.pathUtil.getHeadPath(spec);
              var pathhead = fluid.pathUtil.getHeadPath(path);
              // if we fail to match on a specific component, fail.
              if (spechead !== "*" && spechead !== pathhead) {
                  return null;
              }
              togo = fluid.pathUtil.composePath(togo, pathhead);
              spec = fluid.pathUtil.getFromHeadPath(spec);
              path = fluid.pathUtil.getFromHeadPath(path);
          }
          return togo;
      };
          
      /** CHANGE APPLIER **/    
        
      fluid.model.isNullChange = function (model, request, resolverGetConfig) {
          if (request.type === "ADD") {
              var existing = fluid.get(model, request.path, resolverGetConfig);
              if (existing === request.value) {
                  return true;
              }
          }
      };
      /** Applies the supplied ChangeRequest object directly to the supplied model.
       */
      fluid.model.applyChangeRequest = function (model, request, resolverSetConfig) {
          var pen = fluid.model.getPenultimate(model, request.path, resolverSetConfig || fluid.model.defaultSetConfig);
          
          if (request.type === "ADD" || request.type === "MERGE") {
              if (request.path === "" || request.type === "MERGE") {
                  if (request.type === "ADD") {
                      fluid.clear(pen.root);
                  }
                  $.extend(true, request.path === "" ? pen.root : pen.root[pen.last], request.value);
              }
              else {
                  pen.root[pen.last] = request.value;
              }
          }
          else if (request.type === "DELETE") {
              if (request.path === "") {
                  fluid.clear(pen.root);
              }
              else {
                  delete pen.root[pen.last];
              }
          }
      };
            
      /** Add a listener to a ChangeApplier event that only acts in the case the event
       * has not come from the specified source (typically ourself)
       * @param modelEvent An model event held by a changeApplier (typically applier.modelChanged)
       * @param path The path specification to listen to
       * @param source The source value to exclude (direct equality used)
       * @param func The listener to be notified of a change
       * @param [eventName] - optional - the event name to be listened to - defaults to "modelChanged" 
       */
      fluid.addSourceGuardedListener = function(applier, path, source, func, eventName) {
          eventName = eventName || "modelChanged";
          applier[eventName].addListener(path, 
              function() {
                  if (!applier.hasChangeSource(source)) {
                      func.apply(null, arguments);
                  }
              });
      };
  
      /** Convenience method to fire a change event to a specified applier, including
       * a supplied "source" identified (perhaps for use with addSourceGuardedListener)
       */ 
      fluid.fireSourcedChange = function (applier, path, value, source) {
          applier.fireChangeRequest({
              path: path,
              value: value,
              source: source
          });         
      };
      
      /** Dispatches a list of changes to the supplied applier */
      fluid.requestChanges = function (applier, changes) {
          for (var i = 0; i < changes.length; ++i) {
              applier.fireChangeRequest(changes[i]);
          }  
      };
      
    
      // Utility shared between changeApplier and superApplier
      
      function bindRequestChange(that) {
          that.requestChange = function (path, value, type) {
              var changeRequest = {
                  path: path,
                  value: value,
                  type: type
              };
              that.fireChangeRequest(changeRequest);
          };
      }
      
      // Utility used for source tracking in changeApplier
      
      function sourceWrapModelChanged(modelChanged, threadLocal) {
          return function(changeRequest) {
              var sources = threadLocal().sources;
              var args = arguments;
              var source = changeRequest.source || "";
              fluid.tryCatch(function() {
                  if (sources[source] === undefined) {
                      sources[source] = 0;
                  }
                  ++sources[source];
                  modelChanged.apply(null, args);
              }, null, function() {
                  --sources[source];
              });
          };
      }
    
      fluid.makeChangeApplier = function (model, options) {
          options = options || {};
          var baseEvents = {
              guards: fluid.event.getEventFirer(false, true, "guard event"),
              postGuards: fluid.event.getEventFirer(false, true, "postGuard event"),
              modelChanged: fluid.event.getEventFirer(false, false, "modelChanged event")
          };
          var threadLocal = fluid.threadLocal(function() { return {sources: {}};});
          var that = {
          // For now, we don't use "id" to avoid confusing component detection which uses
          // a simple algorithm looking for that field
              changeid: fluid.allocateGuid(),
              model: model
          };
          
          function makeGuardWrapper(cullUnchanged) {
              if (!cullUnchanged) {
                  return null;
              }
              var togo = function (guard) {
                  return function (model, changeRequest, internalApplier) {
                      var oldRet = guard(model, changeRequest, internalApplier);
                      if (oldRet === false) {
                          return false;
                      }
                      else {
                          if (fluid.model.isNullChange(model, changeRequest)) {
                              togo.culled = true;
                              return false;
                          }
                      }
                  };
              };
              return togo;
          }
  
          function wrapListener(listener, spec) {
              var pathSpec = spec;
              var transactional = false;
              var priority = Number.MAX_VALUE;
              if (typeof (spec) !== "string") {
                  pathSpec = spec.path;
                  transactional = spec.transactional;
                  if (spec.priority !== undefined) {
                      priority = spec.priority;
                  }
              }
              else {
                  if (pathSpec.charAt(0) === "!") {
                      transactional = true;
                      pathSpec = pathSpec.substring(1);
                  }
              }
              return function (changePath, fireSpec, accum) {
                  var guid = fluid.event.identifyListener(listener);
                  var exist = fireSpec.guids[guid];
                  if (!exist) {
                      var match = fluid.pathUtil.matchPath(pathSpec, changePath);
                      if (match !== null) {
                          var record = {
                              changePath: changePath,
                              pathSpec: pathSpec,
                              listener: listener,
                              priority: priority,
                              transactional: transactional
                          };
                          if (accum) {
                              record.accumulate = [accum];
                          }
                          fireSpec.guids[guid] = record;
                          var collection = transactional ? "transListeners" : "listeners";
                          fireSpec[collection].push(record);
                          fireSpec.all.push(record);
                      }
                  }
                  else if (accum) {
                      if (!exist.accumulate) {
                          exist.accumulate = [];
                      }
                      exist.accumulate.push(accum);
                  }
              };
          }
          
          function fireFromSpec(name, fireSpec, args, category, wrapper) {
              return baseEvents[name].fireToListeners(fireSpec[category], args, wrapper);
          }
          
          function fireComparator(recA, recB) {
              return recA.priority - recB.priority;
          }
  
          function prepareFireEvent(name, changePath, fireSpec, accum) {
              baseEvents[name].fire(changePath, fireSpec, accum);
              fireSpec.all.sort(fireComparator);
              fireSpec.listeners.sort(fireComparator);
              fireSpec.transListeners.sort(fireComparator);
          }
          
          function makeFireSpec() {
              return {guids: {}, all: [], listeners: [], transListeners: []};
          }
          
          function getFireSpec(name, changePath) {
              var fireSpec = makeFireSpec();
              prepareFireEvent(name, changePath, fireSpec);
              return fireSpec;
          }
          
          function fireEvent(name, changePath, args, wrapper) {
              var fireSpec = getFireSpec(name, changePath);
              return fireFromSpec(name, fireSpec, args, "all", wrapper);
          }
          
          function adaptListener(that, name) {
              that[name] = {
                  addListener: function (spec, listener, namespace) {
                      baseEvents[name].addListener(wrapListener(listener, spec), namespace);
                  },
                  removeListener: function (listener) {
                      baseEvents[name].removeListener(listener);
                  }
              };
          }
          adaptListener(that, "guards");
          adaptListener(that, "postGuards");
          adaptListener(that, "modelChanged");
          
          function preFireChangeRequest(changeRequest) {
              if (!changeRequest.type) {
                  changeRequest.type = "ADD";
              }
          }
  
          var bareApplier = {
              fireChangeRequest: function (changeRequest) {
                  that.fireChangeRequest(changeRequest, true);
              }
          };
          bindRequestChange(bareApplier);
  
          that.fireChangeRequest = function (changeRequest, defeatGuards) {
              preFireChangeRequest(changeRequest);
              var guardFireSpec = defeatGuards ? null : getFireSpec("guards", changeRequest.path);
              if (guardFireSpec && guardFireSpec.transListeners.length > 0) {
                  var ation = that.initiate();
                  ation.fireChangeRequest(changeRequest, guardFireSpec);
                  ation.commit();
              }
              else {
                  if (!defeatGuards) {
                      // TODO: this use of "listeners" seems pointless since we have just verified that there are no transactional listeners
                      var prevent = fireFromSpec("guards", guardFireSpec, [model, changeRequest, bareApplier], "listeners");
                      if (prevent === false) {
                          return false;
                      }
                  }
                  var oldModel = model;
                  if (!options.thin) {
                      oldModel = {};
                      fluid.model.copyModel(oldModel, model);                    
                  }
                  fluid.model.applyChangeRequest(model, changeRequest, options.resolverSetConfig);
                  fireEvent("modelChanged", changeRequest.path, [model, oldModel, [changeRequest]]);
              }
          };
          
          that.fireChangeRequest = sourceWrapModelChanged(that.fireChangeRequest, threadLocal);
          bindRequestChange(that);
  
          function fireAgglomerated(eventName, formName, changes, args, accpos) {
              var fireSpec = makeFireSpec();
              for (var i = 0; i < changes.length; ++i) {
                  prepareFireEvent(eventName, changes[i].path, fireSpec, changes[i]);
              }
              for (var j = 0; j < fireSpec[formName].length; ++j) {
                  var spec = fireSpec[formName][j];
                  if (accpos) {
                      args[accpos] = spec.accumulate;
                  }
                  var ret = spec.listener.apply(null, args);
                  if (ret === false) {
                      return false;
                  }
              }
          }
  
          that.initiate = function (newModel) {
              var cancelled = false;
              var changes = [];
              if (options.thin) {
                  newModel = model;
              }
              else {
                  newModel = newModel || {};
                  fluid.model.copyModel(newModel, model);
              }
              // the guard in the inner world is given a private applier to "fast track"
              // and glob collateral changes it requires
              var internalApplier = {
                  fireChangeRequest: function (changeRequest) {
                      preFireChangeRequest(changeRequest);
                      fluid.model.applyChangeRequest(newModel, changeRequest, options.resolverSetConfig);
                      changes.push(changeRequest);
                  }
              };
              bindRequestChange(internalApplier);
              var ation = {
                  commit: function () {
                      var oldModel;
                      if (cancelled) {
                          return false;
                      }
                      var ret = fireAgglomerated("postGuards", "transListeners", changes, [newModel, null, internalApplier], 1);
                      if (ret === false) {
                          return false;
                      }
                      if (options.thin) {
                          oldModel = model;
                      }
                      else {
                          oldModel = {};
                          fluid.model.copyModel(oldModel, model);
                          fluid.clear(model);
                          fluid.model.copyModel(model, newModel);
                      }
                      fireAgglomerated("modelChanged", "all", changes, [model, oldModel, null], 2);
                  },
                  fireChangeRequest: function (changeRequest) {
                      preFireChangeRequest(changeRequest);
                      if (options.cullUnchanged && fluid.model.isNullChange(model, changeRequest, options.resolverGetConfig)) {
                          return;
                      } 
                      var wrapper = makeGuardWrapper(options.cullUnchanged);
                      var prevent = fireEvent("guards", changeRequest.path, [newModel, changeRequest, internalApplier], wrapper);
                      if (prevent === false && !(wrapper && wrapper.culled)) {
                          cancelled = true;
                      }
                      if (!cancelled) {
                          if (!(wrapper && wrapper.culled)) {
                              fluid.model.applyChangeRequest(newModel, changeRequest, options.resolverSetConfig);
                              changes.push(changeRequest);
                          }
                      }
                  }
              };
              
              ation.fireChangeRequest = sourceWrapModelChanged(ation.fireChangeRequest, threadLocal);
              bindRequestChange(ation);
  
              return ation;
          };
          
          that.hasChangeSource = function (source) {
              return threadLocal().sources[source] > 0;
          };
          
          return that;
      };
      
      fluid.makeSuperApplier = function () {
          var subAppliers = {},
              listeners = {};
              var that = fluid.makeChangeApplier();
  
          that.addSubApplier = function (path, subApplier) {
              subAppliers[path] = subApplier;
              fluid.remove_if(listeners, function (thisListeners, seg) {
                  var matchedPath = fluid.pathUtil.matchPath(path, seg);
                  if (!matchedPath) {
                      return;
                  }
                  fluid.each(thisListeners, function (listener) {
                      var subSpec = buildSubSpec(listener.spec, matchedPath);
                      subApplier.modelChanged.addListener(subSpec, listener.listener, listener.namespace);
                  });
                  return true;
              });
          };
  
          that.fireChangeRequest = function (request) {
              fluid.find(subAppliers, function (subApplier, path) {
                  if (request.path.indexOf(path) !== 0) {
                      return;
                  }
                  var subpath = request.path.substring(path.length + 1);
                  var subRequest = fluid.copy(request);
                  subRequest.path = subpath;
                  // TODO: Deal with the as yet unsupported case of an EL rvalue DAR
                  subApplier.fireChangeRequest(subRequest);
                  return true;
              });
          };
          bindRequestChange(that);
  
          function buildSubSpec (spec, matchedPath) {
              var specPath = spec.path || spec,
                  subpath = specPath.substring(matchedPath.length + 1),
                  subSpec = fluid.copy(spec);
              if (subSpec.path) {
                  subSpec.path = subpath;
              } else {
                  subSpec = subpath;
              }
              return subSpec;
          }
  
          that.modelChanged.addListener = function (spec, listener, namespace) {
              var specPath = spec.path || spec,
                  matchedPath, subSpec,
                  subApplier = fluid.find(subAppliers, function (subApplier, path) {
                      matchedPath = fluid.pathUtil.matchPath(path, specPath);
                      if (matchedPath) {
                          return subApplier;
                      }
                  });
              if (subApplier) {
                  subSpec = buildSubSpec(spec, matchedPath);
                  subApplier.modelChanged.addListener(subSpec, listener, namespace);
                  return;
              }
              listeners[specPath] = fluid.makeArray(listeners[specPath]);
              listeners[specPath].push({
                  spec: spec,
                  listener: listener,
                  namespace: namespace
              });
          };
  
          that.modelChanged.removeListener = function (listener) {
              fluid.each(subAppliers, function (subApplier) {
                  subApplier.modelChanged.removeListener(listener);
              });
              // Here we still don't know if the listener is removed so we need to check
              // the ones that are registered but not attached.
              if (typeof (listener) !== "string") {
                  return;
              }
              fluid.remove_if(listeners, function (thisListeners) {
                  fluid.remove_if(thisListeners, function (thisListener) {
                      if (thisListener.namespace === listener) {
                          return true;
                      }
                  });
                  if (thisListeners.length < 1) {
                      return true;
                  }
              });
          };
  
          return that;
      };
      
      fluid.attachModel = function (baseModel, path, model) {
          var segs = fluid.model.parseEL(path);
          for (var i = 0; i < segs.length - 1; ++i) {
              var seg = segs[i];
              var subModel = baseModel[seg];
              if (!subModel) {
                  baseModel[seg] = subModel = {};
              }
              baseModel = subModel;
          }
          baseModel[segs[segs.length - 1]] = model;
      };
      
      fluid.assembleModel = function (modelSpec) {
          var model = {};
          var superApplier = fluid.makeSuperApplier();
          var togo = {model: model, applier: superApplier};
          for (var path in modelSpec) {
              var rec = modelSpec[path];
              fluid.attachModel(model, path, rec.model);
              if (rec.applier) {
                  superApplier.addSubApplier(path, rec.applier);
              }
          }
          return togo;
      };
  
  })(jQuery, fluid_1_5);
  /*
  Copyright 2010 University of Toronto
  Copyright 2010-2011 OCAD University
  
  Licensed under the Educational Community License (ECL), Version 2.0 or the New
  BSD license. You may not use this file except in compliance with one these
  Licenses.
  
  You may obtain a copy of the ECL 2.0 License and BSD License at
  https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
  */
  
  // Declare dependencies
  /*global fluid:true, fluid_1_5:true, jQuery*/
  
  // JSLint options 
  /*jslint white: true, funcinvoke: true, undef: true, newcap: true, nomen: true, regexp: true, bitwise: true, browser: true, forin: true, maxerr: 100, indent: 4 */
  
  var fluid_1_5 = fluid_1_5 || {};
  var fluid = fluid || fluid_1_5;
  
  (function ($) {
  
      fluid.model = fluid.model || {};
      fluid.model.transform = fluid.model.transform || {};
      
      
      /******************************
       * General Model Transformers *
       ******************************/
      
      fluid.model.transform.value = function (model, expandSpec, recurse) {
          var val;
          if (expandSpec.path) {
              val = fluid.get(model, expandSpec.path);
              
              if (typeof(val) !== "undefined") {
                  return val;
              }
          }
          
          return typeof(expandSpec.value) === "object" ? recurse(model, expandSpec.value) : expandSpec.value;    
      };
      
      fluid.model.transform.arrayValue = function (model, expandSpec, recurse) {
          return fluid.makeArray(fluid.model.transform.value(model, expandSpec));
      };
       
      fluid.model.transform.count = function (model, expandSpec, recurse) {
          var value = fluid.get(model, expandSpec.path);
          return fluid.makeArray(value).length;
      };
       
      fluid.model.transform.firstValue = function (model, expandSpec, recurse) {
          var result;
          for (var i = 0; i < expandSpec.values.length; i++) {
              var value = expandSpec.values[i];
              if (typeof(value) === "string") {
                  value = fixupExpandSpec(value);
              }
              result = fluid.model.transform.value(model, value.expander, recurse);
              if (typeof(result) !== "undefined") {
                  break;
              }
          }
          return result;
      };
      
      var getOrRecurse = function (model, value, recurse) {
          return typeof(value) === "string" ? fluid.get(model, value) : recurse(model, value, recurse);
      };
      
      fluid.model.transform.merge = function (model, expandSpec, recurse) {
          var left = getOrRecurse(model, expandSpec.left, recurse);
          var right = getOrRecurse(model, expandSpec.right, recurse);
          
          if (typeof(left) !== "object" || typeof(right) !== "object") {
              return left;
          }
          
          return fluid.merge(expandSpec.policy ? expandSpec.policy : null, {}, left, right);
      };
       
      var fixupExpandSpec = function (expandSpec) {
          return {
              expander: {
                  type: "fluid.model.transform.value",
                  path: expandSpec
              }
          };
      };
      
      var expandRule = function (model, targetPath, rule) {
          var expanded = {};
          for (var key in rule) {
              var value = rule[key];
              if (key === "expander") {
                  var expanderFn = fluid.getGlobalValue(value.type);
                  if (expanderFn) {
                      expanded = expanderFn.call(null, model, value, fluid.model.transformWithRules);
                  }
              } else {
                  expanded[key] = fluid.model.transformWithRules(model, value);
              }
          }
          return expanded;
      };
      
      /**
       * Transforms a model based on a specified expansion rules objects.
       * Rules objects take the form of:
       *   {
       *       "target.path": "value.el.path" || {
       *          expander: {
       *              type: "expander.function.path",
       *               ...
       *           }
       *       }
       *   }
       *
       * @param {Object} model the model to transform
       * @param {Object} rules a rules object containing instructions on how to transform the model
       */
      fluid.model.transformWithRules = function (model, rules) {
          var transformed;
          rules = fluid.makeArray(rules);
          
          fluid.each(rules, function (rulesObj) {
              transformed = {};
              for (var targetPath in rulesObj) {
                  var rule = rulesObj[targetPath];
  
                  if (typeof(rule) === "string") {
                      rule = fixupExpandSpec(rule);
                  }
  
                  var expanded = expandRule(model, targetPath, rule);
                  if (typeof(expanded) !== "undefined") {
                      fluid.set(transformed, targetPath, expanded);
                  }
              };
              model = transformed;
          });
          return transformed;
      };
      
  })(jQuery, fluid_1_5);
  /*
  Copyright 2008-2010 University of Cambridge
  Copyright 2008-2010 University of Toronto
  Copyright 2010-2011 Lucendo Development Ltd.
  Copyright 2010-2011 OCAD University
  
  Licensed under the Educational Community License (ECL), Version 2.0 or the New
  BSD license. You may not use this file except in compliance with one these
  Licenses.
  
  You may obtain a copy of the ECL 2.0 License and BSD License at
  https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
  */
  
  // Declare dependencies
  /*global fluid:true, fluid_1_5:true, jQuery*/
  
  // JSLint options 
  /*jslint white: true, funcinvoke: true, undef: true, newcap: true, nomen: true, regexp: true, bitwise: true, browser: true, forin: true, maxerr: 100, indent: 4 */
  
  var fluid_1_5 = fluid_1_5 || {};
  var fluid = fluid || fluid_1_5;
  
  (function ($, fluid) {
  
      // $().fluid("selectable", args)
      // $().fluid("selectable".that()
      // $().fluid("pager.pagerBar", args)
      // $().fluid("reorderer", options)
  
  /** Create a "bridge" from code written in the Fluid standard "that-ist" style,
   *  to the standard JQuery UI plugin architecture specified at http://docs.jquery.com/UI/Guidelines .
   *  Every Fluid component corresponding to the top-level standard signature (JQueryable, options)
   *  will automatically convert idiomatically to the JQuery UI standard via this adapter. 
   *  Any return value which is a primitive or array type will become the return value
   *  of the "bridged" function - however, where this function returns a general hash
   *  (object) this is interpreted as forming part of the Fluid "return that" pattern,
   *  and the function will instead be bridged to "return this" as per JQuery standard,
   *  permitting chaining to occur. However, as a courtesy, the particular "this" returned
   *  will be augmented with a function that() which will allow the original return
   *  value to be retrieved if desired.
   *  @param {String} name The name under which the "plugin space" is to be injected into
   *  JQuery
   *  @param {Object} peer The root of the namespace corresponding to the peer object.
   */
  
      fluid.thatistBridge = function (name, peer) {
  
          var togo = function(funcname) {
              var segs = funcname.split(".");
              var move = peer;
              for (var i = 0; i < segs.length; ++i) {
                  move = move[segs[i]];
              }
              var args = [this];
              if (arguments.length === 2) {
                  args = args.concat($.makeArray(arguments[1]));
              }
              var ret = move.apply(null, args);
              this.that = function() {
                  return ret;
              }
              var type = typeof(ret);
              return !ret || type === "string" || type === "number" || type === "boolean"
                || ret && ret.length !== undefined? ret: this;
          };
          $.fn[name] = togo;
          return togo;
      };
  
      fluid.thatistBridge("fluid", fluid);
      fluid.thatistBridge("fluid_1_5", fluid_1_5);
  
  /*************************************************************************
   * Tabindex normalization - compensate for browser differences in naming
   * and function of "tabindex" attribute and tabbing order.
   */
  
      // -- Private functions --
      
      
      var normalizeTabindexName = function() {
          return $.browser.msie ? "tabIndex" : "tabindex";
      };
  
      var canHaveDefaultTabindex = function(elements) {
         if (elements.length <= 0) {
             return false;
         }
  
         return $(elements[0]).is("a, input, button, select, area, textarea, object");
      };
      
      var getValue = function(elements) {
          if (elements.length <= 0) {
              return undefined;
          }
  
          if (!fluid.tabindex.hasAttr(elements)) {
              return canHaveDefaultTabindex(elements) ? Number(0) : undefined;
          }
  
          // Get the attribute and return it as a number value.
          var value = elements.attr(normalizeTabindexName());
          return Number(value);
      };
  
      var setValue = function(elements, toIndex) {
          return elements.each(function(i, item) {
              $(item).attr(normalizeTabindexName(), toIndex);
          });
      };
      
      // -- Public API --
      
      /**
       * Gets the value of the tabindex attribute for the first item, or sets the tabindex value of all elements
       * if toIndex is specified.
       * 
       * @param {String|Number} toIndex
       */
      fluid.tabindex = function(target, toIndex) {
          target = $(target);
          if (toIndex !== null && toIndex !== undefined) {
              return setValue(target, toIndex);
          } else {
              return getValue(target);
          }
      };
  
      /**
       * Removes the tabindex attribute altogether from each element.
       */
      fluid.tabindex.remove = function(target) {
          target = $(target);
          return target.each(function(i, item) {
              $(item).removeAttr(normalizeTabindexName());
          });
      };
  
      /**
       * Determines if an element actually has a tabindex attribute present.
       */
      fluid.tabindex.hasAttr = function(target) {
          target = $(target);
          if (target.length <= 0) {
              return false;
          }
          var togo = target.map(
              function() {
                  var attributeNode = this.getAttributeNode(normalizeTabindexName());
                  return attributeNode ? attributeNode.specified : false;
              }
              );
          return togo.length === 1? togo[0] : togo;
      };
  
      /**
       * Determines if an element either has a tabindex attribute or is naturally tab-focussable.
       */
      fluid.tabindex.has = function(target) {
          target = $(target);
          return fluid.tabindex.hasAttr(target) || canHaveDefaultTabindex(target);
      };
  
      // Keyboard navigation
      // Public, static constants needed by the rest of the library.
      fluid.a11y = $.a11y || {};
  
      fluid.a11y.orientation = {
          HORIZONTAL: 0,
          VERTICAL: 1,
          BOTH: 2
      };
  
      var UP_DOWN_KEYMAP = {
          next: $.ui.keyCode.DOWN,
          previous: $.ui.keyCode.UP
      };
  
      var LEFT_RIGHT_KEYMAP = {
          next: $.ui.keyCode.RIGHT,
          previous: $.ui.keyCode.LEFT
      };
  
      // Private functions.
      var unwrap = function(element) {
          return element.jquery ? element[0] : element; // Unwrap the element if it's a jQuery.
      };
  
  
      var makeElementsTabFocussable = function(elements) {
          // If each element doesn't have a tabindex, or has one set to a negative value, set it to 0.
          elements.each(function(idx, item) {
              item = $(item);
              if (!item.fluid("tabindex.has") || item.fluid("tabindex") < 0) {
                  item.fluid("tabindex", 0);
              }
          });
      };
  
      // Public API.
      /**
       * Makes all matched elements available in the tab order by setting their tabindices to "0".
       */
      fluid.tabbable = function(target) {
          target = $(target);
          makeElementsTabFocussable(target);
      };
  
      /*********************************************************************** 
       * Selectable functionality - geometrising a set of nodes such that they
       * can be navigated (by setting focus) using a set of directional keys
       */
  
      var CONTEXT_KEY = "selectionContext";
      var NO_SELECTION = -32768;
  
      var cleanUpWhenLeavingContainer = function(selectionContext) {
          if (selectionContext.activeItemIndex !== NO_SELECTION) {
              if (selectionContext.options.onLeaveContainer) {
                  selectionContext.options.onLeaveContainer(
                    selectionContext.selectables[selectionContext.activeItemIndex]);
              } else if (selectionContext.options.onUnselect) {
                  selectionContext.options.onUnselect(
                  selectionContext.selectables[selectionContext.activeItemIndex]);
              }
          }
  
          if (!selectionContext.options.rememberSelectionState) {
              selectionContext.activeItemIndex = NO_SELECTION;
          }
      };
  
      /**
       * Does the work of selecting an element and delegating to the client handler.
       */
      var drawSelection = function(elementToSelect, handler) {
          if (handler) {
              handler(elementToSelect);
          }
      };
  
      /**
       * Does does the work of unselecting an element and delegating to the client handler.
       */
      var eraseSelection = function(selectedElement, handler) {
          if (handler && selectedElement) {
              handler(selectedElement);
          }
      };
  
      var unselectElement = function(selectedElement, selectionContext) {
          eraseSelection(selectedElement, selectionContext.options.onUnselect);
      };
  
      var selectElement = function(elementToSelect, selectionContext) {
          // It's possible that we're being called programmatically, in which case we should clear any previous selection.
          unselectElement(selectionContext.selectedElement(), selectionContext);
  
          elementToSelect = unwrap(elementToSelect);
          var newIndex = selectionContext.selectables.index(elementToSelect);
  
          // Next check if the element is a known selectable. If not, do nothing.
          if (newIndex === -1) {
             return;
          }
  
          // Select the new element.
          selectionContext.activeItemIndex = newIndex;
          drawSelection(elementToSelect, selectionContext.options.onSelect);
      };
  
      var selectableFocusHandler = function(selectionContext) {
          return function(evt) {
              // FLUID-3590: newer browsers (FF 3.6, Webkit 4) have a form of "bug" in that they will go bananas
              // on attempting to move focus off an element which has tabindex dynamically set to -1.
              $(evt.target).fluid("tabindex", 0);
              selectElement(evt.target, selectionContext);
  
              // Force focus not to bubble on some browsers.
              return evt.stopPropagation();
          };
      };
  
      var selectableBlurHandler = function(selectionContext) {
          return function(evt) {
              $(evt.target).fluid("tabindex", selectionContext.options.selectablesTabindex);
              unselectElement(evt.target, selectionContext);
  
              // Force blur not to bubble on some browsers.
              return evt.stopPropagation();
          };
      };
  
      var reifyIndex = function(sc_that) {
          var elements = sc_that.selectables;
          if (sc_that.activeItemIndex >= elements.length) {
              sc_that.activeItemIndex = 0;
          }
          if (sc_that.activeItemIndex < 0 && sc_that.activeItemIndex !== NO_SELECTION) {
              sc_that.activeItemIndex = elements.length - 1;
          }
          if (sc_that.activeItemIndex >= 0) {
              fluid.focus(elements[sc_that.activeItemIndex]);
          }
      };
  
      var prepareShift = function(selectionContext) {
          // FLUID-3590: FF 3.6 and Safari 4.x won't fire blur() when programmatically moving focus.
          var selElm = selectionContext.selectedElement();
          if (selElm) {
              fluid.blur(selElm);
          }
  
          unselectElement(selectionContext.selectedElement(), selectionContext);
          if (selectionContext.activeItemIndex === NO_SELECTION) {
            selectionContext.activeItemIndex = -1;
          }
      };
  
      var focusNextElement = function(selectionContext) {
          prepareShift(selectionContext);
          ++selectionContext.activeItemIndex;
          reifyIndex(selectionContext);
      };
  
      var focusPreviousElement = function(selectionContext) {
          prepareShift(selectionContext);
          --selectionContext.activeItemIndex;
          reifyIndex(selectionContext);
      };
  
      var arrowKeyHandler = function(selectionContext, keyMap, userHandlers) {
          return function(evt) {
              if (evt.which === keyMap.next) {
                  focusNextElement(selectionContext);
                  evt.preventDefault();
              } else if (evt.which === keyMap.previous) {
                  focusPreviousElement(selectionContext);
                  evt.preventDefault();
              }
          };
      };
  
      var getKeyMapForDirection = function(direction) {
          // Determine the appropriate mapping for next and previous based on the specified direction.
          var keyMap;
          if (direction === fluid.a11y.orientation.HORIZONTAL) {
              keyMap = LEFT_RIGHT_KEYMAP;
          } 
          else if (direction === fluid.a11y.orientation.VERTICAL) {
              // Assume vertical in any other case.
              keyMap = UP_DOWN_KEYMAP;
          }
  
          return keyMap;
      };
  
      var tabKeyHandler = function(selectionContext) {
          return function(evt) {
              if (evt.which !== $.ui.keyCode.TAB) {
                  return;
              }
              cleanUpWhenLeavingContainer(selectionContext);
  
              // Catch Shift-Tab and note that focus is on its way out of the container.
              if (evt.shiftKey) {
                  selectionContext.focusIsLeavingContainer = true;
              }
          };
      };
  
      var containerFocusHandler = function(selectionContext) {
          return function(evt) {
              var shouldOrig = selectionContext.options.autoSelectFirstItem;
              var shouldSelect = typeof(shouldOrig) === "function" ? 
                   shouldOrig() : shouldOrig;
  
              // Override the autoselection if we're on the way out of the container.
              if (selectionContext.focusIsLeavingContainer) {
                  shouldSelect = false;
              }
  
              // This target check works around the fact that sometimes focus bubbles, even though it shouldn't.
              if (shouldSelect && evt.target === selectionContext.container.get(0)) {
                  if (selectionContext.activeItemIndex === NO_SELECTION) {
                      selectionContext.activeItemIndex = 0;
                  }
                  fluid.focus(selectionContext.selectables[selectionContext.activeItemIndex]);
              }
  
             // Force focus not to bubble on some browsers.
             return evt.stopPropagation();
          };
      };
  
      var containerBlurHandler = function(selectionContext) {
          return function(evt) {
              selectionContext.focusIsLeavingContainer = false;
  
              // Force blur not to bubble on some browsers.
              return evt.stopPropagation();
          };
      };
  
      var makeElementsSelectable = function(container, defaults, userOptions) {
  
          var options = $.extend(true, {}, defaults, userOptions);
  
          var keyMap = getKeyMapForDirection(options.direction);
  
          var selectableElements = options.selectableElements? options.selectableElements :
                container.find(options.selectableSelector);
            
          // Context stores the currently active item(undefined to start) and list of selectables.
          var that = {
              container: container,
              activeItemIndex: NO_SELECTION,
              selectables: selectableElements,
              focusIsLeavingContainer: false,
              options: options
          };
  
          that.selectablesUpdated = function(focusedItem) {
            // Remove selectables from the tab order and add focus/blur handlers
              if (typeof(that.options.selectablesTabindex) === "number") {
                  that.selectables.fluid("tabindex", that.options.selectablesTabindex);
              }
              that.selectables.unbind("focus." + CONTEXT_KEY);
              that.selectables.unbind("blur." + CONTEXT_KEY);
              that.selectables.bind("focus."+ CONTEXT_KEY, selectableFocusHandler(that));
              that.selectables.bind("blur." + CONTEXT_KEY, selectableBlurHandler(that));
              if (keyMap && that.options.noBubbleListeners) {
                  that.selectables.unbind("keydown."+CONTEXT_KEY);
                  that.selectables.bind("keydown."+CONTEXT_KEY, arrowKeyHandler(that, keyMap));
              }
              if (focusedItem) {
                  selectElement(focusedItem, that);
              }
              else {
                  reifyIndex(that);
              }
          };
  
          that.refresh = function() {
              if (!that.options.selectableSelector) {
                  throw("Cannot refresh selectable context which was not initialised by a selector");
              }
              that.selectables = container.find(options.selectableSelector);
              that.selectablesUpdated();
          };
          
          that.selectedElement = function() {
              return that.activeItemIndex < 0? null : that.selectables[that.activeItemIndex];
          };
          
          // Add various handlers to the container.
          if (keyMap && !that.options.noBubbleListeners) {
              container.keydown(arrowKeyHandler(that, keyMap));
          }
          container.keydown(tabKeyHandler(that));
          container.focus(containerFocusHandler(that));
          container.blur(containerBlurHandler(that));
          
          that.selectablesUpdated();
  
          return that;
      };
  
      /**
       * Makes all matched elements selectable with the arrow keys.
       * Supply your own handlers object with onSelect: and onUnselect: properties for custom behaviour.
       * Options provide configurability, including direction: and autoSelectFirstItem:
       * Currently supported directions are jQuery.a11y.directions.HORIZONTAL and VERTICAL.
       */
      fluid.selectable = function(target, options) {
          target = $(target);
          var that = makeElementsSelectable(target, fluid.selectable.defaults, options);
          fluid.setScopedData(target, CONTEXT_KEY, that);
          return that;
      };
  
      /**
       * Selects the specified element.
       */
      fluid.selectable.select = function(target, toSelect) {
          fluid.focus(toSelect);
      };
  
      /**
       * Selects the next matched element.
       */
      fluid.selectable.selectNext = function(target) {
          target = $(target);
          focusNextElement(fluid.getScopedData(target, CONTEXT_KEY));
      };
  
      /**
       * Selects the previous matched element.
       */
      fluid.selectable.selectPrevious = function(target) {
          target = $(target);
          focusPreviousElement(fluid.getScopedData(target, CONTEXT_KEY));
      };
  
      /**
       * Returns the currently selected item wrapped as a jQuery object.
       */
      fluid.selectable.currentSelection = function(target) {
          target = $(target);
          var that = fluid.getScopedData(target, CONTEXT_KEY);
          return $(that.selectedElement());
      };
  
      fluid.selectable.defaults = {
          direction: fluid.a11y.orientation.VERTICAL,
          selectablesTabindex: -1,
          autoSelectFirstItem: true,
          rememberSelectionState: true,
          selectableSelector: ".selectable",
          selectableElements: null,
          onSelect: null,
          onUnselect: null,
          onLeaveContainer: null
      };
  
      /********************************************************************
       *  Activation functionality - declaratively associating actions with 
       * a set of keyboard bindings.
       */
  
      var checkForModifier = function(binding, evt) {
          // If no modifier was specified, just return true.
          if (!binding.modifier) {
              return true;
          }
  
          var modifierKey = binding.modifier;
          var isCtrlKeyPresent = modifierKey && evt.ctrlKey;
          var isAltKeyPresent = modifierKey && evt.altKey;
          var isShiftKeyPresent = modifierKey && evt.shiftKey;
  
          return isCtrlKeyPresent || isAltKeyPresent || isShiftKeyPresent;
      };
  
      /** Constructs a raw "keydown"-facing handler, given a binding entry. This
       *  checks whether the key event genuinely triggers the event and forwards it
       *  to any "activateHandler" registered in the binding. 
       */
      var makeActivationHandler = function(binding) {
          return function(evt) {
              var target = evt.target;
              if (!fluid.enabled(evt.target)) {
                  return;
              }
  // The following 'if' clause works in the real world, but there's a bug in the jQuery simulation
  // that causes keyboard simulation to fail in Safari, causing our tests to fail:
  //     http://ui.jquery.com/bugs/ticket/3229
  // The replacement 'if' clause works around this bug.
  // When this issue is resolved, we should revert to the original clause.
  //            if (evt.which === binding.key && binding.activateHandler && checkForModifier(binding, evt)) {
              var code = evt.which? evt.which : evt.keyCode;
              if (code === binding.key && binding.activateHandler && checkForModifier(binding, evt)) {
                  var event = $.Event("fluid-activate");
                  $(evt.target).trigger(event, [binding.activateHandler]);
                  if (event.isDefaultPrevented()) {
                      evt.preventDefault();
                  }
              }
          };
      };
  
      var makeElementsActivatable = function(elements, onActivateHandler, defaultKeys, options) {
          // Create bindings for each default key.
          var bindings = [];
          $(defaultKeys).each(function(index, key) {
              bindings.push({
                  modifier: null,
                  key: key,
                  activateHandler: onActivateHandler
              });
          });
  
          // Merge with any additional key bindings.
          if (options && options.additionalBindings) {
              bindings = bindings.concat(options.additionalBindings);
          }
  
          fluid.initEnablement(elements);
  
          // Add listeners for each key binding.
          for (var i = 0; i < bindings.length; ++ i) {
              var binding = bindings[i];
              elements.keydown(makeActivationHandler(binding));
          }
          elements.bind("fluid-activate", function(evt, handler) {
              handler = handler || onActivateHandler;
              return handler? handler(evt): null;
          });
      };
  
      /**
       * Makes all matched elements activatable with the Space and Enter keys.
       * Provide your own handler function for custom behaviour.
       * Options allow you to provide a list of additionalActivationKeys.
       */
      fluid.activatable = function(target, fn, options) {
          target = $(target);
          makeElementsActivatable(target, fn, fluid.activatable.defaults.keys, options);
      };
  
      /**
       * Activates the specified element.
       */
      fluid.activate = function(target) {
          $(target).trigger("fluid-activate");
      };
  
      // Public Defaults.
      fluid.activatable.defaults = {
          keys: [$.ui.keyCode.ENTER, $.ui.keyCode.SPACE]
      };
  
    
    })(jQuery, fluid_1_5);
  /*
  Copyright 2010-2011 Lucendo Development Ltd.
  Copyright 2010-2011 OCAD University
  
  Licensed under the Educational Community License (ECL), Version 2.0 or the New
  BSD license. You may not use this file except in compliance with one these
  Licenses.
  
  You may obtain a copy of the ECL 2.0 License and BSD License at
  https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
  */
  
  /** This file contains functions which depend on the presence of a DOM document
   *  and which depend on the contents of Fluid.js **/
  
  // Declare dependencies
  /*global fluid_1_5:true, jQuery*/
  
  // JSLint options 
  /*jslint white: true, funcinvoke: true, undef: true, newcap: true, nomen: true, regexp: true, bitwise: true, browser: true, forin: true, maxerr: 100, indent: 4 */
  
  var fluid_1_5 = fluid_1_5 || {};
  
  (function ($, fluid) {
      
      fluid.defaults("fluid.viewComponent", {
          gradeNames: ["fluid.littleComponent", "fluid.modelComponent", "fluid.eventedComponent"],
          initFunction: "fluid.initView",
          argumentMap: {
              container: 0,
              options: 1
          }
      });
  
  
      // unsupported, NON-API function
      // NOTE: this function represents a temporary strategy until we have more integrated IoC debugging.
      // It preserves the current framework behaviour for the 1.4 release, but provides a more informative
      // diagnostic - in fact, it is perfectly acceptable for a component's creator to return no value and
      // the failure is really in assumptions in fluid.initComponent. Revisit this issue for 1.5
      fluid.diagnoseFailedView = function (componentName, that, options, args) {
          if (!that && fluid.hasGrade(options, "fluid.viewComponent")) {
              var container = fluid.wrap(args[1]);
              var message1 = "Instantiation of autoInit component with type " + componentName + " failed, since ";
              if (container.length === 0) {
                  fluid.fail(message1 + "selector \"", args[1], "\" did not match any markup in the document");
              } else {
                  fluid.fail(message1 + " component creator function did not return a value");
              }  
          }  
      };
      
      fluid.checkTryCatchParameter = function () {
          var location = window.location || { search: "", protocol: "file:" };
          var GETParams = location.search.slice(1).split('&');
          return fluid.contains(GETParams, "notrycatch");
      };
      
      fluid.notrycatch = fluid.checkTryCatchParameter();
  
     
      /**
       * Wraps an object in a jQuery if it isn't already one. This function is useful since
       * it ensures to wrap a null or otherwise falsy argument to itself, rather than the
       * often unhelpful jQuery default of returning the overall document node.
       * 
       * @param {Object} obj the object to wrap in a jQuery
       * @param {jQuery} userJQuery the jQuery object to use for the wrapping, optional - use the current jQuery if absent
       */
      fluid.wrap = function (obj, userJQuery) {
          userJQuery = userJQuery || $;
          return ((!obj || obj.jquery) ? obj : userJQuery(obj)); 
      };
      
      /**
       * If obj is a jQuery, this function will return the first DOM element within it.
       * 
       * @param {jQuery} obj the jQuery instance to unwrap into a pure DOM element
       */
      fluid.unwrap = function (obj) {
          return obj && obj.jquery && obj.length === 1 ? obj[0] : obj; // Unwrap the element if it's a jQuery.
      };
      
      /**
       * Fetches a single container element and returns it as a jQuery.
       * 
       * @param {String||jQuery||element} containerSpec an id string, a single-element jQuery, or a DOM element specifying a unique container
       * @param {Boolean} fallible <code>true</code> if an empty container is to be reported as a valid condition
       * @return a single-element jQuery of container
       */
      fluid.container = function (containerSpec, fallible, userJQuery) {
          if (userJQuery) {
              containerSpec = fluid.unwrap(containerSpec);
          }
          var container = fluid.wrap(containerSpec, userJQuery);
          if (fallible && (!container || container.length === 0)) {
              return null;
          }
          
          // Throw an exception if we've got more or less than one element.
          if (!container || !container.jquery || container.length !== 1) {
              if (typeof (containerSpec) !== "string") {
                  containerSpec = container.selector;
              }
              var count = container.length !== undefined ? container.length : 0;
              fluid.fail((count > 1 ? "More than one (" + count + ") container elements were"
                      : "No container element was") + " found for selector " + containerSpec);
          }
          if (!fluid.isDOMNode(container[0])) {
              fluid.fail("fluid.container was supplied a non-jQueryable element");  
          }
          
          return container;
      };
      
      /**
       * Creates a new DOM Binder instance, used to locate elements in the DOM by name.
       * 
       * @param {Object} container the root element in which to locate named elements
       * @param {Object} selectors a collection of named jQuery selectors
       */
      fluid.createDomBinder = function (container, selectors) {
          var cache = {}, that = {};
          var userJQuery = container.constructor;
          
          function cacheKey(name, thisContainer) {
              return fluid.allocateSimpleId(thisContainer) + "-" + name;
          }
  
          function record(name, thisContainer, result) {
              cache[cacheKey(name, thisContainer)] = result;
          }
  
          that.locate = function (name, localContainer) {
              var selector, thisContainer, togo;
              
              selector = selectors[name];
              thisContainer = localContainer ? localContainer : container;
              if (!thisContainer) {
                  fluid.fail("DOM binder invoked for selector " + name + " without container");
              }
  
              if (!selector) {
                  return thisContainer;
              }
  
              if (typeof (selector) === "function") {
                  togo = userJQuery(selector.call(null, fluid.unwrap(thisContainer)));
              } else {
                  togo = userJQuery(selector, thisContainer);
              }
              if (togo.get(0) === document) {
                  togo = [];
              }
              if (!togo.selector) {
                  togo.selector = selector;
                  togo.context = thisContainer;
              }
              togo.selectorName = name;
              record(name, thisContainer, togo);
              return togo;
          };
          that.fastLocate = function (name, localContainer) {
              var thisContainer = localContainer ? localContainer : container;
              var key = cacheKey(name, thisContainer);
              var togo = cache[key];
              return togo ? togo : that.locate(name, localContainer);
          };
          that.clear = function () {
              cache = {};
          };
          that.refresh = function (names, localContainer) {
              var thisContainer = localContainer ? localContainer : container;
              if (typeof names === "string") {
                  names = [names];
              }
              if (thisContainer.length === undefined) {
                  thisContainer = [thisContainer];
              }
              for (var i = 0; i < names.length; ++i) {
                  for (var j = 0; j < thisContainer.length; ++j) {
                      that.locate(names[i], thisContainer[j]);
                  }
              }
          };
          that.resolvePathSegment = that.locate;
          
          return that;
      };
      
      /** Expect that jQuery selector query has resulted in a non-empty set of 
       * results. If none are found, this function will fail with a diagnostic message, 
       * with the supplied message prepended.
       */
      fluid.expectFilledSelector = function (result, message) {
          if (result && result.length === 0 && result.jquery) {
              fluid.fail(message + ": selector \"" + result.selector + "\" with name " + result.selectorName +
                         " returned no results in context " + fluid.dumpEl(result.context));
          }
      };
      
      /** 
       * The central initialiation method called as the first act of every Fluid
       * component. This function automatically merges user options with defaults,
       * attaches a DOM Binder to the instance, and configures events.
       * 
       * @param {String} componentName The unique "name" of the component, which will be used
       * to fetch the default options from store. By recommendation, this should be the global
       * name of the component's creator function.
       * @param {jQueryable} container A specifier for the single root "container node" in the
       * DOM which will house all the markup for this component.
       * @param {Object} userOptions The configuration options for this component.
       */
       // 4th argument is NOT SUPPORTED, see comments for initLittleComponent
      fluid.initView = function (componentName, containerSpec, userOptions, localOptions) {
          var container = fluid.container(containerSpec, true);
          fluid.expectFilledSelector(container, "Error instantiating component with name \"" + componentName);
          if (!container) {
              return null;
          }
          var that = fluid.initLittleComponent(componentName, userOptions, localOptions || {gradeNames: ["fluid.viewComponent"]});
          var userJQuery = that.options.jQuery; // Do it a second time to correct for jQuery injection
          if (userJQuery) {
              container = fluid.container(containerSpec, true, userJQuery);
          }
          fluid.log("Constructing view component " + componentName + " with container " + container.constructor.expando + 
              (userJQuery ? " user jQuery " + userJQuery.expando : "") + " env: " + $.expando);
          that.container = container;
          fluid.initDomBinder(that);
  
          return that;
      };
      
      /**
       * Creates a new DOM Binder instance for the specified component and mixes it in.
       * 
       * @param {Object} that the component instance to attach the new DOM Binder to
       */
      fluid.initDomBinder = function (that) {
          that.dom = fluid.createDomBinder(that.container, that.options.selectors);
          that.locate = that.dom.locate;      
      };
  
      // DOM Utilities.
      
      /**
       * Finds the nearest ancestor of the element that passes the test
       * @param {Element} element DOM element
       * @param {Function} test A function which takes an element as a parameter and return true or false for some test
       */
      fluid.findAncestor = function (element, test) {
          element = fluid.unwrap(element);
          while (element) {
              if (test(element)) {
                  return element;
              }
              element = element.parentNode;
          }
      };
      
      /**
       * Returns a jQuery object given the id of a DOM node. In the case the element
       * is not found, will return an empty list.
       */
      fluid.jById = function (id, dokkument) {
          dokkument = dokkument && dokkument.nodeType === 9 ? dokkument : document;
          var element = fluid.byId(id, dokkument);
          var togo = element ? $(element) : [];
          togo.selector = "#" + id;
          togo.context = dokkument;
          return togo;
      };
      
      /**
       * Returns an DOM element quickly, given an id
       * 
       * @param {Object} id the id of the DOM node to find
       * @param {Document} dokkument the document in which it is to be found (if left empty, use the current document)
       * @return The DOM element with this id, or null, if none exists in the document.
       */
      fluid.byId = function (id, dokkument) {
          dokkument = dokkument && dokkument.nodeType === 9 ? dokkument : document;
          var el = dokkument.getElementById(id);
          if (el) {
          // Use element id property here rather than attribute, to work around FLUID-3953
              if (el.id !== id) {
                  fluid.fail("Problem in document structure - picked up element " +
                      fluid.dumpEl(el) + " for id " + id +
                      " without this id - most likely the element has a name which conflicts with this id");
              }
              return el;
          } else {
              return null;
          }
      };
      
      /**
       * Returns the id attribute from a jQuery or pure DOM element.
       * 
       * @param {jQuery||Element} element the element to return the id attribute for
       */
      fluid.getId = function (element) {
          return fluid.unwrap(element).id;
      };
      
      /** 
       * Allocate an id to the supplied element if it has none already, by a simple
       * scheme resulting in ids "fluid-id-nnnn" where nnnn is an increasing integer.
       */
      
      fluid.allocateSimpleId = function (element) {
          var simpleId = "fluid-id-" + fluid.allocateGuid();
          if (!element) {
              return simpleId;
          }
          element = fluid.unwrap(element);
          if (!element.id) {
              element.id = simpleId;
          }
          return element.id;
      };
  
      fluid.defaults("fluid.ariaLabeller", {
          labelAttribute: "aria-label",
          liveRegionMarkup: "<div class=\"liveRegion fl-offScreen-hidden\" aria-live=\"polite\"></div>",
          liveRegionId: "fluid-ariaLabeller-liveRegion",
          events: {
              generateLiveElement: "unicast"
          },
          listeners: {
              generateLiveElement: "fluid.ariaLabeller.generateLiveElement"
          }
      });
   
      fluid.ariaLabeller = function (element, options) {
          var that = fluid.initView("fluid.ariaLabeller", element, options);
  
          that.update = function (newOptions) {
              newOptions = newOptions || that.options;
              that.container.attr(that.options.labelAttribute, newOptions.text);
              if (newOptions.dynamicLabel) {
                  var live = fluid.jById(that.options.liveRegionId); 
                  if (live.length === 0) {
                      live = that.events.generateLiveElement.fire(that);
                  }
                  live.text(newOptions.text);
              }
          };
          
          that.update();
          return that;
      };
      
      fluid.ariaLabeller.generateLiveElement = function (that) {
          var liveEl = $(that.options.liveRegionMarkup);
          liveEl.prop("id", that.options.liveRegionId);
          $("body").append(liveEl);
          return liveEl;
      };
      
      var LABEL_KEY = "aria-labelling";
      
      fluid.getAriaLabeller = function (element) {
          element = $(element);
          var that = fluid.getScopedData(element, LABEL_KEY);
          return that;      
      };
      
      /** Manages an ARIA-mediated label attached to a given DOM element. An
       * aria-labelledby attribute and target node is fabricated in the document
       * if they do not exist already, and a "little component" is returned exposing a method
       * "update" that allows the text to be updated. */
      
      fluid.updateAriaLabel = function (element, text, options) {
          options = $.extend({}, options || {}, {text: text});
          var that = fluid.getAriaLabeller(element);
          if (!that) {
              that = fluid.ariaLabeller(element, options);
              fluid.setScopedData(element, LABEL_KEY, that);
          } else {
              that.update(options);
          }
          return that;
      };
      
      /** "Global Dismissal Handler" for the entire page. Attaches a click handler to the 
       * document root that will cause dismissal of any elements (typically dialogs) which 
       * have registered themselves. Dismissal through this route will automatically clean up 
       * the record - however, the dismisser themselves must take care to deregister in the case 
       * dismissal is triggered through the dialog interface itself. This component can also be 
       * automatically configured by fluid.deadMansBlur by means of the "cancelByDefault" option */ 
       
      var dismissList = {}; 
       
      $(document).click(function (event) { 
          var target = event.target; 
          while (target) { 
              if (dismissList[target.id]) { 
                  return; 
              } 
              target = target.parentNode; 
          } 
          fluid.each(dismissList, function (dismissFunc, key) { 
              dismissFunc(event); 
              delete dismissList[key]; 
          }); 
      });
      // TODO: extend a configurable equivalent of the above dealing with "focusin" events
       
      /** Accepts a free hash of nodes and an optional "dismissal function".
       * If dismissFunc is set, this "arms" the dismissal system, such that when a click
       * is received OUTSIDE any of the hierarchy covered by "nodes", the dismissal function
       * will be executed.
       */ 
      fluid.globalDismissal = function (nodes, dismissFunc) { 
          fluid.each(nodes, function (node) {
            // Don't bother to use the real id if it is from a foreign document - we will never receive events
            // from it directly in any case - and foreign documents may be under the control of malign fiends
            // such as tinyMCE who allocate the same id to everything
              var id = fluid.unwrap(node).ownerDocument === document? fluid.allocateSimpleId(node) : fluid.allocateGuid();
              if (dismissFunc) { 
                  dismissList[id] = dismissFunc; 
              } 
              else { 
                  delete dismissList[id]; 
              } 
          }); 
      }; 
      
      /** Sets an interation on a target control, which morally manages a "blur" for
       * a possibly composite region.
       * A timed blur listener is set on the control, which waits for a short period of
       * time (options.delay, defaults to 150ms) to discover whether the reason for the 
       * blur interaction is that either a focus or click is being serviced on a nominated
       * set of "exclusions" (options.exclusions, a free hash of elements or jQueries). 
       * If no such event is received within the window, options.handler will be called
       * with the argument "control", to service whatever interaction is required of the
       * blur.
       */
      
      fluid.deadMansBlur = function (control, options) {
          var that = fluid.initLittleComponent("fluid.deadMansBlur", options);
          that.blurPending = false;
          that.lastCancel = 0;
          that.canceller = function (event) {
              fluid.log("Cancellation through " + event.type + " on " + fluid.dumpEl(event.target)); 
              that.lastCancel = Date.now();
              that.blurPending = false;
          };
          that.noteProceeded = function () {
              fluid.globalDismissal(that.options.exclusions);
          };
          that.reArm = function () {
              fluid.globalDismissal(that.options.exclusions, that.proceed);
          };
          that.addExclusion = function (exclusions) {
              fluid.globalDismissal(exclusions, that.proceed);
          };
          that.proceed = function (event) {
              fluid.log("Direct proceed through " + event.type + " on " + fluid.dumpEl(event.target));
              that.blurPending = false;
              that.options.handler(control);
          };
          fluid.each(that.options.exclusions, function (exclusion) {
              exclusion = $(exclusion);
              fluid.each(exclusion, function (excludeEl) {
                  $(excludeEl).bind("focusin", that.canceller).
                      bind("fluid-focus", that.canceller).
                      click(that.canceller).mousedown(that.canceller);
      // Mousedown is added for FLUID-4212, as a result of Chrome bug 6759, 14204
              });
          });
          if (!that.options.cancelByDefault) {
              $(control).bind("focusout", function (event) {
                  fluid.log("Starting blur timer for element " + fluid.dumpEl(event.target));
                  var now = Date.now();
                  fluid.log("back delay: " + (now - that.lastCancel));
                  if (now - that.lastCancel > that.options.backDelay) {
                      that.blurPending = true;
                  }
                  setTimeout(function () {
                      if (that.blurPending) {
                          that.options.handler(control);
                      }
                  }, that.options.delay);
              });
          }
          else {
              that.reArm();
          }
          return that;
      };
  
      fluid.defaults("fluid.deadMansBlur", {
          delay: 150,
          backDelay: 100
      });
      
  })(jQuery, fluid_1_5);
  /*
  Copyright 2011 OCAD University
  Copyright 2010-2011 Lucendo Development Ltd.
  
  Licensed under the Educational Community License (ECL), Version 2.0 or the New
  BSD license. You may not use this file except in compliance with one these
  Licenses.
  
  You may obtain a copy of the ECL 2.0 License and BSD License at
  https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
  */
  
  // Declare dependencies
  /*global fluid_1_5:true, jQuery*/
  
  // JSLint options 
  /*jslint white: true, funcinvoke: true, continue: true, elsecatch: true, operator: true, jslintok:true, undef: true, newcap: true, regexp: true, bitwise: true, browser: true, forin: true, maxerr: 100, indent: 4 */
  
  var fluid_1_5 = fluid_1_5 || {};
  
  (function ($, fluid) {
  
      /** The Fluid "IoC System proper" - resolution of references and 
       * completely automated instantiation of declaratively defined
       * component trees */ 
      
      var inCreationMarker = "__CURRENTLY_IN_CREATION__";
      
      // unsupported, non-API function
      fluid.isFireBreak = function(component) {
          return component.options && component.options["fluid.visitComponents.fireBreak"];
      };
      
      // unsupported, non-API function
      fluid.visitComponentChildren = function(that, visitor, options, up, down) {
          options = options || {};
          for (var name in that) {
              var component = that[name];
              //Every component *should* have an id, but some clients may not yet be compliant
              //if (component && component.typeName && !component.id) {
              //    fluid.fail("No id");
              //}
              if (!component || !component.typeName || (component.id && options.visited && options.visited[component.id])) {continue; }
              if (options.visited) {
                  options.visited[component.id] = true;
              }
              if (visitor(component, name, options, up, down)) {
                  return true;
              }
              if (!fluid.isFireBreak(component) && !options.flat) {
                  fluid.visitComponentChildren(component, visitor, options, up, down + 1);
              }
          }
      };
      
      // thatStack contains an increasing list of MORE SPECIFIC thats.
      var visitComponents = function(instantiator, thatStack, visitor, options) {
          options = options || {
              visited: {},
              flat: true
          };
          var up = 0;
          for (var i = thatStack.length - 1; i >= 0; --i) {
              var that = thatStack[i];
              if (fluid.isFireBreak(that)) {
                  return;
              }
              if (that.typeName) {
                  options.visited[that.id] = true;
                  var path = instantiator.idToPath[that.id] || "";
                  var memberName = fluid.pathUtil.getTailPath(path);
                  if (visitor(that, memberName, options, 0, 0)) {
                      return;
                  }
              }
              if (fluid.visitComponentChildren(that, visitor, options, up, 1)) {
                  return;
              }
              ++up;
          }
      };
      
      // An EL segment resolver strategy that will attempt to trigger creation of
      // components that it discovers along the EL path, if they have been defined but not yet
      // constructed. Spring, eat your heart out! Wot no SPR-2048?
      
      function makeGingerStrategy(instantiator, that, thatStack) {
          return function(component, thisSeg) {
              var atval = component[thisSeg];
              if (atval === undefined) {
                  var parentPath = instantiator.idToPath[component.id];
                  atval = instantiator.pathToComponent[fluid.composePath(parentPath, thisSeg)];
                  // if it was not attached to the component, but it is in the instantiator, it MUST be in creation - prepare to fail
                  if (atval) {
                      atval[inCreationMarker] = true;
                  } 
              }
              if (atval !== undefined) {
                  if (atval[inCreationMarker]) {
                      fluid.fail("Component " + fluid.dumpThat(atval) + " at path \"" + thisSeg 
                          + "\" of parent " + fluid.dumpThat(component) + " cannot be used for lookup" 
                          + " since it is still in creation. Please reorganise your dependencies so that they no longer contain circular references");
                  }
              }
              else {
                  if (fluid.get(component, fluid.path("options", "components", thisSeg, "type"))) {
                      fluid.initDependent(component, thisSeg);
                      atval = component[thisSeg];
                  }
              }
              return atval;
          };
      }
      
      // unsupported, non-API function
      fluid.dumpThat = function(that) {
          return "{ typeName: \"" + that.typeName + "\" id: " + that.id + "}";
      };
      
          // unsupported, non-API function
      fluid.dumpThatStack = function(thatStack, instantiator) {
          var togo = fluid.transform(thatStack, function(that) {
              var path = instantiator.idToPath[that.id];
              return fluid.dumpThat(that) + (path? (" - path: " + path) : "");
          });
          return togo.join("\n");
      };
  
      // Return an array of objects describing the current activity
      // unsupported, non-API function
      fluid.describeActivity = function() {
          return fluid.globalThreadLocal().activityStack || [];
      };
      
      // Execute the supplied function with the specified activity description pushed onto the stack
      // unsupported, non-API function
      fluid.pushActivity = function(func, message) {
          if (!message || fluid.notrycatch) {
              return func();
          }
          var root = fluid.globalThreadLocal();
          if (!root.activityStack) {
              root.activityStack = [];
          }
          var frames = fluid.makeArray(message);
          frames.push("\n");
          frames.unshift("\n");
          root.activityStack = frames.concat(root.activityStack);
          return fluid.tryCatch(func, null, function() {
              root.activityStack = root.activityStack.slice(frames.length);
          });
      };
      
      // Return a function wrapped by the activity of describing its activity
      // unsupported, non-API function
      fluid.wrapActivity = fluid.notrycatch? fluid.identity : function(func, messageSpec) {
          return function() {
              var args = fluid.makeArray(arguments);
              var message = fluid.transform(fluid.makeArray(messageSpec), function(specEl) {
                  if (typeof(specEl) === "string" && specEl.indexOf("arguments.") === 0) {
                      var el = specEl.substring("arguments.".length);
                      return fluid.get(args, el);
                  }
                  else {
                      return specEl;
                  }
              });
              return fluid.pushActivity(function() {
                  return func.apply(null, args);
              }, message);
          };
      };
  
      var localRecordExpected = /arguments|options|container/;
  
      function makeStackFetcher(instantiator, parentThat, localRecord, expandOptions) {
          expandOptions = expandOptions || {};
          var thatStack = instantiator.getFullStack(parentThat);
          var fetchStrategies = [fluid.model.funcResolverStrategy, makeGingerStrategy(instantiator, parentThat, thatStack)]; 
          var fetcher = function(parsed) {
              var context = parsed.context;
              var foundComponent;
              if (context === "instantiator") {
                  // special treatment for the current instantiator which used to be discovered as unique in threadLocal
                  return instantiator;
              }
              else if (context === "that") {
                  foundComponent = parentThat; 
              }
              else if (localRecord && localRecordExpected.test(context)) {
                  var fetched = fluid.get(localRecord[context], parsed.path);
                  return (context === "arguments" || expandOptions.direct)? fetched : {
                      marker: context === "options"? fluid.EXPAND : fluid.EXPAND_NOW,
                      value: fetched
                  };
              }
              if (!foundComponent) {
                  visitComponents(instantiator, thatStack, function(component, name, options, up, down) {
                      if (context === name || context === component.typeName || context === component.nickName) {
                          foundComponent = component;
                          return true; // YOUR VISIT IS AT AN END!!
                      }
                      if (fluid.get(component, fluid.path("options", "components", context, "type")) && !component[context]) {
                          foundComponent = fluid.get(component, context, {strategies: fetchStrategies});
                          return true;
                      }
                  });
              }
              if (!foundComponent && parsed.path !== "") {
                  var ref = fluid.renderContextReference(parsed);
                  fluid.log("Failed to resolve reference " + ref + ": thatStack contains\n" + fluid.dumpThatStack(thatStack, instantiator));
                  fluid.fail("Failed to resolve reference " + ref + " - could not match context with name " 
                      + context + " from component leaf of type " + parentThat.typeName, "\ninstantiator contents: ", instantiator);
              }
              return fluid.get(foundComponent, parsed.path, fetchStrategies);
          };
          return fetcher;
      }
       
      function makeStackResolverOptions(instantiator, parentThat, localRecord, expandOptions) {
          return $.extend(true, {}, fluid.defaults("fluid.resolveEnvironment"), {
              fetcher: makeStackFetcher(instantiator, parentThat, localRecord, expandOptions)
          }); 
      }
      
      // unsupported, non-API function
      fluid.instantiator = function(freeInstantiator) {
          // NB: We may not use the options merging framework itself here, since "withInstantiator" below
          // will blow up, as it tries to resolve the instantiator which we are instantiating *NOW*
          var preThat = {
              options: {
                  "fluid.visitComponents.fireBreak": true         
              },
              idToPath: {},
              pathToComponent: {},
              nickName: "instantiator"
          };
          var that = fluid.typeTag("fluid.instantiator");
          that = $.extend(that, preThat);
  
          that.getThatStack = function(component) {
              var path = that.idToPath[component.id] || "";
              var parsed = fluid.model.parseEL(path);
              var togo = fluid.transform(parsed, function(value, i) {
                  var parentPath = fluid.model.composeSegments.apply(null, parsed.slice(0, i + 1));
                  return that.pathToComponent[parentPath];    
              });
              var root = that.pathToComponent[""];
              if (root) {
                  togo.unshift(root);
              }
              return togo;
          };
          that.getEnvironmentalStack = function() {
              var togo = [fluid.staticEnvironment];
              if (!freeInstantiator) {
                  togo.push(fluid.globalThreadLocal());
              }
              return togo;
          };
          that.getFullStack = function(component) {
              var thatStack = component? that.getThatStack(component) : [];
              return that.getEnvironmentalStack().concat(thatStack);
          };
          function recordComponent(component, path) {
              that.idToPath[component.id] = path;
              if (that.pathToComponent[path]) {
                  fluid.fail("Error during instantiation - path " + path + " which has just created component " + fluid.dumpThat(component) 
                      + " has already been used for component " + fluid.dumpThat(that.pathToComponent[path]) + " - this is a circular instantiation or other oversight."
                      + " Please clear the component using instantiator.clearComponent() before reusing the path.");
              }
              that.pathToComponent[path] = component;          
          }
          that.recordRoot = function(component) {
              if (component && component.id && !that.pathToComponent[""]) {
                  recordComponent(component, "");
              }  
          };
          that.pushUpcomingInstantiation = function(parent, name) {
              that.expectedParent = parent;
              that.expectedName = name;
          };
          that.recordComponent = function(component) {
              if (that.expectedName) {
                  that.recordKnownComponent(that.expectedParent, component, that.expectedName);
                  delete that.expectedName;
                  delete that.expectedParent;
              }
              else {
                  that.recordRoot(component);
              }
          };
          that.clearComponent = function(component, name, child, options, noModTree) {
              options = options || {visited: {}, flat: true};
              child = child || component[name];
              fluid.fireEvent(fluid.get(child, "options.clearFunction"), child);
              fluid.visitComponentChildren(child, function(gchild, gchildname) {
                  that.clearComponent(child, gchildname, null, options, noModTree);
              }, options);
              var path = that.idToPath[child.id];
              delete that.idToPath[child.id];
              delete that.pathToComponent[path];
              if (!noModTree) {
                  delete component[name];
              }
          };
          that.recordKnownComponent = function(parent, component, name) {
              var parentPath = that.idToPath[parent.id] || "";
              var path = fluid.model.composePath(parentPath, name);
              recordComponent(component, path);
          };
          return that;
      };
      
      fluid.freeInstantiator = fluid.instantiator(true);
      
      // unsupported, non-API function
      fluid.argMapToDemands = function(argMap) {
          var togo = [];
          fluid.each(argMap, function(value, key) {
              togo[value] = "{" + key + "}";  
          });
          return togo;
      };
      
      // unsupported, non-API function
      fluid.makePassArgsSpec = function(initArgs) {
          return fluid.transform(initArgs, function(arg, index) {
              return "{arguments}." + index;
          });
      };
      
      function mergeToMergeAll(options) {
          if (options && options.mergeOptions) {
              options.mergeAllOptions = ["{options}"].concat(fluid.makeArray(options.mergeOptions));
          }
      }
      
      function upgradeMergeOptions(demandspec) {
          mergeToMergeAll(demandspec);
          if (demandspec.mergeAllOptions) {
              if (demandspec.options) {
                  fluid.fail("demandspec ", demandspec, 
                      " is invalid - cannot specify literal options together with mergeOptions or mergeAllOptions"); 
              }
              demandspec.options = {
                  mergeAllOptions: demandspec.mergeAllOptions
              };
          }
          if (demandspec.options) {
              delete demandspec.options.mergeOptions;
          }
      }
      
      /** Given a concrete argument list and/or options, determine the final concrete
       * "invocation specification" which is coded by the supplied demandspec in the 
       * environment "thatStack" - the return is a package of concrete global function name
       * and argument list which is suitable to be executed directly by fluid.invokeGlobalFunction.
       */
      // unsupported, non-API function
      fluid.embodyDemands = function(instantiator, parentThat, demandspec, initArgs, options) {
          options = options || {};
          
          upgradeMergeOptions(demandspec);
          var oldOptions = fluid.get(options, "componentRecord.options");
          options.componentRecord = $.extend(true, {}, options.componentRecord, 
              fluid.censorKeys(demandspec, ["args", "funcName", "registeredFrom"]));
          var mergeAllZero = fluid.get(options, "componentRecord.options.mergeAllOptions.0");
          if (mergeAllZero === "{options}") {
              fluid.set(options, "componentRecord.options.mergeAllOptions.0", oldOptions);
          }
          
          var demands = fluid.makeArray(demandspec.args);
          var upDefaults = fluid.defaults(demandspec.funcName); // I can SEE into TIME!!
          var argMap = upDefaults? upDefaults.argumentMap : null;
          var inferMap = false;
          if (!argMap && (upDefaults || (options && options.componentRecord)) && !options.passArgs) {
              inferMap = true;
              // infer that it must be a little component if we have any reason to believe it is a component
              if (demands.length < 2) {
                  argMap = fluid.rawDefaults("fluid.littleComponent").argumentMap;
              }
              else {
                  argMap = {options: demands.length - 1}; // wild guess in the old style
              }
          }
          options = options || {};
          if (demands.length === 0) {
              if (options.componentRecord && argMap) {
                  demands = fluid.argMapToDemands(argMap);
              }
              else if (options.passArgs) {
                  demands = fluid.makePassArgsSpec(initArgs);
              }
          }
          var localRecord = $.extend({"arguments": initArgs}, fluid.censorKeys(options.componentRecord, ["type"]));
          fluid.each(argMap, function(index, name) {
              if (initArgs.length > 0) {
                  localRecord[name] = localRecord["arguments"][index];
              }
              if (demandspec[name] !== undefined && localRecord[name] === undefined) {
                  localRecord[name] = demandspec[name];
              }
          });
          mergeToMergeAll(localRecord.options);
          mergeToMergeAll(argMap && demands[argMap.options]);
          var upstreamLocalRecord = $.extend({}, localRecord);
          if (options.componentRecord.options !== undefined) {
              upstreamLocalRecord.options = options.componentRecord.options;
          }
          var expandOptions = makeStackResolverOptions(instantiator, parentThat, localRecord);
          var args = [];
          if (demands) {
              for (var i = 0; i < demands.length; ++i) {
                  var arg = demands[i];
                  // Weak detection since we cannot guarantee this material has not been copied
                  if (fluid.isMarker(arg) && arg.value === fluid.COMPONENT_OPTIONS.value) {
                      arg = "{options}";
                      // Backwards compatibility for non-users of GRADES - last-ditch chance to correct the inference
                      if (inferMap) {
                          argMap = {options: i};
                      } 
                  }
                  if (typeof(arg) === "string") {
                      if (arg.charAt(0) === "@") {
                          var argpos = arg.substring(1);
                          arg = "{arguments}." + argpos;
                      }
                  }
                  if (!argMap || argMap.options !== i) {
                      // defer expansion required if it is non-pseudoarguments demands and this argument *is* the options
                      args[i] = fluid.expander.expandLight(arg, expandOptions);
                  }
                  else { // It is the component options
                      if (arg && typeof(arg) === "object" && !arg.targetTypeName) {
                          arg.targetTypeName = demandspec.funcName;
                      }
                      // ensure to copy the arg since it is an alias of the demand block material (FLUID-4223)
                      // and will be destructively expanded
                      args[i] = {marker: fluid.EXPAND, value: fluid.copy(arg), localRecord: upstreamLocalRecord};
                  }
                  if (args[i] && fluid.isMarker(args[i].marker, fluid.EXPAND_NOW)) {
                      args[i] = fluid.expander.expandLight(args[i].value, expandOptions);
                  }
              }
          }
          else {
              args = initArgs? initArgs : [];
          }
  
          var togo = {
              args: args,
              funcName: demandspec.funcName
          };
          return togo;
      };
      
      var aliasTable = {};
      
      fluid.alias = function(demandingName, aliasName) {
          if (aliasName) {
              aliasTable[demandingName] = aliasName;
          }
          else {
              return aliasTable[demandingName];
          }
      };
     
      var dependentStore = {};
      
      function searchDemands(demandingName, contextNames) {
          var exist = dependentStore[demandingName] || [];
  outer:  for (var i = 0; i < exist.length; ++i) {
              var rec = exist[i];
              for (var j = 0; j < contextNames.length; ++j) {
                  if (rec.contexts[j] !== contextNames[j]) {
                      continue outer;
                  }
              }
              return rec.spec; // jslint:ok
          }
      }
      
      var isDemandLogging = false;
      fluid.setDemandLogging = function(set) {
          isDemandLogging = set;  
      };
      
      // unsupported, non-API function
      fluid.isDemandLogging = function(demandingNames) {
          return isDemandLogging && fluid.isLogging();
      };
      
      fluid.demands = function(demandingName, contextName, spec) {
          var contextNames = fluid.makeArray(contextName).sort(); 
          if (!spec) {
              return searchDemands(demandingName, contextNames);
          }
          else if (spec.length) {
              spec = {args: spec};
          }
          if (fluid.getCallerInfo && fluid.isDemandLogging()) {
              var callerInfo = fluid.getCallerInfo(5);
              if (callerInfo) {
                  spec.registeredFrom = callerInfo;
              }
          }
          var exist = dependentStore[demandingName];
          if (!exist) {
              exist = [];
              dependentStore[demandingName] = exist;
          }
          exist.push({contexts: contextNames, spec: spec});
      };
  
      // unsupported, non-API function
      fluid.compareDemands = function(speca, specb) {
          var p1 = speca.uncess - specb.uncess;
          return p1 === 0? specb.intersect - speca.intersect : p1;
      };
      
      // unsupported, non-API function
      fluid.locateAllDemands = function(instantiator, parentThat, demandingNames) {
          var demandLogging = fluid.isDemandLogging(demandingNames);
          if (demandLogging) {
              fluid.log("Resolving demands for function names ", demandingNames, " in context of " +
                  (parentThat? "component " + parentThat.typeName : "no component"));
          }
          
          var contextNames = {};
          var visited = [];
          var thatStack = instantiator.getFullStack(parentThat);
          visitComponents(instantiator, thatStack, function(component, xname, options, up, down) {
              contextNames[component.typeName] = true;
              visited.push(component);
          });
          if (demandLogging) {
              fluid.log("Components in scope for resolution:\n" + fluid.dumpThatStack(visited, instantiator));  
          }
          var matches = [];
          for (var i = 0; i < demandingNames.length; ++i) {
              var rec = dependentStore[demandingNames[i]] || [];
              for (var j = 0; j < rec.length; ++j) {
                  var spec = rec[j];
                  var record = {spec: spec, intersect: 0, uncess: 0};
                  for (var k = 0; k < spec.contexts.length; ++k) {
                      record[contextNames[spec.contexts[k]]? "intersect" : "uncess"] += 2;
                  }
                  if (spec.contexts.length === 0) { // allow weak priority for contextless matches
                      record.intersect++;
                  }
                  // TODO: Potentially more subtle algorithm here - also ambiguity reports  
                  matches.push(record); 
              }
          }
          matches.sort(fluid.compareDemands);
          return matches;   
      };
  
      // unsupported, non-API function
      fluid.locateDemands = function(instantiator, parentThat, demandingNames) {
          var matches = fluid.locateAllDemands(instantiator, parentThat, demandingNames);
          var demandspec = matches.length === 0 || matches[0].intersect === 0? null : matches[0].spec.spec;
          if (fluid.isDemandLogging(demandingNames)) {
              if (demandspec) {
                  fluid.log("Located " + matches.length + " potential match" + (matches.length === 1? "" : "es") + ", selected best match with " + matches[0].intersect 
                      + " matched context names: ", demandspec);
              }
              else {
                  fluid.log("No matches found for demands, using direct implementation");
              }
          }  
          return demandspec;
      };
      
      /** Determine the appropriate demand specification held in the fluid.demands environment 
       * relative to "thatStack" for the function name(s) funcNames.
       */
      // unsupported, non-API function
      fluid.determineDemands = function (instantiator, parentThat, funcNames) {
          funcNames = fluid.makeArray(funcNames);
          var newFuncName = funcNames[0];
          var demandspec = fluid.locateDemands(instantiator, parentThat, funcNames) || {};
          if (demandspec.funcName) {
              newFuncName = demandspec.funcName;
          }
          
          var aliasTo = fluid.alias(newFuncName);
          
          if (aliasTo) {
              newFuncName = aliasTo;
              fluid.log("Following redirect from function name " + newFuncName + " to " + aliasTo);
              var demandspec2 = fluid.locateDemands(instantiator, parentThat, [aliasTo]);
              if (demandspec2) {
                  fluid.each(demandspec2, function(value, key) {
                      if (localRecordExpected.test(key)) {
                          fluid.fail("Error in demands block ", demandspec2, " - content with key \"" + key 
                              + "\" is not supported since this demands block was resolved via an alias from \"" + newFuncName + "\"");
                      }  
                  });
                  if (demandspec2.funcName) {
                      newFuncName = demandspec2.funcName;
                      fluid.log("Followed final inner demands to function name \"" + newFuncName + "\"");
                  }
              }
          }
          
          return fluid.merge(null, {funcName: newFuncName, args: fluid.makeArray(demandspec.args)}, fluid.censorKeys(demandspec, ["funcName", "args"]));
      };
      
      // unsupported, non-API function
      fluid.resolveDemands = function(instantiator, parentThat, funcNames, initArgs, options) {
          var demandspec = fluid.determineDemands(instantiator, parentThat, funcNames);
          return fluid.embodyDemands(instantiator, parentThat, demandspec, initArgs, options);
      };
      
      // TODO: make a *slightly* more performant version of fluid.invoke that perhaps caches the demands
      // after the first successful invocation
      fluid.invoke = function(functionName, args, that, environment) {
          args = fluid.makeArray(args);
          return fluid.withInstantiator(that, function(instantiator) {
              var invokeSpec = fluid.resolveDemands(instantiator, that, functionName, args, {passArgs: true});
              return fluid.invokeGlobalFunction(invokeSpec.funcName, invokeSpec.args, environment);
          });
      };
      
      fluid.invoke = fluid.wrapActivity(fluid.invoke, ["    while invoking function with name \"", "arguments.0", "\" from component", "arguments.2"]); 
      
      /** Make a function which performs only "static redispatch" of the supplied function name - 
       * that is, taking only account of the contents of the "static environment". Since the static
       * environment is assumed to be constant, the dispatch of the call will be evaluated at the
       * time this call is made, as an optimisation.
       */
      
      fluid.makeFreeInvoker = function(functionName, environment) {
          var demandSpec = fluid.determineDemands(fluid.freeInstantiator, null, functionName);
          return function() {
              var invokeSpec = fluid.embodyDemands(fluid.freeInstantiator, null, demandSpec, fluid.makeArray(arguments), {passArgs: true});
              return fluid.invokeGlobalFunction(invokeSpec.funcName, invokeSpec.args, environment);
          };
      };
      
      fluid.makeInvoker = function(instantiator, that, demandspec, functionName, environment) {
          demandspec = demandspec || fluid.determineDemands(instantiator, that, functionName);
          return function() {
              var args = fluid.makeArray(arguments);
              return fluid.pushActivity(function() {
                  var invokeSpec = fluid.embodyDemands(instantiator, that, demandspec, args, {passArgs: true});
                  return fluid.invokeGlobalFunction(invokeSpec.funcName, invokeSpec.args, environment);
              }, ["    while invoking invoker with name " + functionName + " on component", that]);
          };
      };
      
      fluid.event.listenerEngine = function(eventSpec, callback) {
          var argstruc = {};
          function checkFire() {
              var notall = fluid.find(eventSpec, function(value, key) {
                  if (argstruc[key] === undefined) {
                      return true;
                  }  
              });
              if (!notall) {
                  callback(argstruc);
                  fluid.clear(argstruc);
              }
          }
          fluid.each(eventSpec, function(event, eventName) {
              event.addListener(function() {
                  argstruc[eventName] = fluid.makeArray(arguments);
                  checkFire();
              });
          });
      };
      
      // unsupported, non-API function
      fluid.event.dispatchListener = function(instantiator, that, listener, eventName, eventSpec, indirectArgs) {
          return fluid.wrapActivity(function() {
              listener = fluid.event.resolveListener(listener); // just resolves globals
              var args = indirectArgs? arguments[0] : fluid.makeArray(arguments);
              var demandspec = fluid.determineDemands(instantiator, that, eventName);
              if (demandspec.args.length === 0 && eventSpec.args) {
                  demandspec.args = eventSpec.args;
              }
              var resolved = fluid.embodyDemands(instantiator, that, demandspec, args, {passArgs: true, componentOptions: eventSpec}); 
              return listener.apply(null, resolved.args);
          }, [" firing to listener to event named " + eventName + " of component ", that]);
      };
      
      fluid.event.resolveListenerRecord = function(lisrec, that, eventName) {
          return fluid.withInstantiator(that, function(instantiator) {
              var records = fluid.makeArray(lisrec);
              return fluid.transform(records, function(record) {
                  if (fluid.isPrimitive(record)) {
                      record = {listener: record};
                  }
                  var listener = fluid.expandOptions(record.listener, that);
                  if (!listener) {
                      fluid.fail("Error in listener record - could not resolve reference " + record.listener + " to a listener or firer. "
                          + "Did you miss out \"events.\" when referring to an event firer?");
                  }
                  if (listener.typeName === "fluid.event.firer") {
                      listener = listener.fire;
                  }
                  record.listener = fluid.event.dispatchListener(instantiator, that, listener, eventName, record);
                  return record;
              });
          }, [ "    while resolving listener record for event named " + eventName + " for component ", that]); 
      };
      
      fluid.event.expandOneEvent = function(event, that) {
          var origin;
          if (typeof(event) === "string" && event.charAt(0) !== "{") {
              // Special dispensation so we can resolve onto our own events without GINGER WORLD
              origin = that.events[event];
          }
          else {
              origin = fluid.expandOptions(event, that);
          }
          if (!origin || origin.typeName !== "fluid.event.firer") {
              fluid.fail("Error in event specification - could not resolve base event reference ", event, " to an event firer: got ", origin);
          }
          return origin;
      };
      
      fluid.event.expandEvents = function(event, that) {
          return typeof(event) === "string"?
              fluid.event.expandOneEvent(event, that) :
              fluid.transform(event, function(oneEvent) {
                  return fluid.event.expandOneEvent(oneEvent, that);
              });
      };
      
      // unsupported, non-API function
      fluid.event.resolveEvent = function(that, eventName, eventSpec) {
          return fluid.withInstantiator(that, function(instantiator) {
              if (typeof(eventSpec) === "string") {
                  eventSpec = {event: eventSpec};
              }
              var event = eventSpec.event || eventSpec.events;
              if (!event) {
                  fluid.fail("Event specification for event with name " + eventName + " does not include a base event specification: ", eventSpec);
              }
              
              var origin = fluid.event.expandEvents(event, that);
  
              var isMultiple = origin.typeName !== "fluid.event.firer";
              var isComposite = eventSpec.args || isMultiple;
              // If "event" is not composite, we want to share the listener list and FIRE method with the original
              // If "event" is composite, we need to create a new firer. "composite" includes case where any boiling
              // occurred - this was implemented wrongly in 1.4.
              var firer;
              if (isComposite) {
                  firer = fluid.event.getEventFirer(null, null, " [composite] " + fluid.event.nameEvent(that, eventName));
                  var dispatcher = fluid.event.dispatchListener(instantiator, that, firer.fire, eventName, eventSpec, isMultiple);
                  if (isMultiple) {
                      fluid.event.listenerEngine(origin, dispatcher);
                  }
                  else {
                      origin.addListener(dispatcher);
                  }
              }
              else {
                  firer = {typeName: "fluid.event.firer"}; // jslint:ok - already defined
                  firer.fire = function () {
                      var outerArgs = fluid.makeArray(arguments);
                      // TODO: this resolution should really be supplied for ALL events!
                      return fluid.withInstantiator(that, function () {
                          return origin.fire.apply(null, outerArgs);
                      }, " firing synthetic event " + eventName, instantiator);
                  };
                  firer.addListener = function (listener, namespace, predicate, priority) {
                      var dispatcher = fluid.event.dispatchListener(instantiator, that, listener, eventName, eventSpec);
                      origin.addListener(dispatcher, namespace, predicate, priority);
                  };
                  firer.removeListener = function (listener) {
                      origin.removeListener(listener);
                  };
              }
              return firer;
          }, ["    while resolving event with name " + eventName + " attached to component ", that]); 
      };
      
          
      fluid.registerNamespace("fluid.expander");
      
      /** rescue that part of a component's options which should not be subject to
       * options expansion via IoC - this initially consists of "components" and "mergePolicy" 
       * but will be expanded by the set of paths specified as "noexpand" within "mergePolicy" 
       */
      // unsupported, non-API function
      fluid.expander.preserveFromExpansion = function(options) {
          var preserve = {};
          var preserveList = fluid.arrayToHash(["mergePolicy", "mergeAllOptions", "components", "invokers", "events", "listeners", "transformOptions"]);
          fluid.each(options.mergePolicy, function(value, key) {
              if (fluid.mergePolicyIs(value, "noexpand")) {
                  preserveList[key] = true;
              }
          });
          fluid.each(preserveList, function(xvalue, path) {
              var pen = fluid.model.getPenultimate(options, path);
              var value = pen.root[pen.last];
              delete pen.root[pen.last];
              fluid.set(preserve, path, value);  
          });
          return {
              restore: function(target) {
                  fluid.each(preserveList, function(xvalue, path) {
                      var preserved = fluid.get(preserve, path);
                      if (preserved !== undefined) {
                          fluid.set(target, path, preserved);
                      }
                  });
              }
          };
      };
      
      /** Expand a set of component options with respect to a set of "expanders" (essentially only
       *  deferredCall) -  This substitution is destructive since it is assumed that the options are already "live" as the
       *  result of environmental substitutions. Note that options contained inside "components" will not be expanded
       *  by this call directly to avoid linearly increasing expansion depth if this call is occuring as a result of
       *  "initDependents" */
       // TODO: This needs to be integrated with "embodyDemands" above which makes a call to "resolveEnvironment" directly
       // but with very similarly derived options (makeStackResolverOptions)
      fluid.expandOptions = function(args, that, localRecord, outerExpandOptions) {
          if (!args) {
              return args;
          }
          return fluid.withInstantiator(that, function(instantiator) {
              //fluid.log("expandOptions for " + that.typeName + " executing with instantiator " + instantiator.id);
              var expandOptions = makeStackResolverOptions(instantiator, that, localRecord, outerExpandOptions);
              expandOptions.noCopy = true; // It is still possible a model may be fetched even though it is preserved
              var pres;
              if (!fluid.isArrayable(args) && !fluid.isPrimitive(args)) {
                  pres = fluid.expander.preserveFromExpansion(args);
              }
              var expanded = fluid.expander.expandLight(args, expandOptions);
              if (pres) {
                  pres.restore(expanded);
              }
              return expanded;
          }, ["    while expanding options for component of type " + that.typeName + ": ", that]);
      };
      
      // unsupported, non-API function    
      fluid.locateTransformationRecord = function(that) {
          return fluid.withInstantiator(that, function(instantiator) {
              var matches = fluid.locateAllDemands(instantiator, that, ["fluid.transformOptions"]);
              return fluid.find(matches, function(match) {
                  return match.uncess === 0 && fluid.contains(match.spec.contexts, that.typeName)? match.spec.spec : undefined;
              });
          });
      };
      
      // 
      fluid.hashToArray = function(hash) {
          var togo = [];
          fluid.each(hash, function(value, key) {
              togo.push(key);
          });
          return togo;
      };
      
      // unsupported, non-API function    
      fluid.localRecordExpected = ["type", "options", "arguments", "mergeOptions",
          "mergeAllOptions", "createOnEvent", "priority"];
      // unsupported, non-API function    
      fluid.checkComponentRecord = function(defaults, localRecord) {
          var expected = fluid.arrayToHash(fluid.localRecordExpected);
          fluid.each(defaults.argumentMap, function(value, key) {
              expected[key] = true;
          });
          fluid.each(localRecord, function(value, key) {
              if (!expected[key]) {
                  fluid.fail("Probable error in subcomponent record - key \"" + key + 
                      "\" found, where the only legal options are " + 
                      fluid.hashToArray(expected).join(", "));
              }  
          });
      };
      
      // unsupported, non-API function
      fluid.expandComponentOptions = function(defaults, userOptions, that) {
          if (userOptions && userOptions.localRecord) {
              fluid.checkComponentRecord(defaults, userOptions.localRecord);
          }
          defaults = fluid.expandOptions(fluid.copy(defaults), that);
          var localRecord = {};
          if (userOptions && userOptions.marker === fluid.EXPAND) {
              // TODO: Somewhat perplexing... the local record itself, by any route we could get here, consists of unexpanded
              // material taken from "componentOptions"
              var localOptions = fluid.get(userOptions, "localRecord.options");
              if (localOptions) {
                  if (defaults && defaults.mergePolicy) {
                      localOptions.mergePolicy = defaults.mergePolicy;
                  }
                  localRecord.options = fluid.expandOptions(localOptions, that);
              }
              localRecord["arguments"] = fluid.get(userOptions, "localRecord.arguments");
              var toExpand = userOptions.value;
              userOptions = fluid.expandOptions(toExpand, that, localRecord, {direct: true});
          }
          localRecord.directOptions = userOptions;
          if (!localRecord.options) {
              // Catch the case where there is no demands block and everything is in the subcomponent record - 
              // in this case, embodyDemands will not construct a localRecord and what the user refers to by "options"
              // is really what we properly call "directOptions".
              localRecord.options = userOptions;
          }
          var mergeOptions = (userOptions && userOptions.mergeAllOptions) || ["{directOptions}"];
          var togo = fluid.transform(mergeOptions, function(path) {
              // Avoid use of expandOptions in simple case to avoid infinite recursion when constructing instantiator
              return path === "{directOptions}"? localRecord.directOptions : fluid.expandOptions(path, that, localRecord, {direct: true}); 
          });
          var transRec = fluid.locateTransformationRecord(that);
          if (transRec) {
              togo[0].transformOptions = transRec.options;
          }
          return [defaults].concat(togo);
      };
      
      fluid.expandComponentOptions = fluid.wrapActivity(fluid.expandComponentOptions, 
          ["    while expanding component options ", "arguments.1.value", " with record ", "arguments.1", " for component ", "arguments.2"]);
  
     
      // NON-API function 
      fluid.getInstantiators = function() {
          var root = fluid.globalThreadLocal();
          var ins = root["fluid.instantiator"];
          if (!ins) {
              ins = root["fluid.instantiator"] = [];
          }
          return ins;    
      };
      
      // These two are the only functions which touch the instantiator stack
      // NON-API function
      // This function is stateful and MUST NOT be called by client code
      fluid.withInstantiator = function(that, func, message, userInstantiator) {
          var ins = fluid.getInstantiators();
          var oldLength;
          var instantiator = userInstantiator;
  
          return fluid.pushActivity(function() {
              return fluid.tryCatch(function() {
                  if (!instantiator) {
                      if (ins.length === 0) {
                          instantiator = fluid.instantiator();
                          fluid.log("Created new instantiator with id " + instantiator.id + " in order to operate on component " + (that? that.typeName : "[none]"));
                          }
                      else {
                          instantiator = ins[ins.length - 1];
                      }
                  }
                  ins.push(instantiator);
                  oldLength = ins.length;
                
                  if (that) {
                      instantiator.recordComponent(that);
                  }
                  //fluid.log("Instantiator stack +1 to " + instantiator.stackCount + " for " + typeName);
                  return func(instantiator);
              }, null, function() {
                  if (ins.length !== oldLength) {
                      fluid.fail("Instantiator stack corrupted - old length " + oldLength + " new length " + ins.length);
                  }
                  if (ins[ins.length - 1] != instantiator) {
                      fluid.fail("Instantiator stack corrupted at stack top - old id " + instantiator.id + " new id " + ins[ins.length-1].id); 
                  }
                  ins.length--;
                  //fluid.log("Instantiator stack -1 to " + instantiator.stackCount + " for " + typeName);
                  if (ins.length === 0) {
                      fluid.log("Cleared instantiators (last id " + instantiator.id + ") from threadLocal for end of " + (that? that.typeName : "[none]"));
                  }
              });
          }, message);
      };
      
      // The case without the instantiator is from the ginger strategy - this logic is still a little ragged
      fluid.initDependent = function(that, name, userInstantiator, directArgs) {
          if (!that || that[name]) { return; }
          fluid.log("Beginning instantiation of component with name \"" + name + "\" as child of " + fluid.dumpThat(that));
          directArgs = directArgs || [];
          var component = that.options.components[name];
          var instance; // escape to here for debugging purposes
          
          fluid.withInstantiator(that, function(instantiator) {
              if (typeof(component) === "string") {
                  that[name] = fluid.expandOptions([component], that)[0]; // TODO: expose more sensible semantic for expandOptions 
              }
              else if (component.type) {
                  var invokeSpec = fluid.resolveDemands(instantiator, that, [component.type, name], directArgs, {componentRecord: component});
                  instantiator.pushUpcomingInstantiation(that, name);
                  fluid.tryCatch(function() {
                      that[inCreationMarker] = true;
                      instance = fluid.initSubcomponentImpl(that, {type: invokeSpec.funcName}, invokeSpec.args);
                      // The existing instantiator record will be provisional, adjust it to take account of the true return
                      // TODO: Instantiator contents are generally extremely incomplete
                      var path = fluid.composePath(instantiator.idToPath[that.id] || "", name);
                      var existing = instantiator.pathToComponent[path];
                      if (existing && existing !== instance) {
                          instantiator.clearComponent(that, name, existing, null, true);
                      }
                      if (instance && instance.typeName && instance.id && instance !== existing) {
                          instantiator.recordKnownComponent(that, instance, name);
                      }
                      that[name] = instance;
                  }, null, function() {
                      delete that[inCreationMarker];
                      instantiator.pushUpcomingInstantiation();
                  });
              }
              else { 
                  that[name] = component;
              }
          }, ["    while instantiating dependent component with name \"" + name + "\" with record ", component, " as child of ", that],
          userInstantiator);
          if (instance) {
              fluid.log("Finished instantiation of component with name \"" + name + "\" and id " + instance.id + " as child of " + fluid.dumpThat(that));
          }
      };
      
      // unsupported, non-API function
      fluid.bindDeferredComponent = function(that, componentName, component, instantiator) {
          var events = fluid.makeArray(component.createOnEvent);
          fluid.each(events, function(eventName) {
              that.events[eventName].addListener(function() {
                  fluid.log("Beginning instantiation of deferred component " + componentName + " due to event " + eventName);
                  if (that[componentName]) {
                      instantiator.clearComponent(that, componentName);
                  }
                  fluid.initDependent(that, componentName, instantiator);
              }, null, null, component.priority);
          });
      };
      
      // unsupported, non-API function
      fluid.priorityForComponent = function(component) {
          return component.priority? component.priority : 
              (component.type === "fluid.typeFount" || fluid.hasGrade(fluid.defaults(component.type), "fluid.typeFount"))?
              "first" : undefined;  
      };
      
      fluid.initDependents = function(that) {
          var options = that.options;
          var components = options.components || {};
          var componentSort = {};
          fluid.withInstantiator(that, function(instantiator) {
              fluid.each(components, function(component, name) {
                  if (!component.createOnEvent) {
                      var priority = fluid.priorityForComponent(component);
                      componentSort[name] = {key: name, priority: fluid.event.mapPriority(priority, 0)};
                  }
                  else {
                      fluid.bindDeferredComponent(that, name, component, instantiator);
                  }
              });
              var componentList = fluid.event.sortListeners(componentSort);
              fluid.each(componentList, function(entry) {
                  fluid.initDependent(that, entry.key);  
              });
              var invokers = options.invokers || {};
              for (var name in invokers) {
                  var invokerec = invokers[name];
                  var funcName = typeof(invokerec) === "string"? invokerec : null;
                  that[name] = fluid.withInstantiator(that, function(instantiator) {
                      fluid.log("Beginning instantiation of invoker with name \"" + name + "\" as child of " + fluid.dumpThat(that));
                      return fluid.makeInvoker(instantiator, that, funcName? null : invokerec, funcName);
                  }, ["    while instantiating invoker with name \"" + name + "\" with record ", invokerec, " as child of ", that]); // jslint:ok
                  fluid.log("Finished instantiation of invoker with name \"" + name + "\" as child of " + fluid.dumpThat(that)); 
              }
          }, ["    while instantiating dependent components for component " + that.typeName]);
      };   
          
      fluid.staticEnvironment = fluid.typeTag("fluid.staticEnvironment");
      
      fluid.staticEnvironment.environmentClass = fluid.typeTag("fluid.browser");
      
      fluid.globalThreadLocal = fluid.threadLocal(function() {
          return fluid.typeTag("fluid.dynamicEnvironment");
      });
      
      // Although the following two functions are unsupported and not part of the IoC
      // implementation proper, they are still used in the renderer
      // expander as well as in some old-style tests and various places in CSpace.
      
      // unsupported, non-API function
      fluid.withEnvironment = function(envAdd, func, root) {
          root = root || fluid.globalThreadLocal();
          return fluid.tryCatch(function() {
              for (var key in envAdd) {
                  root[key] = envAdd[key];
              }
              $.extend(root, envAdd);
              return func();
          }, null, function() {
              for (var key in envAdd) { // jslint:ok duplicate "value"
                  delete root[key]; // TODO: users may want a recursive "scoping" model
              }
          });
      };
      
      // unsupported, non-API function  
      fluid.makeEnvironmentFetcher = function(directModel, elResolver, envGetter) {
          envGetter = envGetter || fluid.globalThreadLocal;
          return function(parsed) {
              var env = envGetter();
              return fluid.fetchContextReference(parsed, directModel, env, elResolver);
          };
      };
  
      // unsupported, non-API function  
      fluid.extractEL = function(string, options) {
          if (options.ELstyle === "ALL") {
              return string;
          }
          else if (options.ELstyle.length === 1) {
              if (string.charAt(0) === options.ELstyle) {
                  return string.substring(1);
              }
          }
          else if (options.ELstyle === "${}") {
              var i1 = string.indexOf("${");
              var i2 = string.lastIndexOf("}");
              if (i1 === 0 && i2 !== -1) {
                  return string.substring(2, i2);
              }
          }
      };
      
      // unsupported, non-API function
      fluid.extractELWithContext = function(string, options) {
          var EL = fluid.extractEL(string, options);
          if (EL && EL.charAt(0) === "{") {
              return fluid.parseContextReference(EL, 0);
          }
          return EL? {path: EL} : EL;
      };
  
      fluid.parseContextReference = function(reference, index, delimiter) {
          var endcpos = reference.indexOf("}", index + 1);
          if (endcpos === -1) {
              fluid.fail("Cannot parse context reference \"" + reference + "\": Malformed context reference without }");
          }
          var context = reference.substring(index + 1, endcpos);
          var endpos = delimiter? reference.indexOf(delimiter, endcpos + 1) : reference.length;
          var path = reference.substring(endcpos + 1, endpos);
          if (path.charAt(0) === ".") {
              path = path.substring(1);
          }
          return {context: context, path: path, endpos: endpos};
      };
      
      fluid.renderContextReference = function(parsed) {
          return "{" + parsed.context + "}." + parsed.path;  
      };
      
      fluid.fetchContextReference = function(parsed, directModel, env, elResolver) {
          if (elResolver) {
              parsed = elResolver(parsed, env);
          }
          var base = parsed.context? env[parsed.context] : directModel;
          if (!base) {
              return base;
          }
          return parsed.noDereference? parsed.path : fluid.get(base, parsed.path);
      };
      
      // unsupported, non-API function
      fluid.resolveContextValue = function(string, options) {
          if (options.bareContextRefs && string.charAt(0) === "{") {
              var parsed = fluid.parseContextReference(string, 0);
              return options.fetcher(parsed);        
          }
          else if (options.ELstyle && options.ELstyle !== "${}") {
              var parsed = fluid.extractELWithContext(string, options); // jslint:ok
              if (parsed) {
                  return options.fetcher(parsed);
              }
          }
          while (typeof(string) === "string") {
              var i1 = string.indexOf("${");
              var i2 = string.indexOf("}", i1 + 2);
              if (i1 !== -1 && i2 !== -1) {
                  var parsed; // jslint:ok
                  if (string.charAt(i1 + 2) === "{") {
                      parsed = fluid.parseContextReference(string, i1 + 2, "}");
                      i2 = parsed.endpos;
                  }
                  else {
                      parsed = {path: string.substring(i1 + 2, i2)};
                  }
                  var subs = options.fetcher(parsed);
                  var all = (i1 === 0 && i2 === string.length - 1); 
                  // TODO: test case for all undefined substitution
                  if (subs === undefined || subs === null) {
                      return subs;
                  }
                  string = all? subs : string.substring(0, i1) + subs + string.substring(i2 + 1);
              }
              else {
                  break;
              }
          }
          return string;
      };
      
      fluid.resolveContextValue = fluid.wrapActivity(fluid.resolveContextValue, 
          ["    while resolving context value ", "arguments.0"]);
      
      function resolveEnvironmentImpl(obj, options) {
          fluid.guardCircularity(options.seenIds, obj, "expansion", 
               " - please ensure options are not circularly connected, or protect from expansion using the \"noexpand\" policy or expander");
          function recurse(arg) {
              return resolveEnvironmentImpl(arg, options);
          }
          if (typeof(obj) === "string" && !options.noValue) {
              return fluid.resolveContextValue(obj, options);
          }
          else if (fluid.isPrimitive(obj) || obj.nodeType !== undefined || obj.jquery) {
              return obj;
          }
          else if (options.filter) {
              return options.filter(obj, recurse, options);
          }
          else {
              return (options.noCopy? fluid.each : fluid.transform)(obj, function(value, key) {
                  return resolveEnvironmentImpl(value, options);
              });
          }
      }
      
      fluid.defaults("fluid.resolveEnvironment", {
          ELstyle:     "${}",
          seenIds:     {},
          bareContextRefs: true
      });
      
      fluid.resolveEnvironment = function(obj, options) {
          // Don't create a component here since this function is itself used in the 
          // component expansion pathway - avoid all expansion in any case to head off FLUID-4301
          options = $.extend({}, fluid.rawDefaults("fluid.resolveEnvironment"), options);
          options.seenIds = {};
          return resolveEnvironmentImpl(obj, options);
      };
  
      /** "light" expanders, starting with support functions for the "deferredFetcher" expander **/
  
      fluid.expander.deferredCall = function(target, source, recurse) {
          var expander = source.expander;
          var args = (!expander.args || fluid.isArrayable(expander.args))? expander.args : fluid.makeArray(expander.args);
          args = recurse(args); 
          return fluid.invokeGlobalFunction(expander.func, args);
      };
      
      fluid.deferredCall = fluid.expander.deferredCall; // put in top namespace for convenience
      
      fluid.deferredInvokeCall = function(target, source, recurse) {
          var expander = source.expander;
          var args = (!expander.args || fluid.isArrayable(expander.args))? expander.args : fluid.makeArray(expander.args);
          args = recurse(args);  
          return fluid.invoke(expander.func, args);
      };
      
      // The "noexpand" expander which simply unwraps one level of expansion and ceases.
      fluid.expander.noexpand = function(target, source) {
          return $.extend(target, source.expander.tree);
      };
    
      fluid.noexpand = fluid.expander.noexpand; // TODO: check naming and namespacing
    
      // unsupported, non-API function
      fluid.expander.lightFilter = function (obj, recurse, options) {
          var togo;
          if (fluid.isArrayable(obj)) {
              togo = options.noCopy? obj : [];
              fluid.each(obj, function(value, key) {togo[key] = recurse(value);});
          }
          else {
              togo = options.noCopy? obj : {};
              for (var key in obj) {
                  var value = obj[key];
                  var expander;
                  if (key === "expander" && !(options.expandOnly && options.expandOnly[value.type])) {
                      expander = fluid.getGlobalValue(value.type);  
                      if (expander) {
                          return expander.call(null, togo, obj, recurse, options);
                      }
                  }
                  if (key !== "expander" || !expander) {
                      togo[key] = recurse(value);
                  }
              }
          }
          return options.noCopy? obj : togo;
      };
        
      // unsupported, non-API function
      fluid.expander.expandLight = function (source, expandOptions) {
          var options = $.extend({}, expandOptions);
          options.filter = fluid.expander.lightFilter;
          return fluid.resolveEnvironment(source, options);       
      };
            
  })(jQuery, fluid_1_5);
  /*
  Copyright 2010-2011 OCAD University
  Copyright 2010-2011 Lucendo Development Ltd.
  
  Licensed under the Educational Community License (ECL), Version 2.0 or the New
  BSD license. You may not use this file except in compliance with one these
  Licenses.
  
  You may obtain a copy of the ECL 2.0 License and BSD License at
  https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
  */
  
  // Declare dependencies
  /*global fluid_1_5:true, jQuery*/
  
  // JSLint options 
  /*jslint white: true, funcinvoke: true, undef: true, newcap: true, nomen: true, regexp: true, bitwise: true, browser: true, forin: true, maxerr: 100, indent: 4 */
  
  var fluid_1_5 = fluid_1_5 || {};
  
  (function ($, fluid) {
  
      /** Framework-global caching state for fluid.fetchResources **/
  
      var resourceCache = {};
    
      var pendingClass = {};
   
      /** Accepts a hash of structures with free keys, where each entry has either
       * href/url or nodeId set - on completion, callback will be called with the populated
       * structure with fetched resource text in the field "resourceText" for each
       * entry. Each structure may contain "options" holding raw options to be forwarded
       * to jQuery.ajax().
       */
    
      fluid.fetchResources = function(resourceSpecs, callback, options) {
          var that = fluid.initLittleComponent("fluid.fetchResources", options);
          that.resourceSpecs = resourceSpecs;
          that.callback = callback;
          that.operate = function() {
              fluid.fetchResources.fetchResourcesImpl(that);
          };
          fluid.each(resourceSpecs, function(resourceSpec, key) {
               resourceSpec.recurseFirer = fluid.event.getEventFirer(null, null, "I/O completion for resource \"" + key + "\"");
               resourceSpec.recurseFirer.addListener(that.operate);
               if (resourceSpec.url && !resourceSpec.href) {
                  resourceSpec.href = resourceSpec.url;
               }
          });
          if (that.options.amalgamateClasses) {
              fluid.fetchResources.amalgamateClasses(resourceSpecs, that.options.amalgamateClasses, that.operate);
          }
          that.operate();
          return that;
      };
    
      /*
       * This function is unsupported: It is not really intended for use by implementors.
       */
      // Add "synthetic" elements of *this* resourceSpec list corresponding to any
      // still pending elements matching the PROLEPTICK CLASS SPECIFICATION supplied 
      fluid.fetchResources.amalgamateClasses = function(specs, classes, operator) {
          fluid.each(classes, function(clazz) {
              var pending = pendingClass[clazz];
              fluid.each(pending, function(pendingrec, canon) {
                  specs[clazz+"!"+canon] = pendingrec;
                  pendingrec.recurseFirer.addListener(operator);
              });
          });
      };
    
      /*
       * This function is unsupported: It is not really intended for use by implementors.
       */
      fluid.fetchResources.timeSuccessCallback = function(resourceSpec) {
          if (resourceSpec.timeSuccess && resourceSpec.options && resourceSpec.options.success) {
              var success = resourceSpec.options.success;
              resourceSpec.options.success = function() {
              var startTime = new Date();
              var ret = success.apply(null, arguments);
              fluid.log("External callback for URL " + resourceSpec.href + " completed - callback time: " + 
                      (new Date().getTime() - startTime.getTime()) + "ms");
              return ret;
              };
          }
      };
      
      // TODO: Integrate punch-through from old Engage implementation
      function canonUrl(url) {
          return url;
      }
      
      fluid.fetchResources.clearResourceCache = function(url) {
          if (url) {
              delete resourceCache[canonUrl(url)];
          }
          else {
              fluid.clear(resourceCache);
          }  
      };
    
      /*
       * This function is unsupported: It is not really intended for use by implementors.
       */
      fluid.fetchResources.handleCachedRequest = function(resourceSpec, response) {
           var canon = canonUrl(resourceSpec.href);
           var cached = resourceCache[canon];
           if (cached.$$firer$$) {
               fluid.log("Handling request for " + canon + " from cache");
               var fetchClass = resourceSpec.fetchClass;
               if (fetchClass && pendingClass[fetchClass]) {
                   fluid.log("Clearing pendingClass entry for class " + fetchClass);
                   delete pendingClass[fetchClass][canon];
               }
               resourceCache[canon] = response;      
               cached.fire(response);
           }
      };
      
      /*
       * This function is unsupported: It is not really intended for use by implementors.
       */
      fluid.fetchResources.completeRequest = function(thisSpec, recurseCall) {
          thisSpec.queued = false;
          thisSpec.completeTime = new Date();
          fluid.log("Request to URL " + thisSpec.href + " completed - total elapsed time: " + 
              (thisSpec.completeTime.getTime() - thisSpec.initTime.getTime()) + "ms");
          thisSpec.recurseFirer.fire();
      };
    
      /*
       * This function is unsupported: It is not really intended for use by implementors.
       */
      fluid.fetchResources.makeResourceCallback = function(thisSpec) {
          return {
              success: function(response) {
                  thisSpec.resourceText = response;
                  thisSpec.resourceKey = thisSpec.href;
                  if (thisSpec.forceCache) {
                      fluid.fetchResources.handleCachedRequest(thisSpec, response);
                  }
                  fluid.fetchResources.completeRequest(thisSpec);
              },
              error: function(response, textStatus, errorThrown) {
                  thisSpec.fetchError = {
                      status: response.status,
                      textStatus: response.textStatus,
                      errorThrown: errorThrown
                  };
                  fluid.fetchResources.completeRequest(thisSpec);
              }
              
          };
      };
      
          
      /*
       * This function is unsupported: It is not really intended for use by implementors.
       */
      fluid.fetchResources.issueCachedRequest = function(resourceSpec, options) {
           var canon = canonUrl(resourceSpec.href);
           var cached = resourceCache[canon];
           if (!cached) {
               fluid.log("First request for cached resource with url " + canon);
               cached = fluid.event.getEventFirer(null, null, "cache notifier for resource URL " + canon);
               cached.$$firer$$ = true;
               resourceCache[canon] = cached;
               var fetchClass = resourceSpec.fetchClass;
               if (fetchClass) {
                   if (!pendingClass[fetchClass]) {
                       pendingClass[fetchClass] = {};
                   }
                   pendingClass[fetchClass][canon] = resourceSpec;
               }
               // options.cache = false; // TODO: Getting weird "not modified" issues on Firefox
               $.ajax(options);
           }
           else {
               if (!cached.$$firer$$) {
                   options.success(cached);
               }
               else {
                   fluid.log("Request for cached resource which is in flight: url " + canon);
                   cached.addListener(function(response) {
                       options.success(response);
                   });
               }
           }
      };
      
      /*
       * This function is unsupported: It is not really intended for use by implementors.
       */
      // Compose callbacks in such a way that the 2nd, marked "external" will be applied
      // first if it exists, but in all cases, the first, marked internal, will be 
      // CALLED WITHOUT FAIL
      fluid.fetchResources.composeCallbacks = function(internal, external) {
          return external? function() {
              try {
                  external.apply(null, arguments);
              }
              catch (e) {
                  fluid.log("Exception applying external fetchResources callback: " + e);
              }
              internal.apply(null, arguments); // call the internal callback without fail
          } : internal;
      };
      
      /*
       * This function is unsupported: It is not really intended for use by implementors.
       */
      fluid.fetchResources.composePolicy = function(target, source, key) {
          return fluid.fetchResources.composeCallbacks(target, source);
      };
      
      fluid.defaults("fluid.fetchResources.issueRequest", {
          mergePolicy: {
              success: fluid.fetchResources.composePolicy,
              error: fluid.fetchResources.composePolicy,
              url: "reverse"
          }
      });
      
      /*
       * This function is unsupported: It is not really intended for use by implementors.
       */
      fluid.fetchResources.issueRequest = function(resourceSpec, key) {
          var thisCallback = fluid.fetchResources.makeResourceCallback(resourceSpec);
          var options = {  
               url:     resourceSpec.href,
               success: thisCallback.success, 
               error:   thisCallback.error,
               dataType: "text"};
          fluid.fetchResources.timeSuccessCallback(resourceSpec);
          fluid.merge(fluid.defaults("fluid.fetchResources.issueRequest").mergePolicy,
                        options, resourceSpec.options);
          resourceSpec.queued = true;
          resourceSpec.initTime = new Date();
          fluid.log("Request with key " + key + " queued for " + resourceSpec.href);
  
          if (resourceSpec.forceCache) {
              fluid.fetchResources.issueCachedRequest(resourceSpec, options);
          }
          else {
              $.ajax(options);
          }
      };
      
      fluid.fetchResources.fetchResourcesImpl = function(that) {
          var complete = true;
          var allSync = true;
          var resourceSpecs = that.resourceSpecs;
          for (var key in resourceSpecs) {
              var resourceSpec = resourceSpecs[key];
              if (!resourceSpec.options || resourceSpec.options.async) {
                  allSync = false;
              }
              if (resourceSpec.href && !resourceSpec.completeTime) {
                   if (!resourceSpec.queued) {
                       fluid.fetchResources.issueRequest(resourceSpec, key);  
                   }
                   if (resourceSpec.queued) {
                       complete = false;
                   }
              }
              else if (resourceSpec.nodeId && !resourceSpec.resourceText) {
                  var node = document.getElementById(resourceSpec.nodeId);
                  // upgrade this to somehow detect whether node is "armoured" somehow
                  // with comment or CDATA wrapping
                  resourceSpec.resourceText = fluid.dom.getElementText(node);
                  resourceSpec.resourceKey = resourceSpec.nodeId;
              }
          }
          if (complete && that.callback && !that.callbackCalled) {
              that.callbackCalled = true;
              if ($.browser.mozilla && !allSync) {
                  // Defer this callback to avoid debugging problems on Firefox
                  setTimeout(function() {
                      that.callback(resourceSpecs);
                      }, 1);
              }
              else {
                  that.callback(resourceSpecs);
              }
          }
      };
      
      fluid.fetchResources.primeCacheFromResources = function(componentName) {
          var resources = fluid.defaults(componentName).resources;
          var that = {typeName: "fluid.fetchResources.primeCacheFromResources"};
          var expanded = (fluid.expandOptions ? fluid.expandOptions : fluid.identity)(fluid.copy(resources), that);
          fluid.fetchResources(expanded);
      };
      
      /** Utilities invoking requests for expansion **/
      fluid.registerNamespace("fluid.expander");
        
      /*
       * This function is unsupported: It is not really intended for use by implementors.
       */
      fluid.expander.makeDefaultFetchOptions = function (successdisposer, failid, options) {
          return $.extend(true, {dataType: "text"}, options, {
              success: function(response, environmentdisposer) {
                  var json = JSON.parse(response);
                  environmentdisposer(successdisposer(json));
              },
              error: function(response, textStatus) {
                  fluid.log("Error fetching " + failid + ": " + textStatus);
              }
          });
      };
    
      /*
       * This function is unsupported: It is not really intended for use by implementors.
       */
      fluid.expander.makeFetchExpander = function (options) {
          return { expander: {
              type: "fluid.expander.deferredFetcher",
              href: options.url,
              options: fluid.expander.makeDefaultFetchOptions(options.disposer, options.url, options.options),
              resourceSpecCollector: "{resourceSpecCollector}",
              fetchKey: options.fetchKey
          }};
      };
      
      fluid.expander.deferredFetcher = function(target, source, recurse, expandOptions) {
          var expander = source.expander;
          var spec = fluid.copy(expander);
          // fetch the "global" collector specified in the external environment to receive
          // this resourceSpec
          var collector = fluid.resolveEnvironment(expander.resourceSpecCollector, expandOptions);
          delete spec.type;
          delete spec.resourceSpecCollector;
          delete spec.fetchKey;
          var environmentdisposer = function(disposed) {
              $.extend(target, disposed);
          };
          // replace the callback which is there (taking 2 arguments) with one which
          // directly responds to the request, passing in the result and OUR "disposer" - 
          // which once the user has processed the response (say, parsing JSON and repackaging)
          // finally deposits it in the place of the expander in the tree to which this reference
          // has been stored at the point this expander was evaluated.
          spec.options.success = function(response) {
               expander.options.success(response, environmentdisposer);
          };
          var key = expander.fetchKey || fluid.allocateGuid();
          collector[key] = spec;
          return target;
      };
      
      
  })(jQuery, fluid_1_5);
  // =========================================================================
  //
  // tinyxmlsax.js - an XML SAX parser in JavaScript compressed for downloading
  //
  // version 3.1
  //
  // =========================================================================
  //
  // Copyright (C) 2000 - 2002, 2003 Michael Houghton (mike@idle.org), Raymond Irving and David Joham (djoham@yahoo.com)
  //
  // This library is free software; you can redistribute it and/or
  // modify it under the terms of the GNU Lesser General Public
  // License as published by the Free Software Foundation; either
  // version 2.1 of the License, or (at your option) any later version.
  
  // This library is distributed in the hope that it will be useful,
  // but WITHOUT ANY WARRANTY; without even the implied warranty of
  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  // Lesser General Public License for more details.
  
  // You should have received a copy of the GNU Lesser General Public
  // License along with this library; if not, write to the Free Software
  // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  //
  // Visit the XML for <SCRIPT> home page at http://xmljs.sourceforge.net
  //
  
  /*
  The zlib/libpng License
  
  Copyright (c) 2000 - 2002, 2003 Michael Houghton (mike@idle.org), Raymond Irving and David Joham (djoham@yahoo.com)
  
  This software is provided 'as-is', without any express or implied
  warranty. In no event will the authors be held liable for any damages
  arising from the use of this software.
  
  Permission is granted to anyone to use this software for any purpose,
  including commercial applications, and to alter it and redistribute it
  freely, subject to the following restrictions:
  
      1. The origin of this software must not be misrepresented; you must not
      claim that you wrote the original software. If you use this software
      in a product, an acknowledgment in the product documentation would be
      appreciated but is not required.
  
      2. Altered source versions must be plainly marked as such, and must not be
      misrepresented as being the original software.
  
      3. This notice may not be removed or altered from any source
      distribution.
   */
  
  // Declare dependencies
  /*global fluid_1_5:true, jQuery*/
  
  // JSLint options 
  /*jslint white: true, funcinvoke: true, undef: true, newcap: true, nomen: true, regexp: true, bitwise: true, browser: true, forin: true, maxerr: 100, indent: 4 */
  
  var fluid_1_5 = fluid_1_5 || {};
  
  (function ($, fluid) {
      
      fluid.XMLP = function(strXML) {
          return fluid.XMLP.XMLPImpl(strXML);
      };
  
          
      // List of closed HTML tags, taken from JQuery 1.2.3
      fluid.XMLP.closedTags = {
          abbr: true, br: true, col: true, img: true, input: true,
          link: true, meta: true, param: true, hr: true, area: true, embed:true
          };
  
      fluid.XMLP._NONE = 0;
      fluid.XMLP._ELM_B = 1;
      fluid.XMLP._ELM_E = 2;
      fluid.XMLP._ELM_EMP = 3; 
      fluid.XMLP._ATT = 4;
      fluid.XMLP._TEXT = 5;
      fluid.XMLP._ENTITY = 6; 
      fluid.XMLP._PI = 7;
      fluid.XMLP._CDATA = 8;
      fluid.XMLP._COMMENT = 9; 
      fluid.XMLP._DTD = 10;
      fluid.XMLP._ERROR = 11;
       
      fluid.XMLP._CONT_XML = 0; 
      fluid.XMLP._CONT_ALT = 1; 
      fluid.XMLP._ATT_NAME = 0; 
      fluid.XMLP._ATT_VAL = 1;
      
      fluid.XMLP._STATE_PROLOG = 1;
      fluid.XMLP._STATE_DOCUMENT = 2; 
      fluid.XMLP._STATE_MISC = 3;
      
      fluid.XMLP._errs = [];
      fluid.XMLP._errs[fluid.XMLP.ERR_CLOSE_PI = 0 ] = "PI: missing closing sequence"; 
      fluid.XMLP._errs[fluid.XMLP.ERR_CLOSE_DTD = 1 ] = "DTD: missing closing sequence"; 
      fluid.XMLP._errs[fluid.XMLP.ERR_CLOSE_COMMENT = 2 ] = "Comment: missing closing sequence"; 
      fluid.XMLP._errs[fluid.XMLP.ERR_CLOSE_CDATA = 3 ] = "CDATA: missing closing sequence"; 
      fluid.XMLP._errs[fluid.XMLP.ERR_CLOSE_ELM = 4 ] = "Element: missing closing sequence"; 
      fluid.XMLP._errs[fluid.XMLP.ERR_CLOSE_ENTITY = 5 ] = "Entity: missing closing sequence"; 
      fluid.XMLP._errs[fluid.XMLP.ERR_PI_TARGET = 6 ] = "PI: target is required"; 
      fluid.XMLP._errs[fluid.XMLP.ERR_ELM_EMPTY = 7 ] = "Element: cannot be both empty and closing"; 
      fluid.XMLP._errs[fluid.XMLP.ERR_ELM_NAME = 8 ] = "Element: name must immediatly follow \"<\""; 
      fluid.XMLP._errs[fluid.XMLP.ERR_ELM_LT_NAME = 9 ] = "Element: \"<\" not allowed in element names"; 
      fluid.XMLP._errs[fluid.XMLP.ERR_ATT_VALUES = 10] = "Attribute: values are required and must be in quotes"; 
      fluid.XMLP._errs[fluid.XMLP.ERR_ATT_LT_NAME = 11] = "Element: \"<\" not allowed in attribute names"; 
      fluid.XMLP._errs[fluid.XMLP.ERR_ATT_LT_VALUE = 12] = "Attribute: \"<\" not allowed in attribute values"; 
      fluid.XMLP._errs[fluid.XMLP.ERR_ATT_DUP = 13] = "Attribute: duplicate attributes not allowed"; 
      fluid.XMLP._errs[fluid.XMLP.ERR_ENTITY_UNKNOWN = 14] = "Entity: unknown entity"; 
      fluid.XMLP._errs[fluid.XMLP.ERR_INFINITELOOP = 15] = "Infinite loop"; 
      fluid.XMLP._errs[fluid.XMLP.ERR_DOC_STRUCTURE = 16] = "Document: only comments, processing instructions, or whitespace allowed outside of document element"; 
      fluid.XMLP._errs[fluid.XMLP.ERR_ELM_NESTING = 17] = "Element: must be nested correctly"; 
                  
  
      fluid.XMLP._checkStructure = function(that, iEvent) {
          var stack = that.m_stack; 
          if (fluid.XMLP._STATE_PROLOG == that.m_iState) {
              // disabled original check for text node in prologue
              that.m_iState = fluid.XMLP._STATE_DOCUMENT;
              }
      
          if (fluid.XMLP._STATE_DOCUMENT === that.m_iState) {
              if ((fluid.XMLP._ELM_B == iEvent) || (fluid.XMLP._ELM_EMP == iEvent)) { 
                  that.m_stack[stack.length] = that.getName();
                  }
              if ((fluid.XMLP._ELM_E == iEvent) || (fluid.XMLP._ELM_EMP == iEvent)) {
                  if (stack.length === 0) {
                      //return this._setErr(XMLP.ERR_DOC_STRUCTURE);
                      return fluid.XMLP._NONE;
                      }
                  var strTop = stack[stack.length - 1];
                  that.m_stack.length--;
                  if (strTop === null || strTop !== that.getName()) { 
                      return that._setErr(that, fluid.XMLP.ERR_ELM_NESTING);
                      }
                  }
      
              // disabled original check for text node in epilogue - "MISC" state is disused
          }
          return iEvent;
      };
      
              
      fluid.XMLP._parseCDATA = function(that, iB) { 
          var iE = that.m_xml.indexOf("]]>", iB); 
          if (iE == -1) { return fluid.XMLP._setErr(that, fluid.XMLP.ERR_CLOSE_CDATA);}
          fluid.XMLP._setContent(that, fluid.XMLP._CONT_XML, iB, iE); 
          that.m_iP = iE + 3; 
          return fluid.XMLP._CDATA;
          };
          
      
      fluid.XMLP._parseComment = function(that, iB) { 
          var iE = that.m_xml.indexOf("-" + "->", iB); 
          if (iE == -1) { 
              return fluid.XMLP._setErr(that, fluid.XMLP.ERR_CLOSE_COMMENT);
              }
          fluid.XMLP._setContent(that, fluid.XMLP._CONT_XML, iB - 4, iE + 3); 
          that.m_iP = iE + 3; 
          return fluid.XMLP._COMMENT;
          };    
      
      fluid.XMLP._parseDTD = function(that, iB) { 
          var iE, strClose, iInt, iLast; 
          iE = that.m_xml.indexOf(">", iB); 
          if (iE == -1) { 
              return fluid.XMLP._setErr(that, fluid.XMLP.ERR_CLOSE_DTD);
              }
          iInt = that.m_xml.indexOf("[", iB); 
          strClose = ((iInt != -1) && (iInt < iE)) ? "]>" : ">"; 
          while (true) { 
              if (iE == iLast) { 
                  return fluid.XMLP._setErr(that, fluid.XMLP.ERR_INFINITELOOP);
                  }
              iLast = iE; 
              iE = that.m_xml.indexOf(strClose, iB); 
              if(iE == -1) { 
                  return fluid.XMLP._setErr(that, fluid.XMLP.ERR_CLOSE_DTD);
                  }
              if (that.m_xml.substring(iE - 1, iE + 2) != "]]>") { break;}
              }
          that.m_iP = iE + strClose.length; 
          return fluid.XMLP._DTD;
          };
          
      fluid.XMLP._parsePI = function(that, iB) { 
          var iE, iTB, iTE, iCB, iCE; 
          iE = that.m_xml.indexOf("?>", iB); 
          if (iE == -1) { return fluid.XMLP._setErr(that, fluid.XMLP.ERR_CLOSE_PI);}
          iTB = fluid.SAXStrings.indexOfNonWhitespace(that.m_xml, iB, iE); 
          if (iTB == -1) { return fluid.XMLP._setErr(that, fluid.XMLP.ERR_PI_TARGET);}
          iTE = fluid.SAXStrings.indexOfWhitespace(that.m_xml, iTB, iE); 
          if (iTE == -1) { iTE = iE;}
          iCB = fluid.SAXStrings.indexOfNonWhitespace(that.m_xml, iTE, iE); 
          if (iCB == -1) { iCB = iE;}
          iCE = fluid.SAXStrings.lastIndexOfNonWhitespace(that.m_xml, iCB, iE); 
          if (iCE == -1) { iCE = iE - 1;}
          that.m_name = that.m_xml.substring(iTB, iTE); 
          fluid.XMLP._setContent(that, fluid.XMLP._CONT_XML, iCB, iCE + 1); 
          that.m_iP = iE + 2; 
          return fluid.XMLP._PI;
          };
          
      fluid.XMLP._parseText = function(that, iB) { 
          var iE = that.m_xml.indexOf("<", iB);
          if (iE == -1) { iE = that.m_xml.length;}
          fluid.XMLP._setContent(that, fluid.XMLP._CONT_XML, iB, iE); 
          that.m_iP = iE; 
          return fluid.XMLP._TEXT;
          };
          
      fluid.XMLP._setContent = function(that, iSrc) { 
          var args = arguments; 
          if (fluid.XMLP._CONT_XML == iSrc) { 
              that.m_cAlt = null; 
              that.m_cB = args[2]; 
              that.m_cE = args[3];
              } 
          else { 
              that.m_cAlt = args[2]; 
              that.m_cB = 0; 
              that.m_cE = args[2].length;
              }
              
          that.m_cSrc = iSrc;
          };
          
      fluid.XMLP._setErr = function(that, iErr) { 
          var strErr = fluid.XMLP._errs[iErr]; 
          that.m_cAlt = strErr; 
          that.m_cB = 0; 
          that.m_cE = strErr.length; 
          that.m_cSrc = fluid.XMLP._CONT_ALT; 
          return fluid.XMLP._ERROR;
          };
              
      
      fluid.XMLP._parseElement = function(that, iB) {
          var iE, iDE, iRet; 
          var iType, strN, iLast; 
          iDE = iE = that.m_xml.indexOf(">", iB); 
          if (iE == -1) { 
              return that._setErr(that, fluid.XMLP.ERR_CLOSE_ELM);
              }
          if (that.m_xml.charAt(iB) == "/") { 
              iType = fluid.XMLP._ELM_E; 
              iB++;
              } 
          else { 
              iType = fluid.XMLP._ELM_B;
              }
          if (that.m_xml.charAt(iE - 1) == "/") { 
              if (iType == fluid.XMLP._ELM_E) { 
                  return fluid.XMLP._setErr(that, fluid.XMLP.ERR_ELM_EMPTY);
                  }
              iType = fluid.XMLP._ELM_EMP; iDE--;
              }
      
          that.nameRegex.lastIndex = iB;
          var nameMatch = that.nameRegex.exec(that.m_xml);
          if (!nameMatch) {
              return fluid.XMLP._setErr(that, fluid.XMLP.ERR_ELM_NAME);
              }
          strN = nameMatch[1].toLowerCase();
          // This branch is specially necessary for broken markup in IE. If we see an li
          // tag apparently directly nested in another, first emit a synthetic close tag
          // for the earlier one without advancing the pointer, and set a flag to ensure
          // doing this just once.
          if ("li" === strN && iType !== fluid.XMLP._ELM_E && that.m_stack.length > 0 && 
              that.m_stack[that.m_stack.length - 1] === "li" && !that.m_emitSynthetic) {
              that.m_name = "li";
              that.m_emitSynthetic = true;
              return fluid.XMLP._ELM_E;
          }
          // We have acquired the tag name, now set about parsing any attribute list
          that.m_attributes = {};
          that.m_cAlt = ""; 
      
          if (that.nameRegex.lastIndex < iDE) {
              that.m_iP = that.nameRegex.lastIndex;
              while (that.m_iP < iDE) {
                  that.attrStartRegex.lastIndex = that.m_iP;
                  var attrMatch = that.attrStartRegex.exec(that.m_xml);
                  if (!attrMatch) {
                      return fluid.XMLP._setErr(that, fluid.XMLP.ERR_ATT_VALUES);
                      }
                  var attrname = attrMatch[1].toLowerCase();
                  var attrval;
                  if (that.m_xml.charCodeAt(that.attrStartRegex.lastIndex) === 61) { // = 
                      var valRegex = that.m_xml.charCodeAt(that.attrStartRegex.lastIndex + 1) === 34? that.attrValRegex : that.attrValIERegex; // "
                      valRegex.lastIndex = that.attrStartRegex.lastIndex + 1;
                      attrMatch = valRegex.exec(that.m_xml);
                      if (!attrMatch) {
                          return fluid.XMLP._setErr(that, fluid.XMLP.ERR_ATT_VALUES);
                          }
                      attrval = attrMatch[1];
                      }
                  else { // accommodate insanity on unvalued IE attributes
                      attrval = attrname;
                      valRegex = that.attrStartRegex;
                      }
                  if (!that.m_attributes[attrname]) {
                      that.m_attributes[attrname] = attrval;
                      }
                  else { 
                      return fluid.XMLP._setErr(that, fluid.XMLP.ERR_ATT_DUP);
                  }
                  that.m_iP = valRegex.lastIndex;
                      
                  }
              }
          if (strN.indexOf("<") != -1) { 
              return fluid.XMLP._setErr(that, fluid.XMLP.ERR_ELM_LT_NAME);
              }
      
          that.m_name = strN; 
          that.m_iP = iE + 1;
          // Check for corrupted "closed tags" from innerHTML
          if (fluid.XMLP.closedTags[strN]) {
              that.closeRegex.lastIndex = iE + 1;
              var closeMatch = that.closeRegex.exec;
              if (closeMatch) {
                  var matchclose = that.m_xml.indexOf(strN, closeMatch.lastIndex);
                  if (matchclose === closeMatch.lastIndex) {
                      return iType; // bail out, a valid close tag is separated only by whitespace
                  }
                  else {
                      return fluid.XMLP._ELM_EMP;
                  }
              }
          }
          that.m_emitSynthetic = false;
          return iType;
      };
      
      fluid.XMLP._parse = function(that) {
          var iP = that.m_iP;
          var xml = that.m_xml; 
          if (iP === xml.length) { return fluid.XMLP._NONE;}
          var c = xml.charAt(iP);
          if (c === '<') {
              var c2 = xml.charAt(iP + 1);
              if (c2 === '?') {
                  return fluid.XMLP._parsePI(that, iP + 2);
                  }
              else if (c2 === '!') {
                  if (iP === xml.indexOf("<!DOCTYPE", iP)) { 
                      return fluid.XMLP._parseDTD(that, iP + 9);
                      }
                  else if (iP === xml.indexOf("<!--", iP)) { 
                      return fluid.XMLP._parseComment(that, iP + 4);
                      }
                  else if (iP === xml.indexOf("<![CDATA[", iP)) { 
                      return fluid.XMLP._parseCDATA(that, iP + 9);
                      }
                  }
              else {
                  return fluid.XMLP._parseElement(that, iP + 1);
                  }
              }
          else {
              return fluid.XMLP._parseText(that, iP);
              }
          };
          
      
      fluid.XMLP.XMLPImpl = function(strXML) { 
          var that = {};    
          that.m_xml = strXML; 
          that.m_iP = 0;
          that.m_iState = fluid.XMLP._STATE_PROLOG; 
          that.m_stack = [];
          that.m_attributes = {};
          that.m_emitSynthetic = false; // state used for emitting synthetic tags used to correct broken markup (IE)
          
          that.getColumnNumber = function() { 
              return fluid.SAXStrings.getColumnNumber(that.m_xml, that.m_iP);
          };
          
          that.getContent = function() { 
              return (that.m_cSrc == fluid.XMLP._CONT_XML) ? that.m_xml : that.m_cAlt;
          };
          
          that.getContentBegin = function() { return that.m_cB;};
          that.getContentEnd = function() { return that.m_cE;};
      
          that.getLineNumber = function() { 
              return fluid.SAXStrings.getLineNumber(that.m_xml, that.m_iP);
          };
          
          that.getName = function() { 
              return that.m_name;
          };
          
          that.next = function() { 
              return fluid.XMLP._checkStructure(that, fluid.XMLP._parse(that));
          };
      
          that.nameRegex = /([^\s\/>]+)/g;
          that.attrStartRegex = /\s*([\w:_][\w:_\-\.]*)/gm;
          that.attrValRegex = /\"([^\"]*)\"\s*/gm; // "normal" XHTML attribute values
          that.attrValIERegex = /([^\>\s]+)\s*/gm; // "stupid" unquoted IE attribute values (sometimes)
          that.closeRegex = /\s*<\//g;
  
          return that;
      };
      
      
      fluid.SAXStrings = {};
      
      fluid.SAXStrings.WHITESPACE = " \t\n\r"; 
      fluid.SAXStrings.QUOTES = "\"'"; 
      fluid.SAXStrings.getColumnNumber = function (strD, iP) { 
          if (!strD) { return -1;}
          iP = iP || strD.length; 
          var arrD = strD.substring(0, iP).split("\n"); 
          arrD.length--; 
          var iLinePos = arrD.join("\n").length; 
          return iP - iLinePos;
          };
          
      fluid.SAXStrings.getLineNumber = function (strD, iP) { 
          if (!strD) { return -1;}
          iP = iP || strD.length; 
          return strD.substring(0, iP).split("\n").length;
          };
          
      fluid.SAXStrings.indexOfNonWhitespace = function (strD, iB, iE) {
          if (!strD) return -1;
          iB = iB || 0; 
          iE = iE || strD.length; 
          
          for (var i = iB; i < iE; ++ i) { 
              var c = strD.charAt(i);
              if (c !== ' ' && c !== '\t' && c !== '\n' && c !== '\r') return i;
              }
          return -1;
          };
          
          
      fluid.SAXStrings.indexOfWhitespace = function (strD, iB, iE) { 
          if (!strD) { return -1;}
              iB = iB || 0; 
              iE = iE || strD.length; 
              for (var i = iB; i < iE; i++) { 
                  if (fluid.SAXStrings.WHITESPACE.indexOf(strD.charAt(i)) != -1) { return i;}
              }
          return -1;
          };
          
          
      fluid.SAXStrings.lastIndexOfNonWhitespace = function (strD, iB, iE) { 
              if (!strD) { return -1;}
              iB = iB || 0; iE = iE || strD.length; 
              for (var i = iE - 1; i >= iB; i--) { 
              if (fluid.SAXStrings.WHITESPACE.indexOf(strD.charAt(i)) == -1) { 
                  return i;
                  }
              }
          return -1;
          };
          
      fluid.SAXStrings.replace = function(strD, iB, iE, strF, strR) { 
          if (!strD) { return "";}
          iB = iB || 0; 
          iE = iE || strD.length; 
          return strD.substring(iB, iE).split(strF).join(strR);
          };
              
  })(jQuery, fluid_1_5);
          /*
  Copyright 2008-2010 University of Cambridge
  Copyright 2008-2009 University of Toronto
  Copyright 2010-2011 Lucendo Development Ltd.
  
  Licensed under the Educational Community License (ECL), Version 2.0 or the New
  BSD license. You may not use this file except in compliance with one these
  Licenses.
  
  You may obtain a copy of the ECL 2.0 License and BSD License at
  https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
  */
  
  // Declare dependencies
  /*global fluid_1_5:true, jQuery*/
  
  // JSLint options 
  /*jslint white: true, funcinvoke: true, continue: true, elsecatch: true, operator: true, jslintok:true, undef: true, newcap: true, regexp: true, bitwise: true, browser: true, forin: true, maxerr: 100, indent: 4 */
  
  fluid_1_5 = fluid_1_5 || {};
  
  (function ($, fluid) {
        
      fluid.parseTemplate = function (template, baseURL, scanStart, cutpoints_in, opts) {
          opts = opts || {};
        
          if (!template) {
              fluid.fail("empty template supplied to fluid.parseTemplate");
          }
        
          var t;
          var parser;
          var tagstack;
          var lumpindex = 0;
          var nestingdepth = 0;
          var justended = false;
          
          var defstart = -1;
          var defend = -1;   
          
          var debugMode = false;
          
          var cutpoints = []; // list of selector, tree, id
          var simpleClassCutpoints = {};
          
          var cutstatus = [];
          
          var XMLLump = function (lumpindex, nestingdepth) {
              return {
                  //rsfID: "",
                  //text: "",
                  //downmap: {},
                  //attributemap: {},
                  //finallump: {},
                  nestingdepth: nestingdepth,
                  lumpindex: lumpindex,
                  parent: t
              };
          };
          
          function isSimpleClassCutpoint(tree) {
              return tree.length === 1 && tree[0].predList.length === 1 && tree[0].predList[0].clazz;
          }
          
          function init(baseURLin, debugModeIn, cutpointsIn) {
              t.rootlump = XMLLump(0, -1); // jslint:ok - capital letter
              tagstack = [t.rootlump];
              lumpindex = 0;
              nestingdepth = 0;
              justended = false;
              defstart = -1;
              defend = -1;
              baseURL = baseURLin;
              debugMode = debugModeIn;
              if (cutpointsIn) {
                  for (var i = 0; i < cutpointsIn.length; ++i) {
                      var tree = fluid.parseSelector(cutpointsIn[i].selector);
                      var clazz = isSimpleClassCutpoint(tree);
                      if (clazz) {
                          simpleClassCutpoints[clazz] = cutpointsIn[i].id;
                      }
                      else {
                          cutstatus.push([]);
                          cutpoints.push($.extend({}, cutpointsIn[i], {tree: tree}));
                      }
                  }
              }
          }
          
          function findTopContainer() {
              for (var i = tagstack.length - 1; i >= 0; --i) {
                  var lump = tagstack[i];
                  if (lump.rsfID !== undefined) {
                      return lump;
                  }
              }
              return t.rootlump;
          }
          
          function newLump() {
              var togo = XMLLump(lumpindex, nestingdepth); // jslint:ok - capital letter
              if (debugMode) {
                  togo.line = parser.getLineNumber();
                  togo.column = parser.getColumnNumber();
              }
              //togo.parent = t;
              t.lumps[lumpindex] = togo;
              ++lumpindex;
              return togo;
          }
          
          function addLump(mmap, ID, lump) {
              var list = mmap[ID];
              if (!list) {
                  list = [];
                  mmap[ID] = list;
              }
              list[list.length] = lump;
          }
            
          function checkContribute(ID, lump) {
              if (ID.indexOf("scr=contribute-") !== -1) {
                  var scr = ID.substring("scr=contribute-".length);
                  addLump(t.collectmap, scr, lump);
              }
          }
          
          function debugLump(lump) {
            // TODO expand this to agree with the Firebug "self-selector" idiom
              return "<" + lump.tagname + ">";
          }
          
          function hasCssClass(clazz, totest) {
              if (!totest) {
                  return false;
              }
              // algorithm from JQuery
              return (" " + totest + " ").indexOf(" " + clazz + " ") !== -1;
          }
          
          function matchNode(term, headlump, headclazz) {
              if (term.predList) {
                  for (var i = 0; i < term.predList.length; ++i) {
                      var pred = term.predList[i];
                      if (pred.id && headlump.attributemap.id !== pred.id) {return false;}
                      if (pred.clazz && !hasCssClass(pred.clazz, headclazz)) {return false;}
                      if (pred.tag && headlump.tagname !== pred.tag) {return false;}
                  }
                  return true;
              }
          }
          
          function tagStartCut(headlump) {
              var togo;
              var headclazz = headlump.attributemap["class"];
              if (headclazz) {
                  var split = headclazz.split(" ");
                  for (var i = 0; i < split.length; ++i) {
                      var simpleCut = simpleClassCutpoints[$.trim(split[i])];
                      if (simpleCut) {
                          return simpleCut;
                      }
                  }
              }
              for (var i = 0; i < cutpoints.length; ++i) { // jslint:ok - scoping
                  var cut = cutpoints[i];
                  var cutstat = cutstatus[i];
                  var nextterm = cutstat.length; // the next term for this node
                  if (nextterm < cut.tree.length) {
                      var term = cut.tree[nextterm];
                      if (nextterm > 0) {
                          if (cut.tree[nextterm - 1].child && 
                                  cutstat[nextterm - 1] !== headlump.nestingdepth - 1) {
                              continue; // it is a failure to match if not at correct nesting depth 
                          }
                      }
                      var isMatch = matchNode(term, headlump, headclazz);
                      if (isMatch) {
                          cutstat[cutstat.length] = headlump.nestingdepth;
                          if (cutstat.length === cut.tree.length) {
                              if (togo !== undefined) {
                                  fluid.fail("Cutpoint specification error - node " +
                                      debugLump(headlump) +
                                      " has already matched with rsf:id of " + togo);
                              }
                              if (cut.id === undefined || cut.id === null) {
                                  fluid.fail("Error in cutpoints list - entry at position " + i + " does not have an id set");
                              }
                              togo = cut.id;
                          }
                      }
                  }
              }
              return togo;
          }
            
          function tagEndCut() {
              if (cutpoints) {
                  for (var i = 0; i < cutpoints.length; ++i) {
                      var cutstat = cutstatus[i];
                      if (cutstat.length > 0 && cutstat[cutstat.length - 1] === nestingdepth) {
                          cutstat.length--;
                      }
                  }
              }
          }
          
          function processTagEnd() {
              tagEndCut();
              var endlump = newLump();
              --nestingdepth;
              endlump.text = "</" + parser.getName() + ">";
              var oldtop = tagstack[tagstack.length - 1];
              oldtop.close_tag = t.lumps[lumpindex - 1];
              tagstack.length--;
              justended = true;
          }
          
          function processTagStart(isempty, text) {
              ++nestingdepth;
              if (justended) {
                  justended = false;
                  var backlump = newLump();
                  backlump.nestingdepth--;
              }
              if (t.firstdocumentindex === -1) {
                  t.firstdocumentindex = lumpindex;
              }
              var headlump = newLump();
              var stacktop = tagstack[tagstack.length - 1];
              headlump.uplump = stacktop;
              var tagname = parser.getName();
              headlump.tagname = tagname;
              // NB - attribute names and values are now NOT DECODED!!
              var attrs = headlump.attributemap = parser.m_attributes;
              var ID = attrs[fluid.ID_ATTRIBUTE];
              if (ID === undefined) {
                  ID = tagStartCut(headlump);
              }
              for (var attrname in attrs) {
                  if (ID === undefined) {
                      if (/href|src|codebase|action/.test(attrname)) {
                          ID = "scr=rewrite-url";
                      }
                      // port of TPI effect of IDRelationRewriter
                      else if (ID === undefined && /for|headers/.test(attrname)) {
                          ID = "scr=null";
                      }
                  }
              }
          
              if (ID) {
                  // TODO: ensure this logic is correct on RSF Server
                  if (ID.charCodeAt(0) === 126) { // "~"
                      ID = ID.substring(1);
                      headlump.elide = true;
                  }
                  checkContribute(ID, headlump);
                  headlump.rsfID = ID;
                  var downreg = findTopContainer();
                  if (!downreg.downmap) {
                      downreg.downmap = {};
                  }
                  while (downreg) { // TODO: unusual fix for locating branches in parent contexts (applies to repetitive leaves)
                      if (downreg.downmap) {
                          addLump(downreg.downmap, ID, headlump);
                      }
                      downreg = downreg.uplump;
                  }
                  addLump(t.globalmap, ID, headlump);
                  var colpos = ID.indexOf(":");
                  if (colpos !== -1) {
                      var prefix = ID.substring(0, colpos);
                      if (!stacktop.finallump) {
                          stacktop.finallump = {};
                      }
                      stacktop.finallump[prefix] = headlump;
                  }
              }
              
              // TODO: accelerate this by grabbing original template text (requires parser
              // adjustment) as well as dealing with empty tags
              headlump.text = "<" + tagname + fluid.dumpAttributes(attrs) + (isempty && !ID? "/>" : ">");
              tagstack[tagstack.length] = headlump;
              if (isempty) {
                  if (ID) {
                      processTagEnd();
                  }
                  else {
                      --nestingdepth;
                      tagstack.length--;
                  }
              }
          }
          
  
          
          function processDefaultTag() {
              if (defstart !== -1) {
                  if (t.firstdocumentindex === -1) {
                      t.firstdocumentindex = lumpindex;
                  }
                  var text = parser.getContent().substr(defstart, defend - defstart);
                  justended = false;
                  var newlump = newLump();
                  newlump.text = text; 
                  defstart = -1;
              }
          }
         
         /** ACTUAL BODY of fluid.parseTemplate begins here **/
            
          t = fluid.XMLViewTemplate();
          
          init(baseURL, opts.debugMode, cutpoints_in);
      
          var idpos = template.indexOf(fluid.ID_ATTRIBUTE);
          if (scanStart) {
              var brackpos = template.indexOf('>', idpos);
              parser = fluid.XMLP(template.substring(brackpos + 1));
          }
          else {
              parser = fluid.XMLP(template); 
          }
      
  parseloop: while (true) {
              var iEvent = parser.next();
              switch (iEvent) {
              case fluid.XMLP._ELM_B:
                  processDefaultTag();
                  //var text = parser.getContent().substr(parser.getContentBegin(), parser.getContentEnd() - parser.getContentBegin());
                  processTagStart(false, "");
                  break;
              case fluid.XMLP._ELM_E:
                  processDefaultTag();
                  processTagEnd();
                  break;
              case fluid.XMLP._ELM_EMP:
                  processDefaultTag();
                  //var text = parser.getContent().substr(parser.getContentBegin(), parser.getContentEnd() - parser.getContentBegin());    
                  processTagStart(true, "");
                  break;
              case fluid.XMLP._PI:
              case fluid.XMLP._DTD:
                  defstart = -1;
                  continue; // not interested in reproducing these
              case fluid.XMLP._TEXT:
              case fluid.XMLP._ENTITY:
              case fluid.XMLP._CDATA:
              case fluid.XMLP._COMMENT:
                  if (defstart === -1) {
                      defstart = parser.m_cB;
                  }
                  defend = parser.m_cE;
                  break;
              case fluid.XMLP._ERROR:
                  fluid.setLogging(true);
                  var message = "Error parsing template: " + parser.m_cAlt + " at line " + parser.getLineNumber(); 
                  fluid.log(message);
                  fluid.log("Just read: " + parser.m_xml.substring(parser.m_iP - 30, parser.m_iP));
                  fluid.log("Still to read: " + parser.m_xml.substring(parser.m_iP, parser.m_iP + 30));
                  fluid.fail(message);
                  break parseloop;
              case fluid.XMLP._NONE:
                  break parseloop;
              }
          }
          processDefaultTag();
          var excess = tagstack.length - 1; 
          if (excess) {
              fluid.fail("Error parsing template - unclosed tag(s) of depth " + (excess) + 
                  ": " + fluid.transform(tagstack.splice(1, excess), function (lump) {return debugLump(lump);}).join(", "));
          }
          return t;
      };
      
      fluid.debugLump = function (lump) {
          var togo = lump.text;
          togo += " at ";
          togo += "lump line " + lump.line + " column " + lump.column + " index " + lump.lumpindex;
          togo += lump.parent.href === null? "" : " in file " + lump.parent.href;
          return togo;
      };
      
      // Public definitions begin here
      
      fluid.ID_ATTRIBUTE = "rsf:id";
      
      fluid.getPrefix = function (id) {
          var colpos = id.indexOf(':');
          return colpos === -1? id : id.substring(0, colpos);
      };
      
      fluid.SplitID = function (id) {
          var that = {};
          var colpos = id.indexOf(':');
          if (colpos === -1) {
              that.prefix = id;
          }
          else {
              that.prefix = id.substring(0, colpos);
              that.suffix = id.substring(colpos + 1);
          }
          return that;
      };
      
      fluid.XMLViewTemplate = function () {
          return {
              globalmap: {},
              collectmap: {},
              lumps: [],
              firstdocumentindex: -1
          };
      };
      
        // TODO: find faster encoder
      fluid.XMLEncode = function (text) {
          return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/\"/g, "&quot;"); 
      };
      
      fluid.dumpAttributes = function (attrcopy) {
          var togo = "";
          for (var attrname in attrcopy) {
              var attrvalue = attrcopy[attrname];
              if (attrvalue !== null && attrvalue !== undefined) {
                  togo += " " + attrname + "=\"" + attrvalue + "\"";
              }
          }
          return togo;
      };
      
      fluid.aggregateMMap = function (target, source) {
          for (var key in source) {
              var targhas = target[key];
              if (!targhas) {
                  target[key] = [];
              }
              target[key] = target[key].concat(source[key]);
          }
      };
    
      
      
      /** Returns a "template structure", with globalmap in the root, and a list
       * of entries {href, template, cutpoints} for each parsed template.
       */
      fluid.parseTemplates = function (resourceSpec, templateList, opts) {
          var togo = [];
          opts = opts || {};
          togo.globalmap = {};
          for (var i = 0; i < templateList.length; ++i) {
              var resource = resourceSpec[templateList[i]];
              var lastslash = resource.href.lastIndexOf("/");
              var baseURL = lastslash === -1? "" : resource.href.substring(0, lastslash + 1);
                
              var template = fluid.parseTemplate(resource.resourceText, baseURL, 
                  opts.scanStart && i === 0, resource.cutpoints, opts);
              if (i === 0) {
                  fluid.aggregateMMap(togo.globalmap, template.globalmap);
              }
              template.href = resource.href;
              template.baseURL = baseURL;
              template.resourceKey = resource.resourceKey;
        
              togo[i] = template;
              fluid.aggregateMMap(togo.globalmap, template.rootlump.downmap);
          }
          return togo;
      };
    
      // ******* SELECTOR ENGINE *********  
        
      // selector regexps copied from JQuery
      var chars = "(?:[\\w\u0128-\uFFFF*_-]|\\\\.)";
  //    var quickChild = new RegExp("^>\\s*(" + chars + "+)");
  //    var quickID = new RegExp("^(" + chars + "+)(#)(" + chars + "+)");
  //    var selSeg = new RegExp("^\\s*([#.]?)(" + chars + "*)");
    
      var quickClass = new RegExp("([#.]?)(" + chars + "+)", "g");
      var childSeg = new RegExp("\\s*(>)?\\s*", "g");
  //    var whiteSpace = new RegExp("^\\w*$");
    
      fluid.parseSelector = function (selstring) {
          var togo = [];
          selstring = $.trim(selstring);
          //ws-(ss*)[ws/>]
          quickClass.lastIndex = 0;
          var lastIndex = 0;
          while (true) {
              var atNode = []; // a list of predicates at a particular node
              while (true) {
                  var segMatch = quickClass.exec(selstring);
                  if (!segMatch || segMatch.index !== lastIndex) {
                      break;
                  }
                  var thisNode = {};
                  var text = segMatch[2];
                  if (segMatch[1] === "") {
                      thisNode.tag = text;
                  }
                  else if (segMatch[1] === "#") {
                      thisNode.id = text;
                  }
                  else if (segMatch[1] === ".") {
                      thisNode.clazz = text;
                  }
                  atNode[atNode.length] = thisNode;
                  lastIndex = quickClass.lastIndex;
              }
              childSeg.lastIndex = lastIndex;
              var fullAtNode = {predList: atNode};
              var childMatch = childSeg.exec(selstring);
              if (!childMatch || childMatch.index !== lastIndex) {
                  var remainder = selstring.substring(lastIndex);
                  fluid.fail("Error in selector string - can not match child selector expression at " + remainder);
              }
              if (childMatch[1] === ">") {
                  fullAtNode.child = true;
              }
              togo[togo.length] = fullAtNode;
              // >= test here to compensate for IE bug http://blog.stevenlevithan.com/archives/exec-bugs
              if (childSeg.lastIndex >= selstring.length) {
                  break;
              }
              lastIndex = childSeg.lastIndex;
              quickClass.lastIndex = childSeg.lastIndex; 
          }
          return togo;
      };
        
  })(jQuery, fluid_1_5);
  /*
  Copyright 2008-2010 University of Cambridge
  Copyright 2008-2009 University of Toronto
  Copyright 2010-2011 Lucendo Development Ltd.
  
  Licensed under the Educational Community License (ECL), Version 2.0 or the New
  BSD license. You may not use this file except in compliance with one these
  Licenses.
  
  You may obtain a copy of the ECL 2.0 License and BSD License at
  https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
  */
  
  // Declare dependencies
  /*global fluid_1_5:true, jQuery*/
  
  // JSLint options 
  /*jslint white: true, funcinvoke: true, continue: true, elsecatch: true, operator: true, jslintok:true, undef: true, newcap: true, regexp: true, bitwise: true, browser: true, forin: true, maxerr: 100, indent: 4 */
  
  fluid_1_5 = fluid_1_5 || {};
  
  (function ($, fluid) {
    
      function debugPosition(component) {
          return "as child of " + (component.parent.fullID ? "component with full ID " + component.parent.fullID : "root");
      }
       
      function computeFullID(component) {
          var togo = "";
          var move = component;
          if (component.children === undefined) { // not a container
              // unusual case on the client-side, since a repetitive leaf may have localID blasted onto it.
              togo = component.ID + (component.localID !== undefined ? component.localID : "");
              move = component.parent;
          }
          
          while (move.parent) {
              var parent = move.parent;
              if (move.fullID !== undefined) {
                  togo = move.fullID + togo;
                  return togo;
              }
              if (move.noID === undefined) {
                  var ID = move.ID;
                  if (ID === undefined) {
                      fluid.fail("Error in component tree - component found with no ID " +
                          debugPosition(parent) + ": please check structure");
                  }
                  var colpos = ID.indexOf(":");
                  var prefix = colpos === -1 ? ID : ID.substring(0, colpos);
                  togo = prefix + ":" + (move.localID === undefined ? "" : move.localID) + ":" + togo;
              }
              move = parent;
          }
          
          return togo;
      }
  
      var renderer = {};
    
      renderer.isBoundPrimitive = function (value) {
          return fluid.isPrimitive(value) || value instanceof Array 
              && (value.length === 0 || typeof (value[0]) === "string"); // jslint:ok
      };
    
      var unzipComponent;
    
      function processChild(value, key) {
          if (renderer.isBoundPrimitive(value)) {
              return {componentType: "UIBound", value: value, ID: key};
          } 
          else {
              var unzip = unzipComponent(value);
              if (unzip.ID) {
                  return {ID: key, componentType: "UIContainer", children: [unzip]};
              } else {
                  unzip.ID = key;
                  return unzip;
              } 
          }
      }
    
      function fixChildren(children) {
          if (!(children instanceof Array)) {
              var togo = [];
              for (var key in children) {
                  var value = children[key];
                  if (value instanceof Array) {
                      for (var i = 0; i < value.length; ++i) {
                          var processed = processChild(value[i], key);
            //            if (processed.componentType === "UIContainer" &&
            //              processed.localID === undefined) {
            //              processed.localID = i;
            //            }
                          togo[togo.length] = processed;
                      }
                  } else {
                      togo[togo.length] = processChild(value, key);
                  } 
              }
              return togo;
          } else {return children; }
      }
    
      function fixupValue(uibound, model, resolverGetConfig) {
          if (uibound.value === undefined && uibound.valuebinding !== undefined) {
              if (!model) {
                  fluid.fail("Cannot perform value fixup for valuebinding " 
                      + uibound.valuebinding + " since no model was supplied to rendering");
              }
              uibound.value = fluid.get(model, uibound.valuebinding, resolverGetConfig);
          }
      }
    
      function upgradeBound(holder, property, model, resolverGetConfig) {
          if (holder[property] !== undefined) {
              if (renderer.isBoundPrimitive(holder[property])) {
                  holder[property] = {value: holder[property]};
              }
              else if (holder[property].messagekey) {
                  holder[property].componentType = "UIMessage";
              }
          }
          else {
              holder[property] = {value: null};
          }
          fixupValue(holder[property], model, resolverGetConfig);
      }
    
      renderer.duckMap = {children: "UIContainer", 
              value: "UIBound", valuebinding: "UIBound", messagekey: "UIMessage", 
              markup: "UIVerbatim", selection: "UISelect", target: "UILink",
              choiceindex: "UISelectChoice", functionname: "UIInitBlock"};
        
      var boundMap = {
          UISelect:   ["selection", "optionlist", "optionnames"],
          UILink:     ["target", "linktext"],
          UIVerbatim: ["markup"],
          UIMessage:  ["messagekey"]
      };
    
      renderer.boundMap = fluid.transform(boundMap, fluid.arrayToHash);
        
      renderer.inferComponentType = function (component) {
          for (var key in renderer.duckMap) {
              if (component[key] !== undefined) {
                  return renderer.duckMap[key];
              }
          }
      };
    
      renderer.applyComponentType = function (component) {
          component.componentType = renderer.inferComponentType(component);
          if (component.componentType === undefined && component.ID !== undefined) {
              component.componentType = "UIBound";
          }
      };
      
      unzipComponent = function (component, model, resolverGetConfig) {
          if (component) {
              renderer.applyComponentType(component);
          }
          if (!component || component.componentType === undefined) {
              var decorators = component.decorators;
              if (decorators) {delete component.decorators;}
              component = {componentType: "UIContainer", children: component};
              component.decorators = decorators;
          }
          var cType = component.componentType;
          if (cType === "UIContainer") {
              component.children = fixChildren(component.children);
          }
          else {
              var map = renderer.boundMap[cType];
              if (map) {
                  fluid.each(map, function (value, key) {
                      upgradeBound(component, key, model, resolverGetConfig);
                  });
              }
          }
          
          return component;
      };
      
      function fixupTree(tree, model, resolverGetConfig) {
          if (tree.componentType === undefined) {
              tree = unzipComponent(tree, model, resolverGetConfig);
          }
          if (tree.componentType !== "UIContainer" && !tree.parent) {
              tree = {children: [tree]};
          }
          
          if (tree.children) {
              tree.childmap = {};
              for (var i = 0; i < tree.children.length; ++i) {
                  var child = tree.children[i];
                  if (child.componentType === undefined) {
                      child = unzipComponent(child, model, resolverGetConfig);
                      tree.children[i] = child;
                  }
                  child.parent = tree;
                  if (child.ID === undefined) {
                      fluid.fail("Error in component tree: component found with no ID " + debugPosition(child));
                  }
                  tree.childmap[child.ID] = child;
                  var colpos = child.ID.indexOf(":"); 
                  if (colpos === -1) {
                  //  tree.childmap[child.ID] = child; // moved out of branch to allow
                  // "relative id expressions" to be easily parsed
                  }
                  else { // jslint:ok - TODO: review the above
                      var prefix = child.ID.substring(0, colpos);
                      var childlist = tree.childmap[prefix]; 
                      if (!childlist) {
                          childlist = [];
                          tree.childmap[prefix] = childlist;
                      }
                      if (child.localID === undefined && childlist.length !== 0) {
                          child.localID = childlist.length;
                      }
                      childlist[childlist.length] = child;
                  }
                  child.fullID = computeFullID(child);
          
                  var componentType = child.componentType;
                  if (componentType === "UISelect") {
                      child.selection.fullID = child.fullID + "-selection";
                  }
                  else if (componentType === "UIInitBlock") {
                      var call = child.functionname + '(';
                      for (var j = 0; j < child.arguments.length; ++j) { // jslint:ok
                          if (child.arguments[j] instanceof fluid.ComponentReference) { // jslint:ok
                              // TODO: support more forms of id reference
                              child.arguments[j] = child.parent.fullID + child.arguments[j].reference; // jslint:ok
                          }
                          call += JSON.stringify(child.arguments[j]); // jslint:ok
                          if (j < child.arguments.length - 1) { // jslint:ok
                              call += ", ";
                          }
                      }
                      child.markup = {value: call + ")\n"};
                      child.componentType = "UIVerbatim";
                  }
                  else if (componentType === "UIBound") {
                      fixupValue(child, model, resolverGetConfig);
                  }
                  fixupTree(child, model, resolverGetConfig);
              }
          }
          return tree;
      }
      
      fluid.NULL_STRING = "\u25a9null\u25a9";
    
      var LINK_ATTRIBUTES = {
          a: "href", link: "href", img: "src", frame: "src", script: "src", style: "src", input: "src", embed: "src", // jslint:ok
          form: "action",
          applet: "codebase", object: "codebase" //jslint:ok
      };
      
      renderer.decoratorComponentPrefix = "**-renderer-";
    
      renderer.IDtoComponentName = function(ID, num) {
          return renderer.decoratorComponentPrefix + ID.replace(/\./g, "") + "-" + num;
      };
      
      renderer.invokeFluidDecorator = function(func, args, ID, num, options) {
          var that;
          if (options.instantiator && options.parentComponent) {
              var parent = options.parentComponent;
              var name = renderer.IDtoComponentName(ID, num);
              // TODO: The best we can do here without GRADES is to wildly guess 
              // that it is a view component with options in the 2nd place and container in first place
              fluid.set(parent, fluid.path("options", "components", name), {type: func});
              // This MIGHT really be a variant of fluid.invoke... only we often probably DO want the component
              // itself to be inserted into the that stack. This *ALSO* requires GRADES to resolve. A 
              // "function" is that which has no grade. The gradeless grade.
              that = fluid.initDependent(options.parentComponent, name, options.instantiator, args);
          }
          else {
              that = fluid.invokeGlobalFunction(func, args);
          }
          return that;
      };
    
      fluid.renderer = function (templates, tree, options, fossilsIn) {
        
          options = options || {};
          tree = tree || {};
          var debugMode = options.debugMode;
          if (!options.messageLocator && options.messageSource) {
              options.messageLocator = fluid.resolveMessageSource(options.messageSource);
          }
          options.document = options.document || document;
          options.jQuery = options.jQuery || $;
          options.fossils = options.fossils || fossilsIn || {}; // map of submittingname to {EL, submittingname, oldvalue}
        
          var globalmap = {};
          var branchmap = {};
          var rewritemap = {}; // map of rewritekey (for original id in template) to full ID 
          var seenset = {};
          var collected = {};
          var out = "";
          var renderOptions = options;
          var decoratorQueue = [];
          
          var renderedbindings = {}; // map of fullID to true for UISelects which have already had bindings written
          var usedIDs = {};
          
          var that = {options: options};
          
          function getRewriteKey(template, parent, id) {
              return template.resourceKey + parent.fullID + id;
          }
          // returns: lump
          function resolveInScope(searchID, defprefix, scope, child) {
              var deflump;
              var scopelook = scope? scope[searchID] : null;
              if (scopelook) {
                  for (var i = 0; i < scopelook.length; ++i) {
                      var scopelump = scopelook[i];
                      if (!deflump && scopelump.rsfID === defprefix) {
                          deflump = scopelump;
                      }
                      if (scopelump.rsfID === searchID) {
                          return scopelump;
                      }
                  }
              }
              return deflump;
          }
          // returns: lump
          function resolveCall(sourcescope, child) {
              var searchID = child.jointID? child.jointID : child.ID;
              var split = fluid.SplitID(searchID);
              var defprefix = split.prefix + ':';
              var match = resolveInScope(searchID, defprefix, sourcescope.downmap, child);
              if (match) {return match;}
              if (child.children) {
                  match = resolveInScope(searchID, defprefix, globalmap, child);
                  if (match) {return match;}
              }
              return null;
          }
          
          function noteCollected(template) {
              if (!seenset[template.href]) {
                  fluid.aggregateMMap(collected, template.collectmap);
                  seenset[template.href] = true;
              }
          }
          
          var fetchComponent;
          
          function resolveRecurse(basecontainer, parentlump) {
              for (var i = 0; i < basecontainer.children.length; ++i) {
                  var branch = basecontainer.children[i];
                  if (branch.children) { // it is a branch
                      var resolved = resolveCall(parentlump, branch);
                      if (resolved) {
                          branchmap[branch.fullID] = resolved;
                          var id = resolved.attributemap.id;
                          if (id !== undefined) {
                              rewritemap[getRewriteKey(parentlump.parent, basecontainer, id)] = branch.fullID;
                          }
                          // on server-side this is done separately
                          noteCollected(resolved.parent);
                          resolveRecurse(branch, resolved);
                      }
                  }
              }
              // collect any rewritten ids for the purpose of later rewriting
              if (parentlump.downmap) {
                  for (var id in parentlump.downmap) { // jslint:ok - scoping
                    //if (id.indexOf(":") === -1) {
                      var lumps = parentlump.downmap[id];
                      for (var i = 0; i < lumps.length; ++i) { // jslint:ok - scoping
                          var lump = lumps[i];
                          var lumpid = lump.attributemap.id;
                          if (lumpid !== undefined && lump.rsfID !== undefined) {
                              var resolved = fetchComponent(basecontainer, lump.rsfID); //jslint:ok - scoping
                              if (resolved !== null) {
                                  var resolveID = resolved.fullID;
                                  if (resolved.componentType === "UISelect") {
                                      resolveID = resolveID + "-selection";
                                  }
                                  rewritemap[getRewriteKey(parentlump.parent, basecontainer,
                                      lumpid)] = resolveID;
                              }
                          }
                      }
                  //  }
                  } 
              }
              
          }
          
          function resolveBranches(globalmapp, basecontainer, parentlump) {
              branchmap = {};
              rewritemap = {};
              seenset = {};
              collected = {};
              globalmap = globalmapp;
              branchmap[basecontainer.fullID] = parentlump;
              resolveRecurse(basecontainer, parentlump);
          }
                 
          function dumpTillLump(lumps, start, limit) {
              for (; start < limit; ++start) {
                  var text = lumps[start].text;
                  if (text) { // guard against "undefined" lumps from "justended"
                      out += lumps[start].text;
                  }
              }
          }
        
          function dumpScan(lumps, renderindex, basedepth, closeparent, insideleaf) {
              var start = renderindex;
              while (true) {
                  if (renderindex === lumps.length) {
                      break;
                  }
                  var lump = lumps[renderindex];
                  if (lump.nestingdepth < basedepth) {
                      break;
                  }
                  if (lump.rsfID !== undefined) {
                      if (!insideleaf) {break;}
                      if (insideleaf && lump.nestingdepth > basedepth + (closeparent? 0 : 1)) {
                          fluid.log("Error in component tree - leaf component found to contain further components - at " +
                              lump.toString());
                      }
                      else {break;}
                  }
                  // target.print(lump.text);
                  ++renderindex;
              }
              // ASSUMPTIONS: close tags are ONE LUMP
              if (!closeparent && (renderindex === lumps.length || !lumps[renderindex].rsfID)) {
                  --renderindex;
              }
              
              dumpTillLump(lumps, start, renderindex);
              //target.write(buffer, start, limit - start);
              return renderindex;
          }
          
          
          function isPlaceholder(value) {
              // TODO: equivalent of server-side "placeholder" system
              return false;
          }
          
          function isValue(value) {
              return value !== null && value !== undefined && !isPlaceholder(value);
          }
          
          // In RSF Client, this is a "flyweight" "global" object that is reused for every tag, 
          // to avoid generating garbage. In RSF Server, it is an argument to the following rendering
          // methods of type "TagRenderContext".
          
          var trc = {};
          
          /*** TRC METHODS ***/
          
          function openTag() {
              if (!trc.iselide) {
                  out += "<" + trc.uselump.tagname;
              }
          }
          
          function closeTag() {
              if (!trc.iselide) {
                  out += "</" + trc.uselump.tagname + ">";
              }
          }
        
          function renderUnchanged() {
              // TODO needs work since we don't keep attributes in text
              dumpTillLump(trc.uselump.parent.lumps, trc.uselump.lumpindex + 1,
                  trc.close.lumpindex + (trc.iselide ? 0 : 1));
          }
  
          function isSelfClose() {
              return trc.endopen.lumpindex === trc.close.lumpindex && fluid.XMLP.closedTags[trc.uselump.tagname]; 
          }
  
          function dumpTemplateBody() {
              if (isSelfClose()) {
                  if (!trc.iselide) {
                      out += "/>";
                  }
              }
              else {
                  if (!trc.iselide) {
                      out += ">";
                  }
                  dumpTillLump(trc.uselump.parent.lumps, trc.endopen.lumpindex,
                      trc.close.lumpindex + (trc.iselide ? 0 : 1));
              }
          }
          
          function replaceAttributes() {
              if (!trc.iselide) {
                  out += fluid.dumpAttributes(trc.attrcopy);
              }
              dumpTemplateBody();
          }
        
          function replaceAttributesOpen() {
              if (trc.iselide) {
                  replaceAttributes();
              }
              else {
                  out += fluid.dumpAttributes(trc.attrcopy);
                  var selfClose = isSelfClose();
                  // TODO: the parser does not ever produce empty tags
                  out += selfClose ? "/>" : ">";
            
                  trc.nextpos = selfClose? trc.close.lumpindex + 1 : trc.endopen.lumpindex;
              }
          }
  
          function replaceBody(value) {
              out += fluid.dumpAttributes(trc.attrcopy);
              if (!trc.iselide) {
                  out += ">";
              }
              out += fluid.XMLEncode(value.toString());
              closeTag();
          }
        
          function rewriteLeaf(value) {
              if (isValue(value)) {
                  replaceBody(value);
              }
              else {
                  replaceAttributes();
              }
          }
        
          function rewriteLeafOpen(value) {
              if (trc.iselide) {
                  rewriteLeaf(trc.value);
              }
              else {
                  if (isValue(value)) {
                      replaceBody(value);
                  }
                  else {
                      replaceAttributesOpen();
                  }
              }
          }
  
          
          /*** END TRC METHODS**/
          
          function rewriteUrl(template, url) {
              if (renderOptions.urlRewriter) {
                  var rewritten = renderOptions.urlRewriter(url);
                  if (rewritten) {
                      return rewritten;
                  }
              }
              if (!renderOptions.rebaseURLs) {
                  return url;
              }
              var protpos = url.indexOf(":/");
              if (url.charAt(0) === '/' || protpos !== -1 && protpos < 7) { // jslint:ok
                  return url;
              }
              else {
                  return renderOptions.baseURL + url;
              }
          }
          
          function dumpHiddenField(/** UIParameter **/ todump) { // jslint:ok
              out += "<input type=\"hidden\" ";
              var isvirtual = todump.virtual;
              var outattrs = {};
              outattrs[isvirtual? "id" : "name"] = todump.name;
              outattrs.value = todump.value;
              out += fluid.dumpAttributes(outattrs);
              out += " />\n";
          }
          
          var outDecoratorsImpl;
          
          function applyAutoBind(torender, finalID) {
              if (!finalID) {
                // if no id is assigned so far, this is a signal that this is a "virtual" component such as
                // a non-HTML UISelect which will not have physical markup.
                  return; 
              }
              var tagname = trc.uselump.tagname;
              var applier = renderOptions.applier;
              function applyFunc() {
                  fluid.applyBoundChange(fluid.byId(finalID, renderOptions.document), undefined, applier);
              }
              if (renderOptions.autoBind && /input|select|textarea/.test(tagname) 
                      && !renderedbindings[finalID]) {
                  var decorators = [{jQuery: ["change", applyFunc]}];
                  // Work around bug 193: http://webbugtrack.blogspot.com/2007/11/bug-193-onchange-does-not-fire-properly.html
                  if ($.browser.msie && tagname === "input" 
                          && /radio|checkbox/.test(trc.attrcopy.type)) {
                      decorators.push({jQuery: ["click", applyFunc]});
                  }
                  if ($.browser.safari && tagname === "input" && trc.attrcopy.type === "radio") {
                      decorators.push({jQuery: ["keyup", applyFunc]});
                  }
                  outDecoratorsImpl(torender, decorators, trc.attrcopy, finalID); // jslint:ok - forward reference
              }    
          }
          
          function dumpBoundFields(/** UIBound**/ torender, parent) { // jslint:ok - whitespace
              if (torender) {
                  var holder = parent? parent : torender;
                  if (renderOptions.fossils && holder.valuebinding) {
                      var fossilKey = holder.submittingname || torender.finalID;
                    // TODO: this will store multiple times for each member of a UISelect
                      renderOptions.fossils[fossilKey] = {
                          name: fossilKey,
                          EL: holder.valuebinding,
                          oldvalue: holder.value
                      };
                    // But this has to happen multiple times
                      applyAutoBind(torender, torender.finalID);
                  }
                  if (torender.fossilizedbinding) {
                      dumpHiddenField(torender.fossilizedbinding);
                  }
                  if (torender.fossilizedshaper) {
                      dumpHiddenField(torender.fossilizedshaper);
                  }
              }
          }
          
          function dumpSelectionBindings(uiselect) {
              if (!renderedbindings[uiselect.selection.fullID]) {
                  renderedbindings[uiselect.selection.fullID] = true; // set this true early so that selection does not autobind twice
                  dumpBoundFields(uiselect.selection);
                  dumpBoundFields(uiselect.optionlist);
                  dumpBoundFields(uiselect.optionnames);
              }
          }
            
          function isSelectedValue(torender, value) {
              var selection = torender.selection;
              return selection.value && typeof(selection.value) !== "string" && typeof(selection.value.length) === "number" ? 
                  $.inArray(value, selection.value, value) !== -1 :
                  selection.value === value;
          }
          
          function getRelativeComponent(component, relativeID) {
              component = component.parent;
              while (relativeID.indexOf("..::") === 0) {
                  relativeID = relativeID.substring(4);
                  component = component.parent;
              }
              return component.childmap[relativeID];
          }
          
          function adjustForID(attrcopy, component, late, forceID) {
              if (!late) {
                  delete attrcopy["rsf:id"];
              }
              if (component.finalID !== undefined) {
                  attrcopy.id = component.finalID;
              }
              else if (forceID !== undefined) {
                  attrcopy.id = forceID;
              }
              else {
                  if (attrcopy.id || late) {
                      attrcopy.id = component.fullID;
                  }
              }
              
              var count = 1;
              var baseid = attrcopy.id;
              while (renderOptions.document.getElementById(attrcopy.id) || usedIDs[attrcopy.id]) {
                  attrcopy.id = baseid + "-" + (count++); 
              }
              component.finalID = attrcopy.id;
              return attrcopy.id;
          }
          
          function assignSubmittingName(attrcopy, component, parent) {
              var submitting = parent || component;
            // if a submittingName is required, we must already go out to the document to 
            // uniquify the id that it will be derived from
              adjustForID(attrcopy, component, true, component.fullID);
              if (submitting.submittingname === undefined && submitting.willinput !== false) {
                  submitting.submittingname = submitting.finalID || submitting.fullID;
              }
              return submitting.submittingname;
          }
               
          function explodeDecorators(decorators) {
              var togo = [];
              if (decorators.type) {
                  togo[0] = decorators;
              }
              else {
                  for (var key in decorators) {
                      if (key === "$") {key = "jQuery";}
                      var value = decorators[key];
                      var decorator = {
                          type: key
                      };
                      if (key === "jQuery") {
                          decorator.func = value[0];
                          decorator.args = value.slice(1);
                      }
                      else if (key === "addClass" || key === "removeClass") {
                          decorator.classes = value;
                      }
                      else if (key === "attrs") {
                          decorator.attributes = value;
                      }
                      else if (key === "identify") {
                          decorator.key = value;
                      }
                      togo[togo.length] = decorator;
                  }
              }
              return togo;
          }
          
          outDecoratorsImpl = function(torender, decorators, attrcopy, finalID) {
              renderOptions.idMap = renderOptions.idMap || {};
              for (var i = 0; i < decorators.length; ++i) {
                  var decorator = decorators[i];
                  var type = decorator.type;
                  if (!type) {
                      var explodedDecorators = explodeDecorators(decorator);
                      outDecoratorsImpl(torender, explodedDecorators, attrcopy, finalID);
                      continue;
                  }
                  if (type === "$") {type = decorator.type = "jQuery";}
                  if (type === "jQuery" || type === "event" || type === "fluid") {
                      var id = adjustForID(attrcopy, torender, true, finalID);
                      if (decorator.ids === undefined) {
                          decorator.ids = [];
                          decoratorQueue[decoratorQueue.length] = decorator; 
                      }
                      decorator.ids.push(id);
                  }
                  // honour these remaining types immediately
                  else if (type === "attrs") {
                      fluid.each(decorator.attributes, function(value, key) {
                          if (value === null || value === undefined) {
                              delete attrcopy[key];
                          }
                          else {
                              attrcopy[key] = fluid.XMLEncode(value);
                          }
                      }); // jslint:ok - function within loop
                  }
                  else if (type === "addClass" || type === "removeClass") {
                      var fakeNode = {
                          nodeType: 1,
                          className: attrcopy["class"] || ""
                      };
                      renderOptions.jQuery(fakeNode)[type](decorator.classes);
                      attrcopy["class"] = fakeNode.className;
                  }
                  else if (type === "identify") {
                      var id = adjustForID(attrcopy, torender, true, finalID); // jslint:ok - scoping
                      renderOptions.idMap[decorator.key] = id;
                  }
                  else if (type !== "null") {
                      fluid.log("Unrecognised decorator of type " + type + " found at component of ID " + finalID);
                  }
              }
          };
          
          function outDecorators(torender, attrcopy) {
              if (!torender.decorators) {return;}
              if (torender.decorators.length === undefined) {
                  torender.decorators = explodeDecorators(torender.decorators);
              }
              outDecoratorsImpl(torender, torender.decorators, attrcopy);
          }
          
          function dumpBranchHead(branch, targetlump) {
              if (targetlump.elide) {
                  return;
              }
              var attrcopy = {};
              $.extend(true, attrcopy, targetlump.attributemap);
              adjustForID(attrcopy, branch); // jslint:ok - forward reference
              outDecorators(branch, attrcopy);
              out += "<" + targetlump.tagname + " ";
              out += fluid.dumpAttributes(attrcopy);
              out += ">";
          }
          
          function resolveArgs(args) {
              if (!args) {return args;}
              return fluid.transform(args, function (arg, index) {
                  upgradeBound(args, index, renderOptions.model, renderOptions.resolverGetConfig);
                  return args[index].value;
              });
          }
              
          function degradeMessage(torender) {
              if (torender.componentType === "UIMessage") {
                  // degrade UIMessage to UIBound by resolving the message
                  torender.componentType = "UIBound";
                  if (!renderOptions.messageLocator) {
                      torender.value = "[No messageLocator is configured in options - please consult documentation on options.messageSource]";
                  }
                  else {
                      upgradeBound(torender, "messagekey", renderOptions.model, renderOptions.resolverGetConfig);
                      var resArgs = resolveArgs(torender.args);
                      torender.value = renderOptions.messageLocator(torender.messagekey.value, resArgs);
                  }
              }
          }  
          
            
          function renderComponent(torender) {
              var attrcopy = trc.attrcopy;
              
              degradeMessage(torender);
              var componentType = torender.componentType;
              var tagname = trc.uselump.tagname;
              
              outDecorators(torender, attrcopy);
              
              function makeFail(torender, end) {
                  fluid.fail("Error in component tree - UISelectChoice with id " + torender.fullID + end);
              } 
              
              if (componentType === "UIBound" || componentType === "UISelectChoice") {
                  var parent;
                  if (torender.choiceindex !== undefined) {
                      if (torender.parentRelativeID !== undefined) {
                          parent = getRelativeComponent(torender, torender.parentRelativeID);
                          if (!parent) {
                              makeFail(torender, " has parentRelativeID of " + torender.parentRelativeID + " which cannot be resolved");
                          }
                      }
                      else {
                          makeFail(torender, " does not have parentRelativeID set");
                      }
                      assignSubmittingName(attrcopy, torender, parent.selection);
                      dumpSelectionBindings(parent);
                  }
          
                  var submittingname = parent? parent.selection.submittingname : torender.submittingname;
                  if (!parent && torender.valuebinding) {
                      // Do this for all bound fields even if non submitting so that finalID is set in order to track fossils (FLUID-3387)
                      submittingname = assignSubmittingName(attrcopy, torender);
                  }
                  if (tagname === "input" || tagname === "textarea") {
                      if (submittingname !== undefined) {
                          attrcopy.name = submittingname;
                      }
                  }
                  // this needs to happen early on the client, since it may cause the allocation of the
                  // id in the case of a "deferred decorator". However, for server-side bindings, this 
                  // will be an inappropriate time, unless we shift the timing of emitting the opening tag.
                  dumpBoundFields(torender, parent? parent.selection : null);
            
                  if (typeof(torender.value) === 'boolean' || attrcopy.type === "radio" 
                          || attrcopy.type === "checkbox") {
                      var underlyingValue;
                      var directValue = torender.value;
                      
                      if (torender.choiceindex !== undefined) {
                          if (!parent.optionlist.value) {
                              fluid.fail("Error in component tree - selection control with full ID " + parent.fullID + " has no values");
                          }
                          underlyingValue = parent.optionlist.value[torender.choiceindex];
                          directValue = isSelectedValue(parent, underlyingValue);
                      }
                      if (isValue(directValue)) {
                          if (directValue) {
                              attrcopy.checked = "checked";
                          }
                          else {
                              delete attrcopy.checked;
                          }
                      }
                      attrcopy.value = fluid.XMLEncode(underlyingValue? underlyingValue : "true");
                      rewriteLeaf(null);
                  }
                  else if (torender.value instanceof Array) {
                      // Cannot be rendered directly, must be fake
                      renderUnchanged();
                  }
                  else { // String value
                      var value = parent? 
                          parent[tagname === "textarea" || tagname === "input" ? "optionlist" : "optionnames"].value[torender.choiceindex] : 
                              torender.value; // jslint:ok - whitespace
                      if (tagname === "textarea") {
                          if (isPlaceholder(value) && torender.willinput) {
                              // FORCE a blank value for input components if nothing from
                              // model, if input was intended.
                              value = "";
                          }
                          rewriteLeaf(value);
                      }
                      else if (tagname === "input") {
                          if (torender.willinput || isValue(value)) {
                              attrcopy.value = fluid.XMLEncode(String(value));
                          }
                          rewriteLeaf(null);
                      }
                      else {
                          delete attrcopy.name;
                          rewriteLeafOpen(value);
                      }
                  }
              }
              else if (componentType === "UISelect") {
    
                  var ishtmlselect = tagname === "select";
                  var ismultiple = false;
            
                  if (torender.selection.value instanceof Array) {
                      ismultiple = true;
                      if (ishtmlselect) {
                          attrcopy.multiple = "multiple";
                      }
                  }
                  // assignSubmittingName is now the definitive trigger point for uniquifying output IDs
                  // However, if id is already assigned it is probably through attempt to decorate root select.
                  // in this case restore it.
                  var oldid = attrcopy.id;
                  assignSubmittingName(attrcopy, torender.selection);
                  if (oldid !== undefined) {
                      attrcopy.id = oldid;
                  }
                  
                  if (ishtmlselect) {
                      // The HTML submitted value from a <select> actually corresponds
                      // with the selection member, not the top-level component.
                      if (torender.selection.willinput !== false) {
                          attrcopy.name = torender.selection.submittingname;
                      }
                      applyAutoBind(torender, attrcopy.id);
                  }
                  
                  out += fluid.dumpAttributes(attrcopy);
                  if (ishtmlselect) {
                      out += ">";
                      var values = torender.optionlist.value;
                      var names = torender.optionnames === null || torender.optionnames === undefined || !torender.optionnames.value? values : torender.optionnames.value;
                      if (!names || !names.length) {
                          fluid.fail("Error in component tree - UISelect component with fullID " 
                              + torender.fullID + " does not have optionnames set");
                      }
                      for (var i = 0; i < names.length; ++i) {
                          out += "<option value=\"";
                          var value = values[i]; //jslint:ok - scoping
                          if (value === null) {
                              value = fluid.NULL_STRING;
                          }
                          out += fluid.XMLEncode(value);
                          if (isSelectedValue(torender, value)) {
                              out += "\" selected=\"selected";
                          }
                          out += "\">";
                          out += fluid.XMLEncode(names[i]);
                          out += "</option>\n";
                      }
                      closeTag();
                  }
                  else {
                      dumpTemplateBody();
                  }
                  dumpSelectionBindings(torender);
              }
              else if (componentType === "UILink") {
                  var attrname = LINK_ATTRIBUTES[tagname];
                  if (attrname) {
                      degradeMessage(torender.target);
                      var target = torender.target.value;
                      if (!isValue(target)) {
                          target = attrcopy[attrname];
                      }
                      target = rewriteUrl(trc.uselump.parent, target);
                      // Note that all real browsers succeed in recovering the URL here even if it is presented in violation of XML
                      // seemingly due to the purest accident, the text &amp; cannot occur in a properly encoded URL :P
                      attrcopy[attrname] = fluid.XMLEncode(target);
                  }
                  var value; // jslint:ok
                  if (torender.linktext) { 
                      degradeMessage(torender.linktext);
                      value = torender.linktext.value; // jslint:ok - scoping
                  }
                  if (!isValue(value)) {
                      replaceAttributesOpen();
                  }
                  else {
                      rewriteLeaf(value);
                  }
              }
              
              else if (torender.markup !== undefined) { // detect UIVerbatim
                  degradeMessage(torender.markup);
                  var rendered = torender.markup.value;
                  if (rendered === null) {
                    // TODO, doesn't quite work due to attr folding cf Java code
                      out += fluid.dumpAttributes(attrcopy);
                      out += ">";
                      renderUnchanged(); 
                  }
                  else {
                      if (!trc.iselide) {
                          out += fluid.dumpAttributes(attrcopy);
                          out += ">";
                      }
                      out += rendered;
                      closeTag();
                  }
              }
              if (attrcopy.id !== undefined) {
                  usedIDs[attrcopy.id] = true;
              }
          }
               
          function rewriteIDRelation(context) {
              var attrname;
              var attrval = trc.attrcopy["for"];
              if (attrval !== undefined) {
                  attrname = "for";
              }
              else {
                  attrval = trc.attrcopy.headers;
                  if (attrval !== undefined) {
                      attrname = "headers";
                  }
              }
              if (!attrname) {return;}
              var tagname = trc.uselump.tagname;
              if (attrname === "for" && tagname !== "label") {return;}
              if (attrname === "headers" && tagname !== "td" && tagname !== "th") {return;}
              var rewritten = rewritemap[getRewriteKey(trc.uselump.parent, context, attrval)];
              if (rewritten !== undefined) {
                  trc.attrcopy[attrname] = rewritten;
              }
          }
          
          function renderComment(message) {
              out += ("<!-- " + fluid.XMLEncode(message) + "-->");
          }
          
          function renderDebugMessage(message) {
              out += "<span style=\"background-color:#FF466B;color:white;padding:1px;\">";
              out += message;
              out += "</span><br/>";
          }
          
          function reportPath(/*UIComponent*/ branch) { // jslint:ok - whitespace
              var path = branch.fullID;
              return !path ? "component tree root" : "full path " + path;
          }
          
          function renderComponentSystem(context, torendero, lump) {
              var lumpindex = lump.lumpindex;
              var lumps = lump.parent.lumps;
              var nextpos = -1;
              var outerendopen = lumps[lumpindex + 1];
              var outerclose = lump.close_tag;
          
              nextpos = outerclose.lumpindex + 1;
          
              var payloadlist = lump.downmap? lump.downmap["payload-component"] : null;
              var payload = payloadlist? payloadlist[0] : null;
              
              var iselide = lump.rsfID.charCodeAt(0) === 126; // "~"
              
              var endopen = outerendopen;
              var close = outerclose;
              var uselump = lump;
              var attrcopy = {};
              $.extend(true, attrcopy, (payload === null? lump : payload).attributemap);
              
              trc.attrcopy = attrcopy;
              trc.uselump = uselump;
              trc.endopen = endopen;
              trc.close = close;
              trc.nextpos = nextpos;
              trc.iselide = iselide;
              
              rewriteIDRelation(context);
              
              if (torendero === null) {
                  if (lump.rsfID.indexOf("scr=") === (iselide? 1 : 0)) {
                      var scrname = lump.rsfID.substring(4 + (iselide? 1 : 0));
                      if (scrname === "ignore") {
                          nextpos = trc.close.lumpindex + 1;
                      }
                      else if (scrname === "rewrite-url") {
                          torendero = {componentType: "UILink", target: {}};
                      }
                      else {
                          openTag();
                          replaceAttributesOpen();
                          nextpos = trc.endopen.lumpindex;
                      }
                  }
              }
              if (torendero !== null) {
                  // else there IS a component and we are going to render it. First make
                  // sure we render any preamble.
            
                  if (payload) {
                      trc.endopen = lumps[payload.lumpindex + 1];
                      trc.close = payload.close_tag;
                      trc.uselump = payload;
                      dumpTillLump(lumps, lumpindex, payload.lumpindex);
                      lumpindex = payload.lumpindex;
                  }
            
                  adjustForID(attrcopy, torendero);
                  //decoratormanager.decorate(torendero.decorators, uselump.getTag(), attrcopy);
            
                  
                  // ALWAYS dump the tag name, this can never be rewritten. (probably?!)
                  openTag();
            
                  renderComponent(torendero);
                  // if there is a payload, dump the postamble.
                  if (payload !== null) {
                      // the default case is initialised to tag close
                      if (trc.nextpos === nextpos) {
                          dumpTillLump(lumps, trc.close.lumpindex + 1, outerclose.lumpindex + 1);
                      }
                  }
                  nextpos = trc.nextpos;
              }
              return nextpos;
          }
          var renderRecurse;
          
          function renderContainer(child, targetlump) {
              var t2 = targetlump.parent;
              var firstchild = t2.lumps[targetlump.lumpindex + 1];
              if (child.children !== undefined) {
                  dumpBranchHead(child, targetlump);
              }
              else {
                  renderComponentSystem(child.parent, child, targetlump);
              }
              renderRecurse(child, targetlump, firstchild);
          }
          
          fetchComponent = function(basecontainer, id, lump) {
              if (id.indexOf("msg=") === 0) {
                  var key = id.substring(4);
                  return {componentType: "UIMessage", messagekey: key};
              }
              while (basecontainer) {
                  var togo = basecontainer.childmap[id];
                  if (togo) {
                      return togo;
                  }
                  basecontainer = basecontainer.parent;
              }
              return null;
          };
        
          function fetchComponents(basecontainer, id) {
              var togo;
              while (basecontainer) {
                  togo = basecontainer.childmap[id];
                  if (togo) {
                      break;
                  }
                  basecontainer = basecontainer.parent;
              }
              return togo;
          }
        
          function findChild(sourcescope, child) {
              var split = fluid.SplitID(child.ID);
              var headlumps = sourcescope.downmap[child.ID];
              if (!headlumps) {
                  headlumps = sourcescope.downmap[split.prefix + ":"];
              }
              return headlumps? headlumps[0] : null;
          }
          
          renderRecurse = function(basecontainer, parentlump, baselump) {
              var renderindex = baselump.lumpindex;
              var basedepth = parentlump.nestingdepth;
              var t1 = parentlump.parent;
              var rendered;
              if (debugMode) {
                  rendered = {};
              }
              while (true) {
                  renderindex = dumpScan(t1.lumps, renderindex, basedepth, !parentlump.elide, false);
                  if (renderindex === t1.lumps.length) { 
                      break;
                  }
                  var lump = t1.lumps[renderindex];      
                  var id = lump.rsfID;
                  // new stopping rule - we may have been inside an elided tag
                  if (lump.nestingdepth < basedepth || id === undefined) {
                      break;
                  } 
            
                  if (id.charCodeAt(0) === 126) { // "~"
                      id = id.substring(1);
                  }
                  
                  //var ismessagefor = id.indexOf("message-for:") === 0;
                  
                  if (id.indexOf(':') !== -1) {
                      var prefix = fluid.getPrefix(id);
                      var children = fetchComponents(basecontainer, prefix);
                      
                      var finallump = lump.uplump.finallump[prefix];
                      var closefinal = finallump.close_tag;
                      
                      if (children) {
                          for (var i = 0; i < children.length; ++i) {
                              var child = children[i];
                              if (child.children) { // it is a branch 
                                  if (debugMode) {
                                      rendered[child.fullID] = true;
                                  }
                                  var targetlump = branchmap[child.fullID];
                                  if (targetlump) {
                                      if (debugMode) {
                                          renderComment("Branching for " + child.fullID + " from "
                                              + fluid.debugLump(lump) + " to " + fluid.debugLump(targetlump));
                                      }
                                      
                                      renderContainer(child, targetlump);
                                      
                                      if (debugMode) {
                                          renderComment("Branch returned for " + child.fullID
                                              + fluid.debugLump(lump) + " to " + fluid.debugLump(targetlump));
                                      }
                                  }
                                  else if (debugMode) {
                                      renderDebugMessage(
                                          "No matching template branch found for branch container with full ID "
                                              + child.fullID
                                              + " rendering from parent template branch "
                                              + fluid.debugLump(baselump)); // jslint:ok - line breaking
                                  }
                              }
                              else { // repetitive leaf
                                  var targetlump = findChild(parentlump, child); // jslint:ok - scoping
                                  if (!targetlump) {
                                      if (debugMode) {
                                          renderDebugMessage("Repetitive leaf with full ID " + child.fullID
                                              + " could not be rendered from parent template branch "
                                              + fluid.debugLump(baselump)); // jslint:ok - line breaking
                                      }
                                      continue;
                                  }
                                  var renderend = renderComponentSystem(basecontainer, child, targetlump);
                                  var wasopentag = renderend < t1.lumps.lengtn && t1.lumps[renderend].nestingdepth >= targetlump.nestingdepth;
                                  var newbase = child.children? child : basecontainer;
                                  if (wasopentag) {
                                      renderRecurse(newbase, targetlump, t1.lumps[renderend]);
                                      renderend = targetlump.close_tag.lumpindex + 1;
                                  }
                                  if (i !== children.length - 1) {
                                      // TODO - fix this bug in RSF Server!
                                      if (renderend < closefinal.lumpindex) {
                                          dumpScan(t1.lumps, renderend, targetlump.nestingdepth - 1, false, false);
                                      }
                                  }
                                  else {
                                      dumpScan(t1.lumps, renderend, targetlump.nestingdepth, true, false);
                                  }
                              }
                          } // end for each repetitive child
                      }
                      else {
                          if (debugMode) {
                              renderDebugMessage("No branch container with prefix "
                                  + prefix + ": found in container "
                                  + reportPath(basecontainer)
                                  + " rendering at template position " + fluid.debugLump(baselump)
                                  + ", skipping");
                          }
                      }
                      
                      renderindex = closefinal.lumpindex + 1;
                      if (debugMode) {
                          renderComment("Stack returned from branch for ID " + id + " to "
                              + fluid.debugLump(baselump) + ": skipping from " + fluid.debugLump(lump)
                              + " to " + fluid.debugLump(closefinal));
                      }
                  }
                  else {
                      var component;
                      if (id) {
                          component = fetchComponent(basecontainer, id, lump);
                          if (debugMode && component) {
                              rendered[component.fullID] = true;
                          }
                      }
                      if (component && component.children !== undefined) {
                          renderContainer(component);
                          renderindex = lump.close_tag.lumpindex + 1;
                      }
                      else {
                          renderindex = renderComponentSystem(basecontainer, component, lump);
                      }
                  }
                  if (renderindex === t1.lumps.length) {
                      break;
                  }
              }
              if (debugMode) {
                  var children = basecontainer.children; // jslint:ok - scoping
                  for (var key = 0; key < children.length; ++key) {
                      var child = children[key]; // jslint:ok - scoping
                      if (!rendered[child.fullID]) {
                          renderDebugMessage("Component "
                              + child.componentType + " with full ID "
                              + child.fullID + " could not be found within template "
                              + fluid.debugLump(baselump));
                      }
                  }
              }  
              
          };
          
          function renderCollect(collump) {
              dumpTillLump(collump.parent.lumps, collump.lumpindex, collump.close_tag.lumpindex + 1);
          }
          
          // Let us pray
          function renderCollects() {
              for (var key in collected) {
                  var collist = collected[key];
                  for (var i = 0; i < collist.length; ++i) {
                      renderCollect(collist[i]);
                  }
              }
          }
          
          function processDecoratorQueue() {
              for (var i = 0; i < decoratorQueue.length; ++i) {
                  var decorator = decoratorQueue[i];
                  for (var j = 0; j < decorator.ids.length; ++j) {
                      var id = decorator.ids[j];
                      var node = fluid.byId(id, renderOptions.document);
                      if (!node) {
                          fluid.fail("Error during rendering - component with id " + id 
                              + " which has a queued decorator was not found in the output markup");
                      }
                      if (decorator.type === "jQuery") {
                          var jnode = renderOptions.jQuery(node);
                          jnode[decorator.func].apply(jnode, fluid.makeArray(decorator.args));
                      }
                      else if (decorator.type === "fluid") {
                          var args = decorator.args;
                          if (!args) {
                              var thisContainer = renderOptions.jQuery(node);
                              if (!decorator.container) {
                                  decorator.container = thisContainer;
                              }
                              else {
                                  decorator.container.push(node);
                              }
                              args = [thisContainer, decorator.options];
                          }
                          var that = renderer.invokeFluidDecorator(decorator.func, args, id, i, options);
                          decorator.that = that;
                      }
                      else if (decorator.type === "event") {
                          node[decorator.event] = decorator.handler; 
                      }
                  }
              }
          }
    
          that.renderTemplates = function () {
              tree = fixupTree(tree, options.model, options.resolverGetConfig);
              var template = templates[0];
              resolveBranches(templates.globalmap, tree, template.rootlump);
              renderedbindings = {};
              renderCollects();
              renderRecurse(tree, template.rootlump, template.lumps[template.firstdocumentindex]);
              return out;
          };  
          
          that.processDecoratorQueue = function () {
              processDecoratorQueue();
          };
          return that;
          
      };
      
      jQuery.extend(true, fluid.renderer, renderer);
    
      /*
       * This function is unsupported: It is not really intended for use by implementors.
       */
      fluid.ComponentReference = function (reference) {
          this.reference = reference;
      };
      
      // Explodes a raw "hash" into a list of UIOutput/UIBound entries
      fluid.explode = function (hash, basepath) {
          var togo = [];
          for (var key in hash) {
              var binding = basepath === undefined ? key : basepath + "." + key;
              togo[togo.length] = {ID: key, value: hash[key], valuebinding: binding};
          }
          return togo;
      };
        
      
     /**
      * A common utility function to make a simple view of rows, where each row has a selection control and a label
      * @param {Object} optionlist An array of the values of the options in the select
      * @param {Object} opts An object with this structure: {
              selectID: "",         
              rowID: "",            
              inputID: "",
              labelID: ""
          }
      */ 
      fluid.explodeSelectionToInputs = function (optionlist, opts) {
          return fluid.transform(optionlist, function (option, index) {
              return {
                  ID: opts.rowID, 
                  children: [
                      {ID: opts.inputID, parentRelativeID: "..::" + opts.selectID, choiceindex: index},
                      {ID: opts.labelID, parentRelativeID: "..::" + opts.selectID, choiceindex: index}]
              };
          });
      };
    
      fluid.resolveMessageSource = function (messageSource) {
          if (messageSource.type === "data") {
              if (messageSource.url === undefined) {
                  return fluid.messageLocator(messageSource.messages, messageSource.resolveFunc);
              }
              else {
                // TODO: fetch via AJAX, and convert format if necessary
              }
          } // jslint:ok - empty block
          else if (messageSource.type === "resolver") {
              return messageSource.resolver.resolve;
          }
      };
      
      fluid.renderTemplates = function (templates, tree, options, fossilsIn) {
          var renderer = fluid.renderer(templates, tree, options, fossilsIn);
          var rendered = renderer.renderTemplates();
          return rendered;
      };
      /** A driver to render and bind an already parsed set of templates onto
       * a node. See documentation for fluid.selfRender.
       * @param templates A parsed template set, as returned from fluid.selfRender or 
       * fluid.parseTemplates.
       */
    
      fluid.reRender = function (templates, node, tree, options) {
          options = options || {};
          var renderer = fluid.renderer(templates, tree, options, options.fossils);
          options = renderer.options;
                // Empty the node first, to head off any potential id collisions when rendering
          node = fluid.unwrap(node);
          var lastFocusedElement = fluid.getLastFocusedElement ? fluid.getLastFocusedElement() : null;
          var lastId;
          if (lastFocusedElement && fluid.dom.isContainer(node, lastFocusedElement)) {
              lastId = lastFocusedElement.id;
          }
          if ($.browser.msie) {
              options.jQuery(node).empty(); //- this operation is very slow.
          }
          else {
              node.innerHTML = "";
          }
          
          var rendered = renderer.renderTemplates();
          if (options.renderRaw) {
              rendered = fluid.XMLEncode(rendered);
              rendered = rendered.replace(/\n/g, "<br/>");
          }
          if (options.model) {
              fluid.bindFossils(node, options.model, options.fossils);
          }
          if ($.browser.msie) {
              options.jQuery(node).html(rendered);
          }
          else {
              node.innerHTML = rendered;
          }
          renderer.processDecoratorQueue();
          if (lastId) {
              var element = fluid.byId(lastId, options.document);
              if (element) {
                  options.jQuery(element).focus();
              }      
          }
            
          return templates;
      };
    
      function findNodeValue(rootNode) {
          var node = fluid.dom.iterateDom(rootNode, function (node) {
            // NB, in Firefox at least, comment and cdata nodes cannot be distinguished!
              return node.nodeType === 8 || node.nodeType === 4 ? "stop" : null;
              }, true); // jslint:ok
          var value = node.nodeValue;
          if (value.indexOf("[CDATA[") === 0) {
              return value.substring(6, value.length - 2);
          }
          else {
              return value;
          }
      }
    
      fluid.extractTemplate = function (node, armouring) {
          if (!armouring) {
              return node.innerHTML;
          }
          else {
              return findNodeValue(node);
          }
      };
      /** A slightly generalised version of fluid.selfRender that does not assume that the
       * markup used to source the template is within the target node.
       * @param source Either a structure {node: node, armouring: armourstyle} or a string
       * holding a literal template
       * @param target The node to receive the rendered markup
       * @param tree, options, return as for fluid.selfRender
       */
      fluid.render = function (source, target, tree, options) {
          options = options || {};
          var template = source;
          if (typeof(source) === "object") {
              template = fluid.extractTemplate(fluid.unwrap(source.node), source.armouring);
          }
          target = fluid.unwrap(target);
          var resourceSpec = {base: {resourceText: template, 
                              href: ".", resourceKey: ".", cutpoints: options.cutpoints}
                              };
          var templates = fluid.parseTemplates(resourceSpec, ["base"], options);
          return fluid.reRender(templates, target, tree, options);    
      };
      
      /** A simple driver for single node self-templating. Treats the markup for a
       * node as a template, parses it into a template structure, renders it using
       * the supplied component tree and options, then replaces the markup in the 
       * node with the rendered markup, and finally performs any required data
       * binding. The parsed template is returned for use with a further call to
       * reRender.
       * @param node The node both holding the template, and whose markup is to be
       * replaced with the rendered result.
       * @param tree The component tree to be rendered.
       * @param options An options structure to configure the rendering and binding process.
       * @return A templates structure, suitable for a further call to fluid.reRender or
       * fluid.renderTemplates.
       */  
      fluid.selfRender = function (node, tree, options) {
          options = options || {};
          return fluid.render({node: node, armouring: options.armouring}, node, tree, options);
      };
  
  })(jQuery, fluid_1_5);
  /*
  Copyright 2008-2010 University of Cambridge
  Copyright 2008-2009 University of Toronto
  Copyright 2010-2011 Lucendo Development Ltd.
  
  Licensed under the Educational Community License (ECL), Version 2.0 or the New
  BSD license. You may not use this file except in compliance with one these
  Licenses.
  
  You may obtain a copy of the ECL 2.0 License and BSD License at
  https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
  */
  
  // Declare dependencies
  /*global fluid_1_5:true, jQuery*/
  
  // JSLint options 
  /*jslint white: true, funcinvoke: true, continue: true, elsecatch: true, operator: true, jslintok:true, undef: true, newcap: true, regexp: true, bitwise: true, browser: true, forin: true, maxerr: 100, indent: 4 */
  
  fluid_1_5 = fluid_1_5 || {};
  
  (function ($, fluid) {
  
      if (!fluid.renderer) {
          fluid.fail("fluidRenderer.js is a necessary dependency of RendererUtilities");
      }
      
      /** Returns an array of size count, filled with increasing integers, 
       *  starting at 0 or at the index specified by first. 
       */
      
      fluid.iota = function (count, first) {
          first = first || 0;
          var togo = [];
          for (var i = 0; i < count; ++i) {
              togo[togo.length] = first++;
          }
          return togo;
      };
      
      fluid.renderer.visitDecorators = function(that, visitor) {
          fluid.visitComponentChildren(that, function(component, name) {
              if (name.indexOf(fluid.renderer.decoratorComponentPrefix) === 0) {
                  visitor(component, name);
              }
          }, {flat: true});  
      };
  
      fluid.renderer.clearDecorators = function(instantiator, that) {
          fluid.renderer.visitDecorators(that, function(component, name) {
              instantiator.clearComponent(that, name);
          });
      };
      
      fluid.renderer.getDecoratorComponents = function(that) {
          var togo = {};
          fluid.renderer.visitDecorators(that, function(component, name) {
              togo[name] = component;
          });
          return togo;
      };
  
      // Utilities for coordinating options in renderer components - this code is all pretty
      // dreadful and needs to be organised as a suitable set of defaults and policies
      fluid.renderer.modeliseOptions = function (options, defaults, baseOptions) {
          return $.extend({}, defaults, options, fluid.filterKeys(baseOptions, ["model", "applier"]));
      };
      fluid.renderer.reverseMerge = function (target, source, names) {
          names = fluid.makeArray(names);
          fluid.each(names, function (name) {
              if (target[name] === undefined && source[name] !== undefined) {
                  target[name] = source[name];
              }
          });
      };
  
      /** "Renderer component" infrastructure **/
    // TODO: fix this up with IoC and improved handling of templateSource as well as better 
    // options layout (model appears in both rOpts and eOpts)
      fluid.renderer.createRendererSubcomponent = function (container, selectors, options, baseObject, fossils) {
          options = options || {};
          var source = options.templateSource ? options.templateSource : {node: $(container)};
          var rendererOptions = fluid.renderer.modeliseOptions(options.rendererOptions, null, baseObject);
          rendererOptions.fossils = fossils || {};
          if (container.jquery) {
              var cascadeOptions = {
                  document: container[0].ownerDocument,
                  jQuery: container.constructor  
              };
              fluid.renderer.reverseMerge(rendererOptions, cascadeOptions, fluid.keys(cascadeOptions));
          }
          
          var expanderOptions = fluid.renderer.modeliseOptions(options.expanderOptions, {ELstyle: "${}"}, baseObject);
          fluid.renderer.reverseMerge(expanderOptions, options, ["resolverGetConfig", "resolverSetConfig"]);
          var that = {};
          if (!options.noexpand) {
              that.expander = fluid.renderer.makeProtoExpander(expanderOptions);
          }
          
          var templates = null;
          that.render = function (tree) {
              var cutpointFn = options.cutpointGenerator || "fluid.renderer.selectorsToCutpoints";
              rendererOptions.cutpoints = rendererOptions.cutpoints || fluid.invokeGlobalFunction(cutpointFn, [selectors, options]);
              container = typeof(container) === "function" ? container() : $(container);
                
              if (templates) {
                  fluid.clear(rendererOptions.fossils);
                  fluid.reRender(templates, container, tree, rendererOptions);
              } 
              else {
                  if (typeof(source) === "function") { // TODO: make a better attempt than this at asynchrony
                      source = source();  
                  }
                  templates = fluid.render(source, container, tree, rendererOptions);
              }
          };
          return that;
      };
      
      fluid.defaults("fluid.rendererComponent", {
          gradeNames: ["fluid.viewComponent"],
          initFunction: "fluid.initRendererComponent",
          mergePolicy: {
              protoTree: "noexpand, replace",
              parentBundle: "nomerge"
          },
          rendererOptions: {
              autoBind: true
          },
          events: {
              prepareModelForRender: null,
              onRenderTree: null,
              afterRender: null,
              produceTree: "unicast"
          }
      });
  
      fluid.initRendererComponent = function (componentName, container, options) {
          var that = fluid.initView(componentName, container, options, {gradeNames: ["fluid.rendererComponent"]});
          
          fluid.fetchResources(that.options.resources); // TODO: deal with asynchrony
          
          var rendererOptions = fluid.renderer.modeliseOptions(that.options.rendererOptions, null, that);
          if (!that.options.noUpgradeDecorators) {
              fluid.withInstantiator(that, function(currentInst) {
                  rendererOptions.instantiator = currentInst;
                  rendererOptions.parentComponent = that;
              });
          }
          var messageResolver;
          if (!rendererOptions.messageSource && that.options.strings) {
              messageResolver = fluid.messageResolver({
                  messageBase: that.options.strings,
                  resolveFunc: that.options.messageResolverFunction,
                  parents: fluid.makeArray(that.options.parentBundle)
              });
              rendererOptions.messageSource = {type: "resolver", resolver: messageResolver}; 
          }
          fluid.renderer.reverseMerge(rendererOptions, that.options, ["resolverGetConfig", "resolverSetConfig"]);
  
  
          var rendererFnOptions = $.extend({}, that.options.rendererFnOptions, { 
              rendererOptions: rendererOptions,
              repeatingSelectors: that.options.repeatingSelectors,
              selectorsToIgnore: that.options.selectorsToIgnore,
              expanderOptions: {
                  envAdd: {styles: that.options.styles}
              }
          });
             
          if (that.options.resources && that.options.resources.template) {
              rendererFnOptions.templateSource = function () { // TODO: don't obliterate, multitemplates, etc.
                  return that.options.resources.template.resourceText;
              };
          }
          var produceTree = that.events.produceTree;
          produceTree.addListener(function() {
              return that.options.protoTree;
          });
          
          if (that.options.produceTree) {
              produceTree.addListener(that.options.produceTree);
          }
  
          fluid.renderer.reverseMerge(rendererFnOptions, that.options, ["resolverGetConfig", "resolverSetConfig"]);
          if (rendererFnOptions.rendererTargetSelector) {
              container = function () {return that.dom.locate(rendererFnOptions.rendererTargetSelector); };
          }
         
          var renderer = {
              fossils: {},
              boundPathForNode: function (node) {
                  return fluid.boundPathForNode(node, renderer.fossils);
              }
          };
         
          var rendererSub = fluid.renderer.createRendererSubcomponent(container, that.options.selectors, rendererFnOptions, that, renderer.fossils);
          that.renderer = $.extend(renderer, rendererSub);
          
          if (messageResolver) {
              that.messageResolver = messageResolver;
          }
  
          that.refreshView = renderer.refreshView = function () {
              if (rendererOptions.instantiator && rendererOptions.parentComponent) {
                  fluid.renderer.clearDecorators(rendererOptions.instantiator, rendererOptions.parentComponent);
              }
              that.events.prepareModelForRender.fire(that.model, that.applier, that);
              var tree = produceTree.fire(that);
              if (that.renderer.expander) {
                  tree = that.renderer.expander(tree);
              }
              that.events.onRenderTree.fire(that, tree);
              that.renderer.render(tree);
              that.events.afterRender.fire(that);
          };
          
          if (that.options.renderOnInit) {
              that.refreshView();
          }
          
          return that;
      };
      
      var removeSelectors = function (selectors, selectorsToIgnore) {
          fluid.each(fluid.makeArray(selectorsToIgnore), function (selectorToIgnore) {
              delete selectors[selectorToIgnore];
          });
          return selectors;
      };
  
      var markRepeated = function (selectorKey, repeatingSelectors) {
          if (repeatingSelectors) {
              fluid.each(repeatingSelectors, function (repeatingSelector) {
                  if (selectorKey === repeatingSelector) {
                      selectorKey = selectorKey + ":";
                  }
              });
          }
          return selectorKey;
      };
  
      fluid.renderer.selectorsToCutpoints = function (selectors, options) {
          var togo = [];
          options = options || {};
          selectors = fluid.copy(selectors); // Make a copy before potentially destructively changing someone's selectors.
      
          if (options.selectorsToIgnore) {
              selectors = removeSelectors(selectors, options.selectorsToIgnore);
          }
      
          for (var selectorKey in selectors) {
              togo.push({
                  id: markRepeated(selectorKey, options.repeatingSelectors),
                  selector: selectors[selectorKey]
              });
          }
      
          return togo;
      };
    
      /** END of "Renderer Components" infrastructure **/
      
      fluid.renderer.NO_COMPONENT = {};
    
      /** A special "shallow copy" operation suitable for nondestructively
       * merging trees of components. jQuery.extend in shallow mode will 
       * neglect null valued properties.
       * This function is unsupported: It is not really intended for use by implementors.
       */
      fluid.renderer.mergeComponents = function (target, source) {
          for (var key in source) {
              target[key] = source[key];
          }
          return target;
      };
      
      fluid.registerNamespace("fluid.renderer.selection");
          
      /** Definition of expanders - firstly, "heavy" expanders **/
      
      fluid.renderer.selection.inputs = function (options, container, key, config) {
          fluid.expect("Selection to inputs expander", ["selectID", "inputID", "labelID", "rowID"], options);
          var selection = config.expander(options.tree);
          var rows = fluid.transform(selection.optionlist.value, function (option, index) {
              var togo = {};
              var element =  {parentRelativeID: "..::" + options.selectID, choiceindex: index};
              togo[options.inputID] = element;
              togo[options.labelID] = fluid.copy(element); 
              return togo;
          });
          var togo = {}; // TODO: JICO needs to support "quoted literal key initialisers" :P
          togo[options.selectID] = selection;
          togo[options.rowID] = {children: rows};
          togo = config.expander(togo);
          return togo;
      };
      
      fluid.renderer.repeat = function (options, container, key, config) {
          fluid.expect("Repetition expander", ["controlledBy", "tree"], options);
          var env = config.threadLocal();
          var path = fluid.extractContextualPath(options.controlledBy, {ELstyle: "ALL"}, env);
          var list = fluid.get(config.model, path, config.resolverGetConfig);
          
          var togo = {};
          if (!list || list.length === 0) {
              return options.ifEmpty ? config.expander(options.ifEmpty) : togo;
          }
          var expanded = [];
          fluid.each(list, function (element, i) {
              var EL = fluid.model.composePath(path, i);
              var envAdd = {}; 
              if (options.pathAs) {
                  envAdd[options.pathAs] = "${" + EL + "}";
              }
              if (options.valueAs) {
                  envAdd[options.valueAs] = fluid.get(config.model, EL, config.resolverGetConfig);
              }
              var expandrow = fluid.withEnvironment(envAdd, function() {
                  return config.expander(options.tree);
              }, env);
              if (fluid.isArrayable(expandrow)) {
                  if (expandrow.length > 0) {
                      expanded.push({children: expandrow});
                  }
              }
              else if (expandrow !== fluid.renderer.NO_COMPONENT) {
                  expanded.push(expandrow);
              }
          });
          var repeatID = options.repeatID;
          if (repeatID.indexOf(":") === -1) {
              repeatID = repeatID + ":";
          }
          fluid.each(expanded, function (entry) {entry.ID = repeatID; });
          return expanded;
      };
      
      fluid.renderer.condition = function (options, container, key, config) {
          fluid.expect("Selection to condition expander", ["condition"], options);
          var condition;
          if (options.condition.funcName) {
              var args = config.expandLight(options.condition.args);
              condition = fluid.invoke(options.condition.funcName, args);
          } else if (options.condition.expander) {
              condition = config.expander(options.condition);
          } else {
              condition = config.expandLight(options.condition);
          }
          var tree = (condition ? options.trueTree : options.falseTree);
          if (!tree) {
              tree = fluid.renderer.NO_COMPONENT;
          }
          return config.expander(tree);
      };
      
      
      /* An EL extraction utility suitable for context expressions which occur in 
       * expanding component trees. It assumes that any context expressions refer
       * to EL paths that are to be referred to the "true (direct) model" - since
       * the context during expansion may not agree with the context during rendering.
       * It satisfies the same contract as fluid.extractEL, in that it will either return
       * an EL path, or undefined if the string value supplied cannot be interpreted
       * as an EL path with respect to the supplied options.
       */
      // unsupported, non-API function
      fluid.extractContextualPath = function (string, options, env) {
          var parsed = fluid.extractELWithContext(string, options);
          if (parsed) {
              if (parsed.context) {
                  return fluid.transformContextPath(parsed, env).path;
              }
              else {
                  return parsed.path;
              }
          }
      };
      
      fluid.transformContextPath = function (parsed, env) {
          if (parsed.context) {
              var fetched = env[parsed.context];
              var EL;
              if (typeof(fetched) === "string") {
                  EL = fluid.extractEL(fetched, {ELstyle: "${}"});
              }
              if (EL) {
                  return {
                      noDereference: parsed.path === "", 
                      path: fluid.model.composePath(EL, parsed.path) 
                  }; 
              }
          }
          return parsed;
      };
  
      /** Create a "protoComponent expander" with the supplied set of options.
       * The returned value will be a function which accepts a "protoComponent tree"
       * as argument, and returns a "fully expanded" tree suitable for supplying
       * directly to the renderer.
       * A "protoComponent tree" is similar to the "dehydrated form" accepted by
       * the historical renderer - only
       * i) The input format is unambiguous - this expander will NOT accept hydrated
       * components in the {ID: "myId, myfield: "myvalue"} form - but ONLY in
       * the dehydrated {myID: {myfield: myvalue}} form.
       * ii) This expander has considerably greater power to expand condensed trees.
       * In particular, an "EL style" option can be supplied which will expand bare
       * strings found as values in the tree into UIBound components by a configurable
       * strategy. Supported values for "ELstyle" are a) "ALL" - every string will be
       * interpreted as an EL reference and assigned to the "valuebinding" member of
       * the UIBound, or b) any single character, which if it appears as the first
       * character of the string, will mark it out as an EL reference - otherwise it
       * will be considered a literal value, or c) the value "${}" which will be
       * recognised bracketing any other EL expression.
       */
  
      fluid.renderer.makeProtoExpander = function (expandOptions) {
        // shallow copy of options - cheaply avoid destroying model, and all others are primitive
          var options = $.extend({
              ELstyle: "${}"
          }, expandOptions); // shallow copy of options
          var threadLocal; // rebound on every expansion at entry point
          
          function fetchEL(string) {
              var env = threadLocal();
              return fluid.extractContextualPath(string, options, env);
          }
           
          var IDescape = options.IDescape || "\\";
          
          var expandLight = function (source) {
              return fluid.resolveEnvironment(source, options); 
          };
  
          var expandBound = function (value, concrete) {
              if (value.messagekey !== undefined) {
                  return {
                      componentType: "UIMessage",
                      messagekey: expandBound(value.messagekey),
                      args: expandLight(value.args)
                  };
              }
              var proto;
              if (!fluid.isPrimitive(value) && !fluid.isArrayable(value)) {
                  proto = $.extend({}, value);
                  if (proto.decorators) {
                      proto.decorators = expandLight(proto.decorators);
                  }
                  value = proto.value;
                  delete proto.value;
              } else {
                  proto = {};
              }
              var EL = typeof (value) === "string" ? fetchEL(value) : null;
              if (EL) {
                  proto.valuebinding = EL;
              } else if (value !== undefined) {
                  proto.value = value;
              }
              if (options.model && proto.valuebinding && proto.value === undefined) {
                  proto.value = fluid.get(options.model, proto.valuebinding, options.resolverGetConfig);
              }
              if (concrete) {
                  proto.componentType = "UIBound";
              }
              return proto;
          };
          
          options.filter = fluid.expander.lightFilter;
          
          var expandCond;
          var expandLeafOrCond;
          
          var expandEntry = function (entry) {
              var comp = [];
              expandCond(entry, comp);
              return {children: comp};
          };
          
          var expandExternal = function (entry) {
              if (entry === fluid.renderer.NO_COMPONENT) {
                  return entry;
              }
              var singleTarget;
              var target = [];
              var pusher = function (comp) {
                  singleTarget = comp;
              };
              expandLeafOrCond(entry, target, pusher);
              return singleTarget || target;
          };
          
          var expandConfig = {
              model: options.model,
              resolverGetConfig: options.resolverGetConfig,
              resolverSetConfig: options.resolverSetConfig,
              expander: expandExternal,
              expandLight: expandLight
              //threadLocal: threadLocal
          };
          
          var expandLeaf = function (leaf, componentType) {
              var togo = {componentType: componentType};
              var map = fluid.renderer.boundMap[componentType] || {};
              for (var key in leaf) {
                  if (/decorators|args/.test(key)) {
                      togo[key] = expandLight(leaf[key]);
                      continue;
                  } else if (map[key]) {
                      togo[key] = expandBound(leaf[key]);
                  } else {
                      togo[key] = leaf[key];
                  }
              }
              return togo;
          };
          
          // A child entry may be a cond, a leaf, or another "thing with children".
          // Unlike the case with a cond's contents, these must be homogeneous - at least
          // they may either be ALL leaves, or else ALL cond/childed etc. 
          // In all of these cases, the key will be THE PARENT'S KEY
          var expandChildren = function (entry, pusher) {
              var children = entry.children;
              for (var i = 0; i < children.length; ++i) {
                  // each child in this list will lead to a WHOLE FORKED set of children.
                  var target = [];
                  var comp = { children: target};
                  var child = children[i];
                  var childPusher = function (comp) {
                      target[target.length] = comp;
                  }; // jslint:ok - function in loop 
                  expandLeafOrCond(child, target, childPusher);
                  // Rescue the case of an expanded leaf into single component - TODO: check what sense this makes of the grammar
                  if (comp.children.length === 1 && !comp.children[0].ID) {
                      comp = comp.children[0];
                  }
                  pusher(comp); 
              }
          };
          
          function detectBareBound(entry) {
              return fluid.find(entry, function (value, key) {
                  return key === "decorators";
              }) !== false;
          }
          
          // We have reached something which is either a leaf or Cond - either inside
          // a Cond or as an entry in children.
          var expandLeafOrCond = function (entry, target, pusher) { // jslint:ok - forward declaration
              var componentType = fluid.renderer.inferComponentType(entry);
              if (!componentType && (fluid.isPrimitive(entry) || detectBareBound(entry))) {
                  componentType = "UIBound";
              }
              if (componentType) {
                  pusher(componentType === "UIBound" ? expandBound(entry, true) : expandLeaf(entry, componentType));
              } else {
                // we couldn't recognise it as a leaf, so it must be a cond
                // this may be illegal if we are already in a cond.
                  if (!target) {
                      fluid.fail("Illegal cond->cond transition");
                  }
                  expandCond(entry, target);
              }
          };
          
          // cond entry may be a leaf, "thing with children" or a "direct bound".
          // a Cond can ONLY occur as a direct member of "children". Each "cond" entry may
          // give rise to one or many elements with the SAME key - if "expandSingle" discovers
          // "thing with children" they will all share the same key found in proto. 
          expandCond = function (proto, target) {
              for (var key in proto) {
                  var entry = proto[key];
                  if (key.charAt(0) === IDescape) {
                      key = key.substring(1);
                  }
                  if (key === "expander") {
                      var expanders = fluid.makeArray(entry);
                      fluid.each(expanders, function (expander) {
                          var expanded = fluid.invokeGlobalFunction(expander.type, [expander, proto, key, expandConfig]);
                          if (expanded !== fluid.renderer.NO_COMPONENT) {
                              fluid.each(expanded, function (el) {target[target.length] = el; });
                          }
                      }); // jslint:ok - function in loop
                  } else if (entry) {
                      var condPusher = function (comp) {
                          comp.ID = key;
                          target[target.length] = comp; 
                      }; // jslint:ok - function in loop
  
                      if (entry.children) {
                          if (key.indexOf(":") === -1) {
                              key = key + ":";
                          }
                          expandChildren(entry, condPusher);
                      } else if (fluid.renderer.isBoundPrimitive(entry)) {
                          condPusher(expandBound(entry, true));
                      } else {
                          expandLeafOrCond(entry, null, condPusher);
                      }
                  }
              }
                  
          };
          
          return function(entry) {
              threadLocal = fluid.threadLocal(function() {
                  return $.extend({}, options.envAdd);
              });
              options.fetcher = fluid.makeEnvironmentFetcher(options.model, fluid.transformContextPath, threadLocal);
              expandConfig.threadLocal = threadLocal;
              return expandEntry(entry);
          };
      };
      
  })(jQuery, fluid_1_5);
      /*
   * jQuery UI Tooltip @VERSION
   *
   * Copyright 2010, AUTHORS.txt (http://jqueryui.com/about)
   * Dual licensed under the MIT or GPL Version 2 licenses.
   * http://jquery.org/license
   *
   * http://docs.jquery.com/UI/Tooltip
   *
   * Depends:
   *	jquery.ui.core.js
   *	jquery.ui.widget.js
   *	jquery.ui.position.js
   */
  (function($) {
  
  var increments = 0;
  
  $.widget("ui.tooltip", {
  	options: {
  		items: "[title]",
  		content: function() {
  			return $(this).attr("title");
  		},
  		position: {
  			my: "left center",
  			at: "right center",
  			offset: "15 0"
  		}
  	},
  	_create: function() {
  		var self = this;
  		this.tooltip = $("<div></div>")
  			.attr("id", "ui-tooltip-" + increments++)
  			.attr("role", "tooltip")
  			.attr("aria-hidden", "true")
  			.addClass("ui-tooltip ui-widget ui-corner-all ui-widget-content")
  			.appendTo(document.body)
  			.hide();
  		this.tooltipContent = $("<div></div>")
  			.addClass("ui-tooltip-content")
  			.appendTo(this.tooltip);
  		this.opacity = this.tooltip.css("opacity");
  		this.element
  			.bind("focus.tooltip mouseover.tooltip", function(event) {
  				self.open( event );
  			})
  			.bind("blur.tooltip mouseout.tooltip", function(event) {
  				self.close( event );
  			});
  	},
  	
  	enable: function() {
  		this.options.disabled = false;
  	},
  	
  	disable: function() {
  		this.options.disabled = true;
  	},
  	
  	destroy: function() {
  		this.tooltip.remove();
  		$.Widget.prototype.destroy.apply(this, arguments);
  	},
  	
  	widget: function() {
  		return this.element.pushStack(this.tooltip.get());
  	},
  	
  	open: function(event) {
  		var target = $(event && event.target || this.element).closest(this.options.items);
  		// already visible? possible when both focus and mouseover events occur
  		if (this.current && this.current[0] == target[0])
  			return;
  		var self = this;
  		this.current = target;
  		this.currentTitle = target.attr("title");
  		var content = this.options.content.call(target[0], function(response) {
  			// IE may instantly serve a cached response, need to give it a chance to finish with _show before that
  			setTimeout(function() {
  				// ignore async responses that come in after the tooltip is already hidden
  				if (self.current == target)
  					self._show(event, target, response);
  			}, 13);
  		});
  		if (content) {
  			self._show(event, target, content);
  		}
  	},
  	
  	_show: function(event, target, content) {
  		if (!content)
  			return;
  		
  		target.attr("title", "");
  		
  		if (this.options.disabled)
  			return;
  			
  		this.tooltipContent.html(content);
  		this.tooltip.css({
  			top: 0,
  			left: 0
  		}).show().position( $.extend({
  			of: target
  		}, this.options.position )).hide();
  		
  		this.tooltip.attr("aria-hidden", "false");
  		target.attr("aria-describedby", this.tooltip.attr("id"));
  
  		this.tooltip.stop(false, true).fadeIn();
  
  		this._trigger( "open", event );
  	},
  	
  	close: function(event) {
  		if (!this.current)
  			return;
  		
  		var current = this.current;
  		this.current = null;
  		current.attr("title", this.currentTitle);
  		
  		if (this.options.disabled)
  			return;
  		
  		current.removeAttr("aria-describedby");
  		this.tooltip.attr("aria-hidden", "true");
  		
  		this.tooltip.stop(false, true).fadeOut();
  		
  		this._trigger( "close", event );
  	}
  	
  });
  
  })(jQuery);
  /* Copyright (c) 2006 Brandon Aaron (http://brandonaaron.net)
   * Dual licensed under the MIT (http://www.opensource.org/licenses/mit-license.php) 
   * and GPL (http://www.opensource.org/licenses/gpl-license.php) licenses.
   *
   * $LastChangedDate$
   * $Rev$
   *
   * Version 2.1
   */
  
  (function($){
  
  /**
   * The bgiframe is chainable and applies the iframe hack to get 
   * around zIndex issues in IE6. It will only apply itself in IE 
   * and adds a class to the iframe called 'bgiframe'. The iframe
   * is appeneded as the first child of the matched element(s) 
   * with a tabIndex and zIndex of -1.
   * 
   * By default the plugin will take borders, sized with pixel units,
   * into account. If a different unit is used for the border's width,
   * then you will need to use the top and left settings as explained below.
   *
   * NOTICE: This plugin has been reported to cause perfromance problems
   * when used on elements that change properties (like width, height and
   * opacity) a lot in IE6. Most of these problems have been caused by 
   * the expressions used to calculate the elements width, height and 
   * borders. Some have reported it is due to the opacity filter. All 
   * these settings can be changed if needed as explained below.
   *
   * @example $('div').bgiframe();
   * @before <div><p>Paragraph</p></div>
   * @result <div><iframe class="bgiframe".../><p>Paragraph</p></div>
   *
   * @param Map settings Optional settings to configure the iframe.
   * @option String|Number top The iframe must be offset to the top
   * 		by the width of the top border. This should be a negative 
   *      number representing the border-top-width. If a number is 
   * 		is used here, pixels will be assumed. Otherwise, be sure
   *		to specify a unit. An expression could also be used. 
   * 		By default the value is "auto" which will use an expression 
   * 		to get the border-top-width if it is in pixels.
   * @option String|Number left The iframe must be offset to the left
   * 		by the width of the left border. This should be a negative 
   *      number representing the border-left-width. If a number is 
   * 		is used here, pixels will be assumed. Otherwise, be sure
   *		to specify a unit. An expression could also be used. 
   * 		By default the value is "auto" which will use an expression 
   * 		to get the border-left-width if it is in pixels.
   * @option String|Number width This is the width of the iframe. If
   *		a number is used here, pixels will be assume. Otherwise, be sure
   * 		to specify a unit. An experssion could also be used.
   *		By default the value is "auto" which will use an experssion
   * 		to get the offsetWidth.
   * @option String|Number height This is the height of the iframe. If
   *		a number is used here, pixels will be assume. Otherwise, be sure
   * 		to specify a unit. An experssion could also be used.
   *		By default the value is "auto" which will use an experssion
   * 		to get the offsetHeight.
   * @option Boolean opacity This is a boolean representing whether or not
   * 		to use opacity. If set to true, the opacity of 0 is applied. If
   *		set to false, the opacity filter is not applied. Default: true.
   * @option String src This setting is provided so that one could change 
   *		the src of the iframe to whatever they need.
   *		Default: "javascript:false;"
   *
   * @name bgiframe
   * @type jQuery
   * @cat Plugins/bgiframe
   * @author Brandon Aaron (brandon.aaron@gmail.com || http://brandonaaron.net)
   */
  $.fn.bgIframe = $.fn.bgiframe = function(s) {
  	// This is only for IE6
  	if ( $.browser.msie && parseInt($.browser.version) <= 6 ) {
  		s = $.extend({
  			top     : 'auto', // auto == .currentStyle.borderTopWidth
  			left    : 'auto', // auto == .currentStyle.borderLeftWidth
  			width   : 'auto', // auto == offsetWidth
  			height  : 'auto', // auto == offsetHeight
  			opacity : true,
  			src     : 'javascript:false;'
  		}, s || {});
  		var prop = function(n){return n&&n.constructor==Number?n+'px':n;},
  		    html = '<iframe class="bgiframe"frameborder="0"tabindex="-1"src="'+s.src+'"'+
  		               'style="display:block;position:absolute;z-index:-1;'+
  			               (s.opacity !== false?'filter:Alpha(Opacity=\'0\');':'')+
  					       'top:'+(s.top=='auto'?'expression(((parseInt(this.parentNode.currentStyle.borderTopWidth)||0)*-1)+\'px\')':prop(s.top))+';'+
  					       'left:'+(s.left=='auto'?'expression(((parseInt(this.parentNode.currentStyle.borderLeftWidth)||0)*-1)+\'px\')':prop(s.left))+';'+
  					       'width:'+(s.width=='auto'?'expression(this.parentNode.offsetWidth+\'px\')':prop(s.width))+';'+
  					       'height:'+(s.height=='auto'?'expression(this.parentNode.offsetHeight+\'px\')':prop(s.height))+';'+
  					'"/>';
  		return this.each(function() {
  			if ( $('> iframe.bgiframe', this).length == 0 )
  				this.insertBefore( document.createElement(html), this.firstChild );
  		});
  	}
  	return this;
  };
  
  // Add browser.version if it doesn't exist
  if (!$.browser.version)
  	$.browser.version = navigator.userAgent.toLowerCase().match(/.+(?:rv|it|ra|ie)[\/: ]([\d.]+)/)[1];
  
  })(jQuery);/*
  Copyright 2010 OCAD University
  
  Licensed under the Educational Community License (ECL), Version 2.0 or the New
  BSD license. You may not use this file except in compliance with one these
  Licenses.
  
  You may obtain a copy of the ECL 2.0 License and BSD License at
  https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
  */
  
  // Declare dependencies
  /*global fluid_1_5:true, jQuery*/
  
  // JSLint options 
  /*jslint white: true, funcinvoke: true, undef: true, newcap: true, nomen: true, regexp: true, bitwise: true, browser: true, forin: true, maxerr: 100, indent: 4 */
  
  var fluid_1_5 = fluid_1_5 || {};
  
  (function ($, fluid) {
      
      var createContentFunc = function (content) {
          return typeof content === "function" ? content : function () {
              return content;
          };
      };
  
      var setup = function (that) {
          that.container.tooltip({
              content: createContentFunc(that.options.content),
              position: that.options.position,
              items: that.options.items,
              open: function (event) {
                  var tt = $(event.target).tooltip("widget");
                  tt.stop(false, true);
                  tt.hide();
                  if (that.options.delay) {
                      tt.delay(that.options.delay).fadeIn("default", that.events.afterOpen.fire());
                  } else {
                      tt.show();
                      that.events.afterOpen.fire();
                  }
              },
              close: function (event) {
                  var tt = $(event.target).tooltip("widget");
                  tt.stop(false, true);
                  tt.hide();
                  tt.clearQueue();
                  that.events.afterClose.fire();
              } 
          });
          
          that.elm = that.container.tooltip("widget");
          
          that.elm.addClass(that.options.styles.tooltip);
      };
  
      fluid.tooltip = function (container, options) {
          var that = fluid.initView("fluid.tooltip", container, options);
          
          /**
           * Updates the contents displayed in the tooltip
           * 
           * @param {Object} content, the content to be displayed in the tooltip
           */
          that.updateContent = function (content) {
              that.container.tooltip("option", "content", createContentFunc(content));
          };
          
          /**
           * Destroys the underlying jquery ui tooltip
           */
          that.destroy = function () {
              that.container.tooltip("destroy");
          };
          
          /**
           * Manually displays the tooltip
           */
          that.open = function () {
              that.container.tooltip("open");
          };
          
          /**
           * Manually hides the tooltip
           */
          that.close = function () {
              that.container.tooltip("close");
          };
          
          setup(that);
          
          return that;
      };
      
      fluid.defaults("fluid.tooltip", {
          styles: {
              tooltip: ""
          },
          
          events: {
              afterOpen: null,
              afterClose: null  
          },
          
          content: "",
          
          position: {
              my: "left top",
              at: "left bottom",
              offset: "0 5"
          },
          
          items: "*",
          
          delay: 300
      });
  
  })(jQuery, fluid_1_5);
  /*
  Copyright 2008-2009 University of Cambridge
  Copyright 2008-2009 University of Toronto
  Copyright 2010-2011 OCAD University
  Copyright 2010-2011 Lucendo Development Ltd.
  
  Licensed under the Educational Community License (ECL), Version 2.0 or the New
  BSD license. You may not use this file except in compliance with one these
  Licenses.
  
  You may obtain a copy of the ECL 2.0 License and BSD License at
  https://github.com/fluid-project/infusion/raw/master/Infusion-LICENSE.txt
  */
  
  // Declare dependencies
  /*global fluid_1_5:true, jQuery*/
  
  // JSLint options 
  /*jslint white: true, funcinvoke: true, undef: true, newcap: true, nomen: true, regexp: true, bitwise: true, browser: true, forin: true, maxerr: 100, indent: 4 */
  
  var fluid_1_5 = fluid_1_5 || {};
  
  (function ($, fluid) {
  
      /******************
       * Pager Bar View *
       ******************/
  
      
      function updateStyles(pageListThat, newModel, oldModel) {
          if (!pageListThat.pageLinks) {
              return;
          }
          if (oldModel.pageIndex !== undefined) {
              var oldLink = pageListThat.pageLinks.eq(oldModel.pageIndex);
              oldLink.removeClass(pageListThat.options.styles.currentPage);
          }
          var pageLink = pageListThat.pageLinks.eq(newModel.pageIndex);
          pageLink.addClass(pageListThat.options.styles.currentPage); 
      }
      
      function bindLinkClick(link, events, eventArg) {
          link.unbind("click.fluid.pager");
          link.bind("click.fluid.pager", function () {
              events.initiatePageChange.fire(eventArg);
          });
      }
      
      // 10 -> 1, 11 -> 2
      function computePageCount(model) {
          model.pageCount = Math.max(1, Math.floor((model.totalRange - 1) / model.pageSize) + 1);
      }
  
      fluid.pager = function () {
          return fluid.pagerImpl.apply(null, arguments);
      };
      
      fluid.pager.computePageLimit = function (model) {
          return Math.min(model.totalRange, (model.pageIndex + 1) * model.pageSize);
      };
  
      fluid.pager.directPageList = function (container, events, options) {
          var that = fluid.initView("fluid.pager.directPageList", container, options);
          that.pageLinks = that.locate("pageLinks");
          for (var i = 0; i < that.pageLinks.length; ++i) {
              var pageLink = that.pageLinks.eq(i);
              bindLinkClick(pageLink, events, {pageIndex: i});
          }
          events.onModelChange.addListener(
              function (newModel, oldModel) {
                  updateStyles(that, newModel, oldModel);
              }
          );
          that.defaultModel = {
              pageIndex: undefined,
              pageSize: 1,
              totalRange: that.pageLinks.length
          };
          return that;
      };
      
      /** Returns an array of size count, filled with increasing integers, 
       *  starting at 0 or at the index specified by first. 
       */
      
      fluid.iota = function (count, first) {
          first = first || 0;
          var togo = [];
          for (var i = 0; i < count; ++i) {
              togo[togo.length] = first++;
          }
          return togo;
      };
      
      fluid.pager.everyPageStrategy = fluid.iota;
      
      fluid.pager.gappedPageStrategy = function (locality, midLocality) {
          if (!locality) {
              locality = 3;
          }
          if (!midLocality) {
              midLocality = locality;
          }
          return function (count, first, mid) {
              var togo = [];
              var j = 0;
              var lastSkip = false;
              for (var i = 0; i < count; ++i) {
                  if (i < locality || (count - i - 1) < locality || (i >= mid - midLocality && i <= mid + midLocality)) {
                      togo[j++] = i;
                      lastSkip = false;
                  } else if (!lastSkip) {
                      togo[j++] = -1;
                      lastSkip = true;
                  }
              }
              return togo;
          };
      };
      
      /**
       * An impl of a page strategy that will always display same number of page links (including skip place holders). 
       * @param   endLinkCount    int     The # of elements first and last trunks of elements
       * @param   midLinkCount    int     The # of elements from beside the selected #
       * @author  Eric Dalquist
       */
      fluid.pager.consistentGappedPageStrategy = function (endLinkCount, midLinkCount) {
          if (!endLinkCount) {
              endLinkCount = 1;
          }
          if (!midLinkCount) {
              midLinkCount = endLinkCount;
          }
          var endWidth = endLinkCount + 2 + midLinkCount;
  
          return function (count, first, mid) {
              var pages = [];
              var anchoredLeft = mid < endWidth;
              var anchoredRight = mid >= count - endWidth;
              var anchoredEndWidth = endWidth + midLinkCount;
              var midStart = mid - midLinkCount;
              var midEnd = mid + midLinkCount;
              var lastSkip = false;
              
              for (var page = 0; page < count; page++) {
                  if (page < endLinkCount || // start pages
                          count - page <= endLinkCount || // end pages
                          (anchoredLeft && page < anchoredEndWidth) || // pages if no skipped pages between start and mid
                          (anchoredRight && page >= count - anchoredEndWidth) || // pages if no skipped pages between mid and end
                          (page >= midStart && page <= midEnd) // pages around the mid
                          ) {
                      pages.push(page);
                      lastSkip = false;
                  } else if (!lastSkip) {
                      pages.push(-1);
                      lastSkip = true;
                  }
              }
              return pages;
          };
      };  
      
      fluid.pager.renderedPageList = function (container, events, pagerBarOptions, options, strings) {
          options = $.extend(true, pagerBarOptions, options);
          var that = fluid.initView("fluid.pager.renderedPageList", container, options);
          options = that.options; // pick up any defaults
          var idMap = {};
          var renderOptions = {
              cutpoints: [ 
                  {
                      id: "page-link:link",
                      selector: pagerBarOptions.selectors.pageLinks
                  },
                  {
                      id: "page-link:skip",
                      selector: pagerBarOptions.selectors.pageLinkSkip
                  }
              ],
              idMap: idMap
          };
          
          if (options.linkBody) {
              renderOptions.cutpoints[renderOptions.cutpoints.length] = {
                  id: "payload-component",
                  selector: options.linkBody
              };
          }   
          
          var assembleComponent = function (page, isCurrent) {
              var obj = {
                  ID: "page-link:link",
                  localID: page + 1,
                  value: page + 1,
                  pageIndex: page,
                  decorators: [
                      {
                          type: "jQuery",
                          func: "click", 
                          args: function (event) {
                              events.initiatePageChange.fire({pageIndex: page});
                              event.preventDefault();
                          }
                      }
                  ]
              };
              
              if (isCurrent) {
                  obj.current = true;
                  obj.decorators = obj.decorators.concat([
                      {
                          type: "addClass",
                          classes: that.options.styles.currentPage
                      },
                      {
                          type: "jQuery",
                          func: "attr", 
                          args: ["aria-label", that.options.strings.currentPageIndexMsg] 
                      }
                  ]);
              }
              
              return obj;
          };
               
          function pageToComponent(current) {
              return function (page) {
                  return page === -1 ? {
                      ID: "page-link:skip"
                  } : assembleComponent(page, page === current);
              };
          }
          
          var root = that.locate("root");
          fluid.expectFilledSelector(root, "Error finding root template for fluid.pager.renderedPageList");
          
          var template = fluid.selfRender(root, {}, renderOptions);
          events.onModelChange.addListener(
              function (newModel, oldModel) {
                  var pages = that.options.pageStrategy(newModel.pageCount, 0, newModel.pageIndex);
                  var pageTree = fluid.transform(pages, pageToComponent(newModel.pageIndex));
                  if (pageTree.length > 1) {
                      pageTree[pageTree.length - 1].value = pageTree[pageTree.length - 1].value + strings.last;
                  }
                  events.onRenderPageLinks.fire(pageTree, newModel);
                  
                  //Destroys all the tooltips before rerendering the pagelinks.
                  //This will clean up the tooltips, which are all added to the end at the end of the DOM,
                  //and prevent the tooltips from sticking around when using the keyboard to activate
                  //the page links.
                  $.each(idMap, function (key, id) {
                      var pageLink = fluid.jById(id);
                      if (pageLink.tooltip) {
                          pageLink.tooltip("destroy");
                      }
                  });
                  fluid.reRender(template, root, pageTree, renderOptions);
                  updateStyles(that, newModel, oldModel);
              }
          );
          return that;
      };
      
      fluid.defaults("fluid.pager.renderedPageList", {
          selectors: {
              root: ".flc-pager-links"
          },
          linkBody: "a",
          pageStrategy: fluid.pager.everyPageStrategy
      });
      
      var updatePreviousNext = function (that, options, newModel) {
          if (newModel.pageIndex === 0) {
              that.previous.addClass(options.styles.disabled);
          } else {
              that.previous.removeClass(options.styles.disabled);
          }
          
          if (newModel.pageIndex === newModel.pageCount - 1) {
              that.next.addClass(options.styles.disabled);
          } else {
              that.next.removeClass(options.styles.disabled);
          }
      };
      
      fluid.pager.previousNext = function (container, events, options) {
          var that = fluid.initView("fluid.pager.previousNext", container, options);
          that.previous = that.locate("previous");
          bindLinkClick(that.previous, events, {relativePage: -1});
          that.next = that.locate("next");
          bindLinkClick(that.next, events, {relativePage: +1});
          events.onModelChange.addListener(
              function (newModel, oldModel, overallThat) {
                  updatePreviousNext(that, options, newModel);
              }
          );
          return that;
      };
  
      fluid.pager.pagerBar = function (events, container, options, strings) {
          var that = fluid.initView("fluid.pager.pagerBar", container, options);
          that.pageList = fluid.initSubcomponent(that, "pageList", 
              [container, events, that.options, fluid.COMPONENT_OPTIONS, strings]);
          that.previousNext = fluid.initSubcomponent(that, "previousNext", 
              [container, events, that.options, fluid.COMPONENT_OPTIONS, strings]);
          
          return that;
      };
  
      
      fluid.defaults("fluid.pager.pagerBar", {
              
          previousNext: {
              type: "fluid.pager.previousNext"
          },
          
          pageList: {
              type: "fluid.pager.renderedPageList",
              options: {
                  pageStrategy: fluid.pager.gappedPageStrategy(3, 1)
              }
          },
          
          selectors: {
              pageLinks: ".flc-pager-pageLink",
              pageLinkSkip: ".flc-pager-pageLink-skip",
              previous: ".flc-pager-previous",
              next: ".flc-pager-next"
          },
          
          styles: {
              currentPage: "fl-pager-currentPage",
              disabled: "fl-pager-disabled"
          },
          
          strings: {
              currentPageIndexMsg: "Current page"
          }
      });
  
      function getColumnDefs(that) {
          return that.options.columnDefs;
      }
  
      fluid.pager.findColumnDef = function (columnDefs, key) {
          var columnDef = $.grep(columnDefs, function (def) {
              return def.key === key;
          })[0];
          return columnDef;
      };
      
      function getRoots(target, overallThat, index) {
          var cellRoot = (overallThat.options.dataOffset ? overallThat.options.dataOffset + "." : "");
          target.shortRoot = index;
          target.longRoot = cellRoot + target.shortRoot;
      }
      
      function expandPath(EL, shortRoot, longRoot) {
          if (EL.charAt(0) === "*") {
              return longRoot + EL.substring(1); 
          } else {
              return EL.replace("*", shortRoot);
          }
      }
      
      fluid.pager.fetchValue = function (that, dataModel, index, valuebinding, roots) {
          getRoots(roots, that, index);
  
          var path = expandPath(valuebinding, roots.shortRoot, roots.longRoot);
          return fluid.get(dataModel, path);
      };
      
      fluid.pager.basicSorter = function (overallThat, model) {        
          var dataModel = overallThat.options.dataModel;
          var roots = {};
          var columnDefs = getColumnDefs(overallThat);
          var columnDef = fluid.pager.findColumnDef(columnDefs, model.sortKey);
          var sortrecs = [];
          for (var i = 0; i < model.totalRange; ++i) {
              sortrecs[i] = {
                  index: i,
                  value: fluid.pager.fetchValue(overallThat, dataModel, i, columnDef.valuebinding, roots)
              };
          }
          function sortfunc(arec, brec) {
              var a = arec.value;
              var b = brec.value;
              return a === b ? 0 : (a > b ? model.sortDir : -model.sortDir); 
          }
          sortrecs.sort(sortfunc);
          return fluid.transform(sortrecs, function (row) {
              return row.index;
          });
      };
  
      
      fluid.pager.directModelFilter = function (model, pagerModel, perm) {
          var togo = [];
          var limit = fluid.pager.computePageLimit(pagerModel);
          for (var i = pagerModel.pageIndex * pagerModel.pageSize; i < limit; ++i) {
              var index = perm ? perm[i] : i;
              togo[togo.length] = {index: index, row: model[index]};
          }
          return togo;
      };
      
      function expandVariables(value, opts) {
          var togo = "";
          var index = 0;
          while (true) {
              var nextindex = value.indexOf("${", index);
              if (nextindex === -1) {
                  togo += value.substring(index);
                  break;
              } else {
                  togo += value.substring(index, nextindex);
                  var endi = value.indexOf("}", nextindex + 2);
                  var EL = value.substring(nextindex + 2, endi);
                  if (EL === "VALUE") {
                      EL = opts.EL;
                  } else {
                      EL = expandPath(EL, opts.shortRoot, opts.longRoot);
                  }
                  var val = fluid.get(opts.dataModel, EL);
                  togo += val;
                  index = endi + 1;
              }
          }
          return togo;
      }
     
      function expandPaths(target, tree, opts) {
          for (var i in tree) {
              var val = tree[i];
              if (val === fluid.VALUE) {
                  if (i === "valuebinding") {
                      target[i] = opts.EL;
                  } else {
                      target[i] = {"valuebinding" : opts.EL};
                  }
              } else if (i === "valuebinding") {
                  target[i] = expandPath(tree[i], opts);
              } else if (typeof (val) === 'object') {
                  target[i] = val.length !== undefined ? [] : {};
                  expandPaths(target[i], val, opts);
              } else if (typeof (val) === 'string') {
                  target[i] = expandVariables(val, opts);
              } else {
                  target[i] = tree[i];
              }
          }
          return target;
      }
     
     // sets opts.EL, returns ID
      function iDforColumn(columnDef, opts) {
          var options = opts.options;
          var EL = columnDef.valuebinding;
          var key = columnDef.key;
          if (!EL) {
              fluid.fail("Error in definition for column with key " + key + ": valuebinding is not set");
          }
          opts.EL = expandPath(EL, opts.shortRoot, opts.longRoot);
          if (!key) {
              var segs = fluid.model.parseEL(EL);
              key = segs[segs.length - 1];
          }
          var ID = (options.keyPrefix ? options.keyPrefix : "") + key;
          return ID;
      }
     
      function expandColumnDefs(filteredRow, opts) {
          var tree = fluid.transform(opts.columnDefs, function (columnDef) {
              var ID = iDforColumn(columnDef, opts);
              var togo;
              if (!columnDef.components) {
                  return {
                      ID: ID,
                      valuebinding: opts.EL
                  };
              } else if (typeof columnDef.components === 'function') {
                  togo = columnDef.components(filteredRow.row, filteredRow.index);
              } else {
                  togo = columnDef.components;
              }
              togo = expandPaths({}, togo, opts);
              togo.ID = ID;
              return togo;
          });
          return tree;
      }
     
      function fetchModel(overallThat) {
          return fluid.get(overallThat.options.dataModel, 
              overallThat.options.dataOffset);
      }
     
      
      function bigHeaderForKey(key, opts) {
          var id = opts.options.renderOptions.idMap["header:" + key];
          var smallHeader = fluid.jById(id);
          if (smallHeader.length === 0) {
              return null;
          }
          var headerSortStylisticOffset = opts.overallOptions.selectors.headerSortStylisticOffset;
          var bigHeader = fluid.findAncestor(smallHeader, function (element) {
              return $(element).is(headerSortStylisticOffset); 
          });
          return bigHeader;
      }
     
      function setSortHeaderClass(styles, element, sort) {
          element = $(element);
          element.removeClass(styles.ascendingHeader);
          element.removeClass(styles.descendingHeader);
          if (sort !== 0) {
              element.addClass(sort === 1 ? styles.ascendingHeader : styles.descendingHeader);
              //aria-sort property are specified in the w3 WAI spec, ascending, descending, none, other.
              //since pager currently uses ascending and descending, we do not support the others.
              //http://www.w3.org/WAI/PF/aria/states_and_properties#aria-sort
              element.attr('aria-sort', sort === 1 ? 'ascending' : 'descending'); 
          }
      }
      
      function isCurrentColumnSortable(columnDefs, model) {
          var columnDef = model.sortKey ? fluid.pager.findColumnDef(columnDefs, model.sortKey) : null;
          return columnDef ? columnDef.sortable : false;
      }
      
      function setModelSortHeaderClass(newModel, opts) {
          var styles = opts.overallOptions.styles;
          var sort = isCurrentColumnSortable(opts.columnDefs, newModel) ? newModel.sortDir : 0;
          setSortHeaderClass(styles, bigHeaderForKey(newModel.sortKey, opts), sort);
      }
     
      function fireModelChange(that, newModel, forceUpdate) {
          computePageCount(newModel);
          if (newModel.pageIndex >= newModel.pageCount) {
              newModel.pageIndex = newModel.pageCount - 1;
          }
          if (forceUpdate || newModel.pageIndex !== that.model.pageIndex || newModel.pageSize !== that.model.pageSize || newModel.sortKey !== that.model.sortKey ||
                  newModel.sortDir !== that.model.sortDir) {
              var sorted = isCurrentColumnSortable(getColumnDefs(that), newModel) ? 
                  that.options.sorter(that, newModel) : null;
              that.permutation = sorted;
              that.events.onModelChange.fire(newModel, that.model, that);
              fluid.model.copyModel(that.model, newModel);
          }
      }
  
      function generateColumnClick(overallThat, columnDef, opts) {
          return function () {
              if (columnDef.sortable === true) {
                  var model = overallThat.model;
                  var newModel = fluid.copy(model);
                  var styles = overallThat.options.styles;
                  var oldKey = model.sortKey;
                  if (columnDef.key !== model.sortKey) {
                      newModel.sortKey = columnDef.key;
                      newModel.sortDir = 1;
                      var oldBig = bigHeaderForKey(oldKey, opts);
                      if (oldBig) {
                          setSortHeaderClass(styles, oldBig, 0);
                      }
                  } else if (newModel.sortKey === columnDef.key) {
                      newModel.sortDir = -1 * newModel.sortDir;
                  } else {
                      return false;
                  }
                  newModel.pageIndex = 0;
                  fireModelChange(overallThat, newModel, true);
                  setModelSortHeaderClass(newModel, opts);                
              }
              return false;
          };
      }
     
      function fetchHeaderDecorators(decorators, columnDef) {
          return decorators[columnDef.sortable ? "sortableHeader" : "unsortableHeader"];
      }
     
      function generateHeader(overallThat, newModel, columnDefs, opts) {
          var sortableColumnTxt = opts.options.strings.sortableColumnText;
          if (newModel.sortDir === 1) {
              sortableColumnTxt = opts.options.strings.sortableColumnTextAsc;
          } else if (newModel.sortDir === -1) {
              sortableColumnTxt = opts.options.strings.sortableColumnTextDesc;
          }
  
          return {
              children:  
                  fluid.transform(columnDefs, function (columnDef) {
                      return {
                          ID: iDforColumn(columnDef, opts),
                          value: columnDef.label,
                          decorators: [ 
                              {"jQuery": ["click", generateColumnClick(overallThat, columnDef, opts)]},
                              {identify: "header:" + columnDef.key},
                              {type: "attrs", attributes: { title: (columnDef.key === newModel.sortKey) ? sortableColumnTxt : opts.options.strings.sortableColumnText}}
                          ].concat(fetchHeaderDecorators(opts.overallOptions.decorators, columnDef))
                      };
                  })  
          };
      }
     
      /** A body renderer implementation which uses the Fluid renderer to render a table section **/
     
      fluid.pager.selfRender = function (overallThat, inOptions) {
          var that = fluid.initView("fluid.pager.selfRender", overallThat.container, inOptions);
          var options = that.options;
          options.renderOptions.idMap = options.renderOptions.idMap || {};
          var idMap = options.renderOptions.idMap;
          var root = that.locate("root");
          var template;
          if (options.template) {
              template = fluid.render($(that.options.selectors.root, options.template).html(), root, {}, options.renderOptions);
          } else {
              template = fluid.selfRender(root, {}, options.renderOptions);
          }
          root.addClass(options.styles.root);
          var columnDefs = getColumnDefs(overallThat);
          var expOpts = {options: options, columnDefs: columnDefs, overallOptions: overallThat.options, dataModel: overallThat.options.dataModel, idMap: idMap};
          var directModel = fetchModel(overallThat);
  
          return {
              returnedOptions: {
                  listeners: {
                      onModelChange: function (newModel, oldModel) {
                          var filtered = overallThat.options.modelFilter(directModel, newModel, overallThat.permutation);
                          var tree = fluid.transform(filtered, 
                              function (filteredRow) {
                                  getRoots(expOpts, overallThat, filteredRow.index);
                                  if (columnDefs === "explode") {
                                      return fluid.explode(filteredRow.row, expOpts.longRoot);
                                  } else if (columnDefs.length) {
                                      return expandColumnDefs(filteredRow, expOpts);
                                  }
                              });
                          var fullTree = {};
                          fullTree[options.row] = tree;
                          if (typeof (columnDefs) === "object") {
                              fullTree[options.header] = generateHeader(overallThat, newModel, columnDefs, expOpts);
                          }
                          options.renderOptions = options.renderOptions || {};
                          options.renderOptions.model = expOpts.dataModel;
                          fluid.reRender(template, root, fullTree, options.renderOptions);
                          overallThat.events.afterRender.fire(overallThat);
                          setModelSortHeaderClass(newModel, expOpts); // TODO, should this not be actually renderable?
                      }
                  }
              }
          };
      };
  
      fluid.defaults("fluid.pager.selfRender", {
          selectors: {
              root: ".flc-pager-body-template"
          },
          
          styles: {
              root: "fl-pager"
          },
          
          keyStrategy: "id",
          keyPrefix: "",
          row: "row:",
          header: "header:",
          
          strings: {
              sortableColumnText: "Select to sort",
              sortableColumnTextDesc: "Select to sort in ascending, currently in descending order.",
              sortableColumnTextAsc: "Select to sort in descending, currently in ascending order."
          },
  
          // Options passed upstream to the renderer
          renderOptions: {}
      });
  
      fluid.pager.summaryAria = function (element) {
          element.attr({
              "aria-relevant": "all",
              "aria-atomic": "false",
              "aria-live": "assertive",
              "role": "status"
          });
      };
  
      fluid.pager.summary = function (dom, options) {
          var node = dom.locate("summary");
          fluid.pager.summaryAria(node);
          return {
              returnedOptions: {
                  listeners: {
                      onModelChange: function (newModel, oldModel) {
                          var text = fluid.stringTemplate(options.message, {
                              first: newModel.pageIndex * newModel.pageSize + 1,
                              last: fluid.pager.computePageLimit(newModel),
                              total: newModel.totalRange,
                              currentPage: newModel.pageIndex + 1
                          });
                          if (node.length > 0) {
                              node.text(text);
                          }
                      }
                  }
              }
          };
      };
      
      fluid.pager.directPageSize = function (that) {
          var node = that.locate("pageSize");
          if (node.length > 0) {
              that.events.onModelChange.addListener(
                  function (newModel, oldModel) {
                      if (node.val() !== newModel.pageSize) {
                          node.val(newModel.pageSize);
                      }
                  }
              );
              node.change(function () {
                  that.events.initiatePageSizeChange.fire(node.val());
              });
          }
      };
  
  
      fluid.pager.rangeAnnotator = function (that, options) {
          var roots = {};
          that.events.onRenderPageLinks.addListener(function (tree, newModel) {
              var column = that.options.annotateColumnRange;
              var dataModel = that.options.dataModel;
              // TODO: reaching into another component's options like this is a bit unfortunate
              var columnDefs = getColumnDefs(that);
  
              if (!column || !dataModel || !columnDefs) {
                  return;
              }
              var columnDef = fluid.pager.findColumnDef(columnDefs, column);
              
              function fetchValue(index) {
                  index = that.permutation ? that.permutation[index] : index;
                  return fluid.pager.fetchValue(that, dataModel, index, columnDef.valuebinding, roots);
              }
              var tModel = {};
              fluid.model.copyModel(tModel, newModel);
              
              fluid.transform(tree, function (cell) {
                  if (cell.ID === "page-link:link") {
                      var page = cell.pageIndex;
                      var start = page * tModel.pageSize;
                      tModel.pageIndex = page;
                      var limit = fluid.pager.computePageLimit(tModel);
                      var iValue = fetchValue(start);
                      var lValue = fetchValue(limit - 1);
                      
                      var tooltipOpts = fluid.copy(that.options.tooltip.options) || {};
                      
                      if (!tooltipOpts.content) {
                          tooltipOpts.content = function () { 
                              return fluid.stringTemplate(that.options.markup.rangeAnnotation, {
                                  first: iValue,
                                  last: lValue
                              });
                          };
                      }
                      
                      if (!cell.current) {
                          var decorators = [
                              {
                                  type: "fluid",
                                  func: that.options.tooltip.type,
                                  options: tooltipOpts
                              },
                              {
                                  identify: page
                              }
                          ];
                          cell.decorators = cell.decorators.concat(decorators);
                      }
                  }
              });
          });
      };
  
      /*******************
       * Pager Component *
       *******************/
      
      fluid.pagerImpl = function (container, options) {
          var that = fluid.initView("fluid.pager", container, options);
                  
          that.container.attr("role", "application");
          
          that.events.initiatePageChange.addListener(
              function (arg) {
                  var newModel = fluid.copy(that.model);
                  if (arg.relativePage !== undefined) {
                      newModel.pageIndex = that.model.pageIndex + arg.relativePage;
                  } else {
                      newModel.pageIndex = arg.pageIndex;
                  }
                  if (newModel.pageIndex === undefined || newModel.pageIndex < 0) {
                      newModel.pageIndex = 0;
                  }
                  fireModelChange(that, newModel, arg.forceUpdate);
              }
          );
          
          that.events.initiatePageSizeChange.addListener(
              function (arg) {
                  var newModel = fluid.copy(that.model);
                  newModel.pageSize = arg;
                  fireModelChange(that, newModel);     
              }
          );
  
          // Setup the top and bottom pager bars.
          var pagerBarElement = that.locate("pagerBar");
          if (pagerBarElement.length > 0) {
              that.pagerBar = fluid.initSubcomponent(that, "pagerBar", 
                  [that.events, pagerBarElement, fluid.COMPONENT_OPTIONS, that.options.strings]);
          }
          
          var pagerBarSecondaryElement = that.locate("pagerBarSecondary");
          if (pagerBarSecondaryElement.length > 0) {
              that.pagerBarSecondary = fluid.initSubcomponent(that, "pagerBar",
                  [that.events, pagerBarSecondaryElement, fluid.COMPONENT_OPTIONS, that.options.strings]);
          }
   
          that.bodyRenderer = fluid.initSubcomponent(that, "bodyRenderer", [that, fluid.COMPONENT_OPTIONS]);
          
          that.summary = fluid.initSubcomponent(that, "summary", [that.dom, fluid.COMPONENT_OPTIONS]);
          
          that.pageSize = fluid.initSubcomponent(that, "pageSize", [that]);
          
          that.rangeAnnotator = fluid.initSubcomponent(that, "rangeAnnotator", [that, fluid.COMPONENT_OPTIONS]);
   
          that.model = fluid.copy(that.options.model);
          
          var dataModel = fetchModel(that);
          if (dataModel) {
              that.model.totalRange = dataModel.length;
          }
          if (that.model.totalRange === undefined) {
              if (!that.pagerBar) {
                  fluid.fail("Error in Pager configuration - cannot determine total range, " +
                      " since not configured in model.totalRange and no PagerBar is configured");
              }
              that.model = that.pagerBar.pageList.defaultModel;
          }
          that.applier = fluid.makeChangeApplier(that.model);
  
          that.events.initiatePageChange.fire({pageIndex: that.model.pageIndex ? that.model.pageIndex : 0, 
              forceUpdate: true});
  
          return that;
      };
      
      fluid.defaults("fluid.pager", {
          mergePolicy: {
              dataModel: "preserve",
              model: "preserve"
          },
          pagerBar: {
              type: "fluid.pager.pagerBar"
          },
          
          summary: {type: "fluid.pager.summary", options: {
              message: "Viewing page %currentPage. Showing records %first - %last of %total items." 
          }},
          
          pageSize: {
              type: "fluid.pager.directPageSize"
          },
          
          modelFilter: fluid.pager.directModelFilter,
          
          sorter: fluid.pager.basicSorter,
          
          bodyRenderer: {
              type: "fluid.pager.selfRender"
          },
          
          model: {
              pageIndex: undefined,
              pageSize: 10,
              totalRange: undefined
          },
          
          dataModel: undefined,
          // Offset of the tree's "main" data from the overall dataModel root
          dataOffset: "",
          
          // strategy for generating a tree row, either "explode" or an array of columnDef objects
          columnDefs: [], // [{key: "columnName", valuebinding: "*.valuePath", sortable: true/false}]
          
          annotateColumnRange: undefined, // specify a "key" from the columnDefs
          
          tooltip: {
              type: "fluid.tooltip"
          },
          
          rangeAnnotator: {
              type: "fluid.pager.rangeAnnotator"
          },
          
          selectors: {
              pagerBar: ".flc-pager-top",
              pagerBarSecondary: ".flc-pager-bottom",
              summary: ".flc-pager-summary",
              pageSize: ".flc-pager-page-size",
              headerSortStylisticOffset: ".flc-pager-sort-header"
          },
          
          styles: {
              ascendingHeader: "fl-pager-asc",
              descendingHeader: "fl-pager-desc"
          },
          
          decorators: {
              sortableHeader: [],
              unsortableHeader: []
          },
          
          strings: {
              last: " (last)"
          },
          
          events: {
              initiatePageChange: null,
              initiatePageSizeChange: null,
              onModelChange: null,
              onRenderPageLinks: null,
              afterRender: null
          },
          
          markup: {
              rangeAnnotation: "<b> %first </b><br/>&mdash;<br/><b> %last </b>"
          }
      });
  })(jQuery, fluid_1_5);
  /*
   * jQuery UI Draggable 1.8.12
   *
   * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
   * Dual licensed under the MIT or GPL Version 2 licenses.
   * http://jquery.org/license
   *
   * http://docs.jquery.com/UI/Draggables
   *
   * Depends:
   *	jquery.ui.core.js
   *	jquery.ui.mouse.js
   *	jquery.ui.widget.js
   */
  (function( $, undefined ) {
  
  $.widget("ui.draggable", $.ui.mouse, {
  	widgetEventPrefix: "drag",
  	options: {
  		addClasses: true,
  		appendTo: "parent",
  		axis: false,
  		connectToSortable: false,
  		containment: false,
  		cursor: "auto",
  		cursorAt: false,
  		grid: false,
  		handle: false,
  		helper: "original",
  		iframeFix: false,
  		opacity: false,
  		refreshPositions: false,
  		revert: false,
  		revertDuration: 500,
  		scope: "default",
  		scroll: true,
  		scrollSensitivity: 20,
  		scrollSpeed: 20,
  		snap: false,
  		snapMode: "both",
  		snapTolerance: 20,
  		stack: false,
  		zIndex: false
  	},
  	_create: function() {
  
  		if (this.options.helper == 'original' && !(/^(?:r|a|f)/).test(this.element.css("position")))
  			this.element[0].style.position = 'relative';
  
  		(this.options.addClasses && this.element.addClass("ui-draggable"));
  		(this.options.disabled && this.element.addClass("ui-draggable-disabled"));
  
  		this._mouseInit();
  
  	},
  
  	destroy: function() {
  		if(!this.element.data('draggable')) return;
  		this.element
  			.removeData("draggable")
  			.unbind(".draggable")
  			.removeClass("ui-draggable"
  				+ " ui-draggable-dragging"
  				+ " ui-draggable-disabled");
  		this._mouseDestroy();
  
  		return this;
  	},
  
  	_mouseCapture: function(event) {
  
  		var o = this.options;
  
  		// among others, prevent a drag on a resizable-handle
  		if (this.helper || o.disabled || $(event.target).is('.ui-resizable-handle'))
  			return false;
  
  		//Quit if we're not on a valid handle
  		this.handle = this._getHandle(event);
  		if (!this.handle)
  			return false;
  
  		return true;
  
  	},
  
  	_mouseStart: function(event) {
  
  		var o = this.options;
  
  		//Create and append the visible helper
  		this.helper = this._createHelper(event);
  
  		//Cache the helper size
  		this._cacheHelperProportions();
  
  		//If ddmanager is used for droppables, set the global draggable
  		if($.ui.ddmanager)
  			$.ui.ddmanager.current = this;
  
  		/*
  		 * - Position generation -
  		 * This block generates everything position related - it's the core of draggables.
  		 */
  
  		//Cache the margins of the original element
  		this._cacheMargins();
  
  		//Store the helper's css position
  		this.cssPosition = this.helper.css("position");
  		this.scrollParent = this.helper.scrollParent();
  
  		//The element's absolute position on the page minus margins
  		this.offset = this.positionAbs = this.element.offset();
  		this.offset = {
  			top: this.offset.top - this.margins.top,
  			left: this.offset.left - this.margins.left
  		};
  
  		$.extend(this.offset, {
  			click: { //Where the click happened, relative to the element
  				left: event.pageX - this.offset.left,
  				top: event.pageY - this.offset.top
  			},
  			parent: this._getParentOffset(),
  			relative: this._getRelativeOffset() //This is a relative to absolute position minus the actual position calculation - only used for relative positioned helper
  		});
  
  		//Generate the original position
  		this.originalPosition = this.position = this._generatePosition(event);
  		this.originalPageX = event.pageX;
  		this.originalPageY = event.pageY;
  
  		//Adjust the mouse offset relative to the helper if 'cursorAt' is supplied
  		(o.cursorAt && this._adjustOffsetFromHelper(o.cursorAt));
  
  		//Set a containment if given in the options
  		if(o.containment)
  			this._setContainment();
  
  		//Trigger event + callbacks
  		if(this._trigger("start", event) === false) {
  			this._clear();
  			return false;
  		}
  
  		//Recache the helper size
  		this._cacheHelperProportions();
  
  		//Prepare the droppable offsets
  		if ($.ui.ddmanager && !o.dropBehaviour)
  			$.ui.ddmanager.prepareOffsets(this, event);
  
  		this.helper.addClass("ui-draggable-dragging");
  		this._mouseDrag(event, true); //Execute the drag once - this causes the helper not to be visible before getting its correct position
  		return true;
  	},
  
  	_mouseDrag: function(event, noPropagation) {
  
  		//Compute the helpers position
  		this.position = this._generatePosition(event);
  		this.positionAbs = this._convertPositionTo("absolute");
  
  		//Call plugins and callbacks and use the resulting position if something is returned
  		if (!noPropagation) {
  			var ui = this._uiHash();
  			if(this._trigger('drag', event, ui) === false) {
  				this._mouseUp({});
  				return false;
  			}
  			this.position = ui.position;
  		}
  
  		if(!this.options.axis || this.options.axis != "y") this.helper[0].style.left = this.position.left+'px';
  		if(!this.options.axis || this.options.axis != "x") this.helper[0].style.top = this.position.top+'px';
  		if($.ui.ddmanager) $.ui.ddmanager.drag(this, event);
  
  		return false;
  	},
  
  	_mouseStop: function(event) {
  
  		//If we are using droppables, inform the manager about the drop
  		var dropped = false;
  		if ($.ui.ddmanager && !this.options.dropBehaviour)
  			dropped = $.ui.ddmanager.drop(this, event);
  
  		//if a drop comes from outside (a sortable)
  		if(this.dropped) {
  			dropped = this.dropped;
  			this.dropped = false;
  		}
  		
  		//if the original element is removed, don't bother to continue if helper is set to "original"
  		if((!this.element[0] || !this.element[0].parentNode) && this.options.helper == "original")
  			return false;
  
  		if((this.options.revert == "invalid" && !dropped) || (this.options.revert == "valid" && dropped) || this.options.revert === true || ($.isFunction(this.options.revert) && this.options.revert.call(this.element, dropped))) {
  			var self = this;
  			$(this.helper).animate(this.originalPosition, parseInt(this.options.revertDuration, 10), function() {
  				if(self._trigger("stop", event) !== false) {
  					self._clear();
  				}
  			});
  		} else {
  			if(this._trigger("stop", event) !== false) {
  				this._clear();
  			}
  		}
  
  		return false;
  	},
  	
  	cancel: function() {
  		
  		if(this.helper.is(".ui-draggable-dragging")) {
  			this._mouseUp({});
  		} else {
  			this._clear();
  		}
  		
  		return this;
  		
  	},
  
  	_getHandle: function(event) {
  
  		var handle = !this.options.handle || !$(this.options.handle, this.element).length ? true : false;
  		$(this.options.handle, this.element)
  			.find("*")
  			.andSelf()
  			.each(function() {
  				if(this == event.target) handle = true;
  			});
  
  		return handle;
  
  	},
  
  	_createHelper: function(event) {
  
  		var o = this.options;
  		var helper = $.isFunction(o.helper) ? $(o.helper.apply(this.element[0], [event])) : (o.helper == 'clone' ? this.element.clone() : this.element);
  
  		if(!helper.parents('body').length)
  			helper.appendTo((o.appendTo == 'parent' ? this.element[0].parentNode : o.appendTo));
  
  		if(helper[0] != this.element[0] && !(/(fixed|absolute)/).test(helper.css("position")))
  			helper.css("position", "absolute");
  
  		return helper;
  
  	},
  
  	_adjustOffsetFromHelper: function(obj) {
  		if (typeof obj == 'string') {
  			obj = obj.split(' ');
  		}
  		if ($.isArray(obj)) {
  			obj = {left: +obj[0], top: +obj[1] || 0};
  		}
  		if ('left' in obj) {
  			this.offset.click.left = obj.left + this.margins.left;
  		}
  		if ('right' in obj) {
  			this.offset.click.left = this.helperProportions.width - obj.right + this.margins.left;
  		}
  		if ('top' in obj) {
  			this.offset.click.top = obj.top + this.margins.top;
  		}
  		if ('bottom' in obj) {
  			this.offset.click.top = this.helperProportions.height - obj.bottom + this.margins.top;
  		}
  	},
  
  	_getParentOffset: function() {
  
  		//Get the offsetParent and cache its position
  		this.offsetParent = this.helper.offsetParent();
  		var po = this.offsetParent.offset();
  
  		// This is a special case where we need to modify a offset calculated on start, since the following happened:
  		// 1. The position of the helper is absolute, so it's position is calculated based on the next positioned parent
  		// 2. The actual offset parent is a child of the scroll parent, and the scroll parent isn't the document, which means that
  		//    the scroll is included in the initial calculation of the offset of the parent, and never recalculated upon drag
  		if(this.cssPosition == 'absolute' && this.scrollParent[0] != document && $.ui.contains(this.scrollParent[0], this.offsetParent[0])) {
  			po.left += this.scrollParent.scrollLeft();
  			po.top += this.scrollParent.scrollTop();
  		}
  
  		if((this.offsetParent[0] == document.body) //This needs to be actually done for all browsers, since pageX/pageY includes this information
  		|| (this.offsetParent[0].tagName && this.offsetParent[0].tagName.toLowerCase() == 'html' && $.browser.msie)) //Ugly IE fix
  			po = { top: 0, left: 0 };
  
  		return {
  			top: po.top + (parseInt(this.offsetParent.css("borderTopWidth"),10) || 0),
  			left: po.left + (parseInt(this.offsetParent.css("borderLeftWidth"),10) || 0)
  		};
  
  	},
  
  	_getRelativeOffset: function() {
  
  		if(this.cssPosition == "relative") {
  			var p = this.element.position();
  			return {
  				top: p.top - (parseInt(this.helper.css("top"),10) || 0) + this.scrollParent.scrollTop(),
  				left: p.left - (parseInt(this.helper.css("left"),10) || 0) + this.scrollParent.scrollLeft()
  			};
  		} else {
  			return { top: 0, left: 0 };
  		}
  
  	},
  
  	_cacheMargins: function() {
  		this.margins = {
  			left: (parseInt(this.element.css("marginLeft"),10) || 0),
  			top: (parseInt(this.element.css("marginTop"),10) || 0),
  			right: (parseInt(this.element.css("marginRight"),10) || 0),
  			bottom: (parseInt(this.element.css("marginBottom"),10) || 0)
  		};
  	},
  
  	_cacheHelperProportions: function() {
  		this.helperProportions = {
  			width: this.helper.outerWidth(),
  			height: this.helper.outerHeight()
  		};
  	},
  
  	_setContainment: function() {
  
  		var o = this.options;
  		if(o.containment == 'parent') o.containment = this.helper[0].parentNode;
  		if(o.containment == 'document' || o.containment == 'window') this.containment = [
  			(o.containment == 'document' ? 0 : $(window).scrollLeft()) - this.offset.relative.left - this.offset.parent.left,
  			(o.containment == 'document' ? 0 : $(window).scrollTop()) - this.offset.relative.top - this.offset.parent.top,
  			(o.containment == 'document' ? 0 : $(window).scrollLeft()) + $(o.containment == 'document' ? document : window).width() - this.helperProportions.width - this.margins.left,
  			(o.containment == 'document' ? 0 : $(window).scrollTop()) + ($(o.containment == 'document' ? document : window).height() || document.body.parentNode.scrollHeight) - this.helperProportions.height - this.margins.top
  		];
  
  		if(!(/^(document|window|parent)$/).test(o.containment) && o.containment.constructor != Array) {
  			var ce = $(o.containment)[0]; if(!ce) return;
  			var co = $(o.containment).offset();
  			var over = ($(ce).css("overflow") != 'hidden');
  
  			this.containment = [
  				co.left + (parseInt($(ce).css("borderLeftWidth"),10) || 0) + (parseInt($(ce).css("paddingLeft"),10) || 0),
  				co.top + (parseInt($(ce).css("borderTopWidth"),10) || 0) + (parseInt($(ce).css("paddingTop"),10) || 0),
  				co.left+(over ? Math.max(ce.scrollWidth,ce.offsetWidth) : ce.offsetWidth) - (parseInt($(ce).css("borderLeftWidth"),10) || 0) - (parseInt($(ce).css("paddingRight"),10) || 0) - this.helperProportions.width - this.margins.left - this.margins.right,
  				co.top+(over ? Math.max(ce.scrollHeight,ce.offsetHeight) : ce.offsetHeight) - (parseInt($(ce).css("borderTopWidth"),10) || 0) - (parseInt($(ce).css("paddingBottom"),10) || 0) - this.helperProportions.height - this.margins.top  - this.margins.bottom
  			];
  		} else if(o.containment.constructor == Array) {
  			this.containment = o.containment;
  		}
  
  	},
  
  	_convertPositionTo: function(d, pos) {
  
  		if(!pos) pos = this.position;
  		var mod = d == "absolute" ? 1 : -1;
  		var o = this.options, scroll = this.cssPosition == 'absolute' && !(this.scrollParent[0] != document && $.ui.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent, scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);
  
  		return {
  			top: (
  				pos.top																	// The absolute mouse position
  				+ this.offset.relative.top * mod										// Only for relative positioned nodes: Relative offset from element to offset parent
  				+ this.offset.parent.top * mod											// The offsetParent's offset without borders (offset + border)
  				- ($.browser.safari && $.browser.version < 526 && this.cssPosition == 'fixed' ? 0 : ( this.cssPosition == 'fixed' ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ) * mod)
  			),
  			left: (
  				pos.left																// The absolute mouse position
  				+ this.offset.relative.left * mod										// Only for relative positioned nodes: Relative offset from element to offset parent
  				+ this.offset.parent.left * mod											// The offsetParent's offset without borders (offset + border)
  				- ($.browser.safari && $.browser.version < 526 && this.cssPosition == 'fixed' ? 0 : ( this.cssPosition == 'fixed' ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ) * mod)
  			)
  		};
  
  	},
  
  	_generatePosition: function(event) {
  
  		var o = this.options, scroll = this.cssPosition == 'absolute' && !(this.scrollParent[0] != document && $.ui.contains(this.scrollParent[0], this.offsetParent[0])) ? this.offsetParent : this.scrollParent, scrollIsRootNode = (/(html|body)/i).test(scroll[0].tagName);
  		var pageX = event.pageX;
  		var pageY = event.pageY;
  
  		/*
  		 * - Position constraining -
  		 * Constrain the position to a mix of grid, containment.
  		 */
  
  		if(this.originalPosition) { //If we are not dragging yet, we won't check for options
  
  			if(this.containment) {
  				if(event.pageX - this.offset.click.left < this.containment[0]) pageX = this.containment[0] + this.offset.click.left;
  				if(event.pageY - this.offset.click.top < this.containment[1]) pageY = this.containment[1] + this.offset.click.top;
  				if(event.pageX - this.offset.click.left > this.containment[2]) pageX = this.containment[2] + this.offset.click.left;
  				if(event.pageY - this.offset.click.top > this.containment[3]) pageY = this.containment[3] + this.offset.click.top;
  			}
  
  			if(o.grid) {
  				var top = this.originalPageY + Math.round((pageY - this.originalPageY) / o.grid[1]) * o.grid[1];
  				pageY = this.containment ? (!(top - this.offset.click.top < this.containment[1] || top - this.offset.click.top > this.containment[3]) ? top : (!(top - this.offset.click.top < this.containment[1]) ? top - o.grid[1] : top + o.grid[1])) : top;
  
  				var left = this.originalPageX + Math.round((pageX - this.originalPageX) / o.grid[0]) * o.grid[0];
  				pageX = this.containment ? (!(left - this.offset.click.left < this.containment[0] || left - this.offset.click.left > this.containment[2]) ? left : (!(left - this.offset.click.left < this.containment[0]) ? left - o.grid[0] : left + o.grid[0])) : left;
  			}
  
  		}
  
  		return {
  			top: (
  				pageY																// The absolute mouse position
  				- this.offset.click.top													// Click offset (relative to the element)
  				- this.offset.relative.top												// Only for relative positioned nodes: Relative offset from element to offset parent
  				- this.offset.parent.top												// The offsetParent's offset without borders (offset + border)
  				+ ($.browser.safari && $.browser.version < 526 && this.cssPosition == 'fixed' ? 0 : ( this.cssPosition == 'fixed' ? -this.scrollParent.scrollTop() : ( scrollIsRootNode ? 0 : scroll.scrollTop() ) ))
  			),
  			left: (
  				pageX																// The absolute mouse position
  				- this.offset.click.left												// Click offset (relative to the element)
  				- this.offset.relative.left												// Only for relative positioned nodes: Relative offset from element to offset parent
  				- this.offset.parent.left												// The offsetParent's offset without borders (offset + border)
  				+ ($.browser.safari && $.browser.version < 526 && this.cssPosition == 'fixed' ? 0 : ( this.cssPosition == 'fixed' ? -this.scrollParent.scrollLeft() : scrollIsRootNode ? 0 : scroll.scrollLeft() ))
  			)
  		};
  
  	},
  
  	_clear: function() {
  		this.helper.removeClass("ui-draggable-dragging");
  		if(this.helper[0] != this.element[0] && !this.cancelHelperRemoval) this.helper.remove();
  		//if($.ui.ddmanager) $.ui.ddmanager.current = null;
  		this.helper = null;
  		this.cancelHelperRemoval = false;
  	},
  
  	// From now on bulk stuff - mainly helpers
  
  	_trigger: function(type, event, ui) {
  		ui = ui || this._uiHash();
  		$.ui.plugin.call(this, type, [event, ui]);
  		if(type == "drag") this.positionAbs = this._convertPositionTo("absolute"); //The absolute position has to be recalculated after plugins
  		return $.Widget.prototype._trigger.call(this, type, event, ui);
  	},
  
  	plugins: {},
  
  	_uiHash: function(event) {
  		return {
  			helper: this.helper,
  			position: this.position,
  			originalPosition: this.originalPosition,
  			offset: this.positionAbs
  		};
  	}
  
  });
  
  $.extend($.ui.draggable, {
  	version: "1.8.12"
  });
  
  $.ui.plugin.add("draggable", "connectToSortable", {
  	start: function(event, ui) {
  
  		var inst = $(this).data("draggable"), o = inst.options,
  			uiSortable = $.extend({}, ui, { item: inst.element });
  		inst.sortables = [];
  		$(o.connectToSortable).each(function() {
  			var sortable = $.data(this, 'sortable');
  			if (sortable && !sortable.options.disabled) {
  				inst.sortables.push({
  					instance: sortable,
  					shouldRevert: sortable.options.revert
  				});
  				sortable.refreshPositions();	// Call the sortable's refreshPositions at drag start to refresh the containerCache since the sortable container cache is used in drag and needs to be up to date (this will ensure it's initialised as well as being kept in step with any changes that might have happened on the page).
  				sortable._trigger("activate", event, uiSortable);
  			}
  		});
  
  	},
  	stop: function(event, ui) {
  
  		//If we are still over the sortable, we fake the stop event of the sortable, but also remove helper
  		var inst = $(this).data("draggable"),
  			uiSortable = $.extend({}, ui, { item: inst.element });
  
  		$.each(inst.sortables, function() {
  			if(this.instance.isOver) {
  
  				this.instance.isOver = 0;
  
  				inst.cancelHelperRemoval = true; //Don't remove the helper in the draggable instance
  				this.instance.cancelHelperRemoval = false; //Remove it in the sortable instance (so sortable plugins like revert still work)
  
  				//The sortable revert is supported, and we have to set a temporary dropped variable on the draggable to support revert: 'valid/invalid'
  				if(this.shouldRevert) this.instance.options.revert = true;
  
  				//Trigger the stop of the sortable
  				this.instance._mouseStop(event);
  
  				this.instance.options.helper = this.instance.options._helper;
  
  				//If the helper has been the original item, restore properties in the sortable
  				if(inst.options.helper == 'original')
  					this.instance.currentItem.css({ top: 'auto', left: 'auto' });
  
  			} else {
  				this.instance.cancelHelperRemoval = false; //Remove the helper in the sortable instance
  				this.instance._trigger("deactivate", event, uiSortable);
  			}
  
  		});
  
  	},
  	drag: function(event, ui) {
  
  		var inst = $(this).data("draggable"), self = this;
  
  		var checkPos = function(o) {
  			var dyClick = this.offset.click.top, dxClick = this.offset.click.left;
  			var helperTop = this.positionAbs.top, helperLeft = this.positionAbs.left;
  			var itemHeight = o.height, itemWidth = o.width;
  			var itemTop = o.top, itemLeft = o.left;
  
  			return $.ui.isOver(helperTop + dyClick, helperLeft + dxClick, itemTop, itemLeft, itemHeight, itemWidth);
  		};
  
  		$.each(inst.sortables, function(i) {
  			
  			//Copy over some variables to allow calling the sortable's native _intersectsWith
  			this.instance.positionAbs = inst.positionAbs;
  			this.instance.helperProportions = inst.helperProportions;
  			this.instance.offset.click = inst.offset.click;
  			
  			if(this.instance._intersectsWith(this.instance.containerCache)) {
  
  				//If it intersects, we use a little isOver variable and set it once, so our move-in stuff gets fired only once
  				if(!this.instance.isOver) {
  
  					this.instance.isOver = 1;
  					//Now we fake the start of dragging for the sortable instance,
  					//by cloning the list group item, appending it to the sortable and using it as inst.currentItem
  					//We can then fire the start event of the sortable with our passed browser event, and our own helper (so it doesn't create a new one)
  					this.instance.currentItem = $(self).clone().appendTo(this.instance.element).data("sortable-item", true);
  					this.instance.options._helper = this.instance.options.helper; //Store helper option to later restore it
  					this.instance.options.helper = function() { return ui.helper[0]; };
  
  					event.target = this.instance.currentItem[0];
  					this.instance._mouseCapture(event, true);
  					this.instance._mouseStart(event, true, true);
  
  					//Because the browser event is way off the new appended portlet, we modify a couple of variables to reflect the changes
  					this.instance.offset.click.top = inst.offset.click.top;
  					this.instance.offset.click.left = inst.offset.click.left;
  					this.instance.offset.parent.left -= inst.offset.parent.left - this.instance.offset.parent.left;
  					this.instance.offset.parent.top -= inst.offset.parent.top - this.instance.offset.parent.top;
  
  					inst._trigger("toSortable", event);
  					inst.dropped = this.instance.element; //draggable revert needs that
  					//hack so receive/update callbacks work (mostly)
  					inst.currentItem = inst.element;
  					this.instance.fromOutside = inst;
  
  				}
  
  				//Provided we did all the previous steps, we can fire the drag event of the sortable on every draggable drag, when it intersects with the sortable
  				if(this.instance.currentItem) this.instance._mouseDrag(event);
  
  			} else {
  
  				//If it doesn't intersect with the sortable, and it intersected before,
  				//we fake the drag stop of the sortable, but make sure it doesn't remove the helper by using cancelHelperRemoval
  				if(this.instance.isOver) {
  
  					this.instance.isOver = 0;
  					this.instance.cancelHelperRemoval = true;
  					
  					//Prevent reverting on this forced stop
  					this.instance.options.revert = false;
  					
  					// The out event needs to be triggered independently
  					this.instance._trigger('out', event, this.instance._uiHash(this.instance));
  					
  					this.instance._mouseStop(event, true);
  					this.instance.options.helper = this.instance.options._helper;
  
  					//Now we remove our currentItem, the list group clone again, and the placeholder, and animate the helper back to it's original size
  					this.instance.currentItem.remove();
  					if(this.instance.placeholder) this.instance.placeholder.remove();
  
  					inst._trigger("fromSortable", event);
  					inst.dropped = false; //draggable revert needs that
  				}
  
  			};
  
  		});
  
  	}
  });
  
  $.ui.plugin.add("draggable", "cursor", {
  	start: function(event, ui) {
  		var t = $('body'), o = $(this).data('draggable').options;
  		if (t.css("cursor")) o._cursor = t.css("cursor");
  		t.css("cursor", o.cursor);
  	},
  	stop: function(event, ui) {
  		var o = $(this).data('draggable').options;
  		if (o._cursor) $('body').css("cursor", o._cursor);
  	}
  });
  
  $.ui.plugin.add("draggable", "iframeFix", {
  	start: function(event, ui) {
  		var o = $(this).data('draggable').options;
  		$(o.iframeFix === true ? "iframe" : o.iframeFix).each(function() {
  			$('<div class="ui-draggable-iframeFix" style="background: #fff;"></div>')
  			.css({
  				width: this.offsetWidth+"px", height: this.offsetHeight+"px",
  				position: "absolute", opacity: "0.001", zIndex: 1000
  			})
  			.css($(this).offset())
  			.appendTo("body");
  		});
  	},
  	stop: function(event, ui) {
  		$("div.ui-draggable-iframeFix").each(function() { this.parentNode.removeChild(this); }); //Remove frame helpers
  	}
  });
  
  $.ui.plugin.add("draggable", "opacity", {
  	start: function(event, ui) {
  		var t = $(ui.helper), o = $(this).data('draggable').options;
  		if(t.css("opacity")) o._opacity = t.css("opacity");
  		t.css('opacity', o.opacity);
  	},
  	stop: function(event, ui) {
  		var o = $(this).data('draggable').options;
  		if(o._opacity) $(ui.helper).css('opacity', o._opacity);
  	}
  });
  
  $.ui.plugin.add("draggable", "scroll", {
  	start: function(event, ui) {
  		var i = $(this).data("draggable");
  		if(i.scrollParent[0] != document && i.scrollParent[0].tagName != 'HTML') i.overflowOffset = i.scrollParent.offset();
  	},
  	drag: function(event, ui) {
  
  		var i = $(this).data("draggable"), o = i.options, scrolled = false;
  
  		if(i.scrollParent[0] != document && i.scrollParent[0].tagName != 'HTML') {
  
  			if(!o.axis || o.axis != 'x') {
  				if((i.overflowOffset.top + i.scrollParent[0].offsetHeight) - event.pageY < o.scrollSensitivity)
  					i.scrollParent[0].scrollTop = scrolled = i.scrollParent[0].scrollTop + o.scrollSpeed;
  				else if(event.pageY - i.overflowOffset.top < o.scrollSensitivity)
  					i.scrollParent[0].scrollTop = scrolled = i.scrollParent[0].scrollTop - o.scrollSpeed;
  			}
  
  			if(!o.axis || o.axis != 'y') {
  				if((i.overflowOffset.left + i.scrollParent[0].offsetWidth) - event.pageX < o.scrollSensitivity)
  					i.scrollParent[0].scrollLeft = scrolled = i.scrollParent[0].scrollLeft + o.scrollSpeed;
  				else if(event.pageX - i.overflowOffset.left < o.scrollSensitivity)
  					i.scrollParent[0].scrollLeft = scrolled = i.scrollParent[0].scrollLeft - o.scrollSpeed;
  			}
  
  		} else {
  
  			if(!o.axis || o.axis != 'x') {
  				if(event.pageY - $(document).scrollTop() < o.scrollSensitivity)
  					scrolled = $(document).scrollTop($(document).scrollTop() - o.scrollSpeed);
  				else if($(window).height() - (event.pageY - $(document).scrollTop()) < o.scrollSensitivity)
  					scrolled = $(document).scrollTop($(document).scrollTop() + o.scrollSpeed);
  			}
  
  			if(!o.axis || o.axis != 'y') {
  				if(event.pageX - $(document).scrollLeft() < o.scrollSensitivity)
  					scrolled = $(document).scrollLeft($(document).scrollLeft() - o.scrollSpeed);
  				else if($(window).width() - (event.pageX - $(document).scrollLeft()) < o.scrollSensitivity)
  					scrolled = $(document).scrollLeft($(document).scrollLeft() + o.scrollSpeed);
  			}
  
  		}
  
  		if(scrolled !== false && $.ui.ddmanager && !o.dropBehaviour)
  			$.ui.ddmanager.prepareOffsets(i, event);
  
  	}
  });
  
  $.ui.plugin.add("draggable", "snap", {
  	start: function(event, ui) {
  
  		var i = $(this).data("draggable"), o = i.options;
  		i.snapElements = [];
  
  		$(o.snap.constructor != String ? ( o.snap.items || ':data(draggable)' ) : o.snap).each(function() {
  			var $t = $(this); var $o = $t.offset();
  			if(this != i.element[0]) i.snapElements.push({
  				item: this,
  				width: $t.outerWidth(), height: $t.outerHeight(),
  				top: $o.top, left: $o.left
  			});
  		});
  
  	},
  	drag: function(event, ui) {
  
  		var inst = $(this).data("draggable"), o = inst.options;
  		var d = o.snapTolerance;
  
  		var x1 = ui.offset.left, x2 = x1 + inst.helperProportions.width,
  			y1 = ui.offset.top, y2 = y1 + inst.helperProportions.height;
  
  		for (var i = inst.snapElements.length - 1; i >= 0; i--){
  
  			var l = inst.snapElements[i].left, r = l + inst.snapElements[i].width,
  				t = inst.snapElements[i].top, b = t + inst.snapElements[i].height;
  
  			//Yes, I know, this is insane ;)
  			if(!((l-d < x1 && x1 < r+d && t-d < y1 && y1 < b+d) || (l-d < x1 && x1 < r+d && t-d < y2 && y2 < b+d) || (l-d < x2 && x2 < r+d && t-d < y1 && y1 < b+d) || (l-d < x2 && x2 < r+d && t-d < y2 && y2 < b+d))) {
  				if(inst.snapElements[i].snapping) (inst.options.snap.release && inst.options.snap.release.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
  				inst.snapElements[i].snapping = false;
  				continue;
  			}
  
  			if(o.snapMode != 'inner') {
  				var ts = Math.abs(t - y2) <= d;
  				var bs = Math.abs(b - y1) <= d;
  				var ls = Math.abs(l - x2) <= d;
  				var rs = Math.abs(r - x1) <= d;
  				if(ts) ui.position.top = inst._convertPositionTo("relative", { top: t - inst.helperProportions.height, left: 0 }).top - inst.margins.top;
  				if(bs) ui.position.top = inst._convertPositionTo("relative", { top: b, left: 0 }).top - inst.margins.top;
  				if(ls) ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l - inst.helperProportions.width }).left - inst.margins.left;
  				if(rs) ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r }).left - inst.margins.left;
  			}
  
  			var first = (ts || bs || ls || rs);
  
  			if(o.snapMode != 'outer') {
  				var ts = Math.abs(t - y1) <= d;
  				var bs = Math.abs(b - y2) <= d;
  				var ls = Math.abs(l - x1) <= d;
  				var rs = Math.abs(r - x2) <= d;
  				if(ts) ui.position.top = inst._convertPositionTo("relative", { top: t, left: 0 }).top - inst.margins.top;
  				if(bs) ui.position.top = inst._convertPositionTo("relative", { top: b - inst.helperProportions.height, left: 0 }).top - inst.margins.top;
  				if(ls) ui.position.left = inst._convertPositionTo("relative", { top: 0, left: l }).left - inst.margins.left;
  				if(rs) ui.position.left = inst._convertPositionTo("relative", { top: 0, left: r - inst.helperProportions.width }).left - inst.margins.left;
  			}
  
  			if(!inst.snapElements[i].snapping && (ts || bs || ls || rs || first))
  				(inst.options.snap.snap && inst.options.snap.snap.call(inst.element, event, $.extend(inst._uiHash(), { snapItem: inst.snapElements[i].item })));
  			inst.snapElements[i].snapping = (ts || bs || ls || rs || first);
  
  		};
  
  	}
  });
  
  $.ui.plugin.add("draggable", "stack", {
  	start: function(event, ui) {
  
  		var o = $(this).data("draggable").options;
  
  		var group = $.makeArray($(o.stack)).sort(function(a,b) {
  			return (parseInt($(a).css("zIndex"),10) || 0) - (parseInt($(b).css("zIndex"),10) || 0);
  		});
  		if (!group.length) { return; }
  		
  		var min = parseInt(group[0].style.zIndex) || 0;
  		$(group).each(function(i) {
  			this.style.zIndex = min + i;
  		});
  
  		this[0].style.zIndex = min + group.length;
  
  	}
  });
  
  $.ui.plugin.add("draggable", "zIndex", {
  	start: function(event, ui) {
  		var t = $(ui.helper), o = $(this).data("draggable").options;
  		if(t.css("zIndex")) o._zIndex = t.css("zIndex");
  		t.css('zIndex', o.zIndex);
  	},
  	stop: function(event, ui) {
  		var o = $(this).data("draggable").options;
  		if(o._zIndex) $(ui.helper).css('zIndex', o._zIndex);
  	}
  });
  
  })(jQuery);
  /*
   * jQuery UI Dialog 1.8.12
   *
   * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
   * Dual licensed under the MIT or GPL Version 2 licenses.
   * http://jquery.org/license
   *
   * http://docs.jquery.com/UI/Dialog
   *
   * Depends:
   *	jquery.ui.core.js
   *	jquery.ui.widget.js
   *  jquery.ui.button.js
   *	jquery.ui.draggable.js
   *	jquery.ui.mouse.js
   *	jquery.ui.position.js
   *	jquery.ui.resizable.js
   */
  (function( $, undefined ) {
  
  var uiDialogClasses =
  		'ui-dialog ' +
  		'ui-widget ' +
  		'ui-widget-content ' +
  		'ui-corner-all ',
  	sizeRelatedOptions = {
  		buttons: true,
  		height: true,
  		maxHeight: true,
  		maxWidth: true,
  		minHeight: true,
  		minWidth: true,
  		width: true
  	},
  	resizableRelatedOptions = {
  		maxHeight: true,
  		maxWidth: true,
  		minHeight: true,
  		minWidth: true
  	},
  	// support for jQuery 1.3.2 - handle common attrFn methods for dialog
  	attrFn = $.attrFn || {
  		val: true,
  		css: true,
  		html: true,
  		text: true,
  		data: true,
  		width: true,
  		height: true,
  		offset: true,
  		click: true
  	};
  
  $.widget("ui.dialog", {
  	options: {
  		autoOpen: true,
  		buttons: {},
  		closeOnEscape: true,
  		closeText: 'close',
  		dialogClass: '',
  		draggable: true,
  		hide: null,
  		height: 'auto',
  		maxHeight: false,
  		maxWidth: false,
  		minHeight: 150,
  		minWidth: 150,
  		modal: false,
  		position: {
  			my: 'center',
  			at: 'center',
  			collision: 'fit',
  			// ensure that the titlebar is never outside the document
  			using: function(pos) {
  				var topOffset = $(this).css(pos).offset().top;
  				if (topOffset < 0) {
  					$(this).css('top', pos.top - topOffset);
  				}
  			}
  		},
  		resizable: true,
  		show: null,
  		stack: true,
  		title: '',
  		width: 300,
  		zIndex: 1000
  	},
  
  	_create: function() {
  		this.originalTitle = this.element.attr('title');
  		// #5742 - .attr() might return a DOMElement
  		if ( typeof this.originalTitle !== "string" ) {
  			this.originalTitle = "";
  		}
  
  		this.options.title = this.options.title || this.originalTitle;
  		var self = this,
  			options = self.options,
  
  			title = options.title || '&#160;',
  			titleId = $.ui.dialog.getTitleId(self.element),
  
  			uiDialog = (self.uiDialog = $('<div></div>'))
  				.appendTo(document.body)
  				.hide()
  				.addClass(uiDialogClasses + options.dialogClass)
  				.css({
  					zIndex: options.zIndex
  				})
  				// setting tabIndex makes the div focusable
  				// setting outline to 0 prevents a border on focus in Mozilla
  				.attr('tabIndex', -1).css('outline', 0).keydown(function(event) {
  					if (options.closeOnEscape && event.keyCode &&
  						event.keyCode === $.ui.keyCode.ESCAPE) {
  						
  						self.close(event);
  						event.preventDefault();
  					}
  				})
  				.attr({
  					role: 'dialog',
  					'aria-labelledby': titleId
  				})
  				.mousedown(function(event) {
  					self.moveToTop(false, event);
  				}),
  
  			uiDialogContent = self.element
  				.show()
  				.removeAttr('title')
  				.addClass(
  					'ui-dialog-content ' +
  					'ui-widget-content')
  				.appendTo(uiDialog),
  
  			uiDialogTitlebar = (self.uiDialogTitlebar = $('<div></div>'))
  				.addClass(
  					'ui-dialog-titlebar ' +
  					'ui-widget-header ' +
  					'ui-corner-all ' +
  					'ui-helper-clearfix'
  				)
  				.prependTo(uiDialog),
  
  			uiDialogTitlebarClose = $('<a href="#"></a>')
  				.addClass(
  					'ui-dialog-titlebar-close ' +
  					'ui-corner-all'
  				)
  				.attr('role', 'button')
  				.hover(
  					function() {
  						uiDialogTitlebarClose.addClass('ui-state-hover');
  					},
  					function() {
  						uiDialogTitlebarClose.removeClass('ui-state-hover');
  					}
  				)
  				.focus(function() {
  					uiDialogTitlebarClose.addClass('ui-state-focus');
  				})
  				.blur(function() {
  					uiDialogTitlebarClose.removeClass('ui-state-focus');
  				})
  				.click(function(event) {
  					self.close(event);
  					return false;
  				})
  				.appendTo(uiDialogTitlebar),
  
  			uiDialogTitlebarCloseText = (self.uiDialogTitlebarCloseText = $('<span></span>'))
  				.addClass(
  					'ui-icon ' +
  					'ui-icon-closethick'
  				)
  				.text(options.closeText)
  				.appendTo(uiDialogTitlebarClose),
  
  			uiDialogTitle = $('<span></span>')
  				.addClass('ui-dialog-title')
  				.attr('id', titleId)
  				.html(title)
  				.prependTo(uiDialogTitlebar);
  
  		//handling of deprecated beforeclose (vs beforeClose) option
  		//Ticket #4669 http://dev.jqueryui.com/ticket/4669
  		//TODO: remove in 1.9pre
  		if ($.isFunction(options.beforeclose) && !$.isFunction(options.beforeClose)) {
  			options.beforeClose = options.beforeclose;
  		}
  
  		uiDialogTitlebar.find("*").add(uiDialogTitlebar).disableSelection();
  
  		if (options.draggable && $.fn.draggable) {
  			self._makeDraggable();
  		}
  		if (options.resizable && $.fn.resizable) {
  			self._makeResizable();
  		}
  
  		self._createButtons(options.buttons);
  		self._isOpen = false;
  
  		if ($.fn.bgiframe) {
  			uiDialog.bgiframe();
  		}
  	},
  
  	_init: function() {
  		if ( this.options.autoOpen ) {
  			this.open();
  		}
  	},
  
  	destroy: function() {
  		var self = this;
  		
  		if (self.overlay) {
  			self.overlay.destroy();
  		}
  		self.uiDialog.hide();
  		self.element
  			.unbind('.dialog')
  			.removeData('dialog')
  			.removeClass('ui-dialog-content ui-widget-content')
  			.hide().appendTo('body');
  		self.uiDialog.remove();
  
  		if (self.originalTitle) {
  			self.element.attr('title', self.originalTitle);
  		}
  
  		return self;
  	},
  
  	widget: function() {
  		return this.uiDialog;
  	},
  
  	close: function(event) {
  		var self = this,
  			maxZ, thisZ;
  		
  		if (false === self._trigger('beforeClose', event)) {
  			return;
  		}
  
  		if (self.overlay) {
  			self.overlay.destroy();
  		}
  		self.uiDialog.unbind('keypress.ui-dialog');
  
  		self._isOpen = false;
  
  		if (self.options.hide) {
  			self.uiDialog.hide(self.options.hide, function() {
  				self._trigger('close', event);
  			});
  		} else {
  			self.uiDialog.hide();
  			self._trigger('close', event);
  		}
  
  		$.ui.dialog.overlay.resize();
  
  		// adjust the maxZ to allow other modal dialogs to continue to work (see #4309)
  		if (self.options.modal) {
  			maxZ = 0;
  			$('.ui-dialog').each(function() {
  				if (this !== self.uiDialog[0]) {
  					thisZ = $(this).css('z-index');
  					if(!isNaN(thisZ)) {
  						maxZ = Math.max(maxZ, thisZ);
  					}
  				}
  			});
  			$.ui.dialog.maxZ = maxZ;
  		}
  
  		return self;
  	},
  
  	isOpen: function() {
  		return this._isOpen;
  	},
  
  	// the force parameter allows us to move modal dialogs to their correct
  	// position on open
  	moveToTop: function(force, event) {
  		var self = this,
  			options = self.options,
  			saveScroll;
  
  		if ((options.modal && !force) ||
  			(!options.stack && !options.modal)) {
  			return self._trigger('focus', event);
  		}
  
  		if (options.zIndex > $.ui.dialog.maxZ) {
  			$.ui.dialog.maxZ = options.zIndex;
  		}
  		if (self.overlay) {
  			$.ui.dialog.maxZ += 1;
  			self.overlay.$el.css('z-index', $.ui.dialog.overlay.maxZ = $.ui.dialog.maxZ);
  		}
  
  		//Save and then restore scroll since Opera 9.5+ resets when parent z-Index is changed.
  		//  http://ui.jquery.com/bugs/ticket/3193
  		saveScroll = { scrollTop: self.element.attr('scrollTop'), scrollLeft: self.element.attr('scrollLeft') };
  		$.ui.dialog.maxZ += 1;
  		self.uiDialog.css('z-index', $.ui.dialog.maxZ);
  		self.element.attr(saveScroll);
  		self._trigger('focus', event);
  
  		return self;
  	},
  
  	open: function() {
  		if (this._isOpen) { return; }
  
  		var self = this,
  			options = self.options,
  			uiDialog = self.uiDialog;
  
  		self.overlay = options.modal ? new $.ui.dialog.overlay(self) : null;
  		self._size();
  		self._position(options.position);
  		uiDialog.show(options.show);
  		self.moveToTop(true);
  
  		// prevent tabbing out of modal dialogs
  		if (options.modal) {
  			uiDialog.bind('keypress.ui-dialog', function(event) {
  				if (event.keyCode !== $.ui.keyCode.TAB) {
  					return;
  				}
  
  				var tabbables = $(':tabbable', this),
  					first = tabbables.filter(':first'),
  					last  = tabbables.filter(':last');
  
  				if (event.target === last[0] && !event.shiftKey) {
  					first.focus(1);
  					return false;
  				} else if (event.target === first[0] && event.shiftKey) {
  					last.focus(1);
  					return false;
  				}
  			});
  		}
  
  		// set focus to the first tabbable element in the content area or the first button
  		// if there are no tabbable elements, set focus on the dialog itself
  		$(self.element.find(':tabbable').get().concat(
  			uiDialog.find('.ui-dialog-buttonpane :tabbable').get().concat(
  				uiDialog.get()))).eq(0).focus();
  
  		self._isOpen = true;
  		self._trigger('open');
  
  		return self;
  	},
  
  	_createButtons: function(buttons) {
  		var self = this,
  			hasButtons = false,
  			uiDialogButtonPane = $('<div></div>')
  				.addClass(
  					'ui-dialog-buttonpane ' +
  					'ui-widget-content ' +
  					'ui-helper-clearfix'
  				),
  			uiButtonSet = $( "<div></div>" )
  				.addClass( "ui-dialog-buttonset" )
  				.appendTo( uiDialogButtonPane );
  
  		// if we already have a button pane, remove it
  		self.uiDialog.find('.ui-dialog-buttonpane').remove();
  
  		if (typeof buttons === 'object' && buttons !== null) {
  			$.each(buttons, function() {
  				return !(hasButtons = true);
  			});
  		}
  		if (hasButtons) {
  			$.each(buttons, function(name, props) {
  				props = $.isFunction( props ) ?
  					{ click: props, text: name } :
  					props;
  				var button = $('<button type="button"></button>')
  					.click(function() {
  						props.click.apply(self.element[0], arguments);
  					})
  					.appendTo(uiButtonSet);
  				// can't use .attr( props, true ) with jQuery 1.3.2.
  				$.each( props, function( key, value ) {
  					if ( key === "click" ) {
  						return;
  					}
  					if ( key in attrFn ) {
  						button[ key ]( value );
  					} else {
  						button.attr( key, value );
  					}
  				});
  				if ($.fn.button) {
  					button.button();
  				}
  			});
  			uiDialogButtonPane.appendTo(self.uiDialog);
  		}
  	},
  
  	_makeDraggable: function() {
  		var self = this,
  			options = self.options,
  			doc = $(document),
  			heightBeforeDrag;
  
  		function filteredUi(ui) {
  			return {
  				position: ui.position,
  				offset: ui.offset
  			};
  		}
  
  		self.uiDialog.draggable({
  			cancel: '.ui-dialog-content, .ui-dialog-titlebar-close',
  			handle: '.ui-dialog-titlebar',
  			containment: 'document',
  			start: function(event, ui) {
  				heightBeforeDrag = options.height === "auto" ? "auto" : $(this).height();
  				$(this).height($(this).height()).addClass("ui-dialog-dragging");
  				self._trigger('dragStart', event, filteredUi(ui));
  			},
  			drag: function(event, ui) {
  				self._trigger('drag', event, filteredUi(ui));
  			},
  			stop: function(event, ui) {
  				options.position = [ui.position.left - doc.scrollLeft(),
  					ui.position.top - doc.scrollTop()];
  				$(this).removeClass("ui-dialog-dragging").height(heightBeforeDrag);
  				self._trigger('dragStop', event, filteredUi(ui));
  				$.ui.dialog.overlay.resize();
  			}
  		});
  	},
  
  	_makeResizable: function(handles) {
  		handles = (handles === undefined ? this.options.resizable : handles);
  		var self = this,
  			options = self.options,
  			// .ui-resizable has position: relative defined in the stylesheet
  			// but dialogs have to use absolute or fixed positioning
  			position = self.uiDialog.css('position'),
  			resizeHandles = (typeof handles === 'string' ?
  				handles	:
  				'n,e,s,w,se,sw,ne,nw'
  			);
  
  		function filteredUi(ui) {
  			return {
  				originalPosition: ui.originalPosition,
  				originalSize: ui.originalSize,
  				position: ui.position,
  				size: ui.size
  			};
  		}
  
  		self.uiDialog.resizable({
  			cancel: '.ui-dialog-content',
  			containment: 'document',
  			alsoResize: self.element,
  			maxWidth: options.maxWidth,
  			maxHeight: options.maxHeight,
  			minWidth: options.minWidth,
  			minHeight: self._minHeight(),
  			handles: resizeHandles,
  			start: function(event, ui) {
  				$(this).addClass("ui-dialog-resizing");
  				self._trigger('resizeStart', event, filteredUi(ui));
  			},
  			resize: function(event, ui) {
  				self._trigger('resize', event, filteredUi(ui));
  			},
  			stop: function(event, ui) {
  				$(this).removeClass("ui-dialog-resizing");
  				options.height = $(this).height();
  				options.width = $(this).width();
  				self._trigger('resizeStop', event, filteredUi(ui));
  				$.ui.dialog.overlay.resize();
  			}
  		})
  		.css('position', position)
  		.find('.ui-resizable-se').addClass('ui-icon ui-icon-grip-diagonal-se');
  	},
  
  	_minHeight: function() {
  		var options = this.options;
  
  		if (options.height === 'auto') {
  			return options.minHeight;
  		} else {
  			return Math.min(options.minHeight, options.height);
  		}
  	},
  
  	_position: function(position) {
  		var myAt = [],
  			offset = [0, 0],
  			isVisible;
  
  		if (position) {
  			// deep extending converts arrays to objects in jQuery <= 1.3.2 :-(
  	//		if (typeof position == 'string' || $.isArray(position)) {
  	//			myAt = $.isArray(position) ? position : position.split(' ');
  
  			if (typeof position === 'string' || (typeof position === 'object' && '0' in position)) {
  				myAt = position.split ? position.split(' ') : [position[0], position[1]];
  				if (myAt.length === 1) {
  					myAt[1] = myAt[0];
  				}
  
  				$.each(['left', 'top'], function(i, offsetPosition) {
  					if (+myAt[i] === myAt[i]) {
  						offset[i] = myAt[i];
  						myAt[i] = offsetPosition;
  					}
  				});
  
  				position = {
  					my: myAt.join(" "),
  					at: myAt.join(" "),
  					offset: offset.join(" ")
  				};
  			} 
  
  			position = $.extend({}, $.ui.dialog.prototype.options.position, position);
  		} else {
  			position = $.ui.dialog.prototype.options.position;
  		}
  
  		// need to show the dialog to get the actual offset in the position plugin
  		isVisible = this.uiDialog.is(':visible');
  		if (!isVisible) {
  			this.uiDialog.show();
  		}
  		this.uiDialog
  			// workaround for jQuery bug #5781 http://dev.jquery.com/ticket/5781
  			.css({ top: 0, left: 0 })
  			.position($.extend({ of: window }, position));
  		if (!isVisible) {
  			this.uiDialog.hide();
  		}
  	},
  
  	_setOptions: function( options ) {
  		var self = this,
  			resizableOptions = {},
  			resize = false;
  
  		$.each( options, function( key, value ) {
  			self._setOption( key, value );
  			
  			if ( key in sizeRelatedOptions ) {
  				resize = true;
  			}
  			if ( key in resizableRelatedOptions ) {
  				resizableOptions[ key ] = value;
  			}
  		});
  
  		if ( resize ) {
  			this._size();
  		}
  		if ( this.uiDialog.is( ":data(resizable)" ) ) {
  			this.uiDialog.resizable( "option", resizableOptions );
  		}
  	},
  
  	_setOption: function(key, value){
  		var self = this,
  			uiDialog = self.uiDialog;
  
  		switch (key) {
  			//handling of deprecated beforeclose (vs beforeClose) option
  			//Ticket #4669 http://dev.jqueryui.com/ticket/4669
  			//TODO: remove in 1.9pre
  			case "beforeclose":
  				key = "beforeClose";
  				break;
  			case "buttons":
  				self._createButtons(value);
  				break;
  			case "closeText":
  				// ensure that we always pass a string
  				self.uiDialogTitlebarCloseText.text("" + value);
  				break;
  			case "dialogClass":
  				uiDialog
  					.removeClass(self.options.dialogClass)
  					.addClass(uiDialogClasses + value);
  				break;
  			case "disabled":
  				if (value) {
  					uiDialog.addClass('ui-dialog-disabled');
  				} else {
  					uiDialog.removeClass('ui-dialog-disabled');
  				}
  				break;
  			case "draggable":
  				var isDraggable = uiDialog.is( ":data(draggable)" );
  				if ( isDraggable && !value ) {
  					uiDialog.draggable( "destroy" );
  				}
  				
  				if ( !isDraggable && value ) {
  					self._makeDraggable();
  				}
  				break;
  			case "position":
  				self._position(value);
  				break;
  			case "resizable":
  				// currently resizable, becoming non-resizable
  				var isResizable = uiDialog.is( ":data(resizable)" );
  				if (isResizable && !value) {
  					uiDialog.resizable('destroy');
  				}
  
  				// currently resizable, changing handles
  				if (isResizable && typeof value === 'string') {
  					uiDialog.resizable('option', 'handles', value);
  				}
  
  				// currently non-resizable, becoming resizable
  				if (!isResizable && value !== false) {
  					self._makeResizable(value);
  				}
  				break;
  			case "title":
  				// convert whatever was passed in o a string, for html() to not throw up
  				$(".ui-dialog-title", self.uiDialogTitlebar).html("" + (value || '&#160;'));
  				break;
  		}
  
  		$.Widget.prototype._setOption.apply(self, arguments);
  	},
  
  	_size: function() {
  		/* If the user has resized the dialog, the .ui-dialog and .ui-dialog-content
  		 * divs will both have width and height set, so we need to reset them
  		 */
  		var options = this.options,
  			nonContentHeight,
  			minContentHeight,
  			isVisible = this.uiDialog.is( ":visible" );
  
  		// reset content sizing
  		this.element.show().css({
  			width: 'auto',
  			minHeight: 0,
  			height: 0
  		});
  
  		if (options.minWidth > options.width) {
  			options.width = options.minWidth;
  		}
  
  		// reset wrapper sizing
  		// determine the height of all the non-content elements
  		nonContentHeight = this.uiDialog.css({
  				height: 'auto',
  				width: options.width
  			})
  			.height();
  		minContentHeight = Math.max( 0, options.minHeight - nonContentHeight );
  		
  		if ( options.height === "auto" ) {
  			// only needed for IE6 support
  			if ( $.support.minHeight ) {
  				this.element.css({
  					minHeight: minContentHeight,
  					height: "auto"
  				});
  			} else {
  				this.uiDialog.show();
  				var autoHeight = this.element.css( "height", "auto" ).height();
  				if ( !isVisible ) {
  					this.uiDialog.hide();
  				}
  				this.element.height( Math.max( autoHeight, minContentHeight ) );
  			}
  		} else {
  			this.element.height( Math.max( options.height - nonContentHeight, 0 ) );
  		}
  
  		if (this.uiDialog.is(':data(resizable)')) {
  			this.uiDialog.resizable('option', 'minHeight', this._minHeight());
  		}
  	}
  });
  
  $.extend($.ui.dialog, {
  	version: "1.8.12",
  
  	uuid: 0,
  	maxZ: 0,
  
  	getTitleId: function($el) {
  		var id = $el.attr('id');
  		if (!id) {
  			this.uuid += 1;
  			id = this.uuid;
  		}
  		return 'ui-dialog-title-' + id;
  	},
  
  	overlay: function(dialog) {
  		this.$el = $.ui.dialog.overlay.create(dialog);
  	}
  });
  
  $.extend($.ui.dialog.overlay, {
  	instances: [],
  	// reuse old instances due to IE memory leak with alpha transparency (see #5185)
  	oldInstances: [],
  	maxZ: 0,
  	events: $.map('focus,mousedown,mouseup,keydown,keypress,click'.split(','),
  		function(event) { return event + '.dialog-overlay'; }).join(' '),
  	create: function(dialog) {
  		if (this.instances.length === 0) {
  			// prevent use of anchors and inputs
  			// we use a setTimeout in case the overlay is created from an
  			// event that we're going to be cancelling (see #2804)
  			setTimeout(function() {
  				// handle $(el).dialog().dialog('close') (see #4065)
  				if ($.ui.dialog.overlay.instances.length) {
  					$(document).bind($.ui.dialog.overlay.events, function(event) {
  						// stop events if the z-index of the target is < the z-index of the overlay
  						// we cannot return true when we don't want to cancel the event (#3523)
  						if ($(event.target).zIndex() < $.ui.dialog.overlay.maxZ) {
  							return false;
  						}
  					});
  				}
  			}, 1);
  
  			// allow closing by pressing the escape key
  			$(document).bind('keydown.dialog-overlay', function(event) {
  				if (dialog.options.closeOnEscape && event.keyCode &&
  					event.keyCode === $.ui.keyCode.ESCAPE) {
  					
  					dialog.close(event);
  					event.preventDefault();
  				}
  			});
  
  			// handle window resize
  			$(window).bind('resize.dialog-overlay', $.ui.dialog.overlay.resize);
  		}
  
  		var $el = (this.oldInstances.pop() || $('<div></div>').addClass('ui-widget-overlay'))
  			.appendTo(document.body)
  			.css({
  				width: this.width(),
  				height: this.height()
  			});
  
  		if ($.fn.bgiframe) {
  			$el.bgiframe();
  		}
  
  		this.instances.push($el);
  		return $el;
  	},
  
  	destroy: function($el) {
  		var indexOf = $.inArray($el, this.instances);
  		if (indexOf != -1){
  			this.oldInstances.push(this.instances.splice(indexOf, 1)[0]);
  		}
  
  		if (this.instances.length === 0) {
  			$([document, window]).unbind('.dialog-overlay');
  		}
  
  		$el.remove();
  		
  		// adjust the maxZ to allow other modal dialogs to continue to work (see #4309)
  		var maxZ = 0;
  		$.each(this.instances, function() {
  			maxZ = Math.max(maxZ, this.css('z-index'));
  		});
  		this.maxZ = maxZ;
  	},
  
  	height: function() {
  		var scrollHeight,
  			offsetHeight;
  		// handle IE 6
  		if ($.browser.msie && $.browser.version < 7) {
  			scrollHeight = Math.max(
  				document.documentElement.scrollHeight,
  				document.body.scrollHeight
  			);
  			offsetHeight = Math.max(
  				document.documentElement.offsetHeight,
  				document.body.offsetHeight
  			);
  
  			if (scrollHeight < offsetHeight) {
  				return $(window).height() + 'px';
  			} else {
  				return scrollHeight + 'px';
  			}
  		// handle "good" browsers
  		} else {
  			return $(document).height() + 'px';
  		}
  	},
  
  	width: function() {
  		var scrollWidth,
  			offsetWidth;
  		// handle IE 6
  		if ($.browser.msie && $.browser.version < 7) {
  			scrollWidth = Math.max(
  				document.documentElement.scrollWidth,
  				document.body.scrollWidth
  			);
  			offsetWidth = Math.max(
  				document.documentElement.offsetWidth,
  				document.body.offsetWidth
  			);
  
  			if (scrollWidth < offsetWidth) {
  				return $(window).width() + 'px';
  			} else {
  				return scrollWidth + 'px';
  			}
  		// handle "good" browsers
  		} else {
  			return $(document).width() + 'px';
  		}
  	},
  
  	resize: function() {
  		/* If the dialog is draggable and the user drags it past the
  		 * right edge of the window, the document becomes wider so we
  		 * need to stretch the overlay. If the user then drags the
  		 * dialog back to the left, the document will become narrower,
  		 * so we need to shrink the overlay to the appropriate size.
  		 * This is handled by shrinking the overlay before setting it
  		 * to the full document size.
  		 */
  		var $overlays = $([]);
  		$.each($.ui.dialog.overlay.instances, function() {
  			$overlays = $overlays.add(this);
  		});
  
  		$overlays.css({
  			width: 0,
  			height: 0
  		}).css({
  			width: $.ui.dialog.overlay.width(),
  			height: $.ui.dialog.overlay.height()
  		});
  	}
  });
  
  $.extend($.ui.dialog.overlay.prototype, {
  	destroy: function() {
  		$.ui.dialog.overlay.destroy(this.$el);
  	}
  });
  
  }(jQuery));
  /*
   * jQuery UI Slider 1.8.12
   *
   * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
   * Dual licensed under the MIT or GPL Version 2 licenses.
   * http://jquery.org/license
   *
   * http://docs.jquery.com/UI/Slider
   *
   * Depends:
   *	jquery.ui.core.js
   *	jquery.ui.mouse.js
   *	jquery.ui.widget.js
   */
  (function( $, undefined ) {
  
  // number of pages in a slider
  // (how many times can you page up/down to go through the whole range)
  var numPages = 5;
  
  $.widget( "ui.slider", $.ui.mouse, {
  
  	widgetEventPrefix: "slide",
  
  	options: {
  		animate: false,
  		distance: 0,
  		max: 100,
  		min: 0,
  		orientation: "horizontal",
  		range: false,
  		step: 1,
  		value: 0,
  		values: null
  	},
  
  	_create: function() {
  		var self = this,
  			o = this.options;
  
  		this._keySliding = false;
  		this._mouseSliding = false;
  		this._animateOff = true;
  		this._handleIndex = null;
  		this._detectOrientation();
  		this._mouseInit();
  
  		this.element
  			.addClass( "ui-slider" +
  				" ui-slider-" + this.orientation +
  				" ui-widget" +
  				" ui-widget-content" +
  				" ui-corner-all" );
  		
  		if ( o.disabled ) {
  			this.element.addClass( "ui-slider-disabled ui-disabled" );
  		}
  
  		this.range = $([]);
  
  		if ( o.range ) {
  			if ( o.range === true ) {
  				this.range = $( "<div></div>" );
  				if ( !o.values ) {
  					o.values = [ this._valueMin(), this._valueMin() ];
  				}
  				if ( o.values.length && o.values.length !== 2 ) {
  					o.values = [ o.values[0], o.values[0] ];
  				}
  			} else {
  				this.range = $( "<div></div>" );
  			}
  
  			this.range
  				.appendTo( this.element )
  				.addClass( "ui-slider-range" );
  
  			if ( o.range === "min" || o.range === "max" ) {
  				this.range.addClass( "ui-slider-range-" + o.range );
  			}
  
  			// note: this isn't the most fittingly semantic framework class for this element,
  			// but worked best visually with a variety of themes
  			this.range.addClass( "ui-widget-header" );
  		}
  
  		if ( $( ".ui-slider-handle", this.element ).length === 0 ) {
  			$( "<a href='#'></a>" )
  				.appendTo( this.element )
  				.addClass( "ui-slider-handle" );
  		}
  
  		if ( o.values && o.values.length ) {
  			while ( $(".ui-slider-handle", this.element).length < o.values.length ) {
  				$( "<a href='#'></a>" )
  					.appendTo( this.element )
  					.addClass( "ui-slider-handle" );
  			}
  		}
  
  		this.handles = $( ".ui-slider-handle", this.element )
  			.addClass( "ui-state-default" +
  				" ui-corner-all" );
  
  		this.handle = this.handles.eq( 0 );
  
  		this.handles.add( this.range ).filter( "a" )
  			.click(function( event ) {
  				event.preventDefault();
  			})
  			.hover(function() {
  				if ( !o.disabled ) {
  					$( this ).addClass( "ui-state-hover" );
  				}
  			}, function() {
  				$( this ).removeClass( "ui-state-hover" );
  			})
  			.focus(function() {
  				if ( !o.disabled ) {
  					$( ".ui-slider .ui-state-focus" ).removeClass( "ui-state-focus" );
  					$( this ).addClass( "ui-state-focus" );
  				} else {
  					$( this ).blur();
  				}
  			})
  			.blur(function() {
  				$( this ).removeClass( "ui-state-focus" );
  			});
  
  		this.handles.each(function( i ) {
  			$( this ).data( "index.ui-slider-handle", i );
  		});
  
  		this.handles
  			.keydown(function( event ) {
  				var ret = true,
  					index = $( this ).data( "index.ui-slider-handle" ),
  					allowed,
  					curVal,
  					newVal,
  					step;
  	
  				if ( self.options.disabled ) {
  					return;
  				}
  	
  				switch ( event.keyCode ) {
  					case $.ui.keyCode.HOME:
  					case $.ui.keyCode.END:
  					case $.ui.keyCode.PAGE_UP:
  					case $.ui.keyCode.PAGE_DOWN:
  					case $.ui.keyCode.UP:
  					case $.ui.keyCode.RIGHT:
  					case $.ui.keyCode.DOWN:
  					case $.ui.keyCode.LEFT:
  						ret = false;
  						if ( !self._keySliding ) {
  							self._keySliding = true;
  							$( this ).addClass( "ui-state-active" );
  							allowed = self._start( event, index );
  							if ( allowed === false ) {
  								return;
  							}
  						}
  						break;
  				}
  	
  				step = self.options.step;
  				if ( self.options.values && self.options.values.length ) {
  					curVal = newVal = self.values( index );
  				} else {
  					curVal = newVal = self.value();
  				}
  	
  				switch ( event.keyCode ) {
  					case $.ui.keyCode.HOME:
  						newVal = self._valueMin();
  						break;
  					case $.ui.keyCode.END:
  						newVal = self._valueMax();
  						break;
  					case $.ui.keyCode.PAGE_UP:
  						newVal = self._trimAlignValue( curVal + ( (self._valueMax() - self._valueMin()) / numPages ) );
  						break;
  					case $.ui.keyCode.PAGE_DOWN:
  						newVal = self._trimAlignValue( curVal - ( (self._valueMax() - self._valueMin()) / numPages ) );
  						break;
  					case $.ui.keyCode.UP:
  					case $.ui.keyCode.RIGHT:
  						if ( curVal === self._valueMax() ) {
  							return;
  						}
  						newVal = self._trimAlignValue( curVal + step );
  						break;
  					case $.ui.keyCode.DOWN:
  					case $.ui.keyCode.LEFT:
  						if ( curVal === self._valueMin() ) {
  							return;
  						}
  						newVal = self._trimAlignValue( curVal - step );
  						break;
  				}
  	
  				self._slide( event, index, newVal );
  	
  				return ret;
  	
  			})
  			.keyup(function( event ) {
  				var index = $( this ).data( "index.ui-slider-handle" );
  	
  				if ( self._keySliding ) {
  					self._keySliding = false;
  					self._stop( event, index );
  					self._change( event, index );
  					$( this ).removeClass( "ui-state-active" );
  				}
  	
  			});
  
  		this._refreshValue();
  
  		this._animateOff = false;
  	},
  
  	destroy: function() {
  		this.handles.remove();
  		this.range.remove();
  
  		this.element
  			.removeClass( "ui-slider" +
  				" ui-slider-horizontal" +
  				" ui-slider-vertical" +
  				" ui-slider-disabled" +
  				" ui-widget" +
  				" ui-widget-content" +
  				" ui-corner-all" )
  			.removeData( "slider" )
  			.unbind( ".slider" );
  
  		this._mouseDestroy();
  
  		return this;
  	},
  
  	_mouseCapture: function( event ) {
  		var o = this.options,
  			position,
  			normValue,
  			distance,
  			closestHandle,
  			self,
  			index,
  			allowed,
  			offset,
  			mouseOverHandle;
  
  		if ( o.disabled ) {
  			return false;
  		}
  
  		this.elementSize = {
  			width: this.element.outerWidth(),
  			height: this.element.outerHeight()
  		};
  		this.elementOffset = this.element.offset();
  
  		position = { x: event.pageX, y: event.pageY };
  		normValue = this._normValueFromMouse( position );
  		distance = this._valueMax() - this._valueMin() + 1;
  		self = this;
  		this.handles.each(function( i ) {
  			var thisDistance = Math.abs( normValue - self.values(i) );
  			if ( distance > thisDistance ) {
  				distance = thisDistance;
  				closestHandle = $( this );
  				index = i;
  			}
  		});
  
  		// workaround for bug #3736 (if both handles of a range are at 0,
  		// the first is always used as the one with least distance,
  		// and moving it is obviously prevented by preventing negative ranges)
  		if( o.range === true && this.values(1) === o.min ) {
  			index += 1;
  			closestHandle = $( this.handles[index] );
  		}
  
  		allowed = this._start( event, index );
  		if ( allowed === false ) {
  			return false;
  		}
  		this._mouseSliding = true;
  
  		self._handleIndex = index;
  
  		closestHandle
  			.addClass( "ui-state-active" )
  			.focus();
  		
  		offset = closestHandle.offset();
  		mouseOverHandle = !$( event.target ).parents().andSelf().is( ".ui-slider-handle" );
  		this._clickOffset = mouseOverHandle ? { left: 0, top: 0 } : {
  			left: event.pageX - offset.left - ( closestHandle.width() / 2 ),
  			top: event.pageY - offset.top -
  				( closestHandle.height() / 2 ) -
  				( parseInt( closestHandle.css("borderTopWidth"), 10 ) || 0 ) -
  				( parseInt( closestHandle.css("borderBottomWidth"), 10 ) || 0) +
  				( parseInt( closestHandle.css("marginTop"), 10 ) || 0)
  		};
  
  		if ( !this.handles.hasClass( "ui-state-hover" ) ) {
  			this._slide( event, index, normValue );
  		}
  		this._animateOff = true;
  		return true;
  	},
  
  	_mouseStart: function( event ) {
  		return true;
  	},
  
  	_mouseDrag: function( event ) {
  		var position = { x: event.pageX, y: event.pageY },
  			normValue = this._normValueFromMouse( position );
  		
  		this._slide( event, this._handleIndex, normValue );
  
  		return false;
  	},
  
  	_mouseStop: function( event ) {
  		this.handles.removeClass( "ui-state-active" );
  		this._mouseSliding = false;
  
  		this._stop( event, this._handleIndex );
  		this._change( event, this._handleIndex );
  
  		this._handleIndex = null;
  		this._clickOffset = null;
  		this._animateOff = false;
  
  		return false;
  	},
  	
  	_detectOrientation: function() {
  		this.orientation = ( this.options.orientation === "vertical" ) ? "vertical" : "horizontal";
  	},
  
  	_normValueFromMouse: function( position ) {
  		var pixelTotal,
  			pixelMouse,
  			percentMouse,
  			valueTotal,
  			valueMouse;
  
  		if ( this.orientation === "horizontal" ) {
  			pixelTotal = this.elementSize.width;
  			pixelMouse = position.x - this.elementOffset.left - ( this._clickOffset ? this._clickOffset.left : 0 );
  		} else {
  			pixelTotal = this.elementSize.height;
  			pixelMouse = position.y - this.elementOffset.top - ( this._clickOffset ? this._clickOffset.top : 0 );
  		}
  
  		percentMouse = ( pixelMouse / pixelTotal );
  		if ( percentMouse > 1 ) {
  			percentMouse = 1;
  		}
  		if ( percentMouse < 0 ) {
  			percentMouse = 0;
  		}
  		if ( this.orientation === "vertical" ) {
  			percentMouse = 1 - percentMouse;
  		}
  
  		valueTotal = this._valueMax() - this._valueMin();
  		valueMouse = this._valueMin() + percentMouse * valueTotal;
  
  		return this._trimAlignValue( valueMouse );
  	},
  
  	_start: function( event, index ) {
  		var uiHash = {
  			handle: this.handles[ index ],
  			value: this.value()
  		};
  		if ( this.options.values && this.options.values.length ) {
  			uiHash.value = this.values( index );
  			uiHash.values = this.values();
  		}
  		return this._trigger( "start", event, uiHash );
  	},
  
  	_slide: function( event, index, newVal ) {
  		var otherVal,
  			newValues,
  			allowed;
  
  		if ( this.options.values && this.options.values.length ) {
  			otherVal = this.values( index ? 0 : 1 );
  
  			if ( ( this.options.values.length === 2 && this.options.range === true ) && 
  					( ( index === 0 && newVal > otherVal) || ( index === 1 && newVal < otherVal ) )
  				) {
  				newVal = otherVal;
  			}
  
  			if ( newVal !== this.values( index ) ) {
  				newValues = this.values();
  				newValues[ index ] = newVal;
  				// A slide can be canceled by returning false from the slide callback
  				allowed = this._trigger( "slide", event, {
  					handle: this.handles[ index ],
  					value: newVal,
  					values: newValues
  				} );
  				otherVal = this.values( index ? 0 : 1 );
  				if ( allowed !== false ) {
  					this.values( index, newVal, true );
  				}
  			}
  		} else {
  			if ( newVal !== this.value() ) {
  				// A slide can be canceled by returning false from the slide callback
  				allowed = this._trigger( "slide", event, {
  					handle: this.handles[ index ],
  					value: newVal
  				} );
  				if ( allowed !== false ) {
  					this.value( newVal );
  				}
  			}
  		}
  	},
  
  	_stop: function( event, index ) {
  		var uiHash = {
  			handle: this.handles[ index ],
  			value: this.value()
  		};
  		if ( this.options.values && this.options.values.length ) {
  			uiHash.value = this.values( index );
  			uiHash.values = this.values();
  		}
  
  		this._trigger( "stop", event, uiHash );
  	},
  
  	_change: function( event, index ) {
  		if ( !this._keySliding && !this._mouseSliding ) {
  			var uiHash = {
  				handle: this.handles[ index ],
  				value: this.value()
  			};
  			if ( this.options.values && this.options.values.length ) {
  				uiHash.value = this.values( index );
  				uiHash.values = this.values();
  			}
  
  			this._trigger( "change", event, uiHash );
  		}
  	},
  
  	value: function( newValue ) {
  		if ( arguments.length ) {
  			this.options.value = this._trimAlignValue( newValue );
  			this._refreshValue();
  			this._change( null, 0 );
  			return;
  		}
  
  		return this._value();
  	},
  
  	values: function( index, newValue ) {
  		var vals,
  			newValues,
  			i;
  
  		if ( arguments.length > 1 ) {
  			this.options.values[ index ] = this._trimAlignValue( newValue );
  			this._refreshValue();
  			this._change( null, index );
  			return;
  		}
  
  		if ( arguments.length ) {
  			if ( $.isArray( arguments[ 0 ] ) ) {
  				vals = this.options.values;
  				newValues = arguments[ 0 ];
  				for ( i = 0; i < vals.length; i += 1 ) {
  					vals[ i ] = this._trimAlignValue( newValues[ i ] );
  					this._change( null, i );
  				}
  				this._refreshValue();
  			} else {
  				if ( this.options.values && this.options.values.length ) {
  					return this._values( index );
  				} else {
  					return this.value();
  				}
  			}
  		} else {
  			return this._values();
  		}
  	},
  
  	_setOption: function( key, value ) {
  		var i,
  			valsLength = 0;
  
  		if ( $.isArray( this.options.values ) ) {
  			valsLength = this.options.values.length;
  		}
  
  		$.Widget.prototype._setOption.apply( this, arguments );
  
  		switch ( key ) {
  			case "disabled":
  				if ( value ) {
  					this.handles.filter( ".ui-state-focus" ).blur();
  					this.handles.removeClass( "ui-state-hover" );
  					this.handles.attr( "disabled", "disabled" );
  					this.element.addClass( "ui-disabled" );
  				} else {
  					this.handles.removeAttr( "disabled" );
  					this.element.removeClass( "ui-disabled" );
  				}
  				break;
  			case "orientation":
  				this._detectOrientation();
  				this.element
  					.removeClass( "ui-slider-horizontal ui-slider-vertical" )
  					.addClass( "ui-slider-" + this.orientation );
  				this._refreshValue();
  				break;
  			case "value":
  				this._animateOff = true;
  				this._refreshValue();
  				this._change( null, 0 );
  				this._animateOff = false;
  				break;
  			case "values":
  				this._animateOff = true;
  				this._refreshValue();
  				for ( i = 0; i < valsLength; i += 1 ) {
  					this._change( null, i );
  				}
  				this._animateOff = false;
  				break;
  		}
  	},
  
  	//internal value getter
  	// _value() returns value trimmed by min and max, aligned by step
  	_value: function() {
  		var val = this.options.value;
  		val = this._trimAlignValue( val );
  
  		return val;
  	},
  
  	//internal values getter
  	// _values() returns array of values trimmed by min and max, aligned by step
  	// _values( index ) returns single value trimmed by min and max, aligned by step
  	_values: function( index ) {
  		var val,
  			vals,
  			i;
  
  		if ( arguments.length ) {
  			val = this.options.values[ index ];
  			val = this._trimAlignValue( val );
  
  			return val;
  		} else {
  			// .slice() creates a copy of the array
  			// this copy gets trimmed by min and max and then returned
  			vals = this.options.values.slice();
  			for ( i = 0; i < vals.length; i+= 1) {
  				vals[ i ] = this._trimAlignValue( vals[ i ] );
  			}
  
  			return vals;
  		}
  	},
  	
  	// returns the step-aligned value that val is closest to, between (inclusive) min and max
  	_trimAlignValue: function( val ) {
  		if ( val <= this._valueMin() ) {
  			return this._valueMin();
  		}
  		if ( val >= this._valueMax() ) {
  			return this._valueMax();
  		}
  		var step = ( this.options.step > 0 ) ? this.options.step : 1,
  			valModStep = (val - this._valueMin()) % step;
  			alignValue = val - valModStep;
  
  		if ( Math.abs(valModStep) * 2 >= step ) {
  			alignValue += ( valModStep > 0 ) ? step : ( -step );
  		}
  
  		// Since JavaScript has problems with large floats, round
  		// the final value to 5 digits after the decimal point (see #4124)
  		return parseFloat( alignValue.toFixed(5) );
  	},
  
  	_valueMin: function() {
  		return this.options.min;
  	},
  
  	_valueMax: function() {
  		return this.options.max;
  	},
  	
  	_refreshValue: function() {
  		var oRange = this.options.range,
  			o = this.options,
  			self = this,
  			animate = ( !this._animateOff ) ? o.animate : false,
  			valPercent,
  			_set = {},
  			lastValPercent,
  			value,
  			valueMin,
  			valueMax;
  
  		if ( this.options.values && this.options.values.length ) {
  			this.handles.each(function( i, j ) {
  				valPercent = ( self.values(i) - self._valueMin() ) / ( self._valueMax() - self._valueMin() ) * 100;
  				_set[ self.orientation === "horizontal" ? "left" : "bottom" ] = valPercent + "%";
  				$( this ).stop( 1, 1 )[ animate ? "animate" : "css" ]( _set, o.animate );
  				if ( self.options.range === true ) {
  					if ( self.orientation === "horizontal" ) {
  						if ( i === 0 ) {
  							self.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { left: valPercent + "%" }, o.animate );
  						}
  						if ( i === 1 ) {
  							self.range[ animate ? "animate" : "css" ]( { width: ( valPercent - lastValPercent ) + "%" }, { queue: false, duration: o.animate } );
  						}
  					} else {
  						if ( i === 0 ) {
  							self.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { bottom: ( valPercent ) + "%" }, o.animate );
  						}
  						if ( i === 1 ) {
  							self.range[ animate ? "animate" : "css" ]( { height: ( valPercent - lastValPercent ) + "%" }, { queue: false, duration: o.animate } );
  						}
  					}
  				}
  				lastValPercent = valPercent;
  			});
  		} else {
  			value = this.value();
  			valueMin = this._valueMin();
  			valueMax = this._valueMax();
  			valPercent = ( valueMax !== valueMin ) ?
  					( value - valueMin ) / ( valueMax - valueMin ) * 100 :
  					0;
  			_set[ self.orientation === "horizontal" ? "left" : "bottom" ] = valPercent + "%";
  			this.handle.stop( 1, 1 )[ animate ? "animate" : "css" ]( _set, o.animate );
  
  			if ( oRange === "min" && this.orientation === "horizontal" ) {
  				this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { width: valPercent + "%" }, o.animate );
  			}
  			if ( oRange === "max" && this.orientation === "horizontal" ) {
  				this.range[ animate ? "animate" : "css" ]( { width: ( 100 - valPercent ) + "%" }, { queue: false, duration: o.animate } );
  			}
  			if ( oRange === "min" && this.orientation === "vertical" ) {
  				this.range.stop( 1, 1 )[ animate ? "animate" : "css" ]( { height: valPercent + "%" }, o.animate );
  			}
  			if ( oRange === "max" && this.orientation === "vertical" ) {
  				this.range[ animate ? "animate" : "css" ]( { height: ( 100 - valPercent ) + "%" }, { queue: false, duration: o.animate } );
  			}
  		}
  	}
  
  });
  
  $.extend( $.ui.slider, {
  	version: "1.8.12"
  });
  
  }(jQuery));
  /*
   * jQuery UI Tabs 1.8.12
   *
   * Copyright 2011, AUTHORS.txt (http://jqueryui.com/about)
   * Dual licensed under the MIT or GPL Version 2 licenses.
   * http://jquery.org/license
   *
   * http://docs.jquery.com/UI/Tabs
   *
   * Depends:
   *	jquery.ui.core.js
   *	jquery.ui.widget.js
   */
  (function( $, undefined ) {
  
  var tabId = 0,
  	listId = 0;
  
  function getNextTabId() {
  	return ++tabId;
  }
  
  function getNextListId() {
  	return ++listId;
  }
  
  $.widget( "ui.tabs", {
  	options: {
  		add: null,
  		ajaxOptions: null,
  		cache: false,
  		cookie: null, // e.g. { expires: 7, path: '/', domain: 'jquery.com', secure: true }
  		collapsible: false,
  		disable: null,
  		disabled: [],
  		enable: null,
  		event: "click",
  		fx: null, // e.g. { height: 'toggle', opacity: 'toggle', duration: 200 }
  		idPrefix: "ui-tabs-",
  		load: null,
  		panelTemplate: "<div></div>",
  		remove: null,
  		select: null,
  		show: null,
  		spinner: "<em>Loading&#8230;</em>",
  		tabTemplate: "<li><a href='#{href}'><span>#{label}</span></a></li>"
  	},
  
  	_create: function() {
  		this._tabify( true );
  	},
  
  	_setOption: function( key, value ) {
  		if ( key == "selected" ) {
  			if (this.options.collapsible && value == this.options.selected ) {
  				return;
  			}
  			this.select( value );
  		} else {
  			this.options[ key ] = value;
  			this._tabify();
  		}
  	},
  
  	_tabId: function( a ) {
  		return a.title && a.title.replace( /\s/g, "_" ).replace( /[^\w\u00c0-\uFFFF-]/g, "" ) ||
  			this.options.idPrefix + getNextTabId();
  	},
  
  	_sanitizeSelector: function( hash ) {
  		// we need this because an id may contain a ":"
  		return hash.replace( /:/g, "\\:" );
  	},
  
  	_cookie: function() {
  		var cookie = this.cookie ||
  			( this.cookie = this.options.cookie.name || "ui-tabs-" + getNextListId() );
  		return $.cookie.apply( null, [ cookie ].concat( $.makeArray( arguments ) ) );
  	},
  
  	_ui: function( tab, panel ) {
  		return {
  			tab: tab,
  			panel: panel,
  			index: this.anchors.index( tab )
  		};
  	},
  
  	_cleanup: function() {
  		// restore all former loading tabs labels
  		this.lis.filter( ".ui-state-processing" )
  			.removeClass( "ui-state-processing" )
  			.find( "span:data(label.tabs)" )
  				.each(function() {
  					var el = $( this );
  					el.html( el.data( "label.tabs" ) ).removeData( "label.tabs" );
  				});
  	},
  
  	_tabify: function( init ) {
  		var self = this,
  			o = this.options,
  			fragmentId = /^#.+/; // Safari 2 reports '#' for an empty hash
  
  		this.list = this.element.find( "ol,ul" ).eq( 0 );
  		this.lis = $( " > li:has(a[href])", this.list );
  		this.anchors = this.lis.map(function() {
  			return $( "a", this )[ 0 ];
  		});
  		this.panels = $( [] );
  
  		this.anchors.each(function( i, a ) {
  			var href = $( a ).attr( "href" );
  			// For dynamically created HTML that contains a hash as href IE < 8 expands
  			// such href to the full page url with hash and then misinterprets tab as ajax.
  			// Same consideration applies for an added tab with a fragment identifier
  			// since a[href=#fragment-identifier] does unexpectedly not match.
  			// Thus normalize href attribute...
  			var hrefBase = href.split( "#" )[ 0 ],
  				baseEl;
  			if ( hrefBase && ( hrefBase === location.toString().split( "#" )[ 0 ] ||
  					( baseEl = $( "base" )[ 0 ]) && hrefBase === baseEl.href ) ) {
  				href = a.hash;
  				a.href = href;
  			}
  
  			// inline tab
  			if ( fragmentId.test( href ) ) {
  				self.panels = self.panels.add( self.element.find( self._sanitizeSelector( href ) ) );
  			// remote tab
  			// prevent loading the page itself if href is just "#"
  			} else if ( href && href !== "#" ) {
  				// required for restore on destroy
  				$.data( a, "href.tabs", href );
  
  				// TODO until #3808 is fixed strip fragment identifier from url
  				// (IE fails to load from such url)
  				$.data( a, "load.tabs", href.replace( /#.*$/, "" ) );
  
  				var id = self._tabId( a );
  				a.href = "#" + id;
  				var $panel = self.element.find( "#" + id );
  				if ( !$panel.length ) {
  					$panel = $( o.panelTemplate )
  						.attr( "id", id )
  						.addClass( "ui-tabs-panel ui-widget-content ui-corner-bottom" )
  						.insertAfter( self.panels[ i - 1 ] || self.list );
  					$panel.data( "destroy.tabs", true );
  				}
  				self.panels = self.panels.add( $panel );
  			// invalid tab href
  			} else {
  				o.disabled.push( i );
  			}
  		});
  
  		// initialization from scratch
  		if ( init ) {
  			// attach necessary classes for styling
  			this.element.addClass( "ui-tabs ui-widget ui-widget-content ui-corner-all" );
  			this.list.addClass( "ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all" );
  			this.lis.addClass( "ui-state-default ui-corner-top" );
  			this.panels.addClass( "ui-tabs-panel ui-widget-content ui-corner-bottom" );
  
  			// Selected tab
  			// use "selected" option or try to retrieve:
  			// 1. from fragment identifier in url
  			// 2. from cookie
  			// 3. from selected class attribute on <li>
  			if ( o.selected === undefined ) {
  				if ( location.hash ) {
  					this.anchors.each(function( i, a ) {
  						if ( a.hash == location.hash ) {
  							o.selected = i;
  							return false;
  						}
  					});
  				}
  				if ( typeof o.selected !== "number" && o.cookie ) {
  					o.selected = parseInt( self._cookie(), 10 );
  				}
  				if ( typeof o.selected !== "number" && this.lis.filter( ".ui-tabs-selected" ).length ) {
  					o.selected = this.lis.index( this.lis.filter( ".ui-tabs-selected" ) );
  				}
  				o.selected = o.selected || ( this.lis.length ? 0 : -1 );
  			} else if ( o.selected === null ) { // usage of null is deprecated, TODO remove in next release
  				o.selected = -1;
  			}
  
  			// sanity check - default to first tab...
  			o.selected = ( ( o.selected >= 0 && this.anchors[ o.selected ] ) || o.selected < 0 )
  				? o.selected
  				: 0;
  
  			// Take disabling tabs via class attribute from HTML
  			// into account and update option properly.
  			// A selected tab cannot become disabled.
  			o.disabled = $.unique( o.disabled.concat(
  				$.map( this.lis.filter( ".ui-state-disabled" ), function( n, i ) {
  					return self.lis.index( n );
  				})
  			) ).sort();
  
  			if ( $.inArray( o.selected, o.disabled ) != -1 ) {
  				o.disabled.splice( $.inArray( o.selected, o.disabled ), 1 );
  			}
  
  			// highlight selected tab
  			this.panels.addClass( "ui-tabs-hide" );
  			this.lis.removeClass( "ui-tabs-selected ui-state-active" );
  			// check for length avoids error when initializing empty list
  			if ( o.selected >= 0 && this.anchors.length ) {
  				self.element.find( self._sanitizeSelector( self.anchors[ o.selected ].hash ) ).removeClass( "ui-tabs-hide" );
  				this.lis.eq( o.selected ).addClass( "ui-tabs-selected ui-state-active" );
  
  				// seems to be expected behavior that the show callback is fired
  				self.element.queue( "tabs", function() {
  					self._trigger( "show", null,
  						self._ui( self.anchors[ o.selected ], self.element.find( self._sanitizeSelector( self.anchors[ o.selected ].hash ) )[ 0 ] ) );
  				});
  
  				this.load( o.selected );
  			}
  
  			// clean up to avoid memory leaks in certain versions of IE 6
  			// TODO: namespace this event
  			$( window ).bind( "unload", function() {
  				self.lis.add( self.anchors ).unbind( ".tabs" );
  				self.lis = self.anchors = self.panels = null;
  			});
  		// update selected after add/remove
  		} else {
  			o.selected = this.lis.index( this.lis.filter( ".ui-tabs-selected" ) );
  		}
  
  		// update collapsible
  		// TODO: use .toggleClass()
  		this.element[ o.collapsible ? "addClass" : "removeClass" ]( "ui-tabs-collapsible" );
  
  		// set or update cookie after init and add/remove respectively
  		if ( o.cookie ) {
  			this._cookie( o.selected, o.cookie );
  		}
  
  		// disable tabs
  		for ( var i = 0, li; ( li = this.lis[ i ] ); i++ ) {
  			$( li )[ $.inArray( i, o.disabled ) != -1 &&
  				// TODO: use .toggleClass()
  				!$( li ).hasClass( "ui-tabs-selected" ) ? "addClass" : "removeClass" ]( "ui-state-disabled" );
  		}
  
  		// reset cache if switching from cached to not cached
  		if ( o.cache === false ) {
  			this.anchors.removeData( "cache.tabs" );
  		}
  
  		// remove all handlers before, tabify may run on existing tabs after add or option change
  		this.lis.add( this.anchors ).unbind( ".tabs" );
  
  		if ( o.event !== "mouseover" ) {
  			var addState = function( state, el ) {
  				if ( el.is( ":not(.ui-state-disabled)" ) ) {
  					el.addClass( "ui-state-" + state );
  				}
  			};
  			var removeState = function( state, el ) {
  				el.removeClass( "ui-state-" + state );
  			};
  			this.lis.bind( "mouseover.tabs" , function() {
  				addState( "hover", $( this ) );
  			});
  			this.lis.bind( "mouseout.tabs", function() {
  				removeState( "hover", $( this ) );
  			});
  			this.anchors.bind( "focus.tabs", function() {
  				addState( "focus", $( this ).closest( "li" ) );
  			});
  			this.anchors.bind( "blur.tabs", function() {
  				removeState( "focus", $( this ).closest( "li" ) );
  			});
  		}
  
  		// set up animations
  		var hideFx, showFx;
  		if ( o.fx ) {
  			if ( $.isArray( o.fx ) ) {
  				hideFx = o.fx[ 0 ];
  				showFx = o.fx[ 1 ];
  			} else {
  				hideFx = showFx = o.fx;
  			}
  		}
  
  		// Reset certain styles left over from animation
  		// and prevent IE's ClearType bug...
  		function resetStyle( $el, fx ) {
  			$el.css( "display", "" );
  			if ( !$.support.opacity && fx.opacity ) {
  				$el[ 0 ].style.removeAttribute( "filter" );
  			}
  		}
  
  		// Show a tab...
  		var showTab = showFx
  			? function( clicked, $show ) {
  				$( clicked ).closest( "li" ).addClass( "ui-tabs-selected ui-state-active" );
  				$show.hide().removeClass( "ui-tabs-hide" ) // avoid flicker that way
  					.animate( showFx, showFx.duration || "normal", function() {
  						resetStyle( $show, showFx );
  						self._trigger( "show", null, self._ui( clicked, $show[ 0 ] ) );
  					});
  			}
  			: function( clicked, $show ) {
  				$( clicked ).closest( "li" ).addClass( "ui-tabs-selected ui-state-active" );
  				$show.removeClass( "ui-tabs-hide" );
  				self._trigger( "show", null, self._ui( clicked, $show[ 0 ] ) );
  			};
  
  		// Hide a tab, $show is optional...
  		var hideTab = hideFx
  			? function( clicked, $hide ) {
  				$hide.animate( hideFx, hideFx.duration || "normal", function() {
  					self.lis.removeClass( "ui-tabs-selected ui-state-active" );
  					$hide.addClass( "ui-tabs-hide" );
  					resetStyle( $hide, hideFx );
  					self.element.dequeue( "tabs" );
  				});
  			}
  			: function( clicked, $hide, $show ) {
  				self.lis.removeClass( "ui-tabs-selected ui-state-active" );
  				$hide.addClass( "ui-tabs-hide" );
  				self.element.dequeue( "tabs" );
  			};
  
  		// attach tab event handler, unbind to avoid duplicates from former tabifying...
  		this.anchors.bind( o.event + ".tabs", function() {
  			var el = this,
  				$li = $(el).closest( "li" ),
  				$hide = self.panels.filter( ":not(.ui-tabs-hide)" ),
  				$show = self.element.find( self._sanitizeSelector( el.hash ) );
  
  			// If tab is already selected and not collapsible or tab disabled or
  			// or is already loading or click callback returns false stop here.
  			// Check if click handler returns false last so that it is not executed
  			// for a disabled or loading tab!
  			if ( ( $li.hasClass( "ui-tabs-selected" ) && !o.collapsible) ||
  				$li.hasClass( "ui-state-disabled" ) ||
  				$li.hasClass( "ui-state-processing" ) ||
  				self.panels.filter( ":animated" ).length ||
  				self._trigger( "select", null, self._ui( this, $show[ 0 ] ) ) === false ) {
  				this.blur();
  				return false;
  			}
  
  			o.selected = self.anchors.index( this );
  
  			self.abort();
  
  			// if tab may be closed
  			if ( o.collapsible ) {
  				if ( $li.hasClass( "ui-tabs-selected" ) ) {
  					o.selected = -1;
  
  					if ( o.cookie ) {
  						self._cookie( o.selected, o.cookie );
  					}
  
  					self.element.queue( "tabs", function() {
  						hideTab( el, $hide );
  					}).dequeue( "tabs" );
  
  					this.blur();
  					return false;
  				} else if ( !$hide.length ) {
  					if ( o.cookie ) {
  						self._cookie( o.selected, o.cookie );
  					}
  
  					self.element.queue( "tabs", function() {
  						showTab( el, $show );
  					});
  
  					// TODO make passing in node possible, see also http://dev.jqueryui.com/ticket/3171
  					self.load( self.anchors.index( this ) );
  
  					this.blur();
  					return false;
  				}
  			}
  
  			if ( o.cookie ) {
  				self._cookie( o.selected, o.cookie );
  			}
  
  			// show new tab
  			if ( $show.length ) {
  				if ( $hide.length ) {
  					self.element.queue( "tabs", function() {
  						hideTab( el, $hide );
  					});
  				}
  				self.element.queue( "tabs", function() {
  					showTab( el, $show );
  				});
  
  				self.load( self.anchors.index( this ) );
  			} else {
  				throw "jQuery UI Tabs: Mismatching fragment identifier.";
  			}
  
  			// Prevent IE from keeping other link focussed when using the back button
  			// and remove dotted border from clicked link. This is controlled via CSS
  			// in modern browsers; blur() removes focus from address bar in Firefox
  			// which can become a usability and annoying problem with tabs('rotate').
  			if ( $.browser.msie ) {
  				this.blur();
  			}
  		});
  
  		// disable click in any case
  		this.anchors.bind( "click.tabs", function(){
  			return false;
  		});
  	},
  
      _getIndex: function( index ) {
  		// meta-function to give users option to provide a href string instead of a numerical index.
  		// also sanitizes numerical indexes to valid values.
  		if ( typeof index == "string" ) {
  			index = this.anchors.index( this.anchors.filter( "[href$=" + index + "]" ) );
  		}
  
  		return index;
  	},
  
  	destroy: function() {
  		var o = this.options;
  
  		this.abort();
  
  		this.element
  			.unbind( ".tabs" )
  			.removeClass( "ui-tabs ui-widget ui-widget-content ui-corner-all ui-tabs-collapsible" )
  			.removeData( "tabs" );
  
  		this.list.removeClass( "ui-tabs-nav ui-helper-reset ui-helper-clearfix ui-widget-header ui-corner-all" );
  
  		this.anchors.each(function() {
  			var href = $.data( this, "href.tabs" );
  			if ( href ) {
  				this.href = href;
  			}
  			var $this = $( this ).unbind( ".tabs" );
  			$.each( [ "href", "load", "cache" ], function( i, prefix ) {
  				$this.removeData( prefix + ".tabs" );
  			});
  		});
  
  		this.lis.unbind( ".tabs" ).add( this.panels ).each(function() {
  			if ( $.data( this, "destroy.tabs" ) ) {
  				$( this ).remove();
  			} else {
  				$( this ).removeClass([
  					"ui-state-default",
  					"ui-corner-top",
  					"ui-tabs-selected",
  					"ui-state-active",
  					"ui-state-hover",
  					"ui-state-focus",
  					"ui-state-disabled",
  					"ui-tabs-panel",
  					"ui-widget-content",
  					"ui-corner-bottom",
  					"ui-tabs-hide"
  				].join( " " ) );
  			}
  		});
  
  		if ( o.cookie ) {
  			this._cookie( null, o.cookie );
  		}
  
  		return this;
  	},
  
  	add: function( url, label, index ) {
  		if ( index === undefined ) {
  			index = this.anchors.length;
  		}
  
  		var self = this,
  			o = this.options,
  			$li = $( o.tabTemplate.replace( /#\{href\}/g, url ).replace( /#\{label\}/g, label ) ),
  			id = !url.indexOf( "#" ) ? url.replace( "#", "" ) : this._tabId( $( "a", $li )[ 0 ] );
  
  		$li.addClass( "ui-state-default ui-corner-top" ).data( "destroy.tabs", true );
  
  		// try to find an existing element before creating a new one
  		var $panel = self.element.find( "#" + id );
  		if ( !$panel.length ) {
  			$panel = $( o.panelTemplate )
  				.attr( "id", id )
  				.data( "destroy.tabs", true );
  		}
  		$panel.addClass( "ui-tabs-panel ui-widget-content ui-corner-bottom ui-tabs-hide" );
  
  		if ( index >= this.lis.length ) {
  			$li.appendTo( this.list );
  			$panel.appendTo( this.list[ 0 ].parentNode );
  		} else {
  			$li.insertBefore( this.lis[ index ] );
  			$panel.insertBefore( this.panels[ index ] );
  		}
  
  		o.disabled = $.map( o.disabled, function( n, i ) {
  			return n >= index ? ++n : n;
  		});
  
  		this._tabify();
  
  		if ( this.anchors.length == 1 ) {
  			o.selected = 0;
  			$li.addClass( "ui-tabs-selected ui-state-active" );
  			$panel.removeClass( "ui-tabs-hide" );
  			this.element.queue( "tabs", function() {
  				self._trigger( "show", null, self._ui( self.anchors[ 0 ], self.panels[ 0 ] ) );
  			});
  
  			this.load( 0 );
  		}
  
  		this._trigger( "add", null, this._ui( this.anchors[ index ], this.panels[ index ] ) );
  		return this;
  	},
  
  	remove: function( index ) {
  		index = this._getIndex( index );
  		var o = this.options,
  			$li = this.lis.eq( index ).remove(),
  			$panel = this.panels.eq( index ).remove();
  
  		// If selected tab was removed focus tab to the right or
  		// in case the last tab was removed the tab to the left.
  		if ( $li.hasClass( "ui-tabs-selected" ) && this.anchors.length > 1) {
  			this.select( index + ( index + 1 < this.anchors.length ? 1 : -1 ) );
  		}
  
  		o.disabled = $.map(
  			$.grep( o.disabled, function(n, i) {
  				return n != index;
  			}),
  			function( n, i ) {
  				return n >= index ? --n : n;
  			});
  
  		this._tabify();
  
  		this._trigger( "remove", null, this._ui( $li.find( "a" )[ 0 ], $panel[ 0 ] ) );
  		return this;
  	},
  
  	enable: function( index ) {
  		index = this._getIndex( index );
  		var o = this.options;
  		if ( $.inArray( index, o.disabled ) == -1 ) {
  			return;
  		}
  
  		this.lis.eq( index ).removeClass( "ui-state-disabled" );
  		o.disabled = $.grep( o.disabled, function( n, i ) {
  			return n != index;
  		});
  
  		this._trigger( "enable", null, this._ui( this.anchors[ index ], this.panels[ index ] ) );
  		return this;
  	},
  
  	disable: function( index ) {
  		index = this._getIndex( index );
  		var self = this, o = this.options;
  		// cannot disable already selected tab
  		if ( index != o.selected ) {
  			this.lis.eq( index ).addClass( "ui-state-disabled" );
  
  			o.disabled.push( index );
  			o.disabled.sort();
  
  			this._trigger( "disable", null, this._ui( this.anchors[ index ], this.panels[ index ] ) );
  		}
  
  		return this;
  	},
  
  	select: function( index ) {
  		index = this._getIndex( index );
  		if ( index == -1 ) {
  			if ( this.options.collapsible && this.options.selected != -1 ) {
  				index = this.options.selected;
  			} else {
  				return this;
  			}
  		}
  		this.anchors.eq( index ).trigger( this.options.event + ".tabs" );
  		return this;
  	},
  
  	load: function( index ) {
  		index = this._getIndex( index );
  		var self = this,
  			o = this.options,
  			a = this.anchors.eq( index )[ 0 ],
  			url = $.data( a, "load.tabs" );
  
  		this.abort();
  
  		// not remote or from cache
  		if ( !url || this.element.queue( "tabs" ).length !== 0 && $.data( a, "cache.tabs" ) ) {
  			this.element.dequeue( "tabs" );
  			return;
  		}
  
  		// load remote from here on
  		this.lis.eq( index ).addClass( "ui-state-processing" );
  
  		if ( o.spinner ) {
  			var span = $( "span", a );
  			span.data( "label.tabs", span.html() ).html( o.spinner );
  		}
  
  		this.xhr = $.ajax( $.extend( {}, o.ajaxOptions, {
  			url: url,
  			success: function( r, s ) {
  				self.element.find( self._sanitizeSelector( a.hash ) ).html( r );
  
  				// take care of tab labels
  				self._cleanup();
  
  				if ( o.cache ) {
  					$.data( a, "cache.tabs", true );
  				}
  
  				self._trigger( "load", null, self._ui( self.anchors[ index ], self.panels[ index ] ) );
  				try {
  					o.ajaxOptions.success( r, s );
  				}
  				catch ( e ) {}
  			},
  			error: function( xhr, s, e ) {
  				// take care of tab labels
  				self._cleanup();
  
  				self._trigger( "load", null, self._ui( self.anchors[ index ], self.panels[ index ] ) );
  				try {
  					// Passing index avoid a race condition when this method is
  					// called after the user has selected another tab.
  					// Pass the anchor that initiated this request allows
  					// loadError to manipulate the tab content panel via $(a.hash)
  					o.ajaxOptions.error( xhr, s, index, a );
  				}
  				catch ( e ) {}
  			}
  		} ) );
  
  		// last, so that load event is fired before show...
  		self.element.dequeue( "tabs" );
  
  		return this;
  	},
  
  	abort: function() {
  		// stop possibly running animations
  		this.element.queue( [] );
  		this.panels.stop( false, true );
  
  		// "tabs" queue must not contain more than two elements,
  		// which are the callbacks for the latest clicked tab...
  		this.element.queue( "tabs", this.element.queue( "tabs" ).splice( -2, 2 ) );
  
  		// terminate pending requests from other tabs
  		if ( this.xhr ) {
  			this.xhr.abort();
  			delete this.xhr;
  		}
  
  		// take care of tab labels
  		this._cleanup();
  		return this;
  	},
  
  	url: function( index, url ) {
  		this.anchors.eq( index ).removeData( "cache.tabs" ).data( "load.tabs", url );
  		return this;
  	},
  
  	length: function() {
  		return this.anchors.length;
  	}
  });
  
  $.extend( $.ui.tabs, {
  	version: "1.8.12"
  });
  
  /*
   * Tabs Extensions
   */
  
  /*
   * Rotate
   */
  $.extend( $.ui.tabs.prototype, {
  	rotation: null,
  	rotate: function( ms, continuing ) {
  		var self = this,
  			o = this.options;
  
  		var rotate = self._rotate || ( self._rotate = function( e ) {
  			clearTimeout( self.rotation );
  			self.rotation = setTimeout(function() {
  				var t = o.selected;
  				self.select( ++t < self.anchors.length ? t : 0 );
  			}, ms );
  			
  			if ( e ) {
  				e.stopPropagation();
  			}
  		});
  
  		var stop = self._unrotate || ( self._unrotate = !continuing
  			? function(e) {
  				if (e.clientX) { // in case of a true click
  					self.rotate(null);
  				}
  			}
  			: function( e ) {
  				t = o.selected;
  				rotate();
  			});
  
  		// start rotation
  		if ( ms ) {
  			this.element.bind( "tabsshow", rotate );
  			this.anchors.bind( o.event + ".tabs", stop );
  			rotate();
  		// stop rotation
  		} else {
  			clearTimeout( self.rotation );
  			this.element.unbind( "tabsshow", rotate );
  			this.anchors.unbind( o.event + ".tabs", stop );
  			delete this._rotate;
  			delete this._unrotate;
  		}
  
  		return this;
  	}
  });
  
  })( jQuery );
  