MediaWiki:Common.js/Enomya.js

/* Any JavaScript here will be loaded for all users on every page load. */

if(window.location.href === 'https://letitdie.gamepedia.com/EnomyaTestSite'){

$(document).ready(function{   $("p").click(function{ $(this).hide; }); });

/*! * jQuery JavaScript Library v1.12.4 * http://jquery.com/ * * Includes Sizzle.js * http://sizzlejs.com/ * * Copyright jQuery Foundation and other contributors * Released under the MIT license * http://jquery.org/license * * Date: 2016-05-20T17:17Z */

(function( global, factory ) {

if ( typeof module === "object" && typeof module.exports === "object" ) { // For CommonJS and CommonJS-like environments where a proper `window` // is present, execute the factory and get jQuery. // For environments that do not have a `window` with a `document` // (such as Node.js), expose a factory as module.exports. // This accentuates the need for the creation of a real `window`. // e.g. var jQuery = require("jquery")(window); // See ticket #14549 for more info. module.exports = global.document ? factory( global, true ) : function( w ) { if ( !w.document ) { throw new Error( "jQuery requires a window with a document" ); }				return factory( w ); };	} else { factory( global ); }

// Pass this if window is not defined yet }(typeof window !== "undefined" ? window : this, function( window, noGlobal ) {

// Support: Firefox 18+ // Can't be in strict mode, several libs including ASP.NET trace // the stack via arguments.caller.callee and Firefox dies if // you try to trace through "use strict" call chains. (#13335) //"use strict"; var deletedIds = [];

var document = window.document;

var slice = deletedIds.slice;

var concat = deletedIds.concat;

var push = deletedIds.push;

var indexOf = deletedIds.indexOf;

var class2type = {};

var toString = class2type.toString;

var hasOwn = class2type.hasOwnProperty;

var support = {};

var version = "1.12.4",

// Define a local copy of jQuery jQuery = function( selector, context ) {

// The jQuery object is actually just the init constructor 'enhanced' // Need init if jQuery is called (just allow error to be thrown if not included) return new jQuery.fn.init( selector, context ); },

// Support: Android<4.1, IE<9 // Make sure we trim BOM and NBSP rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,

// Matches dashed string for camelizing rmsPrefix = /^-ms-/, rdashAlpha = /-([\da-z])/gi,

// Used by jQuery.camelCase as callback to replace fcamelCase = function( all, letter ) { return letter.toUpperCase; };

jQuery.fn = jQuery.prototype = {

// The current version of jQuery being used jquery: version,

constructor: jQuery,

// Start with an empty selector selector: "",

// The default length of a jQuery object is 0 length: 0,

toArray: function { return slice.call( this ); },

// 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 just the one element from the set ( num < 0 ? this[ num + this.length ] : this[ num ] ) :

// Return all the elements in a clean array slice.call( this ); },

// Take an array of elements and push it onto the stack // (returning the new matched element set) pushStack: function( elems ) {

// Build a new jQuery matched element set var ret = jQuery.merge( this.constructor, elems );

// Add the old object onto the stack (as a reference) ret.prevObject = this; ret.context = this.context;

// Return the newly-formed element set return ret; },

// Execute a callback for every element in the matched set. each: function( callback ) { return jQuery.each( this, callback ); },

map: function( callback ) { return this.pushStack( jQuery.map( this, function( elem, i ) { return callback.call( elem, i, elem ); } ) );	},

slice: function { return this.pushStack( slice.apply( this, arguments ) ); },

first: function { return this.eq( 0 ); },

last: function { return this.eq( -1 ); },

eq: function( i ) { var len = this.length, j = +i + ( i < 0 ? len : 0 ); return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] ); },

end: function { return this.prevObject || this.constructor; },

// For internal use only. // Behaves like an Array's method, not like a jQuery method. push: push, sort: deletedIds.sort, splice: deletedIds.splice };

jQuery.extend = jQuery.fn.extend = function { var src, copyIsArray, copy, name, options, clone, target = arguments[ 0 ] || {}, i = 1, length = arguments.length, deep = false;

// Handle a deep copy situation if ( typeof target === "boolean" ) { deep = target;

// skip the boolean and the target target = arguments[ i ] || {}; i++; }

// 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 ( i === length ) { 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( {

// Unique for each copy of jQuery on the page expando: "jQuery" + ( version + Math.random ).replace( /\D/g, "" ),

// Assume jQuery is ready without the ready module isReady: true,

error: function( msg ) { throw new Error( msg ); },

noop: function {},

// 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"; },

isWindow: function( obj ) { /* jshint eqeqeq: false */ return obj != null && obj == obj.window; },

isNumeric: function( obj ) {

// parseFloat NaNs numeric-cast false positives (null|true|false|"") // ...but misinterprets leading-number strings, particularly hex literals ("0x...") // subtraction forces infinities to NaN // adding 1 corrects loss of precision from parseFloat (#15100) var realStringObj = obj && obj.toString; return !jQuery.isArray( obj ) && ( realStringObj - parseFloat( realStringObj ) + 1 ) >= 0; },

isEmptyObject: function( obj ) { var name; for ( name in obj ) { return false; }		return true; },

isPlainObject: function( obj ) { var key;

// 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; }

try {

// Not own constructor property must be Object if ( obj.constructor &&				!hasOwn.call( obj, "constructor" ) &&				!hasOwn.call( obj.constructor.prototype, "isPrototypeOf" ) ) { return false; }		} catch ( e ) {

// IE8,9 Will throw exceptions on certain host objects #9897 return false; }

// Support: IE<9 // Handle iteration over inherited properties before own properties. if ( !support.ownFirst ) { for ( key in obj ) { return hasOwn.call( obj, key ); }		}

// Own properties are enumerated firstly, so to speed up, // if last one is own, then all properties are own. for ( key in obj ) {}

return key === undefined || hasOwn.call( obj, key ); },

type: function( obj ) { if ( obj == null ) { return obj + ""; }		return typeof obj === "object" || typeof obj === "function" ? class2type[ toString.call( obj ) ] || "object" : typeof obj; },

// 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 && jQuery.trim( 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 ); // jscs:ignore requireDotNotation			} )( data ); }	},

// Convert dashed to camelCase; used by the css and data modules // Microsoft forgot to hump their vendor prefix (#9572) camelCase: function( string ) { return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase ); },

nodeName: function( elem, name ) { return elem.nodeName && elem.nodeName.toLowerCase === name.toLowerCase; },

each: function( obj, callback ) { var length, i = 0;

if ( isArrayLike( obj ) ) { length = obj.length; for (i < length; i++ ) { if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) { break; }			}		} else { for ( i in obj ) { if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) { break; }			}		}

return obj; },

// Support: Android<4.1, IE<9 trim: function( text ) { return text == null ? "" :			( text + "" ).replace( rtrim, "" ); },

// results is for internal usage only makeArray: function( arr, results ) { var ret = results || [];

if ( arr != null ) { if ( isArrayLike( Object( arr ) ) ) { jQuery.merge( ret,					typeof arr === "string" ?					[ arr ] : arr				); } else { push.call( ret, arr ); }		}

return ret; },

inArray: function( elem, arr, i ) { var len;

if ( arr ) { if ( indexOf ) { return indexOf.call( arr, elem, i ); }

len = arr.length; i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0;

for (i < len; i++ ) {

// Skip accessing in sparse arrays if ( i in arr && arr[ i ] === elem ) { return i;				} }		}

return -1; },

merge: function( first, second ) { var len = +second.length, j = 0, i = first.length;

while ( j < len ) { first[ i++ ] = second[ j++ ]; }

// Support: IE<9 // Workaround casting of .length to NaN on otherwise arraylike objects (e.g., NodeLists) if ( len !== len ) { while ( second[ j ] !== undefined ) { first[ i++ ] = second[ j++ ]; }		}

first.length = i;

return first; },

grep: function( elems, callback, invert ) { var callbackInverse, matches = [], i = 0, length = elems.length, callbackExpect = !invert;

// Go through the array, only saving the items // that pass the validator function for (i < length; i++ ) { callbackInverse = !callback( elems[ i ], i ); if ( callbackInverse !== callbackExpect ) { matches.push( elems[ i ] ); }		}

return matches; },

// arg is for internal usage only map: function( elems, callback, arg ) { var length, value, i = 0, ret = [];

// Go through the array, translating each of the items to their new values if ( isArrayLike( elems ) ) { length = elems.length; for (i < length; i++ ) { value = callback( elems[ i ], i, arg );

if ( value != null ) { ret.push( value ); }			}

// Go through every key on the object, } else { for ( i in elems ) { value = callback( elems[ i ], i, arg );

if ( value != null ) { ret.push( value ); }			}		}

// Flatten any nested arrays return 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 ) { var args, proxy, tmp;

if ( typeof context === "string" ) { 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 args = slice.call( arguments, 2 ); proxy = function { return fn.apply( context || this, 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 || jQuery.guid++;

return proxy; },

now: function { return +( new Date ); },

// jQuery.support is not used in Core but other projects attach their // properties to it so it needs to exist. support: support } );

// JSHint would error on this code due to the Symbol not being defined in ES5. // Defining this global in .jshintrc would create a danger of using the global // unguarded in another place, it seems safer to just disable JSHint for these // three lines. /* jshint ignore: start */ if ( typeof Symbol === "function" ) { jQuery.fn[ Symbol.iterator ] = deletedIds[ Symbol.iterator ]; } /* jshint ignore: end */

// Populate the class2type map jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ), function( i, name ) {	class2type[ "[object " + name + "]" ] = name.toLowerCase; } );

function isArrayLike( obj ) {

// Support: iOS 8.2 (not reproducible in simulator) // `in` check used to prevent JIT error (gh-2145) // hasOwn isn't used here due to false negatives // regarding Nodelist length in IE	var length = !!obj && "length" in obj && obj.length, type = jQuery.type( obj );

if ( type === "function" || jQuery.isWindow( obj ) ) { return false; }

return type === "array" || length === 0 || typeof length === "number" && length > 0 && ( length - 1 ) in obj; } var Sizzle = /*! * Sizzle CSS Selector Engine v2.2.1 * http://sizzlejs.com/ * * Copyright jQuery Foundation and other contributors * Released under the MIT license * http://jquery.org/license * * Date: 2015-10-17 */ (function( window ) {

var i,	support, Expr, getText, isXML, tokenize, compile, select, outermostContext, sortInput, hasDuplicate,

// Local document vars setDocument, document, docElem, documentIsHTML, rbuggyQSA, rbuggyMatches, matches, contains,

// Instance-specific data expando = "sizzle" + 1 * new Date, preferredDoc = window.document, dirruns = 0, done = 0, classCache = createCache, tokenCache = createCache, compilerCache = createCache, sortOrder = function( a, b ) { if ( a === b ) { hasDuplicate = true; }		return 0; },

// General-purpose constants MAX_NEGATIVE = 1 << 31,

// Instance methods hasOwn = ({}).hasOwnProperty, arr = [], pop = arr.pop, push_native = arr.push, push = arr.push, slice = arr.slice, // Use a stripped-down indexOf as it's faster than native // http://jsperf.com/thor-indexof-vs-for/5 indexOf = function( list, elem ) { var i = 0, len = list.length; for (i < len; i++ ) { if ( list[i] === elem ) { return i;			} }		return -1; },

booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",

// Regular expressions

// http://www.w3.org/TR/css3-selectors/#whitespace whitespace = "[\\x20\\t\\r\\n\\f]",

// http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier identifier = "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+",

// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +		// Operator (capture 2)		"*([*^$|!~]?=)" + whitespace +		// "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"		"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace +		"*\\]",

pseudos = ":(" + identifier + ")(?:\\((" +		// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:		// 1. quoted (capture 3; capture 4 or capture 5)		"('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +		// 2. simple (capture 6)		"((?:\\\\.|[^\\\\[\\]]|" + attributes + ")*)|" +		// 3. anything else (capture 2)		".*" +		")\\)|)",

// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter rwhitespace = new RegExp( whitespace + "+", "g" ), rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ),

rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ), rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ),

rattributeQuotes = new RegExp( "=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g" ),

rpseudo = new RegExp( pseudos ), ridentifier = new RegExp( "^" + identifier + "$" ),

matchExpr = { "ID": new RegExp( "^#(" + identifier + ")" ), "CLASS": new RegExp( "^\\.(" + identifier + ")" ), "TAG": new RegExp( "^(" + identifier + "|[*])" ), "ATTR": new RegExp( "^" + attributes ), "PSEUDO": new RegExp( "^" + pseudos ), "CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace +			"*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace +			"*(\\d+)|))" + whitespace + "*\\)|)", "i" ), "bool": new RegExp( "^(?:" + booleans + ")$", "i" ), // For use in libraries implementing .is // We use this for POS matching in `select` "needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" +			whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" ) },

rinputs = /^(?:input|select|textarea|button)$/i, rheader = /^h\d$/i,

rnative = /^[^{]+\{\s*\[native \w/,

// Easily-parseable/retrievable ID or TAG or CLASS selectors rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,

rsibling = /[+~]/, rescape = /'|\\/g,

// CSS escapes http://www.w3.org/TR/CSS21/syndata.html#escaped-characters runescape = new RegExp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ), funescape = function( _, escaped, escapedWhitespace ) { var high = "0x" + escaped - 0x10000; // NaN means non-codepoint // Support: Firefox<24 // Workaround erroneous numeric interpretation of +"0x" return high !== high || escapedWhitespace ? escaped : high < 0 ? // BMP codepoint String.fromCharCode( high + 0x10000 ) : // Supplemental Plane codepoint (surrogate pair) String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 ); },

// Used for iframes // See setDocument // Removing the function wrapper causes a "Permission Denied" // error in IE	unloadHandler = function { setDocument; };

// Optimize for push.apply( _, NodeList ) try { push.apply(		(arr = slice.call( preferredDoc.childNodes )),		preferredDoc.childNodes	); // Support: Android<4.0 // Detect silently failing push.apply arr[ preferredDoc.childNodes.length ].nodeType; } catch ( e ) { push = { apply: arr.length ?

// Leverage slice if possible function( target, els ) { push_native.apply( target, slice.call(els) ); } :

// Support: IE<9 // Otherwise append directly function( target, els ) { var j = target.length, i = 0; // Can't trust NodeList.length while ( (target[j++] = els[i++]) ) {} target.length = j - 1; }	}; }

function Sizzle( selector, context, results, seed ) { var m, i, elem, nid, nidselect, match, groups, newSelector, newContext = context && context.ownerDocument,

// nodeType defaults to 9, since context defaults to document nodeType = context ? context.nodeType : 9;

results = results || [];

// Return early from calls with invalid selector or context if ( typeof selector !== "string" || !selector ||		nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {

return results; }

// Try to shortcut find operations (as opposed to filters) in HTML documents if ( !seed ) {

if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) { setDocument( context ); }		context = context || document;

if ( documentIsHTML ) {

// If the selector is sufficiently simple, try using a "get*By*" DOM method // (excepting DocumentFragment context, where the methods don't exist) if ( nodeType !== 11 && (match = rquickExpr.exec( selector )) ) {

// ID selector if ( (m = match[1]) ) {

// Document context if ( nodeType === 9 ) { if ( (elem = context.getElementById( m )) ) {

// Support: IE, Opera, Webkit // TODO: identify versions // getElementById can match elements by name instead of ID							if ( elem.id === m ) { results.push( elem ); return results; }						} else { return results; }

// Element context } else {

// Support: IE, Opera, Webkit // TODO: identify versions // getElementById can match elements by name instead of ID						if ( newContext && (elem = newContext.getElementById( m )) &&							contains( context, elem ) &&							elem.id === m ) {

results.push( elem ); return results; }					}

// Type selector } else if ( match[2] ) { push.apply( results, context.getElementsByTagName( selector ) ); return results;

// Class selector } else if ( (m = match[3]) && support.getElementsByClassName &&					context.getElementsByClassName ) {

push.apply( results, context.getElementsByClassName( m ) ); return results; }			}

// Take advantage of querySelectorAll if ( support.qsa &&				!compilerCache[ selector + " " ] &&				(!rbuggyQSA || !rbuggyQSA.test( selector )) ) {

if ( nodeType !== 1 ) { newContext = context; newSelector = selector;

// qSA looks outside Element context, which is not what we want // Thanks to Andrew Dupont for this workaround technique // Support: IE <=8 // Exclude object elements } else if ( context.nodeName.toLowerCase !== "object" ) {

// Capture the context ID, setting it first if necessary if ( (nid = context.getAttribute( "id" )) ) { nid = nid.replace( rescape, "\\$&" ); } else { context.setAttribute( "id", (nid = expando) ); }

// Prefix every selector in the list groups = tokenize( selector ); i = groups.length; nidselect = ridentifier.test( nid ) ? "#" + nid : "[id='" + nid + "']"; while ( i-- ) { groups[i] = nidselect + " " + toSelector( groups[i] ); }					newSelector = groups.join( "," );

// Expand context for sibling selectors newContext = rsibling.test( selector ) && testContext( context.parentNode ) || context; }

if ( newSelector ) { try { push.apply( results,							newContext.querySelectorAll( newSelector )						); return results; } catch ( qsaError ) { } finally { if ( nid === expando ) { context.removeAttribute( "id" ); }					}				}			}		}	}

// All others return select( selector.replace( rtrim, "$1" ), context, results, seed ); }

/** * Create key-value caches of limited size * @returns {function(string, object)} Returns the Object data after storing it on itself with *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength) *	deleting the oldest entry */ function createCache { var keys = [];

function cache( key, value ) { // Use (key + " ") to avoid collision with native prototype properties (see Issue #157) if ( keys.push( key + " " ) > Expr.cacheLength ) { // Only keep the most recent entries delete cache[ keys.shift ]; }		return (cache[ key + " " ] = value); }	return cache; }

/** * Mark a function for special use by Sizzle * @param {Function} fn The function to mark */ function markFunction( fn ) { fn[ expando ] = true; return fn; }

/** * Support testing using an element * @param {Function} fn Passed the created div and expects a boolean result */ function assert( fn ) { var div = document.createElement("div");

try { return !!fn( div ); } catch (e) { return false; } finally { // Remove from its parent by default if ( div.parentNode ) { div.parentNode.removeChild( div ); }		// release memory in IE		div = null; } }

/** * Adds the same handler for all of the specified attrs * @param {String} attrs Pipe-separated list of attributes * @param {Function} handler The method that will be applied */ function addHandle( attrs, handler ) { var arr = attrs.split("|"), i = arr.length;

while ( i-- ) { Expr.attrHandle[ arr[i] ] = handler; } }

/** * Checks document order of two siblings * @param {Element} a * @param {Element} b * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b */ function siblingCheck( a, b ) { var cur = b && a,		diff = cur && a.nodeType === 1 && b.nodeType === 1 && ( ~b.sourceIndex || MAX_NEGATIVE ) - ( ~a.sourceIndex || MAX_NEGATIVE );

// Use IE sourceIndex if available on both nodes if ( diff ) { return diff; }

// Check if b follows a	if ( cur ) { while ( (cur = cur.nextSibling) ) { if ( cur === b ) { return -1; }		}	}

return a ? 1 : -1; }

/** * Returns a function to use in pseudos for input types * @param {String} type */ function createInputPseudo( type ) { return function( elem ) { var name = elem.nodeName.toLowerCase; return name === "input" && elem.type === type; }; }

/** * Returns a function to use in pseudos for buttons * @param {String} type */ function createButtonPseudo( type ) { return function( elem ) { var name = elem.nodeName.toLowerCase; return (name === "input" || name === "button") && elem.type === type; }; }

/** * Returns a function to use in pseudos for positionals * @param {Function} fn */ function createPositionalPseudo( fn ) { return markFunction(function( argument ) {		argument = +argument;		return markFunction(function( seed, matches ) { var j,				matchIndexes = fn( [], seed.length, argument ), i = matchIndexes.length;

// Match elements found at the specified indexes while ( i-- ) { if ( seed[ (j = matchIndexes[i]) ] ) { seed[j] = !(matches[j] = seed[j]); }			}		});	}); }

/** * Checks a node for validity as a Sizzle context * @param {Element|Object=} context * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value */ function testContext( context ) { return context && typeof context.getElementsByTagName !== "undefined" && context; }

// Expose support vars for convenience support = Sizzle.support = {};

/** * Detects XML nodes * @param {Element|Object} elem An element or a document * @returns {Boolean} True iff elem is a non-HTML XML node */ isXML = 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).documentElement; return documentElement ? documentElement.nodeName !== "HTML" : false; };

/** * Sets document-related variables once based on the current document * @param {Element|Object} [doc] An element or document object to use to set the document * @returns {Object} Returns the current document */ setDocument = Sizzle.setDocument = function( node ) { var hasCompare, parent, doc = node ? node.ownerDocument || node : preferredDoc;

// Return early if doc is invalid or already selected if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) { return document; }

// Update global variables document = doc; docElem = document.documentElement; documentIsHTML = !isXML( document );

// Support: IE 9-11, Edge // Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936) if ( (parent = document.defaultView) && parent.top !== parent ) { // Support: IE 11 if ( parent.addEventListener ) { parent.addEventListener( "unload", unloadHandler, false );

// Support: IE 9 - 10 only } else if ( parent.attachEvent ) { parent.attachEvent( "onunload", unloadHandler ); }	}

/* Attributes -- */

// Support: IE<8 // Verify that getAttribute really returns attributes and not properties // (excepting IE8 booleans) support.attributes = assert(function( div ) {		div.className = "i";		return !div.getAttribute("className");	});

/* getElement(s)By* -- */

// Check if getElementsByTagName("*") returns only elements support.getElementsByTagName = assert(function( div ) {		div.appendChild( document.createComment("") );		return !div.getElementsByTagName("*").length;	});

// Support: IE<9 support.getElementsByClassName = rnative.test( document.getElementsByClassName );

// Support: IE<10 // Check if getElementById returns elements by name // The broken getElementById methods don't pick up programatically-set names, // so use a roundabout getElementsByName test support.getById = assert(function( div ) {		docElem.appendChild( div ).id = expando;		return !document.getElementsByName || !document.getElementsByName( expando ).length;	});

// ID find and filter if ( support.getById ) { Expr.find["ID"] = function( id, context ) { if ( typeof context.getElementById !== "undefined" && documentIsHTML ) { var m = context.getElementById( id ); return m ? [ m ] : []; }		};		Expr.filter["ID"] = function( id ) { var attrId = id.replace( runescape, funescape ); return function( elem ) { return elem.getAttribute("id") === attrId; };		};	} else { // Support: IE6/7 // getElementById is not reliable as a find shortcut delete Expr.find["ID"];

Expr.filter["ID"] = function( id ) { var attrId = id.replace( runescape, funescape ); return function( elem ) { var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id"); return node && node.value === attrId; };		};	}

// Tag Expr.find["TAG"] = support.getElementsByTagName ? function( tag, context ) { if ( typeof context.getElementsByTagName !== "undefined" ) { return context.getElementsByTagName( tag );

// DocumentFragment nodes don't have gEBTN } else if ( support.qsa ) { return context.querySelectorAll( tag ); }		} :

function( tag, context ) { var elem, tmp = [], i = 0, // By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too results = context.getElementsByTagName( tag );

// Filter out possible comments if ( tag === "*" ) { while ( (elem = results[i++]) ) { if ( elem.nodeType === 1 ) { tmp.push( elem ); }				}

return tmp; }			return results; };

// Class Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) { if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) { return context.getElementsByClassName( className ); }	};

/* QSA/matchesSelector -- */

// QSA and matchesSelector support

// matchesSelector(:active) reports false when true (IE9/Opera 11.5) rbuggyMatches = [];

// qSa(:focus) reports false when true (Chrome 21) // We allow this because of a bug in IE8/9 that throws an error // whenever `document.activeElement` is accessed on an iframe // So, we allow :focus to pass through QSA all the time to avoid the IE error // See http://bugs.jquery.com/ticket/13378 rbuggyQSA = [];

if ( (support.qsa = rnative.test( document.querySelectorAll )) ) { // Build QSA regex // Regex strategy adopted from Diego Perini assert(function( div ) {			// Select is set to empty string on purpose			// This is to test IE's treatment of not explicitly			// setting a boolean content attribute,			// since its presence should be enough			// http://bugs.jquery.com/ticket/12359			docElem.appendChild( div ).innerHTML = "" +				"" +				" ";

// Support: IE8, Opera 11-12.16 // Nothing should be selected when empty strings follow ^= or $= or *= // The test attribute must be unknown in Opera but "safe" for WinRT // http://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section if ( div.querySelectorAll("[msallowcapture^='']").length ) { rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" ); }

// Support: IE8 // Boolean attributes and "value" are not treated correctly if ( !div.querySelectorAll("[selected]").length ) { rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" ); }

// Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+ if ( !div.querySelectorAll( "[id~=" + expando + "-]" ).length ) { rbuggyQSA.push("~="); }

// Webkit/Opera - :checked should return selected option elements // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked // IE8 throws error here and will not see later tests if ( !div.querySelectorAll(":checked").length ) { rbuggyQSA.push(":checked"); }

// Support: Safari 8+, iOS 8+ // https://bugs.webkit.org/show_bug.cgi?id=136851 // In-page `selector#id sibing-combinator selector` fails if ( !div.querySelectorAll( "a#" + expando + "+*" ).length ) { rbuggyQSA.push(".#.+[+~]"); }		});

assert(function( div ) {			// Support: Windows 8 Native Apps			// The type and name attributes are restricted during .innerHTML assignment			var input = document.createElement("input");			input.setAttribute( "type", "hidden" );			div.appendChild( input ).setAttribute( "name", "D" );

// Support: IE8 // Enforce case-sensitivity of name attribute if ( div.querySelectorAll("[name=d]").length ) { rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" ); }

// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled) // IE8 throws error here and will not see later tests if ( !div.querySelectorAll(":enabled").length ) { rbuggyQSA.push( ":enabled", ":disabled" ); }

// Opera 10-11 does not throw on post-comma invalid pseudos div.querySelectorAll("*,:x"); rbuggyQSA.push(",.*:"); });	}

if ( (support.matchesSelector = rnative.test( (matches = docElem.matches || docElem.webkitMatchesSelector || docElem.mozMatchesSelector || docElem.oMatchesSelector || docElem.msMatchesSelector) )) ) {

assert(function( div ) {			// Check to see if it's possible to do matchesSelector			// on a disconnected node (IE 9)			support.disconnectedMatch = matches.call( div, "div" );

// This should fail with an exception // Gecko does not error, returns false instead matches.call( div, "[s!='']:x" ); rbuggyMatches.push( "!=", pseudos ); });	}

rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") ); rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") );

/* Contains -- */	hasCompare = rnative.test( docElem.compareDocumentPosition );

// Element contains another // Purposefully self-exclusive // As in, an element does not contain itself contains = hasCompare || rnative.test( docElem.contains ) ? function( a, b ) { var adown = a.nodeType === 9 ? a.documentElement : a,				bup = b && b.parentNode; return a === bup || !!( bup && bup.nodeType === 1 && ( adown.contains ? adown.contains( bup ) : a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16 ));		} :		function( a, b ) { if ( b ) { while ( (b = b.parentNode) ) { if ( b === a ) { return true; }				}			}			return false; };

/* Sorting -- */

// Document order sorting sortOrder = hasCompare ? function( a, b ) {

// Flag for duplicate removal if ( a === b ) { hasDuplicate = true; return 0; }

// Sort on method existence if only one input has compareDocumentPosition var compare = !a.compareDocumentPosition - !b.compareDocumentPosition; if ( compare ) { return compare; }

// Calculate position if both inputs belong to the same document compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ? a.compareDocumentPosition( b ) :

// Otherwise we know they are disconnected 1;

// Disconnected nodes if ( compare & 1 ||			(!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {

// Choose the first element that is related to our preferred document if ( a === document || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) { return -1; }			if ( b === document || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) { return 1; }

// Maintain original order return sortInput ? ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) : 0;		}

return compare & 4 ? -1 : 1;	} :	function( a, b ) { // Exit early if the nodes are identical if ( a === b ) { hasDuplicate = true; return 0; }

var cur, i = 0, aup = a.parentNode, bup = b.parentNode, ap = [ a ], bp = [ b ];

// Parentless nodes are either documents or disconnected if ( !aup || !bup ) { return a === document ? -1 :				b === document ? 1 :				aup ? -1 :				bup ? 1 :				sortInput ? ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) : 0;

// If the nodes are siblings, we can do a quick check } else if ( aup === bup ) { return siblingCheck( a, b ); }

// Otherwise we need full lists of their ancestors for comparison cur = a;		while ( (cur = cur.parentNode) ) { ap.unshift( cur ); }		cur = b;		while ( (cur = cur.parentNode) ) { bp.unshift( cur ); }

// Walk down the tree looking for a discrepancy while ( ap[i] === bp[i] ) { i++; }

return i ? // Do a sibling check if the nodes have a common ancestor siblingCheck( ap[i], bp[i] ) :

// Otherwise nodes in our document sort first ap[i] === preferredDoc ? -1 :			bp[i] === preferredDoc ? 1 :			0;	};

return document; };

Sizzle.matches = function( expr, elements ) { return Sizzle( expr, null, null, elements ); };

Sizzle.matchesSelector = function( elem, expr ) { // Set document vars if needed if ( ( elem.ownerDocument || elem ) !== document ) { setDocument( elem ); }

// Make sure that attribute selectors are quoted expr = expr.replace( rattributeQuotes, "='$1']" );

if ( support.matchesSelector && documentIsHTML &&		!compilerCache[ expr + " " ] &&		( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&		( !rbuggyQSA    || !rbuggyQSA.test( expr ) ) ) {

try { var ret = matches.call( elem, expr );

// IE 9's matchesSelector returns false on disconnected nodes if ( ret || support.disconnectedMatch ||					// As well, disconnected nodes are said to be in a document					// fragment in IE 9					elem.document && elem.document.nodeType !== 11 ) { return ret; }		} catch (e) {} }

return Sizzle( expr, document, null, [ elem ] ).length > 0; };

Sizzle.contains = function( context, elem ) { // Set document vars if needed if ( ( context.ownerDocument || context ) !== document ) { setDocument( context ); }	return contains( context, elem ); };

Sizzle.attr = function( elem, name ) { // Set document vars if needed if ( ( elem.ownerDocument || elem ) !== document ) { setDocument( elem ); }

var fn = Expr.attrHandle[ name.toLowerCase ], // Don't get fooled by Object.prototype properties (jQuery #13807) val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase ) ? fn( elem, name, !documentIsHTML ) : undefined;

return val !== undefined ? val : support.attributes || !documentIsHTML ? elem.getAttribute( name ) : (val = elem.getAttributeNode(name)) && val.specified ? val.value : null; };

Sizzle.error = function( msg ) { throw new Error( "Syntax error, unrecognized expression: " + msg ); };

/** * Document sorting and removing duplicates * @param {ArrayLike} results */ Sizzle.uniqueSort = function( results ) { var elem, duplicates = [], j = 0, i = 0;

// Unless we *know* we can detect duplicates, assume their presence hasDuplicate = !support.detectDuplicates; sortInput = !support.sortStable && results.slice( 0 ); results.sort( sortOrder );

if ( hasDuplicate ) { while ( (elem = results[i++]) ) { if ( elem === results[ i ] ) { j = duplicates.push( i ); }		}		while ( j-- ) { results.splice( duplicates[ j ], 1 ); }	}

// Clear input after sorting to release objects // See https://github.com/jquery/sizzle/pull/225 sortInput = null;

return results; };

/** * Utility function for retrieving the text value of an array of DOM nodes * @param {Array|Element} elem */ getText = Sizzle.getText = function( elem ) { var node, ret = "", i = 0, nodeType = elem.nodeType;

if ( !nodeType ) { // If no nodeType, this is expected to be an array while ( (node = elem[i++]) ) { // Do not traverse comment nodes ret += getText( node ); }	} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) { // Use textContent for elements // innerText usage removed for consistency of new lines (jQuery #11153) if ( typeof elem.textContent === "string" ) { return elem.textContent; } else { // Traverse its children for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) { ret += getText( elem ); }		}	} else if ( nodeType === 3 || nodeType === 4 ) { return elem.nodeValue; }	// Do not include comment or processing instruction nodes

return ret; };

Expr = Sizzle.selectors = {

// Can be adjusted by the user cacheLength: 50,

createPseudo: markFunction,

match: matchExpr,

attrHandle: {},

find: {},

relative: { ">": { dir: "parentNode", first: true }, " ": { dir: "parentNode" }, "+": { dir: "previousSibling", first: true }, "~": { dir: "previousSibling" } },

preFilter: { "ATTR": function( match ) { match[1] = match[1].replace( runescape, funescape );

// Move the given value to match[3] whether quoted or unquoted match[3] = ( match[3] || match[4] || match[5] || "" ).replace( runescape, funescape );

if ( match[2] === "~=" ) { match[3] = " " + match[3] + " "; }

return match.slice( 0, 4 ); },

"CHILD": function( match ) { /* matches from matchExpr["CHILD"] 1 type (only|nth|...) 2 what (child|of-type) 3 argument (even|odd|\d*|\d*n([+-]\d+)?|...) 4 xn-component of xn+y argument ([+-]?\d*n|) 5 sign of xn-component 6 x of xn-component 7 sign of y-component 8 y of y-component */			match[1] = match[1].toLowerCase;

if ( match[1].slice( 0, 3 ) === "nth" ) { // nth-* requires argument if ( !match[3] ) { Sizzle.error( match[0] ); }

// numeric x and y parameters for Expr.filter.CHILD // remember that false/true cast respectively to 0/1 match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) ); match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" );

// other types prohibit arguments } else if ( match[3] ) { Sizzle.error( match[0] ); }

return match; },

"PSEUDO": function( match ) { var excess, unquoted = !match[6] && match[2];

if ( matchExpr["CHILD"].test( match[0] ) ) { return null; }

// Accept quoted arguments as-is if ( match[3] ) { match[2] = match[4] || match[5] || "";

// Strip excess characters from unquoted arguments } else if ( unquoted && rpseudo.test( unquoted ) &&				// Get excess from tokenize (recursively)				(excess = tokenize( unquoted, true )) &&				// advance to the next closing parenthesis				(excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) {

// excess is a negative index match[0] = match[0].slice( 0, excess ); match[2] = unquoted.slice( 0, excess ); }

// Return only captures needed by the pseudo filter method (type and argument) return match.slice( 0, 3 ); }	},

filter: {

"TAG": function( nodeNameSelector ) { var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase; return nodeNameSelector === "*" ? function { return true; } : function( elem ) { return elem.nodeName && elem.nodeName.toLowerCase === nodeName; };		},

"CLASS": function( className ) { var pattern = classCache[ className + " " ];

return pattern || (pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) && classCache( className, function( elem ) {					return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "" );				}); },

"ATTR": function( name, operator, check ) { return function( elem ) { var result = Sizzle.attr( elem, name );

if ( result == null ) { return operator === "!="; }				if ( !operator ) { return true; }

result += "";

return operator === "=" ? result === check : operator === "!=" ? result !== check : operator === "^=" ? check && result.indexOf( check ) === 0 : operator === "*=" ? check && result.indexOf( check ) > -1 : operator === "$=" ? check && result.slice( -check.length ) === check : operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 : operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" : false; };		},

"CHILD": function( type, what, argument, first, last ) { var simple = type.slice( 0, 3 ) !== "nth", forward = type.slice( -4 ) !== "last", ofType = what === "of-type";

return first === 1 && last === 0 ?

// Shortcut for :nth-*(n) function( elem ) { return !!elem.parentNode; } :

function( elem, context, xml ) { var cache, uniqueCache, outerCache, node, nodeIndex, start, dir = simple !== forward ? "nextSibling" : "previousSibling", parent = elem.parentNode, name = ofType && elem.nodeName.toLowerCase, useCache = !xml && !ofType, diff = false;

if ( parent ) {

// :(first|last|only)-(child|of-type) if ( simple ) { while ( dir ) { node = elem; while ( (node = node[ dir ]) ) { if ( ofType ?										node.nodeName.toLowerCase === name :										node.nodeType === 1 ) {

return false; }								}								// Reverse direction for :only-* (if we haven't yet done so) start = dir = type === "only" && !start && "nextSibling"; }							return true; }

start = [ forward ? parent.firstChild : parent.lastChild ];

// non-xml :nth-child(...) stores cache data on `parent` if ( forward && useCache ) {

// Seek `elem` from a previously-cached index

// ...in a gzip-friendly way node = parent; outerCache = node[ expando ] || (node[ expando ] = {});

// Support: IE <9 only // Defend against cloned attroperties (jQuery gh-1709) uniqueCache = outerCache[ node.uniqueID ] || (outerCache[ node.uniqueID ] = {});

cache = uniqueCache[ type ] || []; nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ]; diff = nodeIndex && cache[ 2 ]; node = nodeIndex && parent.childNodes[ nodeIndex ];

while ( (node = ++nodeIndex && node && node[ dir ] ||

// Fallback to seeking `elem` from the start (diff = nodeIndex = 0) || start.pop) ) {

// When found, cache indexes on `parent` and break if ( node.nodeType === 1 && ++diff && node === elem ) { uniqueCache[ type ] = [ dirruns, nodeIndex, diff ]; break; }							}

} else { // Use previously-cached element index if available if ( useCache ) { // ...in a gzip-friendly way node = elem; outerCache = node[ expando ] || (node[ expando ] = {});

// Support: IE <9 only // Defend against cloned attroperties (jQuery gh-1709) uniqueCache = outerCache[ node.uniqueID ] || (outerCache[ node.uniqueID ] = {});

cache = uniqueCache[ type ] || []; nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ]; diff = nodeIndex; }

// xml :nth-child(...) // or :nth-last-child(...) or :nth(-last)?-of-type(...) if ( diff === false ) { // Use the same loop as above to seek `elem` from the start while ( (node = ++nodeIndex && node && node[ dir ] || (diff = nodeIndex = 0) || start.pop) ) {

if ( ( ofType ? node.nodeName.toLowerCase === name : node.nodeType === 1 ) &&										++diff ) {

// Cache the index of each encountered element if ( useCache ) { outerCache = node[ expando ] || (node[ expando ] = {});

// Support: IE <9 only // Defend against cloned attroperties (jQuery gh-1709) uniqueCache = outerCache[ node.uniqueID ] || (outerCache[ node.uniqueID ] = {});

uniqueCache[ type ] = [ dirruns, diff ]; }

if ( node === elem ) { break; }									}								}							}						}

// Incorporate the offset, then check against cycle size diff -= last; return diff === first || ( diff % first === 0 && diff / first >= 0 ); }				};		},

"PSEUDO": function( pseudo, argument ) { // pseudo-class names are case-insensitive // http://www.w3.org/TR/selectors/#pseudo-classes // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters // Remember that setFilters inherits from pseudos var args, fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase ] || Sizzle.error( "unsupported pseudo: " + pseudo );

// The user may use createPseudo to indicate that // arguments are needed to create the filter function // just as Sizzle does if ( fn[ expando ] ) { return fn( argument ); }

// But maintain support for old signatures if ( fn.length > 1 ) { args = [ pseudo, pseudo, "", argument ]; return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase ) ? markFunction(function( seed, matches ) {						var idx,							matched = fn( seed, argument ),							i = matched.length;						while ( i-- ) {							idx = indexOf( seed, matched[i] );							seed[ idx ] = !( matches[ idx ] = matched[i] );						}					}) : function( elem ) { return fn( elem, 0, args ); };			}

return fn; }	},

pseudos: { // Potentially complex pseudos "not": markFunction(function( selector ) {			// Trim the selector passed to compile			// to avoid treating leading and trailing			// spaces as combinators			var input = [],				results = [],				matcher = compile( selector.replace( rtrim, "$1" ) );

return matcher[ expando ] ? markFunction(function( seed, matches, context, xml ) {					var elem,						unmatched = matcher( seed, null, xml, [] ),						i = seed.length;

// Match elements unmatched by `matcher` while ( i-- ) { if ( (elem = unmatched[i]) ) { seed[i] = !(matches[i] = elem); }					}				}) :				function( elem, context, xml ) {					input[0] = elem;					matcher( input, null, xml, results );					// Don't keep the element (issue #299)					input[0] = null;					return !results.pop;				};		}),

"has": markFunction(function( selector ) {			return function( elem ) {				return Sizzle( selector, elem ).length > 0;			};		}),

"contains": markFunction(function( text ) {			text = text.replace( runescape, funescape );			return function( elem ) {				return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1;			};		}),

// "Whether an element is represented by a :lang selector		// is based solely on the element's language value		// being equal to the identifier C,		// or beginning with the identifier C immediately followed by "-".		// The matching of C against the element's language value is performed case-insensitively.		// The identifier C does not have to be a valid language name." // http://www.w3.org/TR/selectors/#lang-pseudo "lang": markFunction( function( lang ) {			// lang value must be a valid identifier			if ( !ridentifier.test(lang || "") ) {				Sizzle.error( "unsupported lang: " + lang );			}			lang = lang.replace( runescape, funescape ).toLowerCase;			return function( elem ) {				var elemLang;				do {					if ( (elemLang = documentIsHTML ?						elem.lang :						elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) {

elemLang = elemLang.toLowerCase; return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0; }				} while ( (elem = elem.parentNode) && elem.nodeType === 1 ); return false; };		}),

// Miscellaneous "target": function( elem ) { var hash = window.location && window.location.hash; return hash && hash.slice( 1 ) === elem.id; },

"root": function( elem ) { return elem === docElem; },

"focus": function( elem ) { return elem === document.activeElement && (!document.hasFocus || document.hasFocus) && !!(elem.type || elem.href || ~elem.tabIndex); },

// Boolean properties "enabled": function( elem ) { return elem.disabled === false; },

"disabled": function( elem ) { return elem.disabled === true; },

"checked": function( elem ) { // In CSS3, :checked should return both checked and selected elements // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked var nodeName = elem.nodeName.toLowerCase; return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected); },

"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; },

// Contents "empty": function( elem ) { // http://www.w3.org/TR/selectors/#empty-pseudo // :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5), //  but not by others (comment: 8; processing instruction: 7; etc.) // nodeType < 6 works because attributes (2) do not appear as children for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) { if ( elem.nodeType < 6 ) { return false; }			}			return true; },

"parent": function( elem ) { return !Expr.pseudos["empty"]( elem ); },

// Element/input types "header": function( elem ) { return rheader.test( elem.nodeName ); },

"input": function( elem ) { return rinputs.test( elem.nodeName ); },

"button": function( elem ) { var name = elem.nodeName.toLowerCase; return name === "input" && elem.type === "button" || name === "button"; },

"text": function( elem ) { var attr; return elem.nodeName.toLowerCase === "input" && elem.type === "text" &&

// Support: IE<8 // New HTML5 attribute values (e.g., "search") appear with elem.type === "text" ( (attr = elem.getAttribute("type")) == null || attr.toLowerCase === "text" ); },

// Position-in-collection "first": createPositionalPseudo(function {			return [ 0 ];		}),

"last": createPositionalPseudo(function( matchIndexes, length ) {			return [ length - 1 ];		}),

"eq": createPositionalPseudo(function( matchIndexes, length, argument ) {			return [ argument < 0 ? argument + length : argument ];		}),

"even": createPositionalPseudo(function( matchIndexes, length ) {			var i = 0;			for (i < length; i += 2 ) {				matchIndexes.push( i );			}			return matchIndexes;		}),

"odd": createPositionalPseudo(function( matchIndexes, length ) {			var i = 1;			for (i < length; i += 2 ) {				matchIndexes.push( i );			}			return matchIndexes;		}),

"lt": createPositionalPseudo(function( matchIndexes, length, argument ) {			var i = argument < 0 ? argument + length : argument;			for (--i >= 0; ) {				matchIndexes.push( i );			}			return matchIndexes;		}),

"gt": createPositionalPseudo(function( matchIndexes, length, argument ) {			var i = argument < 0 ? argument + length : argument;			for (++i < length; ) {				matchIndexes.push( i );			}			return matchIndexes;		}) } };

Expr.pseudos["nth"] = Expr.pseudos["eq"];

// Add button/input type pseudos for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) { Expr.pseudos[ i ] = createInputPseudo( i ); } for ( i in { submit: true, reset: true } ) { Expr.pseudos[ i ] = createButtonPseudo( i ); }

// Easy API for creating new setFilters function setFilters {} setFilters.prototype = Expr.filters = Expr.pseudos; Expr.setFilters = new setFilters;

tokenize = Sizzle.tokenize = function( selector, parseOnly ) { var matched, match, tokens, type, soFar, groups, preFilters, cached = tokenCache[ selector + " " ];

if ( cached ) { return parseOnly ? 0 : cached.slice( 0 ); }

soFar = selector; groups = []; preFilters = Expr.preFilter;

while ( soFar ) {

// Comma and first run if ( !matched || (match = rcomma.exec( soFar )) ) { if ( match ) { // Don't consume trailing commas as valid soFar = soFar.slice( match[0].length ) || soFar; }			groups.push( (tokens = []) ); }

matched = false;

// Combinators if ( (match = rcombinators.exec( soFar )) ) { matched = match.shift; tokens.push({				value: matched,				// Cast descendant combinators to space				type: match[0].replace( rtrim, " " )			}); soFar = soFar.slice( matched.length ); }

// Filters for ( type in Expr.filter ) { if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] || (match = preFilters[ type ]( match ))) ) { matched = match.shift; tokens.push({					value: matched,					type: type,					matches: match				}); soFar = soFar.slice( matched.length ); }		}

if ( !matched ) { break; }	}

// Return the length of the invalid excess // if we're just parsing // Otherwise, throw an error or return tokens return parseOnly ? soFar.length : soFar ? Sizzle.error( selector ) : // Cache the tokens tokenCache( selector, groups ).slice( 0 ); };

function toSelector( tokens ) { var i = 0, len = tokens.length, selector = ""; for (i < len; i++ ) { selector += tokens[i].value; }	return selector; }

function addCombinator( matcher, combinator, base ) { var dir = combinator.dir, checkNonElements = base && dir === "parentNode", doneName = done++;

return combinator.first ? // Check against closest ancestor/preceding element function( elem, context, xml ) { while ( (elem = elem[ dir ]) ) { if ( elem.nodeType === 1 || checkNonElements ) { return matcher( elem, context, xml ); }			}		} :

// Check against all ancestor/preceding elements function( elem, context, xml ) { var oldCache, uniqueCache, outerCache, newCache = [ dirruns, doneName ];

// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching if ( xml ) { while ( (elem = elem[ dir ]) ) { if ( elem.nodeType === 1 || checkNonElements ) { if ( matcher( elem, context, xml ) ) { return true; }					}				}			} else { while ( (elem = elem[ dir ]) ) { if ( elem.nodeType === 1 || checkNonElements ) { outerCache = elem[ expando ] || (elem[ expando ] = {});

// Support: IE <9 only // Defend against cloned attroperties (jQuery gh-1709) uniqueCache = outerCache[ elem.uniqueID ] || (outerCache[ elem.uniqueID ] = {});

if ( (oldCache = uniqueCache[ dir ]) &&							oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {

// Assign to newCache so results back-propagate to previous elements return (newCache[ 2 ] = oldCache[ 2 ]); } else { // Reuse newcache so results back-propagate to previous elements uniqueCache[ dir ] = newCache;

// A match means we're done; a fail means we have to keep checking if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) { return true; }						}					}				}			}		}; }

function elementMatcher( matchers ) { return matchers.length > 1 ? function( elem, context, xml ) { var i = matchers.length; while ( i-- ) { if ( !matchers[i]( elem, context, xml ) ) { return false; }			}			return true; } :		matchers[0]; }

function multipleContexts( selector, contexts, results ) { var i = 0, len = contexts.length; for (i < len; i++ ) { Sizzle( selector, contexts[i], results ); }	return results; }

function condense( unmatched, map, filter, context, xml ) { var elem, newUnmatched = [], i = 0, len = unmatched.length, mapped = map != null;

for (i < len; i++ ) { if ( (elem = unmatched[i]) ) { if ( !filter || filter( elem, context, xml ) ) { newUnmatched.push( elem ); if ( mapped ) { map.push( i ); }			}		}	}

return newUnmatched; }

function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) { if ( postFilter && !postFilter[ expando ] ) { postFilter = setMatcher( postFilter ); }	if ( postFinder && !postFinder[ expando ] ) { postFinder = setMatcher( postFinder, postSelector ); }	return markFunction(function( seed, results, context, xml ) {		var temp, i, elem,			preMap = [],			postMap = [],			preexisting = results.length,

// Get initial elements from seed or context elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ),

// Prefilter to get matcher input, preserving a map for seed-results synchronization matcherIn = preFilter && ( seed || !selector ) ? condense( elems, preMap, preFilter, context, xml ) : elems,

matcherOut = matcher ? // If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results, postFinder || ( seed ? preFilter : preexisting || postFilter ) ?

// ...intermediate processing is necessary [] :

// ...otherwise use results directly results : matcherIn;

// Find primary matches if ( matcher ) { matcher( matcherIn, matcherOut, context, xml ); }

// Apply postFilter if ( postFilter ) { temp = condense( matcherOut, postMap ); postFilter( temp, [], context, xml );

// Un-match failing elements by moving them back to matcherIn i = temp.length; while ( i-- ) { if ( (elem = temp[i]) ) { matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem); }			}		}

if ( seed ) { if ( postFinder || preFilter ) { if ( postFinder ) { // Get the final matcherOut by condensing this intermediate into postFinder contexts temp = []; i = matcherOut.length; while ( i-- ) { if ( (elem = matcherOut[i]) ) { // Restore matcherIn since elem is not yet a final match temp.push( (matcherIn[i] = elem) ); }					}					postFinder( null, (matcherOut = []), temp, xml ); }

// Move matched elements from seed to results to keep them synchronized i = matcherOut.length; while ( i-- ) { if ( (elem = matcherOut[i]) &&						(temp = postFinder ? indexOf( seed, elem ) : preMap[i]) > -1 ) {

seed[temp] = !(results[temp] = elem); }				}			}

// Add elements to results, through postFinder if defined } else { matcherOut = condense(				matcherOut === results ?					matcherOut.splice( preexisting, matcherOut.length ) :					matcherOut			); if ( postFinder ) { postFinder( null, results, matcherOut, xml ); } else { push.apply( results, matcherOut ); }		}	}); }

function matcherFromTokens( tokens ) { var checkContext, matcher, j,		len = tokens.length, leadingRelative = Expr.relative[ tokens[0].type ], implicitRelative = leadingRelative || Expr.relative[" "], i = leadingRelative ? 1 : 0,

// The foundational matcher ensures that elements are reachable from top-level context(s) matchContext = addCombinator( function( elem ) {			return elem === checkContext;		}, implicitRelative, true ), matchAnyContext = addCombinator( function( elem ) {			return indexOf( checkContext, elem ) > -1;		}, implicitRelative, true ), matchers = [ function( elem, context, xml ) { var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (				(checkContext = context).nodeType ?					matchContext( elem, context, xml ) :					matchAnyContext( elem, context, xml ) ); // Avoid hanging onto element (issue #299) checkContext = null; return ret; } ];

for (i < len; i++ ) { if ( (matcher = Expr.relative[ tokens[i].type ]) ) { matchers = [ addCombinator(elementMatcher( matchers ), matcher) ]; } else { matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );

// Return special upon seeing a positional matcher if ( matcher[ expando ] ) { // Find the next relative operator (if any) for proper handling j = ++i; for (j < len; j++ ) { if ( Expr.relative[ tokens[j].type ] ) { break; }				}				return setMatcher(					i > 1 && elementMatcher( matchers ),					i > 1 && toSelector( // If the preceding token was a descendant combinator, insert an implicit any-element `*` tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" }) ).replace( rtrim, "$1" ),					matcher,					i < j && matcherFromTokens( tokens.slice( i, j ) ),					j < len && matcherFromTokens( (tokens = tokens.slice( j )) ),					j < len && toSelector( tokens )				); }			matchers.push( matcher ); }	}

return elementMatcher( matchers ); }

function matcherFromGroupMatchers( elementMatchers, setMatchers ) { var bySet = setMatchers.length > 0, byElement = elementMatchers.length > 0, superMatcher = function( seed, context, xml, results, outermost ) { var elem, j, matcher, matchedCount = 0, i = "0", unmatched = seed && [], setMatched = [], contextBackup = outermostContext, // We must always have either seed elements or outermost context elems = seed || byElement && Expr.find["TAG"]( "*", outermost ), // Use integer dirruns iff this is the outermost matcher dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random || 0.1), len = elems.length;

if ( outermost ) { outermostContext = context === document || context || outermost; }

// Add elements passing elementMatchers directly to results // Support: IE<9, Safari // Tolerate NodeList properties (IE: "length"; Safari: ) matching elements by id			for (i !== len && (elem = elems[i]) != null; i++ ) { if ( byElement && elem ) { j = 0; if ( !context && elem.ownerDocument !== document ) { setDocument( elem ); xml = !documentIsHTML; }					while ( (matcher = elementMatchers[j++]) ) { if ( matcher( elem, context || document, xml) ) { results.push( elem ); break; }					}					if ( outermost ) { dirruns = dirrunsUnique; }				}

// Track unmatched elements for set filters if ( bySet ) { // They will have gone through all possible matchers if ( (elem = !matcher && elem) ) { matchedCount--; }

// Lengthen the array for every element, matched or not if ( seed ) { unmatched.push( elem ); }				}			}

// `i` is now the count of elements visited above, and adding it to `matchedCount` // makes the latter nonnegative. matchedCount += i;

// Apply set filters to unmatched elements // NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`			// equals `i`), unless we didn't visit _any_ elements in the above loop because we have // no element matchers and no seed. // Incrementing an initially-string "0" `i` allows `i` to remain a string only in that // case, which will result in a "00" `matchedCount` that differs from `i` but is also // numerically zero. if ( bySet && i !== matchedCount ) { j = 0; while ( (matcher = setMatchers[j++]) ) { matcher( unmatched, setMatched, context, xml ); }

if ( seed ) { // Reintegrate element matches to eliminate the need for sorting if ( matchedCount > 0 ) { while ( i-- ) { if ( !(unmatched[i] || setMatched[i]) ) { setMatched[i] = pop.call( results ); }						}					}

// Discard index placeholder values to get only actual matches setMatched = condense( setMatched ); }

// Add matches to results push.apply( results, setMatched );

// Seedless set matches succeeding multiple successful matchers stipulate sorting if ( outermost && !seed && setMatched.length > 0 &&					( matchedCount + setMatchers.length ) > 1 ) {

Sizzle.uniqueSort( results ); }			}

// Override manipulation of globals by nested matchers if ( outermost ) { dirruns = dirrunsUnique; outermostContext = contextBackup; }

return unmatched; };

return bySet ? markFunction( superMatcher ) : superMatcher; }

compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) { var i,		setMatchers = [], elementMatchers = [], cached = compilerCache[ selector + " " ];

if ( !cached ) { // Generate a function of recursive functions that can be used to check each element if ( !match ) { match = tokenize( selector ); }		i = match.length; while ( i-- ) { cached = matcherFromTokens( match[i] ); if ( cached[ expando ] ) { setMatchers.push( cached ); } else { elementMatchers.push( cached ); }		}

// Cache the compiled function cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );

// Save selector and tokenization cached.selector = selector; }	return cached; };

/** * A low-level selection function that works with Sizzle's compiled * selector functions * @param {String|Function} selector A selector or a pre-compiled * selector function built with Sizzle.compile * @param {Element} context * @param {Array} [results] * @param {Array} [seed] A set of elements to match against */ select = Sizzle.select = function( selector, context, results, seed ) { var i, tokens, token, type, find, compiled = typeof selector === "function" && selector, match = !seed && tokenize( (selector = compiled.selector || selector) );

results = results || [];

// Try to minimize operations if there is only one selector in the list and no seed // (the latter of which guarantees us context) if ( match.length === 1 ) {

// Reduce context if the leading compound selector is an ID		tokens = match[0] = match[0].slice( 0 ); if ( tokens.length > 2 && (token = tokens[0]).type === "ID" &&				support.getById && context.nodeType === 9 && documentIsHTML &&				Expr.relative[ tokens[1].type ] ) {

context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0]; if ( !context ) { return results;

// Precompiled matchers will still verify ancestry, so step up a level } else if ( compiled ) { context = context.parentNode; }

selector = selector.slice( tokens.shift.value.length ); }

// Fetch a seed set for right-to-left matching i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length; while ( i-- ) { token = tokens[i];

// Abort if we hit a combinator if ( Expr.relative[ (type = token.type) ] ) { break; }			if ( (find = Expr.find[ type ]) ) { // Search, expanding context for leading sibling combinators if ( (seed = find(					token.matches[0].replace( runescape, funescape ),					rsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context				)) ) {

// If seed is empty or no tokens remain, we can return early tokens.splice( i, 1 ); selector = seed.length && toSelector( tokens ); if ( !selector ) { push.apply( results, seed ); return results; }

break; }			}		}	}

// Compile and execute a filtering function if one is not provided // Provide `match` to avoid retokenization if we modified the selector above ( compiled || compile( selector, match ) )(		seed,		context,		!documentIsHTML,		results,		!context || rsibling.test( selector ) && testContext( context.parentNode ) || context	); return results; };

// One-time assignments

// Sort stability support.sortStable = expando.split("").sort( sortOrder ).join("") === expando;

// Support: Chrome 14-35+ // Always assume duplicates if they aren't passed to the comparison function support.detectDuplicates = !!hasDuplicate;

// Initialize against the default document setDocument;

// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27) // Detached nodes confoundingly follow *each other* support.sortDetached = assert(function( div1 ) {	// Should return 1, but returns 4 (following)	return div1.compareDocumentPosition( document.createElement("div") ) & 1; });

// Support: IE<8 // Prevent attribute/property "interpolation" // http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx if ( !assert(function( div ) { div.innerHTML = ""; return div.firstChild.getAttribute("href") === "#" ; }) ) {	addHandle( "type|href|height|width", function( elem, name, isXML ) {		if ( !isXML ) {			return elem.getAttribute( name, name.toLowerCase === "type" ? 1 : 2 );		}	}); }

// Support: IE<9 // Use defaultValue in place of getAttribute("value") if ( !support.attributes || !assert(function( div ) { div.innerHTML = " "; div.firstChild.setAttribute( "value", "" ); return div.firstChild.getAttribute( "value" ) === ""; }) ) {	addHandle( "value", function( elem, name, isXML ) {		if ( !isXML && elem.nodeName.toLowerCase === "input" ) {			return elem.defaultValue;		}	}); }

// Support: IE<9 // Use getAttributeNode to fetch booleans when getAttribute lies if ( !assert(function( div ) { return div.getAttribute("disabled") == null; }) ) {	addHandle( booleans, function( elem, name, isXML ) {		var val;		if ( !isXML ) {			return elem[ name ] === true ? name.toLowerCase :					(val = elem.getAttributeNode( name )) && val.specified ?					val.value :				null;		}	}); }

return Sizzle;

})( window );

jQuery.find = Sizzle; jQuery.expr = Sizzle.selectors; jQuery.expr[ ":" ] = jQuery.expr.pseudos; jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort; jQuery.text = Sizzle.getText; jQuery.isXMLDoc = Sizzle.isXML; jQuery.contains = Sizzle.contains;

var dir = function( elem, dir, until ) { var matched = [], truncate = until !== undefined;

while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) { if ( elem.nodeType === 1 ) { if ( truncate && jQuery( elem ).is( until ) ) { break; }			matched.push( elem ); }	}	return matched; };

var siblings = function( n, elem ) { var matched = [];

for (n; n = n.nextSibling ) { if ( n.nodeType === 1 && n !== elem ) { matched.push( n ); }	}

return matched; };

var rneedsContext = jQuery.expr.match.needsContext;

var rsingleTag = ( /^<([\w-]+)\s*\/?>(?:<\/\1>|)$/ );

var risSimple = /^.[^:#\[\.,]*$/;

// Implement the identical functionality for filter and not function winnow( elements, qualifier, not ) { if ( jQuery.isFunction( qualifier ) ) { return jQuery.grep( elements, function( elem, i ) {			/* jshint -W018 */			return !!qualifier.call( elem, i, elem ) !== not;		} );

}

if ( qualifier.nodeType ) { return jQuery.grep( elements, function( elem ) {			return ( elem === qualifier ) !== not;		} );

}

if ( typeof qualifier === "string" ) { if ( risSimple.test( qualifier ) ) { return jQuery.filter( qualifier, elements, not ); }

qualifier = jQuery.filter( qualifier, elements ); }

return jQuery.grep( elements, function( elem ) {		return ( jQuery.inArray( elem, qualifier ) > -1 ) !== not;	} ); }

jQuery.filter = function( expr, elems, not ) { var elem = elems[ 0 ];

if ( not ) { expr = ":not(" + expr + ")"; }

return elems.length === 1 && elem.nodeType === 1 ? jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [] : jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) { return elem.nodeType === 1; } ) ); };

jQuery.fn.extend( {	find: function( selector ) {		var i,			ret = [],			self = this,			len = self.length;

if ( typeof selector !== "string" ) { return this.pushStack( jQuery( selector ).filter( function { for ( i = 0; i < len; i++ ) { if ( jQuery.contains( self[ i ], this ) ) { return true; }				}			} ) );		}

for ( i = 0; i < len; i++ ) { jQuery.find( selector, self[ i ], ret ); }

// Needed because $( selector, context ) becomes $( context ).find( selector ) ret = this.pushStack( len > 1 ? jQuery.unique( ret ) : ret ); ret.selector = this.selector ? this.selector + " " + selector : selector; return ret; },	filter: function( selector ) { return this.pushStack( winnow( this, selector || [], false ) ); },	not: function( selector ) { return this.pushStack( winnow( this, selector || [], true ) ); },	is: function( selector ) { return !!winnow(			this,

// If this is a positional/relative selector, check membership in the returned set // so $("p:first").is("p:last") won't return true for a doc with two "p". typeof selector === "string" && rneedsContext.test( selector ) ? jQuery( selector ) : selector || [], false ).length;	} } );

// Initialize a jQuery object

// A central reference to the root jQuery(document) var rootjQuery,

// A simple way to check for HTML strings // Prioritize #id over to avoid XSS via location.hash (#9521) // Strict HTML recognition (#11290: must start with <) rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]*))$/,

init = jQuery.fn.init = function( selector, context, root ) { var match, elem;

// HANDLE: $(""), $(null), $(undefined), $(false) if ( !selector ) { return this; }

// init accepts an alternate rootjQuery // so migrate can support jQuery.sub (gh-2101) root = root || rootjQuery;

// Handle HTML strings if ( typeof selector === "string" ) { 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 = rquickExpr.exec( selector ); }

// Match html or make sure no context is specified for #id if ( match && ( match[ 1 ] || !context ) ) {

// HANDLE: $(html) -> $(array) if ( match[ 1 ] ) { context = context instanceof jQuery ? context[ 0 ] : context;

// scripts is true for back-compat // Intentionally let the error be thrown if parseHTML is not present jQuery.merge( this, jQuery.parseHTML( match[ 1 ], context && context.nodeType ? context.ownerDocument || context : document, true ) );

// HANDLE: $(html, props) if ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) { for ( match in context ) {

// Properties of context are called as methods if possible if ( jQuery.isFunction( this[ match ] ) ) { this[ match ]( context[ match ] );

// ...and otherwise set as attributes } else { this.attr( match, context[ match ] ); }						}					}

return this;

// 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 || root ).find( selector );

// HANDLE: $(expr, context) // (which is just equivalent to: $(context).find(expr)			} else {				return this.constructor( context ).find( selector );			}

// HANDLE: $(DOMElement) } else if ( selector.nodeType ) { this.context = this[ 0 ] = selector; this.length = 1; return this;

// HANDLE: $(function) // Shortcut for document ready } else if ( jQuery.isFunction( selector ) ) { return typeof root.ready !== "undefined" ? root.ready( selector ) :

// Execute immediately if ready is not present selector( jQuery ); }

if ( selector.selector !== undefined ) { this.selector = selector.selector; this.context = selector.context; }

return jQuery.makeArray( selector, this ); };

// Give the init function the jQuery prototype for later instantiation init.prototype = jQuery.fn;

// Initialize central reference rootjQuery = jQuery( document );

var rparentsprev = /^(?:parents|prev(?:Until|All))/,

// 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( {	has: function( target ) {		var i,			targets = jQuery( target, this ),			len = targets.length;

return this.filter( function {			for ( i = 0; i < len; i++ ) {				if ( jQuery.contains( this, targets[ i ] ) ) {					return true;				}			}		} ); },

closest: function( selectors, context ) { var cur, i = 0, l = this.length, matched = [], pos = rneedsContext.test( selectors ) || typeof selectors !== "string" ? jQuery( selectors, context || this.context ) : 0;

for (i < l; i++ ) { for ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) {

// Always skip document fragments if ( cur.nodeType < 11 && ( pos ? pos.index( cur ) > -1 :

// Don't pass non-elements to Sizzle cur.nodeType === 1 && jQuery.find.matchesSelector( cur, selectors ) ) ) {

matched.push( cur ); break; }			}		}

return this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched ); },

// Determine the position of an element within // the matched set of elements index: function( elem ) {

// No argument, return index in parent if ( !elem ) { return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first.prevAll.length : -1; }

// index in selector if ( typeof elem === "string" ) { return jQuery.inArray( this[ 0 ], jQuery( elem ) ); }

// 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 ) { return this.pushStack(			jQuery.uniqueSort( jQuery.merge( this.get, jQuery( selector, context ) ) )		);	},

addBack: function( selector ) { return this.add( selector == null ?			this.prevObject : this.prevObject.filter( selector )		); } } );

function sibling( cur, dir ) { do { cur = cur[ dir ]; } while ( cur && cur.nodeType !== 1 );

return cur; }

jQuery.each( {	parent: function( elem ) {		var parent = elem.parentNode;		return parent && parent.nodeType !== 11 ? parent : null;	},	parents: function( elem ) {		return dir( elem, "parentNode" );	},	parentsUntil: function( elem, i, until ) {		return dir( elem, "parentNode", until );	},	next: function( elem ) {		return sibling( elem, "nextSibling" );	},	prev: function( elem ) {		return sibling( elem, "previousSibling" );	},	nextAll: function( elem ) {		return dir( elem, "nextSibling" );	},	prevAll: function( elem ) {		return dir( elem, "previousSibling" );	},	nextUntil: function( elem, i, until ) {		return dir( elem, "nextSibling", until );	},	prevUntil: function( elem, i, until ) {		return dir( elem, "previousSibling", until );	},	siblings: function( elem ) {		return siblings( ( elem.parentNode || {} ).firstChild, elem );	},	children: function( elem ) {		return siblings( elem.firstChild ); },	contents: function( elem ) { return jQuery.nodeName( elem, "iframe" ) ? elem.contentDocument || elem.contentWindow.document : jQuery.merge( [], elem.childNodes ); } }, function( name, fn ) { jQuery.fn[ name ] = function( until, selector ) { var ret = jQuery.map( this, fn, until );

if ( name.slice( -5 ) !== "Until" ) { selector = until; }

if ( selector && typeof selector === "string" ) { ret = jQuery.filter( selector, ret ); }

if ( this.length > 1 ) {

// Remove duplicates if ( !guaranteedUnique[ name ] ) { ret = jQuery.uniqueSort( ret ); }

// Reverse order for parents* and prev-derivatives if ( rparentsprev.test( name ) ) { ret = ret.reverse; }		}

return this.pushStack( ret ); }; } ); var rnotwhite = ( /\S+/g );

// Convert String-formatted options into Object-formatted ones function createOptions( options ) { var object = {}; jQuery.each( options.match( rnotwhite ) || [], function( _, flag ) {		object[ flag ] = true;	} ); return object; }

/* * Create a callback list using the following parameters: * *	options: an optional list of space-separated options that will change how *			the callback list behaves or a more traditional option object * * By default a callback list will act like an event callback list and can be * "fired" multiple times. * * Possible options: * *	once:			will ensure the callback list can only be fired once (like a Deferred) * *	memory:			will keep track of previous values and will call any callback added *					after the list has been fired right away with the latest "memorized" *					values (like a Deferred) * *	unique:			will ensure a callback can only be added once (no duplicate in the list) * *	stopOnFalse:	interrupt callings when a callback returns false * */ jQuery.Callbacks = function( options ) {

// Convert options from String-formatted to Object-formatted if needed // (we check in cache first) options = typeof options === "string" ? createOptions( options ) : jQuery.extend( {}, options );

var // Flag to know if list is currently firing firing,

// Last fire value for non-forgettable lists memory,

// Flag to know if list was already fired fired,

// Flag to prevent firing locked,

// Actual callback list list = [],

// Queue of execution data for repeatable lists queue = [],

// Index of currently firing callback (modified by add/remove as needed) firingIndex = -1,

// Fire callbacks fire = function {

// Enforce single-firing locked = options.once;

// Execute callbacks for all pending executions, // respecting firingIndex overrides and runtime changes fired = firing = true; for (queue.length; firingIndex = -1 ) { memory = queue.shift; while ( ++firingIndex < list.length ) {

// Run callback and check for early termination if ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false &&						options.stopOnFalse ) {

// Jump to end and forget the data so .add doesn't re-fire firingIndex = list.length; memory = false; }				}			}

// Forget the data if we're done with it			if ( !options.memory ) { memory = false; }

firing = false;

// Clean up if we're done firing for good if ( locked ) {

// Keep an empty list if we have data for future add calls if ( memory ) { list = [];

// Otherwise, this object is spent } else { list = ""; }			}		},

// Actual Callbacks object self = {

// Add a callback or a collection of callbacks to the list add: function { if ( list ) {

// If we have memory from a past run, we should fire after adding if ( memory && !firing ) { firingIndex = list.length - 1; queue.push( memory ); }

( function add( args ) {						jQuery.each( args, function( _, arg ) { if ( jQuery.isFunction( arg ) ) { if ( !options.unique || !self.has( arg ) ) { list.push( arg ); }							} else if ( arg && arg.length && jQuery.type( arg ) !== "string" ) {

// Inspect recursively add( arg ); }						} );					} )( arguments );

if ( memory && !firing ) { fire; }				}				return this; },

// Remove a callback from the list remove: function { jQuery.each( arguments, function( _, arg ) {					var index;					while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {						list.splice( index, 1 );

// Handle firing indexes if ( index <= firingIndex ) { firingIndex--; }					}				} );				return this;			},

// Check if a given callback is in the list. // If no argument is given, return whether or not list has callbacks attached. has: function( fn ) { return fn ? jQuery.inArray( fn, list ) > -1 : list.length > 0; },

// Remove all callbacks from the list empty: function { if ( list ) { list = []; }				return this; },

// Disable .fire and .add // Abort any current/pending executions // Clear all callbacks and values disable: function { locked = queue = []; list = memory = ""; return this; },			disabled: function { return !list; },

// Disable .fire // Also disable .add unless we have memory (since it would have no effect) // Abort any pending executions lock: function { locked = true; if ( !memory ) { self.disable; }				return this; },			locked: function { return !!locked; },

// Call all callbacks with the given context and arguments fireWith: function( context, args ) { if ( !locked ) { args = args || []; args = [ context, args.slice ? args.slice : args ]; queue.push( args ); if ( !firing ) { fire; }				}				return this; },

// Call all the callbacks with the given arguments fire: function { self.fireWith( this, arguments ); return this; },

// To know if the callbacks have already been called at least once fired: function { return !!fired; }		};

return self; };

jQuery.extend( {

Deferred: function( func ) { var tuples = [

// action, add listener, listener list, final state [ "resolve", "done", jQuery.Callbacks( "once memory" ), "resolved" ], [ "reject", "fail", jQuery.Callbacks( "once memory" ), "rejected" ], [ "notify", "progress", jQuery.Callbacks( "memory" ) ] ],			state = "pending", promise = { state: function { return state; },				always: function { deferred.done( arguments ).fail( arguments ); return this; },				then: function( /* fnDone, fnFail, fnProgress */ ) { var fns = arguments; return jQuery.Deferred( function( newDefer ) {						jQuery.each( tuples, function( i, tuple ) { var fn = jQuery.isFunction( fns[ i ] ) && fns[ i ];

// deferred[ done | fail | progress ] for forwarding actions to newDefer deferred[ tuple[ 1 ] ]( function {								var returned = fn && fn.apply( this, arguments );								if ( returned && jQuery.isFunction( returned.promise ) ) {									returned.promise										.progress( newDefer.notify )										.done( newDefer.resolve )										.fail( newDefer.reject );								} else {									newDefer[ tuple[ 0 ] + "With" ]( this === promise ? newDefer.promise : this, fn ? [ returned ] : arguments );								}							} );						} );						fns = null;					} ).promise; },

// Get a promise for this deferred // If obj is provided, the promise aspect is added to the object promise: function( obj ) { return obj != null ? jQuery.extend( obj, promise ) : promise; }			},			deferred = {};

// Keep pipe for back-compat promise.pipe = promise.then;

// Add list-specific methods jQuery.each( tuples, function( i, tuple ) {			var list = tuple[ 2 ],				stateString = tuple[ 3 ];

// promise[ done | fail | progress ] = list.add promise[ tuple[ 1 ] ] = list.add;

// Handle state if ( stateString ) { list.add( function {

// state = [ resolved | rejected ] state = stateString;

// [ reject_list | resolve_list ].disable; progress_list.lock }, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock );			}

// deferred[ resolve | reject | notify ] deferred[ tuple[ 0 ] ] = function { deferred[ tuple[ 0 ] + "With" ]( this === deferred ? promise : this, arguments ); return this; };			deferred[ tuple[ 0 ] + "With" ] = list.fireWith; } );

// Make the deferred a promise promise.promise( deferred );

// Call given func if any if ( func ) { func.call( deferred, deferred ); }

// All done! return deferred; },

// Deferred helper when: function( subordinate /*, ..., subordinateN */ ) { var i = 0, resolveValues = slice.call( arguments ), length = resolveValues.length,

// the count of uncompleted subordinates remaining = length !== 1 || ( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0,

// the master Deferred. // If resolveValues consist of only a single Deferred, just use that. deferred = remaining === 1 ? subordinate : jQuery.Deferred,

// Update function for both resolve and progress values updateFunc = function( i, contexts, values ) { return function( value ) { contexts[ i ] = this; values[ i ] = arguments.length > 1 ? slice.call( arguments ) : value; if ( values === progressValues ) { deferred.notifyWith( contexts, values );

} else if ( !( --remaining ) ) { deferred.resolveWith( contexts, values ); }				};			},

progressValues, progressContexts, resolveContexts;

// add listeners to Deferred subordinates; treat others as resolved if ( length > 1 ) { progressValues = new Array( length ); progressContexts = new Array( length ); resolveContexts = new Array( length ); for (i < length; i++ ) { if ( resolveValues[ i ] && jQuery.isFunction( resolveValues[ i ].promise ) ) { resolveValues[ i ].promise .progress( updateFunc( i, progressContexts, progressValues ) ) .done( updateFunc( i, resolveContexts, resolveValues ) ) .fail( deferred.reject ); } else { --remaining; }			}		}

// if we're not waiting on anything, resolve the master if ( !remaining ) { deferred.resolveWith( resolveContexts, resolveValues ); }

return deferred.promise; } } );

// The deferred used on DOM ready var readyList;

jQuery.fn.ready = function( fn ) {

// Add the callback jQuery.ready.promise.done( fn );

return this; };

jQuery.extend( {

// 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 ) {

// Abort if there are pending holds or we're already ready if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) { return; }

// 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.triggerHandler ) { jQuery( document ).triggerHandler( "ready" ); jQuery( document ).off( "ready" ); }	} } );

/** * Clean-up method for dom ready events */ function detach { if ( document.addEventListener ) { document.removeEventListener( "DOMContentLoaded", completed ); window.removeEventListener( "load", completed );

} else { document.detachEvent( "onreadystatechange", completed ); window.detachEvent( "onload", completed ); } }

/** * The ready event handler and self cleanup method */ function completed {

// readyState === "complete" is good enough for us to call the dom ready in oldIE if ( document.addEventListener ||		window.event.type === "load" ||		document.readyState === "complete" ) {

detach; jQuery.ready; } }

jQuery.ready.promise = function( obj ) { if ( !readyList ) {

readyList = jQuery.Deferred;

// Catch cases where $(document).ready is called // after the browser event has already occurred. // Support: IE6-10 // Older IE sometimes signals "interactive" too soon if ( document.readyState === "complete" ||			( document.readyState !== "loading" && !document.documentElement.doScroll ) ) {

// Handle it asynchronously to allow scripts the opportunity to delay ready window.setTimeout( jQuery.ready );

// Standards-based browsers support DOMContentLoaded } else if ( document.addEventListener ) {

// Use the handy event callback document.addEventListener( "DOMContentLoaded", completed );

// A fallback to window.onload, that will always work window.addEventListener( "load", completed );

// If IE event model is used } else {

// Ensure firing before onload, maybe late but safe also for iframes document.attachEvent( "onreadystatechange", completed );

// A fallback to window.onload, that will always work window.attachEvent( "onload", completed );

// If IE and not a frame // continually check to see if the document is ready var top = false;

try { top = window.frameElement == null && document.documentElement; } catch ( e ) {}

if ( top && top.doScroll ) { ( function doScrollCheck {					if ( !jQuery.isReady ) {

try {

// Use the trick by Diego Perini // http://javascript.nwbox.com/IEContentLoaded/ top.doScroll( "left" ); } catch ( e ) { return window.setTimeout( doScrollCheck, 50 ); }

// detach all dom ready events detach;

// and execute any waiting functions jQuery.ready; }				} );			}		}	}	return readyList.promise( obj ); };

// Kick off the DOM ready check even if the user does not jQuery.ready.promise;

// Support: IE<9 // Iteration over object's inherited properties before its own var i; for ( i in jQuery( support ) ) { break; } support.ownFirst = i === "0";

// Note: most support tests are defined in their respective modules. // false until the test is run support.inlineBlockNeedsLayout = false;

// Execute ASAP in case we need to set body.style.zoom jQuery( function {

// Minified: var a,b,c,d var val, div, body, container;

body = document.getElementsByTagName( "body" )[ 0 ]; if ( !body || !body.style ) {

// Return for frameset docs that don't have a body return; }

// Setup div = document.createElement( "div" ); container = document.createElement( "div" ); container.style.cssText = "position:absolute;border:0;width:0;height:0;top:0;left:-9999px"; body.appendChild( container ).appendChild( div );

if ( typeof div.style.zoom !== "undefined" ) {

// Support: IE<8 // Check if natively block-level elements act like inline-block // elements when setting their display to 'inline' and giving // them layout div.style.cssText = "display:inline;margin:0;border:0;padding:1px;width:1px;zoom:1";

support.inlineBlockNeedsLayout = val = div.offsetWidth === 3; if ( val ) {

// Prevent IE 6 from affecting layout for positioned elements #11048 // Prevent IE from shrinking the body in IE 7 mode #12869 // Support: IE<8 body.style.zoom = 1; }	}

body.removeChild( container ); } );

( function {	var div = document.createElement( "div" );

// Support: IE<9 support.deleteExpando = true; try { delete div.test; } catch ( e ) { support.deleteExpando = false; }

// Null elements to avoid leaks in IE.	div = null; } ); var acceptData = function( elem ) {	var noData = jQuery.noData[ ( elem.nodeName + " " ).toLowerCase ],		nodeType = +elem.nodeType || 1;

// Do not set data on non-element DOM nodes because it will not be cleared (#8335). return nodeType !== 1 && nodeType !== 9 ? false :

// Nodes accept data unless otherwise specified; rejection can be conditional !noData || noData !== true && elem.getAttribute( "classid" ) === noData; };

var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,	rmultiDash = /([A-Z])/g;

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" ).toLowerCase;

data = elem.getAttribute( name );

if ( typeof data === "string" ) { try { data = data === "true" ? true : data === "false" ? false : data === "null" ? null :

// Only convert to a number if it doesn't change the string +data + "" === data ? +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; }

// checks a cache object for emptiness function isEmptyDataObject( obj ) { var name; for ( name in obj ) {

// if the public data object is empty, the private is still empty if ( name === "data" && jQuery.isEmptyObject( obj[ name ] ) ) { continue; }		if ( name !== "toJSON" ) { return false; }	}

return true; }

function internalData( elem, name, data, pvt /* Internal Use Only */ ) { if ( !acceptData( elem ) ) { return; }

var ret, thisCache, internalKey = jQuery.expando,

// 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[ internalKey ] : elem[ internalKey ] && internalKey;

// 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 || !cache[ id ] || ( !pvt && !cache[ id ].data ) ) &&		data === undefined && typeof name === "string" ) { 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 ) { id = elem[ internalKey ] = deletedIds.pop || jQuery.guid++; } else { id = internalKey; }	}

if ( !cache[ id ] ) {

// Avoid exposing jQuery metadata on plain JS objects when the object // is serialized using JSON.stringify cache[ id ] = isNode ? {} : { 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 ] = jQuery.extend( cache[ id ], name ); } else { cache[ id ].data = jQuery.extend( cache[ id ].data, name ); }	}

thisCache = cache[ id ];

// jQuery data is stored in a separate object inside the object's internal data // cache in order to avoid key collisions between internal data and user-defined // data. if ( !pvt ) { if ( !thisCache.data ) { thisCache.data = {}; }

thisCache = thisCache.data; }

if ( data !== undefined ) { thisCache[ jQuery.camelCase( name ) ] = data; }

// Check for both converted-to-camel and non-converted data property names // If a data property was specified if ( typeof name === "string" ) {

// First Try to find as-is property data ret = thisCache[ name ];

// Test for null|undefined property data if ( ret == null ) {

// Try to find the camelCased property ret = thisCache[ jQuery.camelCase( name ) ]; }	} else { ret = thisCache; }

return ret; }

function internalRemoveData( elem, name, pvt ) { if ( !acceptData( elem ) ) { return; }

var thisCache, i,		isNode = elem.nodeType,

// See jQuery.data for more information cache = isNode ? jQuery.cache : elem, 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 ) {

thisCache = pvt ? cache[ id ] : cache[ id ].data;

if ( thisCache ) {

// Support array or space separated string names for data keys if ( !jQuery.isArray( name ) ) {

// try the string as a key before any manipulation if ( name in thisCache ) { name = [ name ]; } else {

// split the camel cased version by spaces unless a key with the spaces exists name = jQuery.camelCase( name ); if ( name in thisCache ) { name = [ name ]; } else { name = name.split( " " ); }				}			} else {

// If "name" is an array of keys... // When data is initially created, via ("key", "val") signature, // keys will be converted to camelCase. // Since there is no way to tell _how_ a key was added, remove // both plain key and camelCase key. #12786				// This will only penalize the array argument path. name = name.concat( jQuery.map( name, jQuery.camelCase ) ); }

i = name.length; while ( i-- ) { delete thisCache[ name[ i ] ]; }

// If there is no data left in the cache, we want to continue // and let the cache object itself get destroyed if ( pvt ? !isEmptyDataObject( thisCache ) : !jQuery.isEmptyObject( thisCache ) ) { return; }		}	}

// See jQuery.data for more information if ( !pvt ) { delete cache[ id ].data;

// Don't destroy the parent cache unless the internal data object // had been the only thing left in it		if ( !isEmptyDataObject( cache[ id ] ) ) { return; }	}

// Destroy the cache if ( isNode ) { jQuery.cleanData( [ elem ], true );

// Use delete when supported for expandos or `cache` is not a window per isWindow (#10080) /* jshint eqeqeq: false */ } else if ( support.deleteExpando || cache != cache.window ) { /* jshint eqeqeq: true */ delete cache[ id ];

// When all else fails, undefined } else { cache[ id ] = undefined; } }

jQuery.extend( {	cache: {},

// The following elements (space-suffixed to avoid Object.prototype collisions) // throw uncatchable exceptions if you attempt to set expando properties noData: { "applet ": true, "embed ": true,

// ...but Flash objects (which have this classid) *can* handle expandos "object ": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" },

hasData: function( elem ) { elem = elem.nodeType ? jQuery.cache[ elem[ jQuery.expando ] ] : elem[ jQuery.expando ]; return !!elem && !isEmptyDataObject( elem ); },

data: function( elem, name, data ) { return internalData( elem, name, data ); },

removeData: function( elem, name ) { return internalRemoveData( elem, name ); },

// For internal use only. _data: function( elem, name, data ) { return internalData( elem, name, data, true ); },

_removeData: function( elem, name ) { return internalRemoveData( elem, name, true ); } } );

jQuery.fn.extend( {	data: function( key, value ) {		var i, name, data,			elem = this[ 0 ],			attrs = elem && elem.attributes;

// Special expections of .data basically thwart jQuery.access, // so implement the relevant behavior ourselves

// Gets all values if ( key === undefined ) { if ( this.length ) { data = jQuery.data( elem );

if ( elem.nodeType === 1 && !jQuery._data( elem, "parsedAttrs" ) ) { i = attrs.length; while ( i-- ) {

// Support: IE11+ // The attrs elements can be null (#14894) if ( attrs[ i ] ) { name = attrs[ i ].name; if ( name.indexOf( "data-" ) === 0 ) { name = jQuery.camelCase( name.slice( 5 ) ); dataAttr( elem, name, data[ name ] ); }						}					}					jQuery._data( elem, "parsedAttrs", true ); }			}

return data; }

// Sets multiple values if ( typeof key === "object" ) { return this.each( function {				jQuery.data( this, key );			} ); }

return arguments.length > 1 ?

// Sets one value this.each( function {				jQuery.data( this, key, value );			} ) :

// Gets one value // Try to fetch any internally stored data first elem ? dataAttr( elem, key, jQuery.data( elem, key ) ) : undefined; },

removeData: function( key ) { return this.each( function {			jQuery.removeData( this, key );		} ); } } );

jQuery.extend( {	queue: function( elem, type, data ) {		var queue;

if ( elem ) { type = ( type || "fx" ) + "queue"; queue = jQuery._data( elem, type );

// Speed up dequeue by getting out quickly if this is just a lookup if ( data ) { if ( !queue || jQuery.isArray( data ) ) { queue = jQuery._data( elem, type, jQuery.makeArray( data ) ); } else { queue.push( data ); }			}			return queue || []; }	},

dequeue: function( elem, type ) { type = type || "fx";

var queue = jQuery.queue( elem, type ), startLength = queue.length, fn = queue.shift, hooks = jQuery._queueHooks( elem, type ), next = function { jQuery.dequeue( elem, type ); };

// If the fx queue is dequeued, always remove the progress sentinel if ( fn === "inprogress" ) { fn = queue.shift; startLength--; }

if ( fn ) {

// Add a progress sentinel to prevent the fx queue from being // automatically dequeued if ( type === "fx" ) { queue.unshift( "inprogress" ); }

// clear up the last queue stop function delete hooks.stop; fn.call( elem, next, hooks ); }

if ( !startLength && hooks ) { hooks.empty.fire; }	},

// not intended for public consumption - generates a queueHooks object, // or returns the current one _queueHooks: function( elem, type ) { var key = type + "queueHooks"; return jQuery._data( elem, key ) || jQuery._data( elem, key, {			empty: jQuery.Callbacks( "once memory" ).add( function { jQuery._removeData( elem, type + "queue" ); jQuery._removeData( elem, key ); } )		} );	} } );

jQuery.fn.extend( {	queue: function( type, data ) {		var setter = 2;

if ( typeof type !== "string" ) { data = type; type = "fx"; setter--; }

if ( arguments.length < setter ) { return jQuery.queue( this[ 0 ], type ); }

return data === undefined ? this : this.each( function {				var queue = jQuery.queue( this, type, data );

// ensure a hooks for this queue jQuery._queueHooks( this, type );

if ( type === "fx" && queue[ 0 ] !== "inprogress" ) { jQuery.dequeue( this, type ); }			} );	},	dequeue: function( type ) {		return this.each( function { jQuery.dequeue( this, type ); } );	},	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, obj ) { var tmp, count = 1, defer = jQuery.Deferred, elements = this, i = this.length, resolve = function { if ( !( --count ) ) { defer.resolveWith( elements, [ elements ] ); }			};

if ( typeof type !== "string" ) { obj = type; type = undefined; }		type = type || "fx";

while ( i-- ) { tmp = jQuery._data( elements[ i ], type + "queueHooks" ); if ( tmp && tmp.empty ) { count++; tmp.empty.add( resolve ); }		}		resolve; return defer.promise( obj ); } } );

( function {	var shrinkWrapBlocksVal;

support.shrinkWrapBlocks = function { if ( shrinkWrapBlocksVal != null ) { return shrinkWrapBlocksVal; }

// Will be changed later if needed. shrinkWrapBlocksVal = false;

// Minified: var b,c,d var div, body, container;

body = document.getElementsByTagName( "body" )[ 0 ]; if ( !body || !body.style ) {

// Test fired too early or in an unsupported environment, exit. return; }

// Setup div = document.createElement( "div" ); container = document.createElement( "div" ); container.style.cssText = "position:absolute;border:0;width:0;height:0;top:0;left:-9999px"; body.appendChild( container ).appendChild( div );

// Support: IE6 // Check if elements with layout shrink-wrap their children if ( typeof div.style.zoom !== "undefined" ) {

// Reset CSS: box-sizing; display; margin; border div.style.cssText =

// Support: Firefox<29, Android 2.3 // Vendor-prefix box-sizing "-webkit-box-sizing:content-box;-moz-box-sizing:content-box;" + "box-sizing:content-box;display:block;margin:0;border:0;" + "padding:1px;width:1px;zoom:1"; div.appendChild( document.createElement( "div" ) ).style.width = "5px"; shrinkWrapBlocksVal = div.offsetWidth !== 3; }

body.removeChild( container );

return shrinkWrapBlocksVal; };

} ); var pnum = ( /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/ ).source;

var rcssNum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" );

var cssExpand = [ "Top", "Right", "Bottom", "Left" ];

var isHidden = function( elem, el ) {

// isHidden might be called from jQuery#filter function; // in that case, element will be second argument elem = el || elem; return jQuery.css( elem, "display" ) === "none" || !jQuery.contains( elem.ownerDocument, elem ); };

function adjustCSS( elem, prop, valueParts, tween ) { var adjusted, scale = 1, maxIterations = 20, currentValue = tween ? function { return tween.cur; } : function { return jQuery.css( elem, prop, "" ); }, initial = currentValue, unit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ),

// Starting value computation is required for potential unit mismatches initialInUnit = ( jQuery.cssNumber[ prop ] || unit !== "px" && +initial ) && rcssNum.exec( jQuery.css( elem, prop ) );

if ( initialInUnit && initialInUnit[ 3 ] !== unit ) {

// Trust units reported by jQuery.css unit = unit || initialInUnit[ 3 ];

// Make sure we update the tween properties later on		valueParts = valueParts || [];

// Iteratively approximate from a nonzero starting point initialInUnit = +initial || 1;

do {

// If previous iteration zeroed out, double until we get *something*. // Use string for doubling so we don't accidentally see scale as unchanged below scale = scale || ".5";

// Adjust and apply initialInUnit = initialInUnit / scale; jQuery.style( elem, prop, initialInUnit + unit );

// Update scale, tolerating zero or NaN from tween.cur // Break the loop if scale is unchanged or perfect, or if we've just had enough. } while (			scale !== ( scale = currentValue / initial ) && scale !== 1 && --maxIterations		); }

if ( valueParts ) { initialInUnit = +initialInUnit || +initial || 0;

// Apply relative offset (+=/-=) if specified adjusted = valueParts[ 1 ] ? initialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] : +valueParts[ 2 ]; if ( tween ) { tween.unit = unit; tween.start = initialInUnit; tween.end = adjusted; }	}	return adjusted; }

// Multifunctional method to get and set values of a collection // The value/s can optionally be executed if it's a function var access = function( elems, fn, key, value, chainable, emptyGet, raw ) { var i = 0, length = elems.length, bulk = key == null;

// Sets many values if ( jQuery.type( key ) === "object" ) { chainable = true; for ( i in key ) { access( elems, fn, i, key[ i ], true, emptyGet, raw ); }

// Sets one value } else if ( value !== undefined ) { chainable = true;

if ( !jQuery.isFunction( value ) ) { raw = true; }

if ( bulk ) {

// Bulk operations run against the entire set if ( raw ) { fn.call( elems, value ); fn = null;

// ...except when executing function values } else { bulk = fn; fn = function( elem, key, value ) { return bulk.call( jQuery( elem ), value ); };			}		}

if ( fn ) { for (i < length; i++ ) { fn(					elems[ i ],					key,					raw ? value : value.call( elems[ i ], i, fn( elems[ i ], key ) )				); }		}	}

return chainable ? elems :

// Gets bulk ? fn.call( elems ) : length ? fn( elems[ 0 ], key ) : emptyGet; }; var rcheckableType = ( /^(?:checkbox|radio)$/i );

var rtagName = ( /<([\w:-]+)/ );

var rscriptType = ( /^$|\/(?:java|ecma)script/i );

var rleadingWhitespace = ( /^\s+/ );

var nodeNames = "abbr|article|aside|audio|bdi|canvas|data|datalist|" + "details|dialog|figcaption|figure|footer|header|hgroup|main|" + "mark|meter|nav|output|picture|progress|section|summary|template|time|video";

function createSafeFragment( document ) { var list = nodeNames.split( "|" ), safeFrag = document.createDocumentFragment;

if ( safeFrag.createElement ) { while ( list.length ) { safeFrag.createElement(				list.pop			); }	}	return safeFrag; }

( function {	var div = document.createElement( "div" ),		fragment = document.createDocumentFragment,		input = document.createElement( "input" );

// Setup div.innerHTML = " " ], tr: [ 2, " " ], col: [ 2, " " ], td: [ 3, " " ],

// IE6-8 can't serialize link, script, style, or any html5 (NoScope) tags, // unless wrapped in a div with non-breaking characters in front of it. _default: support.htmlSerialize ? [ 0, "", "" ] : [ 1, "X ", " " ] };

// Support: IE8-IE9 wrapMap.optgroup = wrapMap.option;

wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead; wrapMap.th = wrapMap.td;

function getAll( context, tag ) { var elems, elem, i = 0, found = typeof context.getElementsByTagName !== "undefined" ? context.getElementsByTagName( tag || "*" ) : typeof context.querySelectorAll !== "undefined" ? context.querySelectorAll( tag || "*" ) : undefined;

if ( !found ) { for ( found = [], elems = context.childNodes || context;			( elem = elems[ i ] ) != null;			i++		) { if ( !tag || jQuery.nodeName( elem, tag ) ) { found.push( elem ); } else { jQuery.merge( found, getAll( elem, tag ) ); }		}	}

return tag === undefined || tag && jQuery.nodeName( context, tag ) ? jQuery.merge( [ context ], found ) : found; }

// Mark scripts as having already been evaluated function setGlobalEval( elems, refElements ) { var elem, i = 0; for (( elem = elems[ i ] ) != null; i++ ) { jQuery._data(			elem,			"globalEval",			!refElements || jQuery._data( refElements[ i ], "globalEval" )		); } }

var rhtml = /<|&#?\w+;/, rtbody = /<tbody/i;

function fixDefaultChecked( elem ) { if ( rcheckableType.test( elem.type ) ) { elem.defaultChecked = elem.checked; } }

function buildFragment( elems, context, scripts, selection, ignored ) { var j, elem, contains, tmp, tag, tbody, wrap, l = elems.length,

// Ensure a safe fragment safe = createSafeFragment( context ),

nodes = [], i = 0;

for (i < l; i++ ) { elem = elems[ i ];

if ( elem || elem === 0 ) {

// Add nodes directly if ( jQuery.type( elem ) === "object" ) { jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );

// Convert non-html into a text node } else if ( !rhtml.test( elem ) ) { nodes.push( context.createTextNode( elem ) );

// Convert html into DOM nodes } else { tmp = tmp || safe.appendChild( context.createElement( "div" ) );

// Deserialize a standard representation tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase; wrap = wrapMap[ tag ] || wrapMap._default;

tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ];

// Descend through wrappers to the right content j = wrap[ 0 ]; while ( j-- ) { tmp = tmp.lastChild; }

// Manually add leading whitespace removed by IE				if ( !support.leadingWhitespace && rleadingWhitespace.test( elem ) ) { nodes.push( context.createTextNode( rleadingWhitespace.exec( elem )[ 0 ] ) ); }

// Remove IE's autoinserted from table fragments if ( !support.tbody ) {

// String was a ";			div.childNodes[ 0 ].style.borderCollapse = "separate";			contents = div.getElementsByTagName( "td" );			contents[ 0 ].style.cssText = "margin:0;border:0;padding:0;display:none";			reliableHiddenOffsetsVal = contents[ 0 ].offsetHeight === 0;			if ( reliableHiddenOffsetsVal ) {				contents[ 0 ].style.display = "";				contents[ 1 ].style.display = "none";				reliableHiddenOffsetsVal = contents[ 0 ].offsetHeight === 0;			}		}

// Teardown documentElement.removeChild( container ); }

} );

var getStyles, curCSS, rposition = /^(top|right|bottom|left)$/;

if ( window.getComputedStyle ) { getStyles = function( elem ) {

// Support: IE<=11+, Firefox<=30+ (#15098, #14150) // IE throws on elements created in popups // FF meanwhile throws on frame elements through "defaultView.getComputedStyle" var view = elem.ownerDocument.defaultView;

if ( !view || !view.opener ) { view = window; }

return view.getComputedStyle( elem ); };

curCSS = function( elem, name, computed ) { var width, minWidth, maxWidth, ret, style = elem.style;

computed = computed || getStyles( elem );

// getPropertyValue is only needed for .css('filter') in IE9, see #12537 ret = computed ? computed.getPropertyValue( name ) || computed[ name ] : undefined;

// Support: Opera 12.1x only // Fall back to style even without computed // computed is undefined for elems on document fragments if ( ( ret === "" || ret === undefined ) && !jQuery.contains( elem.ownerDocument, elem ) ) { ret = jQuery.style( elem, name ); }

if ( computed ) {

// A tribute to the "awesome hack by Dean Edwards" // Chrome < 17 and Safari 5.0 uses "computed value" // instead of "used value" for margin-right // Safari 5.1.7 (at least) returns percentage for a larger set of values, // but width seems to be reliably pixels // this is against the CSSOM draft spec: // http://dev.w3.org/csswg/cssom/#resolved-values if ( !support.pixelMarginRight && rnumnonpx.test( ret ) && rmargin.test( name ) ) {

// Remember the original values width = style.width; minWidth = style.minWidth; maxWidth = style.maxWidth;

// Put in the new values to get a computed value out style.minWidth = style.maxWidth = style.width = ret; ret = computed.width;

// Revert the changed values style.width = width; style.minWidth = minWidth; style.maxWidth = maxWidth; }		}

// Support: IE // IE returns zIndex value as an integer. return ret === undefined ? ret : ret + ""; }; } else if ( documentElement.currentStyle ) { getStyles = function( elem ) { return elem.currentStyle; };

curCSS = function( elem, name, computed ) { var left, rs, rsLeft, ret, style = elem.style;

computed = computed || getStyles( elem ); ret = computed ? computed[ name ] : undefined;

// Avoid setting ret to empty string here // so we don't default to auto if ( ret == null && style && style[ name ] ) { ret = style[ name ]; }

// 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 // but not position css attributes, as those are // proportional to the parent element instead // and we can't measure the parent instead because it		// might trigger a "stacking dolls" problem if ( rnumnonpx.test( ret ) && !rposition.test( name ) ) {

// Remember the original values left = style.left; rs = elem.runtimeStyle; rsLeft = rs && rs.left;

// Put in the new values to get a computed value out if ( rsLeft ) { rs.left = elem.currentStyle.left; }			style.left = name === "fontSize" ? "1em" : ret; ret = style.pixelLeft + "px";

// Revert the changed values style.left = left; if ( rsLeft ) { rs.left = rsLeft; }		}

// Support: IE // IE returns zIndex value as an integer. return ret === undefined ? ret : ret + "" || "auto"; }; }

function addGetHookIf( conditionFn, hookFn ) {

// Define the hook, we'll check on the first run if it's really needed. return { get: function { if ( conditionFn ) {

// Hook not needed (or it's not possible to use it due				// to missing dependency), remove it. delete this.get; return; }

// Hook needed; redefine it so that the support test is not executed again. return ( this.get = hookFn ).apply( this, arguments ); }	}; }

var

ralpha = /alpha\([^)]*\)/i,	ropacity = /opacity\s*=\s*([^)]*)/i,

// swappable if display is none or starts with table except // "table", "table-cell", or "table-caption" // see here for display values: // https://developer.mozilla.org/en-US/docs/CSS/display rdisplayswap = /^(none|table(?!-c[ea]).+)/, rnumsplit = new RegExp( "^(" + pnum + ")(.*)$", "i" ),

cssShow = { position: "absolute", visibility: "hidden", display: "block" }, cssNormalTransform = { letterSpacing: "0", fontWeight: "400" },

cssPrefixes = [ "Webkit", "O", "Moz", "ms" ], emptyStyle = document.createElement( "div" ).style;

// return a css property mapped to a potentially vendor prefixed property function vendorPropName( name ) {

// shortcut for names that are not vendor prefixed if ( name in emptyStyle ) { return name; }

// check for vendor prefixed names var capName = name.charAt( 0 ).toUpperCase + name.slice( 1 ), i = cssPrefixes.length;

while ( i-- ) { name = cssPrefixes[ i ] + capName; if ( name in emptyStyle ) { return name; }	} }

function showHide( elements, show ) { var display, elem, hidden, values = [], index = 0, length = elements.length;

for (index < length; index++ ) { elem = elements[ index ]; if ( !elem.style ) { continue; }

values[ index ] = jQuery._data( elem, "olddisplay" ); display = elem.style.display; if ( show ) {

// Reset the inline display of this element to learn if it is			// being hidden by cascaded rules or not if ( !values[ index ] && display === "none" ) { 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 ( elem.style.display === "" && isHidden( elem ) ) { values[ index ] = jQuery._data( elem, "olddisplay", defaultDisplay( elem.nodeName ) ); }		} else { hidden = isHidden( elem );

if ( display && display !== "none" || !hidden ) { jQuery._data(					elem,					"olddisplay",					hidden ? display : jQuery.css( elem, "display" )				); }		}	}

// Set the display of most of the elements in a second loop // to avoid the constant reflow for ( index = 0; index < length; index++ ) { elem = elements[ index ]; if ( !elem.style ) { continue; }		if ( !show || elem.style.display === "none" || elem.style.display === "" ) { elem.style.display = show ? values[ index ] || "" : "none"; }	}

return elements; }

function setPositiveNumber( elem, value, subtract ) { var matches = rnumsplit.exec( value ); return matches ?

// Guard against undefined "subtract", e.g., when used as in cssHooks Math.max( 0, matches[ 1 ] - ( subtract || 0 ) ) + ( matches[ 2 ] || "px" ) : value; }

function augmentWidthOrHeight( elem, name, extra, isBorderBox, styles ) { var i = extra === ( isBorderBox ? "border" : "content" ) ?

// If we already have the right measurement, avoid augmentation 4 :

// Otherwise initialize for horizontal or vertical properties name === "width" ? 1 : 0,

val = 0;

for (i < 4; i += 2 ) {

// both box models exclude margin, so add it if we want it		if ( extra === "margin" ) { val += jQuery.css( elem, extra + cssExpand[ i ], true, styles ); }

if ( isBorderBox ) {

// border-box includes padding, so remove it if we want content if ( extra === "content" ) { val -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles ); }

// at this point, extra isn't border nor margin, so remove border if ( extra !== "margin" ) { val -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); }		} else {

// at this point, extra isn't content, so add padding val += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );

// at this point, extra isn't content nor padding, so add border if ( extra !== "padding" ) { val += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); }		}	}

return val; }

function getWidthOrHeight( elem, name, extra ) {

// Start with offset property, which is equivalent to the border-box value var valueIsBorderBox = true, val = name === "width" ? elem.offsetWidth : elem.offsetHeight, styles = getStyles( elem ), isBorderBox = support.boxSizing && jQuery.css( elem, "boxSizing", false, styles ) === "border-box";

// some non-html elements return undefined for offsetWidth, so check for null/undefined // svg - https://bugzilla.mozilla.org/show_bug.cgi?id=649285 // MathML - https://bugzilla.mozilla.org/show_bug.cgi?id=491668 if ( val <= 0 || val == null ) {

// Fall back to computed then uncomputed css if necessary val = curCSS( elem, name, styles ); if ( val < 0 || val == null ) { val = elem.style[ name ]; }

// Computed unit is not pixels. Stop here and return. if ( rnumnonpx.test( val ) ) { return val; }

// we need the check for style in case a browser which returns unreliable values // for getComputedStyle silently falls back to the reliable elem.style valueIsBorderBox = isBorderBox && ( support.boxSizingReliable || val === elem.style[ name ] );

// Normalize "", auto, and prepare for extra val = parseFloat( val ) || 0; }

// use the active box-sizing model to add/subtract irrelevant styles return ( val +		augmentWidthOrHeight( elem, name, extra || ( isBorderBox ? "border" : "content" ), valueIsBorderBox, styles )	) + "px"; }

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" ); return ret === "" ? "1" : ret; }			}		}	},

// Don't automatically add "px" to these possibly-unitless properties cssNumber: { "animationIterationCount": true, "columnCount": true, "fillOpacity": true, "flexGrow": true, "flexShrink": true, "fontWeight": true, "lineHeight": true, "opacity": true, "order": true, "orphans": true, "widows": true, "zIndex": true, "zoom": true },

// Add in properties whose names you wish to fix before // setting or getting the value cssProps: {

// normalize float css property "float": 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, hooks, origName = jQuery.camelCase( name ), style = elem.style;

name = jQuery.cssProps[ origName ] || ( jQuery.cssProps[ origName ] = vendorPropName( origName ) || origName );

// gets hook for the prefixed version // followed by the unprefixed version hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];

// Check if we're setting a value if ( value !== undefined ) { type = typeof value;

// Convert "+=" or "-=" to relative numbers (#7345) if ( type === "string" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) { value = adjustCSS( elem, name, ret );

// Fixes bug #9237 type = "number"; }

// Make sure that null and NaN values aren't set. See: #7116 if ( value == null || value !== value ) { return; }

// If a number was passed in, add the unit (except for certain CSS properties) if ( type === "number" ) { value += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? "" : "px" ); }

// Fixes #8908, it can be done more correctly by specifing setters in cssHooks, // but it would mean to define eight // (for every problematic property) identical functions if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) { style[ name ] = "inherit"; }

// If a hook was provided, use that value, otherwise just set the specified value if ( !hooks || !( "set" in hooks ) ||				( value = hooks.set( elem, value, extra ) ) !== undefined ) {

// Support: IE				// Swallow errors from 'invalid' CSS values (#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, styles ) { var num, val, hooks, origName = jQuery.camelCase( name );

// Make sure that we're working with the right name name = jQuery.cssProps[ origName ] || ( jQuery.cssProps[ origName ] = vendorPropName( origName ) || origName );

// gets hook for the prefixed version // followed by the unprefixed version hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];

// If a hook was provided get the computed value from there if ( hooks && "get" in hooks ) { val = hooks.get( elem, true, extra ); }

// Otherwise, if a way to get the computed value exists, use that if ( val === undefined ) { val = curCSS( elem, name, styles ); }

//convert "normal" to computed value if ( val === "normal" && name in cssNormalTransform ) { val = cssNormalTransform[ name ]; }

// Return, converting to number if forced or a qualifier was provided and val looks numeric if ( extra === "" || extra ) { num = parseFloat( val ); return extra === true || isFinite( num ) ? num || 0 : val; }		return val; } } );

jQuery.each( [ "height", "width" ], function( i, name ) {	jQuery.cssHooks[ name ] = {		get: function( elem, computed, extra ) {			if ( computed ) {

// certain elements can have dimension info if we invisibly show them // however, it must have a current display style that would benefit from this return rdisplayswap.test( jQuery.css( elem, "display" ) ) && elem.offsetWidth === 0 ? swap( elem, cssShow, function {							return getWidthOrHeight( elem, name, extra );						} ) : getWidthOrHeight( elem, name, extra ); }		},

set: function( elem, value, extra ) { var styles = extra && getStyles( elem ); return setPositiveNumber( elem, value, extra ?				augmentWidthOrHeight( elem, name, extra, support.boxSizing && jQuery.css( elem, "boxSizing", false, styles ) === "border-box", styles ) : 0			);		}	}; } );

if ( !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 ) || "" ) ? ( 0.01 * parseFloat( RegExp.$1 ) ) + "" : computed ? "1" : "";		},

set: function( elem, value ) { var style = elem.style, currentStyle = elem.currentStyle, opacity = jQuery.isNumeric( value ) ? "alpha(opacity=" + value * 100 + ")" : "", filter = currentStyle && currentStyle.filter || style.filter || "";

// IE has trouble with opacity if it does not have layout // Force it by setting the zoom level style.zoom = 1;

// if setting opacity to 1, and no other filters exist - // attempt to remove filter attribute #6652 // if value === "", then remove inline opacity #12685 if ( ( value >= 1 || value === "" ) &&					jQuery.trim( filter.replace( ralpha, "" ) ) === "" &&					style.removeAttribute ) {

// Setting style.filter to null, "" & " " still leave "filter:" in the cssText // if "filter:" is present at all, clearType is disabled, we want to avoid this // style.removeAttribute is IE Only, but so apparently is this code path... style.removeAttribute( "filter" );

// if there is no filter style applied in a css rule // or unset inline opacity, we are done if ( value === "" || currentStyle && !currentStyle.filter ) { return; }			}

// otherwise, set new filter values style.filter = ralpha.test( filter ) ? filter.replace( ralpha, opacity ) : filter + " " + opacity; }	}; }

jQuery.cssHooks.marginRight = addGetHookIf( support.reliableMarginRight,	function( elem, computed ) {		if ( computed ) {			return swap( elem, { "display": "inline-block" }, curCSS, [ elem, "marginRight" ] );		}	} );

jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft,	function( elem, computed ) {		if ( computed ) {			return ( parseFloat( curCSS( elem, "marginLeft" ) ) ||

// Support: IE<=11+ // Running getBoundingClientRect on a disconnected node in IE throws an error // Support: IE8 only // getClientRects errors on disconnected elems ( jQuery.contains( elem.ownerDocument, elem ) ?					elem.getBoundingClientRect.left -						swap( elem, { marginLeft: 0 }, function { return elem.getBoundingClientRect.left; } ) :					0				)			) + "px";		}	} );

// These hooks are used by animate to expand properties jQuery.each( {	margin: "",	padding: "",	border: "Width" }, function( prefix, suffix ) {	jQuery.cssHooks[ prefix + suffix ] = {		expand: function( value ) {			var i = 0,				expanded = {},

// assumes a single number if not a string parts = typeof value === "string" ? value.split( " " ) : [ value ];

for (i < 4; i++ ) { expanded[ prefix + cssExpand[ i ] + suffix ] = parts[ i ] || parts[ i - 2 ] || parts[ 0 ]; }

return expanded; }	};

if ( !rmargin.test( prefix ) ) { jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber; } } );

jQuery.fn.extend( {	css: function( name, value ) {		return access( this, function( elem, name, value ) { var styles, len, map = {}, i = 0;

if ( jQuery.isArray( name ) ) { styles = getStyles( elem ); len = name.length;

for (i < len; i++ ) { map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles ); }

return map; }

return value !== undefined ? jQuery.style( elem, name, value ) : jQuery.css( elem, name ); }, name, value, arguments.length > 1 );	},	show: function {		return showHide( this, true );	},	hide: function {		return showHide( this );	},	toggle: function( state ) {		if ( typeof state === "boolean" ) {			return state ? this.show : this.hide;		}

return this.each( function {			if ( isHidden( this ) ) {				jQuery( this ).show;			} else {				jQuery( this ).hide;			}		} ); } } );

function Tween( elem, options, prop, end, easing ) { return new Tween.prototype.init( elem, options, prop, end, easing ); } jQuery.Tween = Tween;

Tween.prototype = { constructor: Tween, init: function( elem, options, prop, end, easing, unit ) { this.elem = elem; this.prop = prop; this.easing = easing || jQuery.easing._default; this.options = options; this.start = this.now = this.cur; this.end = end; this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" ); },	cur: function { var hooks = Tween.propHooks[ this.prop ];

return hooks && hooks.get ? hooks.get( this ) : Tween.propHooks._default.get( this ); },	run: function( percent ) { var eased, hooks = Tween.propHooks[ this.prop ];

if ( this.options.duration ) { this.pos = eased = jQuery.easing[ this.easing ](				percent, this.options.duration * percent, 0, 1, this.options.duration			); } else { this.pos = eased = percent; }		this.now = ( this.end - this.start ) * eased + this.start;

if ( this.options.step ) { this.options.step.call( this.elem, this.now, this ); }

if ( hooks && hooks.set ) { hooks.set( this ); } else { Tween.propHooks._default.set( this ); }		return this; } };

Tween.prototype.init.prototype = Tween.prototype;

Tween.propHooks = { _default: { get: function( tween ) { var result;

// Use a property on the element directly when it is not a DOM element, // or when there is no matching style property that exists. if ( tween.elem.nodeType !== 1 ||				tween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) { return tween.elem[ tween.prop ]; }

// passing an empty string as a 3rd parameter to .css will automatically // attempt a parseFloat and fallback to a string if the parse fails // so, simple values such as "10px" are parsed to Float. // complex values such as "rotate(1rad)" are returned as is. result = jQuery.css( tween.elem, tween.prop, "" );

// Empty strings, null, undefined and "auto" are converted to 0. return !result || result === "auto" ? 0 : result; },		set: function( tween ) {

// use step hook for back compat - use cssHook if its there - use .style if its // available and use plain properties where available if ( jQuery.fx.step[ tween.prop ] ) { jQuery.fx.step[ tween.prop ]( tween ); } else if ( tween.elem.nodeType === 1 &&				( tween.elem.style[ jQuery.cssProps[ tween.prop ] ] != null || jQuery.cssHooks[ tween.prop ] ) ) { jQuery.style( tween.elem, tween.prop, tween.now + tween.unit ); } else { tween.elem[ tween.prop ] = tween.now; }		}	} };

// Support: IE <=9 // Panic based approach to setting things on disconnected nodes

Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = { set: function( tween ) { if ( tween.elem.nodeType && tween.elem.parentNode ) { tween.elem[ tween.prop ] = tween.now; }	} };

jQuery.easing = { linear: function( p ) { return p;	}, swing: function( p ) { return 0.5 - Math.cos( p * Math.PI ) / 2; },	_default: "swing" };

jQuery.fx = Tween.prototype.init;

// Back Compat <1.8 extension point jQuery.fx.step = {};

var fxNow, timerId, rfxtypes = /^(?:toggle|show|hide)$/, rrun = /queueHooks$/;

// Animations created synchronously will run synchronously function createFxNow { window.setTimeout( function {		fxNow = undefined;	} ); return ( fxNow = jQuery.now ); }

// Generate parameters to create a standard animation function genFx( type, includeWidth ) { var which, attrs = { height: type }, i = 0;

// if we include width, step value is 1 to do all cssExpand values, // if we don't include width, step value is 2 to skip over Left and Right includeWidth = includeWidth ? 1 : 0;	for (i < 4 ; i += 2 - includeWidth ) { which = cssExpand[ i ]; attrs[ "margin" + which ] = attrs[ "padding" + which ] = type; }

if ( includeWidth ) { attrs.opacity = attrs.width = type; }

return attrs; }

function createTween( value, prop, animation ) { var tween, collection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ "*" ] ), index = 0, length = collection.length; for (index < length; index++ ) { if ( ( tween = collection[ index ].call( animation, prop, value ) ) ) {

// we're done with this property return tween; }	} }

function defaultPrefilter( elem, props, opts ) { /* jshint validthis: true */ var prop, value, toggle, tween, hooks, oldfire, display, checkDisplay, anim = this, orig = {}, style = elem.style, hidden = elem.nodeType && isHidden( elem ), dataShow = jQuery._data( elem, "fxshow" );

// handle queue: false promises if ( !opts.queue ) { hooks = jQuery._queueHooks( elem, "fx" ); if ( hooks.unqueued == null ) { hooks.unqueued = 0; oldfire = hooks.empty.fire; hooks.empty.fire = function { if ( !hooks.unqueued ) { oldfire; }			};		}		hooks.unqueued++;

anim.always( function {

// doing this makes sure that the complete handler will be called // before this completes anim.always( function {				hooks.unqueued--;				if ( !jQuery.queue( elem, "fx" ).length ) {					hooks.empty.fire;				}			} ); } );	}

// height/width overflow pass if ( elem.nodeType === 1 && ( "height" in props || "width" in props ) ) {

// 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 opts.overflow = [ style.overflow, style.overflowX, style.overflowY ];

// Set display property to inline-block for height/width // animations on inline elements that are having width/height animated display = jQuery.css( elem, "display" );

// Test default display if display is currently "none" checkDisplay = display === "none" ? jQuery._data( elem, "olddisplay" ) || defaultDisplay( elem.nodeName ) : display;

if ( checkDisplay === "inline" && jQuery.css( elem, "float" ) === "none" ) {

// inline-level elements accept inline-block; // block-level elements need to be inline with layout if ( !support.inlineBlockNeedsLayout || defaultDisplay( elem.nodeName ) === "inline" ) { style.display = "inline-block"; } else { style.zoom = 1; }		}	}

if ( opts.overflow ) { style.overflow = "hidden"; if ( !support.shrinkWrapBlocks ) { anim.always( function {				style.overflow = opts.overflow[ 0 ];				style.overflowX = opts.overflow[ 1 ];				style.overflowY = opts.overflow[ 2 ];			} ); }	}

// show/hide pass for ( prop in props ) { value = props[ prop ]; if ( rfxtypes.exec( value ) ) { delete props[ prop ]; toggle = toggle || value === "toggle"; if ( value === ( hidden ? "hide" : "show" ) ) {

// If there is dataShow left over from a stopped hide or show // and we are going to proceed with show, we should pretend to be hidden if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) { hidden = true; } else { continue; }			}			orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop );

// Any non-fx value stops us from restoring the original display value } else { display = undefined; }	}

if ( !jQuery.isEmptyObject( orig ) ) { if ( dataShow ) { if ( "hidden" in dataShow ) { hidden = dataShow.hidden; }		} else { dataShow = jQuery._data( elem, "fxshow", {} ); }

// store state if its toggle - enables .stop.toggle to "reverse" if ( toggle ) { dataShow.hidden = !hidden; }		if ( hidden ) { jQuery( elem ).show; } else { anim.done( function {				jQuery( elem ).hide;			} ); }		anim.done( function {			var prop;			jQuery._removeData( elem, "fxshow" );			for ( prop in orig ) {				jQuery.style( elem, prop, orig[ prop ] );			}		} ); for ( prop in orig ) { tween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim );

if ( !( prop in dataShow ) ) { dataShow[ prop ] = tween.start; if ( hidden ) { tween.end = tween.start; tween.start = prop === "width" || prop === "height" ? 1 : 0;				}			}		}

// If this is a noop like .hide.hide, restore an overwritten display value } else if ( ( display === "none" ? defaultDisplay( elem.nodeName ) : display ) === "inline" ) { style.display = display; } }

function propFilter( props, specialEasing ) { var index, name, easing, value, hooks;

// camelCase, specialEasing and expand cssHook pass for ( index in props ) { name = jQuery.camelCase( index ); easing = specialEasing[ name ]; value = props[ index ]; if ( jQuery.isArray( value ) ) { easing = value[ 1 ]; value = props[ index ] = value[ 0 ]; }

if ( index !== name ) { props[ name ] = value; delete props[ index ]; }

hooks = jQuery.cssHooks[ name ]; if ( hooks && "expand" in hooks ) { value = hooks.expand( value ); delete props[ name ];

// not quite $.extend, this wont overwrite keys already present. // also - reusing 'index' from above because we have the correct "name" for ( index in value ) { if ( !( index in props ) ) { props[ index ] = value[ index ]; specialEasing[ index ] = easing; }			}		} else { specialEasing[ name ] = easing; }	} }

function Animation( elem, properties, options ) { var result, stopped, index = 0, length = Animation.prefilters.length, deferred = jQuery.Deferred.always( function {

// don't match elem in the :animated selector delete tick.elem; } ),		tick = function {			if ( stopped ) {				return false;			}			var currentTime = fxNow || createFxNow,				remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),

// Support: Android 2.3 // Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497) temp = remaining / animation.duration || 0, percent = 1 - temp, index = 0, length = animation.tweens.length;

for (index < length ; index++ ) { animation.tweens[ index ].run( percent ); }

deferred.notifyWith( elem, [ animation, percent, remaining ] );

if ( percent < 1 && length ) { return remaining; } else { deferred.resolveWith( elem, [ animation ] ); return false; }		},		animation = deferred.promise( {			elem: elem,			props: jQuery.extend( {}, properties ),			opts: jQuery.extend( true, { specialEasing: {}, easing: jQuery.easing._default }, options ),			originalProperties: properties,			originalOptions: options,			startTime: fxNow || createFxNow,			duration: options.duration,			tweens: [],			createTween: function( prop, end ) {				var tween = jQuery.Tween( elem, animation.opts, prop, end, animation.opts.specialEasing[ prop ] || animation.opts.easing );				animation.tweens.push( tween );				return tween;			},			stop: function( gotoEnd ) {				var index = 0,

// if we are going to the end, we want to run all the tweens // otherwise we skip this part length = gotoEnd ? animation.tweens.length : 0; if ( stopped ) { return this; }				stopped = true; for (index < length ; index++ ) { animation.tweens[ index ].run( 1 ); }

// resolve when we played the last frame // otherwise, reject if ( gotoEnd ) { deferred.notifyWith( elem, [ animation, 1, 0 ] ); deferred.resolveWith( elem, [ animation, gotoEnd ] ); } else { deferred.rejectWith( elem, [ animation, gotoEnd ] ); }				return this; }		} ),		props = animation.props;

propFilter( props, animation.opts.specialEasing );

for (index < length ; index++ ) { result = Animation.prefilters[ index ].call( animation, elem, props, animation.opts ); if ( result ) { if ( jQuery.isFunction( result.stop ) ) { jQuery._queueHooks( animation.elem, animation.opts.queue ).stop = jQuery.proxy( result.stop, result ); }			return result; }	}

jQuery.map( props, createTween, animation );

if ( jQuery.isFunction( animation.opts.start ) ) { animation.opts.start.call( elem, animation ); }

jQuery.fx.timer(		jQuery.extend( tick, { elem: elem, anim: animation, queue: animation.opts.queue } )	);

// attach callbacks from options return animation.progress( animation.opts.progress ) .done( animation.opts.done, animation.opts.complete ) .fail( animation.opts.fail ) .always( animation.opts.always ); }

jQuery.Animation = jQuery.extend( Animation, {

tweeners: { "*": [ function( prop, value ) { var tween = this.createTween( prop, value ); adjustCSS( tween.elem, prop, rcssNum.exec( value ), tween ); return tween; } ]	},

tweener: function( props, callback ) { if ( jQuery.isFunction( props ) ) { callback = props; props = [ "*" ]; } else { props = props.match( rnotwhite ); }

var prop, index = 0, length = props.length;

for (index < length ; index++ ) { prop = props[ index ]; Animation.tweeners[ prop ] = Animation.tweeners[ prop ] || []; Animation.tweeners[ prop ].unshift( callback ); }	},

prefilters: [ defaultPrefilter ],

prefilter: function( callback, prepend ) { if ( prepend ) { Animation.prefilters.unshift( callback ); } else { Animation.prefilters.push( callback ); }	} } );

jQuery.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;

// normalize opt.queue - true/undefined/null -> "fx" if ( opt.queue == null || opt.queue === true ) { opt.queue = "fx"; }

// Queueing opt.old = opt.complete;

opt.complete = function { if ( jQuery.isFunction( opt.old ) ) { opt.old.call( this ); }

if ( opt.queue ) { jQuery.dequeue( this, opt.queue ); }	};

return opt; };

jQuery.fn.extend( {	fadeTo: function( speed, to, easing, callback ) {

// show any hidden elements after setting opacity to 0 return this.filter( isHidden ).css( "opacity", 0 ).show

// animate to the value specified .end.animate( { opacity: to }, speed, easing, callback ); },	animate: function( prop, speed, easing, callback ) { var empty = jQuery.isEmptyObject( prop ), optall = jQuery.speed( speed, easing, callback ), doAnimation = function {

// Operate on a copy of prop so per-property easing won't be lost var anim = Animation( this, jQuery.extend( {}, prop ), optall );

// Empty animations, or finishing resolves immediately if ( empty || jQuery._data( this, "finish" ) ) { anim.stop( true ); }			};			doAnimation.finish = doAnimation;

return empty || optall.queue === false ? this.each( doAnimation ) : this.queue( optall.queue, doAnimation ); },	stop: function( type, clearQueue, gotoEnd ) { var stopQueue = function( hooks ) { var stop = hooks.stop; delete hooks.stop; stop( gotoEnd ); };

if ( typeof type !== "string" ) { gotoEnd = clearQueue; clearQueue = type; type = undefined; }		if ( clearQueue && type !== false ) { this.queue( type || "fx", [] ); }

return this.each( function {			var dequeue = true,				index = type != null && type + "queueHooks",				timers = jQuery.timers,				data = jQuery._data( this );

if ( index ) { if ( data[ index ] && data[ index ].stop ) { stopQueue( data[ index ] ); }			} else { for ( index in data ) { if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) { stopQueue( data[ index ] ); }				}			}

for ( index = timers.length; index--; ) { if ( timers[ index ].elem === this &&					( type == null || timers[ index ].queue === type ) ) {

timers[ index ].anim.stop( gotoEnd ); dequeue = false; timers.splice( index, 1 ); }			}

// start the next in the queue if the last step wasn't forced // timers currently will call their complete callbacks, which will dequeue // but only if they were gotoEnd if ( dequeue || !gotoEnd ) { jQuery.dequeue( this, type ); }		} );	},	finish: function( type ) {		if ( type !== false ) {			type = type || "fx";		}		return this.each( function { var index, data = jQuery._data( this ), queue = data[ type + "queue" ], hooks = data[ type + "queueHooks" ], timers = jQuery.timers, length = queue ? queue.length : 0;

// enable finishing flag on private data data.finish = true;

// empty the queue first jQuery.queue( this, type, [] );

if ( hooks && hooks.stop ) { hooks.stop.call( this, true ); }

// look for any active animations, and finish them for ( index = timers.length; index--; ) { if ( timers[ index ].elem === this && timers[ index ].queue === type ) { timers[ index ].anim.stop( true ); timers.splice( index, 1 ); }			}

// look for any animations in the old queue and finish them for ( index = 0; index < length; index++ ) { if ( queue[ index ] && queue[ index ].finish ) { queue[ index ].finish.call( this ); }			}

// turn off finishing flag delete data.finish; } );	} } );

jQuery.each( [ "toggle", "show", "hide" ], function( i, name ) {	var cssFn = jQuery.fn[ name ];	jQuery.fn[ name ] = function( speed, easing, callback ) {		return speed == null || typeof speed === "boolean" ?			cssFn.apply( this, arguments ) :			this.animate( genFx( name, true ), speed, easing, callback );	}; } );

// Generate shortcuts for custom animations jQuery.each( {	slideDown: genFx( "show" ),	slideUp: genFx( "hide" ),	slideToggle: genFx( "toggle" ),	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.timers = []; jQuery.fx.tick = function { var timer, timers = jQuery.timers, i = 0;

fxNow = jQuery.now;

for (i < timers.length; i++ ) { timer = timers[ i ];

// Checks the timer has not already been removed if ( !timer && timers[ i ] === timer ) { timers.splice( i--, 1 ); }	}

if ( !timers.length ) { jQuery.fx.stop; }	fxNow = undefined; };

jQuery.fx.timer = function( timer ) { jQuery.timers.push( timer ); if ( timer ) { jQuery.fx.start; } else { jQuery.timers.pop; } };

jQuery.fx.interval = 13;

jQuery.fx.start = function { if ( !timerId ) { timerId = window.setInterval( jQuery.fx.tick, jQuery.fx.interval ); } };

jQuery.fx.stop = function { window.clearInterval( timerId ); timerId = null; };

jQuery.fx.speeds = { slow: 600, fast: 200,

// Default speed _default: 400 };

// Based off of the plugin by Clint Helfers, with permission. // http://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/ jQuery.fn.delay = function( time, type ) { time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time; type = type || "fx";

return this.queue( type, function( next, hooks ) {		var timeout = window.setTimeout( next, time );		hooks.stop = function {			window.clearTimeout( timeout );		};	} ); };

( function {	var a,		input = document.createElement( "input" ),		div = document.createElement( "div" ),		select = document.createElement( "select" ),		opt = select.appendChild( document.createElement( "option" ) );

// Setup div = document.createElement( "div" ); div.setAttribute( "className", "t" ); div.innerHTML = "  a"; a = div.getElementsByTagName( "a" )[ 0 ];

// Support: Windows Web Apps (WWA) // `type` must use .setAttribute for WWA (#14901) input.setAttribute( "type", "checkbox" ); div.appendChild( input );

a = div.getElementsByTagName( "a" )[ 0 ];

// First batch of tests. a.style.cssText = "top:1px";

// Test setAttribute on camelCase class. // If it works, we need attrFixes when doing get/setAttribute (ie6/7) support.getSetAttribute = div.className !== "t";

// Get the style information from getAttribute // (IE uses .cssText instead) support.style = /top/.test( a.getAttribute( "style" ) );

// Make sure that URLs aren't manipulated // (IE normalizes it by default) support.hrefNormalized = a.getAttribute( "href" ) === "/a";

// Check the default checkbox/radio value ("" on WebKit; "on" elsewhere) support.checkOn = !!input.value;

// 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) support.optSelected = opt.selected;

// Tests for enctype support on a form (#6743) support.enctype = !!document.createElement( "form" ).enctype;

// 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;

// Support: IE8 only // Check if we can trust getAttribute("value") input = document.createElement( "input" ); input.setAttribute( "value", "" ); support.input = input.getAttribute( "value" ) === "";

// Check if an input maintains its value after becoming a radio input.value = "t"; input.setAttribute( "type", "radio" ); support.radioValue = input.value === "t"; } );

var rreturn = /\r/g, rspaces = /[\x20\t\r\n\f]+/g;

jQuery.fn.extend( {	val: function( value ) {		var hooks, ret, isFunction,			elem = this[ 0 ];

if ( !arguments.length ) { if ( elem ) { hooks = jQuery.valHooks[ elem.type ] || jQuery.valHooks[ elem.nodeName.toLowerCase ];

if (					hooks &&					"get" in hooks &&					( ret = hooks.get( elem, "value" ) ) !== undefined				) { return ret; }

ret = elem.value;

return typeof ret === "string" ?

// handle most common string cases ret.replace( rreturn, "" ) :

// handle cases where value is null/undef or number ret == null ? "" : ret; }

return; }

isFunction = jQuery.isFunction( value );

return this.each( function( i ) {			var val;

if ( this.nodeType !== 1 ) { return; }

if ( isFunction ) { val = value.call( this, i, jQuery( this ).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.type ] || jQuery.valHooks[ this.nodeName.toLowerCase ];

// 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 ) {				var val = jQuery.find.attr( elem, "value" );				return val != null ?					val :

// Support: IE10-11+ // option.text throws exceptions (#14686, #14858) // Strip and collapse whitespace // https://html.spec.whatwg.org/#strip-and-collapse-whitespace jQuery.trim( jQuery.text( elem ) ).replace( rspaces, " " ); }		},		select: { get: function( elem ) { var value, option, options = elem.options, index = elem.selectedIndex, one = elem.type === "select-one" || index < 0, values = one ? null : [], max = one ? index + 1 : options.length, i = index < 0 ? max : one ? index : 0;

// Loop through all the selected options for (i < max; i++ ) { option = options[ i ];

// oldIE doesn't update selected after form reset (#2551) if ( ( option.selected || i === index ) &&

// Don't return options that are disabled or in a disabled optgroup ( 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 ); }				}

return values; },

set: function( elem, value ) { var optionSet, option, options = elem.options, values = jQuery.makeArray( value ), i = options.length;

while ( i-- ) { option = options[ i ];

if ( jQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1 ) {

// Support: IE6 // When new option element is added to select box we need to						// force reflow of newly added node in order to workaround delay // of initialization properties try { option.selected = optionSet = true;

} catch ( _ ) {

// Will be executed only in IE6 option.scrollHeight; }

} else { option.selected = false; }				}

// Force browsers to behave consistently when non-matching value is set if ( !optionSet ) { elem.selectedIndex = -1; }

return options; }		}	} } );

// Radios and checkboxes getter/setter jQuery.each( [ "radio", "checkbox" ], function {	jQuery.valHooks[ this ] = {		set: function( elem, value ) {			if ( jQuery.isArray( value ) ) {				return ( elem.checked = jQuery.inArray( jQuery( elem ).val, value ) > -1 );			}		}	};	if ( !support.checkOn ) {		jQuery.valHooks[ this ].get = function( elem ) {			return elem.getAttribute( "value" ) === null ? "on" : elem.value;		};	} } );

var nodeHook, boolHook, attrHandle = jQuery.expr.attrHandle, ruseDefault = /^(?:checked|selected)$/i, getSetAttribute = support.getSetAttribute, getSetInput = support.input;

jQuery.fn.extend( {	attr: function( name, value ) {		return access( this, jQuery.attr, name, value, arguments.length > 1 );	},

removeAttr: function( name ) { return this.each( function {			jQuery.removeAttr( this, name );		} ); } } );

jQuery.extend( {	attr: function( elem, name, value ) {		var ret, hooks,			nType = elem.nodeType;

// Don't get/set attributes on text, comment and attribute nodes if ( nType === 3 || nType === 8 || nType === 2 ) { return; }

// Fallback to prop when attributes are not supported if ( typeof elem.getAttribute === "undefined" ) { return jQuery.prop( elem, name, value ); }

// All attributes are lowercase // Grab necessary hook if one is defined if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) { name = name.toLowerCase; hooks = jQuery.attrHooks[ name ] || ( jQuery.expr.match.bool.test( name ) ? boolHook : nodeHook ); }

if ( value !== undefined ) { if ( value === null ) { jQuery.removeAttr( elem, name ); return; }

if ( hooks && "set" in hooks &&				( ret = hooks.set( elem, value, name ) ) !== undefined ) { return ret; }

elem.setAttribute( name, value + "" ); return value; }

if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) { return ret; }

ret = jQuery.find.attr( elem, name );

// Non-existent attributes return null, we normalize to undefined return ret == null ? undefined : ret; },

attrHooks: { type: { set: function( elem, value ) { if ( !support.radioValue && value === "radio" &&					jQuery.nodeName( elem, "input" ) ) {

// Setting the type on a radio button after the value resets the value in IE8-9 // Reset value to default in case type is set after value during creation var val = elem.value; elem.setAttribute( "type", value ); if ( val ) { elem.value = val; }					return value; }			}		}	},

removeAttr: function( elem, value ) { var name, propName, i = 0, attrNames = value && value.match( rnotwhite );

if ( attrNames && elem.nodeType === 1 ) { while ( ( name = attrNames[ i++ ] ) ) { propName = jQuery.propFix[ name ] || name;

// Boolean attributes get special treatment (#10870) if ( jQuery.expr.match.bool.test( name ) ) {

// Set corresponding property to false if ( getSetInput && getSetAttribute || !ruseDefault.test( name ) ) { elem[ propName ] = false;

// Support: IE<9 // Also clear defaultChecked/defaultSelected (if appropriate) } else { elem[ jQuery.camelCase( "default-" + name ) ] = elem[ propName ] = false; }

// See #9699 for explanation of this approach (setting first, then removal) } else { jQuery.attr( elem, name, "" ); }

elem.removeAttribute( getSetAttribute ? name : propName ); }		}	} } );

// Hooks for boolean attributes boolHook = { set: function( elem, value, name ) { if ( value === false ) {

// Remove boolean attributes when set to false jQuery.removeAttr( elem, name ); } else if ( getSetInput && getSetAttribute || !ruseDefault.test( name ) ) {

// IE<8 needs the *property* name elem.setAttribute( !getSetAttribute && jQuery.propFix[ name ] || name, name );

} else {

// Support: IE<9 // Use defaultChecked and defaultSelected for oldIE elem[ jQuery.camelCase( "default-" + name ) ] = elem[ name ] = true; }		return name; } };

jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( i, name ) {	var getter = attrHandle[ name ] || jQuery.find.attr;

if ( getSetInput && getSetAttribute || !ruseDefault.test( name ) ) { attrHandle[ name ] = function( elem, name, isXML ) { var ret, handle; if ( !isXML ) {

// Avoid an infinite loop by temporarily removing this function from the getter handle = attrHandle[ name ]; attrHandle[ name ] = ret; ret = getter( elem, name, isXML ) != null ? name.toLowerCase : null; attrHandle[ name ] = handle; }			return ret; };	} else { attrHandle[ name ] = function( elem, name, isXML ) { if ( !isXML ) { return elem[ jQuery.camelCase( "default-" + name ) ] ? name.toLowerCase : null; }		};	} } );

// fix oldIE attroperties if ( !getSetInput || !getSetAttribute ) { jQuery.attrHooks.value = { set: function( elem, value, name ) { if ( jQuery.nodeName( elem, "input" ) ) {

// Does not return so that setAttribute is also used elem.defaultValue = value; } else {

// Use nodeHook if defined (#1954); otherwise setAttribute is fine return nodeHook && nodeHook.set( elem, value, name ); }		}	}; }

// IE6/7 do not support getting/setting some attributes with get/setAttribute if ( !getSetAttribute ) {

// Use this for any attribute in IE6/7 // This fixes almost every IE6/7 issue nodeHook = { set: function( elem, value, name ) {

// Set the existing or create a new attribute node var ret = elem.getAttributeNode( name ); if ( !ret ) { elem.setAttributeNode(					( ret = elem.ownerDocument.createAttribute( name ) )				); }

ret.value = value += "";

// Break association with cloned elements by also using setAttribute (#9646) if ( name === "value" || value === elem.getAttribute( name ) ) { return value; }		}	};

// Some attributes are constructed with empty-string values when not defined attrHandle.id = attrHandle.name = attrHandle.coords = function( elem, name, isXML ) { var ret; if ( !isXML ) { return ( ret = elem.getAttributeNode( name ) ) && ret.value !== "" ? ret.value : null; }		};

// Fixing value retrieval on a button requires this module jQuery.valHooks.button = { get: function( elem, name ) { var ret = elem.getAttributeNode( name ); if ( ret && ret.specified ) { return ret.value; }		},		set: nodeHook.set };

// Set contenteditable to false on removals(#10429) // Setting to empty string throws an error as an invalid value jQuery.attrHooks.contenteditable = { set: function( elem, value, name ) { nodeHook.set( elem, value === "" ? false : value, name ); }	};

// 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 ] = {			set: function( elem, value ) {				if ( value === "" ) {					elem.setAttribute( name, "auto" );					return value;				}			}		};	} ); }

if ( !support.style ) { jQuery.attrHooks.style = { get: function( elem ) {

// Return undefined in the case of empty string // Note: IE uppercases css property names, but if we were to .toLowerCase // .cssText, that would destroy case sensitivity in URL's, like in "background" return elem.style.cssText || undefined; },		set: function( elem, value ) { return ( elem.style.cssText = value + "" ); }	}; }

var rfocusable = /^(?:input|select|textarea|button|object)$/i, rclickable = /^(?:a|area)$/i;

jQuery.fn.extend( {	prop: function( name, value ) {		return access( this, jQuery.prop, name, value, arguments.length > 1 );	},

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 ) {} } );	} } );

jQuery.extend( {	prop: function( elem, name, value ) {		var ret, hooks,			nType = elem.nodeType;

// Don't get/set properties on text, comment and attribute nodes if ( nType === 3 || nType === 8 || nType === 2 ) { return; }

if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {

// Fix name and attach hooks name = 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; }

return ( elem[ name ] = value ); }

if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) { return ret; }

return elem[ name ]; },

propHooks: { 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/ // Use proper attribute retrieval(#12072) var tabindex = jQuery.find.attr( elem, "tabindex" );

return tabindex ? parseInt( tabindex, 10 ) : rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ? 0 :							-1;			}		}	},

propFix: { "for": "htmlFor", "class": "className" } } );

// Some attributes require a special call on IE // http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx if ( !support.hrefNormalized ) {

// href/src property should get the full normalized URL (#10299/#12915) jQuery.each( [ "href", "src" ], function( i, name ) {		jQuery.propHooks[ name ] = {			get: function( elem ) {				return elem.getAttribute( name, 4 );			}		};	} ); }

// Support: Safari, IE9+ // Accessing the selectedIndex property // forces the browser to respect setting selected // on the option // The getter ensures a default option is selected // when in an optgroup if ( !support.optSelected ) { 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; }			}			return null; },		set: function( elem ) { var parent = elem.parentNode; if ( parent ) { parent.selectedIndex;

if ( parent.parentNode ) { parent.parentNode.selectedIndex; }			}		}	}; }

jQuery.each( [	"tabIndex",	"readOnly",	"maxLength",	"cellSpacing",	"cellPadding",	"rowSpan",	"colSpan",	"useMap",	"frameBorder",	"contentEditable" ], function {	jQuery.propFix[ this.toLowerCase ] = this; } );

// IE6/7 call enctype encoding if ( !support.enctype ) { jQuery.propFix.enctype = "encoding"; }

var rclass = /[\t\r\n\f]/g;

function getClass( elem ) { return jQuery.attr( elem, "class" ) || ""; }

jQuery.fn.extend( {	addClass: function( value ) {		var classes, elem, cur, curValue, clazz, j, finalValue,			i = 0;

if ( jQuery.isFunction( value ) ) { return this.each( function( j ) {				jQuery( this ).addClass( value.call( this, j, getClass( this ) ) );			} ); }

if ( typeof value === "string" && value ) { classes = value.match( rnotwhite ) || [];

while ( ( elem = this[ i++ ] ) ) { curValue = getClass( elem ); cur = elem.nodeType === 1 && ( " " + curValue + " " ).replace( rclass, " " );

if ( cur ) { j = 0; while ( ( clazz = classes[ j++ ] ) ) { if ( cur.indexOf( " " + clazz + " " ) < 0 ) { cur += clazz + " "; }					}

// only assign if different to avoid unneeded rendering. finalValue = jQuery.trim( cur ); if ( curValue !== finalValue ) { jQuery.attr( elem, "class", finalValue ); }				}			}		}

return this; },

removeClass: function( value ) { var classes, elem, cur, curValue, clazz, j, finalValue, i = 0;

if ( jQuery.isFunction( value ) ) { return this.each( function( j ) {				jQuery( this ).removeClass( value.call( this, j, getClass( this ) ) );			} ); }

if ( !arguments.length ) { return this.attr( "class", "" ); }

if ( typeof value === "string" && value ) { classes = value.match( rnotwhite ) || [];

while ( ( elem = this[ i++ ] ) ) { curValue = getClass( elem );

// This expression is here for better compressibility (see addClass) cur = elem.nodeType === 1 && ( " " + curValue + " " ).replace( rclass, " " );

if ( cur ) { j = 0; while ( ( clazz = classes[ j++ ] ) ) {

// Remove *all* instances while ( cur.indexOf( " " + clazz + " " ) > -1 ) { cur = cur.replace( " " + clazz + " ", " " ); }					}

// Only assign if different to avoid unneeded rendering. finalValue = jQuery.trim( cur ); if ( curValue !== finalValue ) { jQuery.attr( elem, "class", finalValue ); }				}			}		}

return this; },

toggleClass: function( value, stateVal ) { var type = typeof value;

if ( typeof stateVal === "boolean" && type === "string" ) { return stateVal ? this.addClass( value ) : this.removeClass( value ); }

if ( jQuery.isFunction( value ) ) { return this.each( function( i ) {				jQuery( this ).toggleClass( value.call( this, i, getClass( this ), stateVal ), stateVal );			} );		}

return this.each( function {			var className, i, self, classNames;

if ( type === "string" ) {

// Toggle individual class names i = 0; self = jQuery( this ); classNames = value.match( rnotwhite ) || [];

while ( ( className = classNames[ i++ ] ) ) {

// Check each className given, space separated list if ( self.hasClass( className ) ) { self.removeClass( className ); } else { self.addClass( className ); }				}

// Toggle whole class name } else if ( value === undefined || type === "boolean" ) { className = getClass( this ); if ( className ) {

// store className if set jQuery._data( this, "__className__", className ); }

// If the element has a class name or if we're passed "false", // then remove the whole classname (if there was one, the above saved it). // Otherwise bring back whatever was previously saved (if anything), // falling back to the empty string if nothing was stored. jQuery.attr( this, "class",					className || value === false ?					"" :					jQuery._data( this, "__className__" ) || ""				); }		} );	},

hasClass: function( selector ) { var className, elem, i = 0;

className = " " + selector + " "; while ( ( elem = this[ i++ ] ) ) { if ( elem.nodeType === 1 &&				( " " + getClass( elem ) + " " ).replace( rclass, " " )					.indexOf( className ) > -1			) { return true; }		}

return false; } } );

// Return jQuery for attributes-only inclusion

jQuery.each( ( "blur focus focusin focusout load resize scroll unload click dblclick " + "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " + "change select submit keydown keypress keyup error contextmenu" ).split( " " ),	function( i, name ) {

// Handle event binding jQuery.fn[ name ] = function( data, fn ) { return arguments.length > 0 ? this.on( name, null, data, fn ) : this.trigger( name ); }; } );

jQuery.fn.extend( {	hover: function( fnOver, fnOut ) {		return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );	} } );

var location = window.location;

var nonce = jQuery.now;

var rquery = ( /\?/ );

var rvalidtokens = /|(\[|{)|(}|])|"(?:[^"\\\r\n]|\\["\\\/bfnrt]|\\u[\da-fA-F]{4})*"\s*:?|true|false|null|-?(?!0\d)\d+(?:\.\d+|)(?:[eE][+-]?\d+|)/g;

jQuery.parseJSON = function( data ) {

// Attempt to parse using the native JSON parser first if ( window.JSON && window.JSON.parse ) {

// Support: Android 2.3 // Workaround failure to string-cast null input return window.JSON.parse( data + "" ); }

var requireNonComma, depth = null, str = jQuery.trim( data + "" );

// Guard against invalid (and possibly dangerous) input by ensuring that nothing remains // after removing valid tokens return str && !jQuery.trim( str.replace( rvalidtokens, function( token, comma, open, close ) {

// Force termination if we see a misplaced comma if ( requireNonComma && comma ) { depth = 0; }

// Perform no more replacements after returning to outermost depth if ( depth === 0 ) { return token; }

// Commas must not follow "[", "{", or "," requireNonComma = open || comma;

// Determine new depth // array/object open ("[" or "{"): depth += true - false (increment) // array/object close ("]" or "}"): depth += false - true (decrement) // other cases ("," or primitive): depth += true - true (numeric cast) depth += !close - !open;

// Remove this token return ""; } ) ) ?		( Function( "return " + str ) ) : jQuery.error( "Invalid JSON: " + data ); };

// Cross-browser xml parsing jQuery.parseXML = function( data ) { var xml, tmp; if ( !data || typeof data !== "string" ) { return null; }	try { if ( window.DOMParser ) { // Standard tmp = new window.DOMParser; xml = tmp.parseFromString( data, "text/xml" ); } else { // IE			xml = new window.ActiveXObject( "Microsoft.XMLDOM" ); xml.async = "false"; xml.loadXML( data ); }	} catch ( e ) { xml = undefined; }	if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) { jQuery.error( "Invalid XML: " + data ); }	return xml; };

var rhash = /#.*$/, rts = /([?&])_=[^&]*/,

// IE leaves an \r character at EOL rheaders = /^(.*?):[ \t]*([^\r\n]*)\r?$/mg,

// #7653, #8125, #8152: local protocol detection rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/, rnoContent = /^(?:GET|HEAD)$/, rprotocol = /^\/\//, rurl = /^([\w.+-]+:)(?:\/\/(?:[^\/?#]*@|)([^\/?#:]*)(?::(\d+)|)|)/,

/* 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 = {},

// Avoid comment-prolog char sequence (#10098); must appease lint and evade compression allTypes = "*/".concat( "*" ),

// Document location ajaxLocation = location.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 = "*"; }

var dataType, i = 0, dataTypes = dataTypeExpression.toLowerCase.match( rnotwhite ) || [];

if ( jQuery.isFunction( func ) ) {

// For each dataType in the dataTypeExpression while ( ( dataType = dataTypes[ i++ ] ) ) {

// Prepend if requested if ( dataType.charAt( 0 ) === "+" ) { dataType = dataType.slice( 1 ) || "*"; ( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func );

// Otherwise append } else { ( structure[ dataType ] = structure[ dataType ] || [] ).push( func ); }			}		}	}; }

// Base inspection function for prefilters and transports function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {

var inspected = {}, seekingTransport = ( structure === transports );

function inspect( dataType ) { var selected; inspected[ dataType ] = true; jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {			var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );			if ( typeof dataTypeOrTransport === "string" && !seekingTransport && !inspected[ dataTypeOrTransport ] ) {

options.dataTypes.unshift( dataTypeOrTransport ); inspect( dataTypeOrTransport ); return false; } else if ( seekingTransport ) { return !( selected = dataTypeOrTransport ); }		} );		return selected;	}

return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" ); }

// A special extend for ajax options // that takes "flat" options (not to be deep extended) // Fixes #9887 function ajaxExtend( target, src ) { var deep, key, flatOptions = jQuery.ajaxSettings.flatOptions || {};

for ( key in src ) { if ( src[ key ] !== undefined ) { ( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ]; }	}	if ( deep ) { jQuery.extend( true, target, deep ); }

return target; }

/* Handles responses to an ajax request: * - finds the right dataType (mediates between content-type and expected dataType) * - returns the corresponding response */ function ajaxHandleResponses( s, jqXHR, responses ) { var firstDataType, ct, finalDataType, type, contents = s.contents, dataTypes = s.dataTypes;

// 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 * Also sets the responseXXX fields on the jqXHR instance */ function ajaxConvert( s, response, jqXHR, isSuccess ) { var conv2, current, conv, tmp, prev, converters = {},

// Work with a copy of dataTypes in case we need to modify it for conversion dataTypes = s.dataTypes.slice;

// Create converters map with lowercased keys if ( dataTypes[ 1 ] ) { for ( conv in s.converters ) { converters[ conv.toLowerCase ] = s.converters[ conv ]; }	}

current = dataTypes.shift;

// Convert to each sequential dataType while ( current ) {

if ( s.responseFields[ current ] ) { jqXHR[ s.responseFields[ current ] ] = response; }

// Apply the dataFilter if provided if ( !prev && isSuccess && s.dataFilter ) { response = s.dataFilter( response, s.dataType ); }

prev = current; current = dataTypes.shift;

if ( current ) {

// There's only work to do if current dataType is non-auto if ( current === "*" ) {

current = prev;

// Convert response if prev dataType is non-auto and differs from current } else if ( prev !== "*" && prev !== current ) {

// Seek a direct converter conv = converters[ prev + " " + current ] || converters[ "* " + current ];

// If none found, seek a pair if ( !conv ) { for ( conv2 in converters ) {

// If conv2 outputs current tmp = conv2.split( " " ); if ( tmp[ 1 ] === current ) {

// If prev can be converted to accepted input conv = converters[ prev + " " + tmp[ 0 ] ] || converters[ "* " + tmp[ 0 ] ]; if ( conv ) {

// Condense equivalence converters if ( conv === true ) { conv = converters[ conv2 ];

// Otherwise, insert the intermediate dataType } else if ( converters[ conv2 ] !== true ) { current = tmp[ 0 ]; dataTypes.unshift( tmp[ 1 ] ); }								break; }						}					}				}

// Apply converter (if not an equivalence) if ( conv !== true ) {

// Unless errors are allowed to bubble, catch and return them if ( conv && s[ "throws" ] ) { // jscs:ignore requireDotNotation response = conv( response ); } else { try { response = conv( response ); } catch ( e ) { return { state: "parsererror", error: conv ? e : "No conversion from " + prev + " to " + current };						}					}				}			}		}	}

return { state: "success", data: response }; }

jQuery.extend( {

// Counter for holding the number of active queries active: 0,

// Last-Modified header cache for next request lastModified: {}, etag: {},

ajaxSettings: { url: ajaxLocation, type: "GET", isLocal: rlocalProtocol.test( ajaxLocParts[ 1 ] ), global: true, processData: true, async: true, contentType: "application/x-www-form-urlencoded; charset=UTF-8", /*		timeout: 0, data: null, dataType: null, username: null, password: null, cache: null, throws: false, traditional: false, headers: {}, */

accepts: { "*": allTypes, text: "text/plain", html: "text/html", xml: "application/xml, text/xml", json: "application/json, text/javascript" },

contents: { xml: /\bxml\b/, html: /\bhtml/, json: /\bjson\b/ },

responseFields: { xml: "responseXML", text: "responseText", json: "responseJSON" },

// Data converters // Keys separate source (or catchall "*") and destination types with a single space converters: {

// Convert anything to text "* text": 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 },

// For options that shouldn't be deep extended: // you can add your own custom options here if		// and when you create one that shouldn't be		// deep extended (see ajaxExtend) flatOptions: { url: true, context: true }	},

// 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 ) { return settings ?

// Building a settings object ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :

// Extending ajaxSettings ajaxExtend( jQuery.ajaxSettings, target ); },

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

// Cross-domain detection vars parts,

// Loop variable i,

// URL without anti-cache param cacheURL,

// Response headers as string responseHeadersString,

// timeout handle timeoutTimer,

// To know if global events are to be dispatched fireGlobals,

transport,

// Response headers responseHeaders,

// Create the final options object s = jQuery.ajaxSetup( {}, options ),

// Callbacks context callbackContext = s.context || s,

// Context for global events is callbackContext if it is a DOM node or jQuery collection globalEventContext = s.context && ( callbackContext.nodeType || callbackContext.jquery ) ? jQuery( callbackContext ) : jQuery.event,

// Deferreds deferred = jQuery.Deferred, completeDeferred = jQuery.Callbacks( "once memory" ),

// Status-dependent callbacks statusCode = s.statusCode || {},

// Headers (they are sent all at once) requestHeaders = {}, requestHeadersNames = {},

// The jqXHR state state = 0,

// Default abort message strAbort = "canceled",

// Fake xhr jqXHR = { readyState: 0,

// 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 == null ? null : match; },

// Raw string getAllResponseHeaders: function { return state === 2 ? responseHeadersString : null; },

// Caches the header setRequestHeader: function( name, value ) { var lname = name.toLowerCase; if ( !state ) { name = requestHeadersNames[ lname ] = requestHeadersNames[ lname ] || name; requestHeaders[ name ] = value; }					return this; },

// Overrides response content-type header overrideMimeType: function( type ) { if ( !state ) { s.mimeType = type; }					return this; },

// Status-dependent callbacks statusCode: function( map ) { var code; if ( map ) { if ( state < 2 ) { for ( code in map ) {

// Lazy-add the new callback in a way that preserves old ones statusCode[ code ] = [ statusCode[ code ], map[ code ] ]; }						} else {

// Execute the appropriate callbacks jqXHR.always( map[ jqXHR.status ] ); }					}					return this; },

// Cancel the request abort: function( statusText ) { var finalText = statusText || strAbort; if ( transport ) { transport.abort( finalText ); }					done( 0, finalText ); return this; }			};

// Attach deferreds deferred.promise( jqXHR ).complete = completeDeferred.add; jqXHR.success = jqXHR.done; jqXHR.error = jqXHR.fail;

// Remove hash character (#7531: and string promotion) // Add protocol if not provided (#5866: IE7 issue with protocol-less urls) // Handle falsy url in the settings object (#10093: consistency with old signature) // We also use the url parameter if available s.url = ( ( url || s.url || ajaxLocation ) + "" ) .replace( rhash, "" ) .replace( rprotocol, ajaxLocParts[ 1 ] + "//" );

// Alias method option to type as per ticket #12004 s.type = options.method || options.type || s.method || s.type;

// Extract dataTypes list s.dataTypes = jQuery.trim( s.dataType || "*" ).toLowerCase.match( rnotwhite ) || [ "" ];

// A cross-domain request is in order when we have a protocol:host:port mismatch 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 prefilter, stop there if ( state === 2 ) { return jqXHR; }

// We can fire global events as of now if asked to		// Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118) fireGlobals = jQuery.event && s.global;

// Watch for a new set of requests if ( fireGlobals && jQuery.active++ === 0 ) { jQuery.event.trigger( "ajaxStart" ); }

// Uppercase the type s.type = s.type.toUpperCase;

// Determine if request has content s.hasContent = !rnoContent.test( s.type );

// Save the URL in case we're toying with the If-Modified-Since // and/or If-None-Match header later on		cacheURL = s.url;

// More options handling for requests with no content if ( !s.hasContent ) {

// If data is available, append data to url if ( s.data ) { cacheURL = ( s.url += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data );

// #9682: remove data so that it's not used in an eventual retry delete s.data; }

// Add anti-cache in url if needed if ( s.cache === false ) { s.url = rts.test( cacheURL ) ?

// If there is already a '_' parameter, set its value cacheURL.replace( rts, "$1_=" + nonce++ ) :

// Otherwise add one to the end cacheURL + ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + nonce++; }		}

// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. if ( s.ifModified ) { if ( jQuery.lastModified[ cacheURL ] ) { jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] ); }			if ( jQuery.etag[ cacheURL ] ) { jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] ); }		}

// 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 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 ] !== "*" ? ", " + allTypes + "; 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 and return return jqXHR.abort; }

// aborting is no longer a cancellation strAbort = "abort";

// 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 ] ); }

// If request was aborted inside ajaxSend, stop there if ( state === 2 ) { return jqXHR; }

// Timeout if ( s.async && s.timeout > 0 ) { timeoutTimer = window.setTimeout( function {					jqXHR.abort( "timeout" );				}, s.timeout ); }

try { state = 1; transport.send( requestHeaders, done ); } catch ( e ) {

// Propagate exception as error if not done if ( state < 2 ) { done( -1, e );

// Simply rethrow otherwise } else { throw e;				} }		}

// Callback for when everything is done function done( status, nativeStatusText, responses, headers ) { var isSuccess, success, error, response, modified, statusText = nativeStatusText;

// Called once if ( state === 2 ) { return; }

// State is "done" now state = 2;

// Clear timeout if it exists if ( timeoutTimer ) { window.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 > 0 ? 4 : 0;

// Determine if successful isSuccess = status >= 200 && status < 300 || status === 304;

// Get response data if ( responses ) { response = ajaxHandleResponses( s, jqXHR, responses ); }

// Convert no matter what (that way responseXXX fields are always set) response = ajaxConvert( s, response, jqXHR, isSuccess );

// If successful, handle type chaining if ( isSuccess ) {

// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. if ( s.ifModified ) { modified = jqXHR.getResponseHeader( "Last-Modified" ); if ( modified ) { jQuery.lastModified[ cacheURL ] = modified; }					modified = jqXHR.getResponseHeader( "etag" ); if ( modified ) { jQuery.etag[ cacheURL ] = modified; }				}

// if no content if ( status === 204 || s.type === "HEAD" ) { statusText = "nocontent";

// if not modified } else if ( status === 304 ) { statusText = "notmodified";

// If we have data, let's convert it				} else { statusText = response.state; success = response.data; error = response.error; isSuccess = !error; }			} else {

// We extract error from statusText // then normalize statusText and status for non-aborts error = statusText; if ( status || !statusText ) { statusText = "error"; if ( status < 0 ) { status = 0; }				}			}

// Set data for the fake xhr object jqXHR.status = status; jqXHR.statusText = ( nativeStatusText || 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( isSuccess ? "ajaxSuccess" : "ajaxError",					[ jqXHR, s, isSuccess ? success : error ] ); }

// Complete completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );

if ( fireGlobals ) { globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );

// Handle the global AJAX counter if ( !( --jQuery.active ) ) { jQuery.event.trigger( "ajaxStop" ); }			}		}

return jqXHR; },

getJSON: function( url, data, callback ) { return jQuery.get( url, data, callback, "json" ); },

getScript: function( url, callback ) { return jQuery.get( url, undefined, callback, "script" ); } } );

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; }

// The url can be an options object (which then must have .url) return jQuery.ajax( jQuery.extend( { url: url, type: method, dataType: type, data: data, success: callback }, jQuery.isPlainObject( url ) && url ) ); }; } );

jQuery._evalUrl = function( url ) { return jQuery.ajax( {		url: url,

// Make this explicit, since user can override this through ajaxSetup (#11264) type: "GET", dataType: "script", cache: true, async: false, global: false, "throws": true } ); };

jQuery.fn.extend( {	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 ) { var isFunction = jQuery.isFunction( html );

return this.each( function( i ) {			jQuery( this ).wrapAll( isFunction ? html.call( this, i ) : html );		} ); },

unwrap: function { return this.parent.each( function {			if ( !jQuery.nodeName( this, "body" ) ) {				jQuery( this ).replaceWith( this.childNodes );			}		} ).end; } } );

function getDisplay( elem ) { return elem.style && elem.style.display || jQuery.css( elem, "display" ); }

function filterHidden( elem ) {

// Disconnected elements are considered hidden if ( !jQuery.contains( elem.ownerDocument || document, elem ) ) { return true; }	while ( elem && elem.nodeType === 1 ) { if ( getDisplay( elem ) === "none" || elem.type === "hidden" ) { return true; }		elem = elem.parentNode; }	return false; }

jQuery.expr.filters.hidden = function( elem ) {

// Support: Opera <= 12.12 // Opera reports offsetWidths and offsetHeights less than zero on some elements return support.reliableHiddenOffsets ? ( elem.offsetWidth <= 0 && elem.offsetHeight <= 0 &&			!elem.getClientRects.length ) : filterHidden( elem ); };

jQuery.expr.filters.visible = function( elem ) { return !jQuery.expr.filters.hidden( elem ); };

var r20 = /%20/g, rbracket = /\[\]$/, rCRLF = /\r?\n/g, rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i, rsubmittable = /^(?:input|select|textarea|keygen)/i;

function buildParams( prefix, obj, traditional, add ) { var name;

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 {

// Item is non-scalar (array or object), encode its numeric index. buildParams(					prefix + "[" + ( typeof v === "object" && v != null ? i : "" ) + "]",					v,					traditional,					add				); }		} );

} else if ( !traditional && jQuery.type( obj ) === "object" ) {

// Serialize object item. for ( name in obj ) { buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add ); }

} else {

// Serialize scalar item. add( prefix, obj ); } }

// Serialize an array of form elements or a set of // key/values into a query string jQuery.param = function( a, traditional ) { var prefix, s = [], add = function( key, value ) {

// If value is a function, invoke it and return its value value = jQuery.isFunction( value ) ? value : ( value == null ? "" : value ); s[ s.length ] = encodeURIComponent( key ) + "=" + encodeURIComponent( value ); };

// Set traditional to true for jQuery <= 1.3.2 behavior. if ( traditional === undefined ) { traditional = jQuery.ajaxSettings && 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 ( prefix in a ) { buildParams( prefix, a[ prefix ], traditional, add ); }	}

// Return the resulting serialization return s.join( "&" ).replace( r20, "+" ); };

jQuery.fn.extend( {	serialize: function {		return jQuery.param( this.serializeArray );	},	serializeArray: function {		return this.map( function {

// Can add propHook for "elements" to filter or add form elements var elements = jQuery.prop( this, "elements" ); return elements ? jQuery.makeArray( elements ) : this; } )		.filter( function { var type = this.type;

// Use .is(":disabled") so that fieldset[disabled] works return this.name && !jQuery( this ).is( ":disabled" ) && rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) && ( this.checked || !rcheckableType.test( type ) ); } )		.map( function( i, elem ) { var val = jQuery( this ).val;

return val == null ? null : jQuery.isArray( val ) ? jQuery.map( val, function( val ) {						return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };					} ) : { name: elem.name, value: val.replace( rCRLF, "\r\n" ) }; } ).get;	} } );

// Create the request object // (This is still attached to ajaxSettings for backward compatibility) jQuery.ajaxSettings.xhr = window.ActiveXObject !== undefined ?

// Support: IE6-IE8 function {

// XHR cannot access local files, always use ActiveX for that case if ( this.isLocal ) { return createActiveXHR; }

// Support: IE 9-11 // IE seems to error on cross-domain PATCH requests when ActiveX XHR // is used. In IE 9+ always use the native XHR. // Note: this condition won't catch Edge as it doesn't define // document.documentMode but it also doesn't support ActiveX so it won't // reach this code. if ( document.documentMode > 8 ) { return createStandardXHR; }

// Support: IE<9 // oldIE XHR does not support non-RFC2616 methods (#13240) // See http://msdn.microsoft.com/en-us/library/ie/ms536648(v=vs.85).aspx // and http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9 // Although this check for six methods instead of eight // since IE also does not support "trace" and "connect" return /^(get|post|head|put|delete|options)$/i.test( this.type ) && createStandardXHR || createActiveXHR; } :

// For all other browsers, use the standard XMLHttpRequest object createStandardXHR;

var xhrId = 0, xhrCallbacks = {}, xhrSupported = jQuery.ajaxSettings.xhr;

// Support: IE<10 // Open requests must be manually aborted on unload (#5280) // See https://support.microsoft.com/kb/2856746 for more info if ( window.attachEvent ) { window.attachEvent( "onunload", function {		for ( var key in xhrCallbacks ) {			xhrCallbacks[ key ]( undefined, true );		}	} ); }

// Determine support properties support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported ); xhrSupported = support.ajax = !!xhrSupported;

// Create transport if the browser can provide an xhr if ( xhrSupported ) {

jQuery.ajaxTransport( function( options ) {

// Cross domain only allowed if supported through XMLHttpRequest if ( !options.crossDomain || support.cors ) {

var callback;

return { send: function( headers, complete ) { var i,						xhr = options.xhr, id = ++xhrId;

// Open the socket xhr.open(						options.type,						options.url,						options.async,						options.username,						options.password					);

// Apply custom fields if provided if ( options.xhrFields ) { for ( i in options.xhrFields ) { xhr[ i ] = options.xhrFields[ i ]; }					}

// Override mime type if needed if ( options.mimeType && xhr.overrideMimeType ) { xhr.overrideMimeType( options.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 ( !options.crossDomain && !headers[ "X-Requested-With" ] ) { headers[ "X-Requested-With" ] = "XMLHttpRequest"; }

// Set headers for ( i in headers ) {

// Support: IE<9 // IE's ActiveXObject throws a 'Type Mismatch' exception when setting // request header to a null-value. //						// To keep consistent with other XHR implementations, cast the value // to string and ignore `undefined`. if ( headers[ i ] !== undefined ) { xhr.setRequestHeader( i, headers[ i ] + "" ); }					}

// Do send the request // This may raise an exception which is actually // handled in jQuery.ajax (so no try/catch here) xhr.send( ( options.hasContent && options.data ) || null );

// Listener callback = function( _, isAbort ) { var status, statusText, responses;

// Was never called and is aborted or complete if ( callback && ( isAbort || xhr.readyState === 4 ) ) {

// Clean up							delete xhrCallbacks[ id ]; callback = undefined; xhr.onreadystatechange = jQuery.noop;

// Abort manually if needed if ( isAbort ) { if ( xhr.readyState !== 4 ) { xhr.abort; }							} else { responses = {}; status = xhr.status;

// Support: IE<10 // Accessing binary-data responseText throws an exception // (#11426)								if ( typeof xhr.responseText === "string" ) { 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 && options.isLocal && !options.crossDomain ) { status = responses.text ? 200 : 404;

// IE - #1450: sometimes returns 1223 when it should be 204 } else if ( status === 1223 ) { status = 204; }							}						}

// Call complete if needed if ( responses ) { complete( status, statusText, responses, xhr.getAllResponseHeaders ); }					};

// Do send the request // `xhr.send` may raise an exception, but it will be					// handled in jQuery.ajax (so no try/catch here) if ( !options.async ) {

// If we're in sync mode we fire the callback callback; } else if ( xhr.readyState === 4 ) {

// (IE6 & IE7) if it's in cache and has been // retrieved directly we need to fire the callback window.setTimeout( callback ); } else {

// Register the callback, but delay it in case `xhr.send` throws // Add to the list of active xhr callbacks xhr.onreadystatechange = xhrCallbacks[ id ] = callback; }				},

abort: function { if ( callback ) { callback( undefined, true ); }				}			};		}	} ); }

// Functions to create xhrs function createStandardXHR { try { return new window.XMLHttpRequest; } catch ( e ) {} }

function createActiveXHR { try { return new window.ActiveXObject( "Microsoft.XMLHTTP" ); } catch ( e ) {} }

// Install script dataType jQuery.ajaxSetup( {	accepts: {		script: "text/javascript, application/javascript, " +			"application/ecmascript, application/x-ecmascript"	},	contents: {		script: /\b(?:java|ecma)script\b/	},	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 || jQuery( "head" )[ 0 ] || document.documentElement;

return {

send: function( _, callback ) {

script = document.createElement( "script" );

script.async = true;

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 ( script.parentNode ) { script.parentNode.removeChild( script ); }

// Dereference the script script = null;

// Callback if not abort if ( !isAbort ) { callback( 200, "success" ); }					}				};

// Circumvent IE6 bugs with base elements (#2709 and #4378) by prepending // Use native DOM manipulation to avoid our domManip AJAX trickery head.insertBefore( script, head.firstChild ); },

abort: function { if ( script ) { script.onload( undefined, true ); }			}		};	} } );

var oldCallbacks = [], rjsonp = /(=)\?(?=&|$)|\?\?/;

// Default jsonp settings jQuery.ajaxSetup( {	jsonp: "callback",	jsonpCallback: function {		var callback = oldCallbacks.pop || ( jQuery.expando + "_" + ( nonce++ ) );		this[ callback ] = true;		return callback;	} } );

// Detect, normalize options and install callbacks for jsonp requests jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {

var callbackName, overwritten, responseContainer, jsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ?			"url" :			typeof s.data === "string" &&				( s.contentType || "" )					.indexOf( "application/x-www-form-urlencoded" ) === 0 &&				rjsonp.test( s.data ) && "data"		);

// Handle iff the expected data type is "jsonp" or we have a parameter to set if ( jsonProp || s.dataTypes[ 0 ] === "jsonp" ) {

// Get callback name, remembering preexisting value associated with it callbackName = s.jsonpCallback = jQuery.isFunction( s.jsonpCallback ) ? s.jsonpCallback : s.jsonpCallback;

// Insert callback into url or form data if ( jsonProp ) { s[ jsonProp ] = s[ jsonProp ].replace( rjsonp, "$1" + callbackName ); } else if ( s.jsonp !== false ) { s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.jsonp + "=" + callbackName; }

// Use data converter to retrieve json after script execution s.converters[ "script json" ] = function { if ( !responseContainer ) { jQuery.error( callbackName + " was not called" ); }			return responseContainer[ 0 ]; };

// force json dataType s.dataTypes[ 0 ] = "json";

// Install callback overwritten = window[ callbackName ]; window[ callbackName ] = function { responseContainer = arguments; };

// Clean-up function (fires after converters) jqXHR.always( function {

// If previous value didn't exist - remove it			if ( overwritten === undefined ) { jQuery( window ).removeProp( callbackName );

// Otherwise restore preexisting value } else { window[ callbackName ] = overwritten; }

// Save back as free if ( s[ callbackName ] ) {

// make sure that re-using the options doesn't screw things around s.jsonpCallback = originalSettings.jsonpCallback;

// save the callback name for future use oldCallbacks.push( callbackName ); }

// Call if it was a function and we have a response if ( responseContainer && jQuery.isFunction( overwritten ) ) { overwritten( responseContainer[ 0 ] ); }

responseContainer = overwritten = undefined; } );

// Delegate to script return "script"; } } );

// data: string of html // context (optional): If specified, the fragment will be created in this context, // defaults to document // keepScripts (optional): If true, will include scripts passed in the html string jQuery.parseHTML = function( data, context, keepScripts ) { if ( !data || typeof data !== "string" ) { return null; }	if ( typeof context === "boolean" ) { keepScripts = context; context = false; }	context = context || document;

var parsed = rsingleTag.exec( data ), scripts = !keepScripts && [];

// Single tag if ( parsed ) { return [ context.createElement( parsed[ 1 ] ) ]; }

parsed = buildFragment( [ data ], context, scripts );

if ( scripts && scripts.length ) { jQuery( scripts ).remove; }

return jQuery.merge( [], parsed.childNodes ); };

// Keep a copy of the old load method var _load = jQuery.fn.load;

/** * Load a url into a page */ jQuery.fn.load = function( url, params, callback ) { if ( typeof url !== "string" && _load ) { return _load.apply( this, arguments ); }

var selector, type, response, self = this, off = url.indexOf( " " );

if ( off > -1 ) { selector = jQuery.trim( url.slice( off, url.length ) ); url = url.slice( 0, off ); }

// 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 ( params && typeof params === "object" ) { type = "POST"; }

// If we have elements to modify, make the request if ( self.length > 0 ) { jQuery.ajax( {			url: url,

// If "type" variable is undefined, then "GET" method will be used. // Make value of this field explicit since // user can override it through ajaxSetup method type: type || "GET", dataType: "html", data: params } ).done( function( responseText ) {

// Save response for use in complete callback response = arguments;

self.html( selector ?

// If a selector was specified, locate the right elements in a dummy div // Exclude scripts to avoid IE 'Permission Denied' errors jQuery( " " ).append( jQuery.parseHTML( responseText ) ).find( selector ) :

// Otherwise use the full result responseText );

// If the request succeeds, this function gets "data", "status", "jqXHR" // but they are ignored because response was set above. // If it fails, this function gets "jqXHR", "status", "error" } ).always( callback && function( jqXHR, status ) { self.each( function {				callback.apply( this, response || [ jqXHR.responseText, status, jqXHR ] );			} ); } );	}

return this; };

// Attach a bunch of functions for handling common AJAX events jQuery.each( [	"ajaxStart",	"ajaxStop",	"ajaxComplete",	"ajaxError",	"ajaxSuccess",	"ajaxSend" ], function( i, type ) {	jQuery.fn[ type ] = function( fn ) {		return this.on( type, fn );	}; } );

jQuery.expr.filters.animated = function( elem ) { return jQuery.grep( jQuery.timers, function( fn ) {		return elem === fn.elem;	} ).length; };

/** * Gets a window from an element */ function getWindow( elem ) { return jQuery.isWindow( elem ) ? elem : elem.nodeType === 9 ? elem.defaultView || elem.parentWindow : false; }

jQuery.offset = { setOffset: function( elem, options, i ) { var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition, position = jQuery.css( elem, "position" ), curElem = jQuery( elem ), props = {};

// set position first, in-case top/left are set even on static elem if ( position === "static" ) { elem.style.position = "relative"; }

curOffset = curElem.offset; curCSSTop = jQuery.css( elem, "top" ); curCSSLeft = jQuery.css( elem, "left" ); calculatePosition = ( position === "absolute" || position === "fixed" ) && jQuery.inArray( "auto", [ curCSSTop, curCSSLeft ] ) > -1;

// 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 ) ) {

// Use jQuery.extend here to allow modification of coordinates argument (gh-1848) options = options.call( elem, i, jQuery.extend( {}, 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( {	offset: function( options ) {		if ( arguments.length ) {			return options === undefined ?				this :				this.each( function( i ) { jQuery.offset.setOffset( this, options, i ); } );		}

var docElem, win, box = { top: 0, left: 0 }, elem = this[ 0 ], doc = elem && elem.ownerDocument;

if ( !doc ) { return; }

docElem = doc.documentElement;

// Make sure it's not a disconnected DOM node if ( !jQuery.contains( docElem, elem ) ) { return box; }

// If we don't have gBCR, just use 0,0 rather than error // BlackBerry 5, iOS 3 (original iPhone) if ( typeof elem.getBoundingClientRect !== "undefined" ) { box = elem.getBoundingClientRect; }		win = getWindow( doc ); return { top: box.top + ( win.pageYOffset || docElem.scrollTop )  - ( docElem.clientTop  || 0 ), left: box.left + ( win.pageXOffset || docElem.scrollLeft ) - ( docElem.clientLeft || 0 ) };	},

position: function { if ( !this[ 0 ] ) { return; }

var offsetParent, offset, parentOffset = { top: 0, left: 0 }, elem = this[ 0 ];

// Fixed elements are offset from window (parentOffset = {top:0, left: 0},		// because it is its only offset parent		if ( jQuery.css( elem, "position" ) === "fixed" ) {

// we assume that getBoundingClientRect is available when computed position is fixed offset = elem.getBoundingClientRect; } else {

// Get *real* offsetParent offsetParent = this.offsetParent;

// Get correct offsets offset = this.offset; if ( !jQuery.nodeName( offsetParent[ 0 ], "html" ) ) { parentOffset = offsetParent.offset; }

// Add offsetParent borders parentOffset.top += jQuery.css( offsetParent[ 0 ], "borderTopWidth", true ); parentOffset.left += jQuery.css( offsetParent[ 0 ], "borderLeftWidth", true ); }

// Subtract parent offsets and 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 return { top: offset.top  - parentOffset.top - jQuery.css( elem, "marginTop", true ), left: offset.left - parentOffset.left - jQuery.css( elem, "marginLeft", true ) };	},

offsetParent: function { return this.map( function {			var offsetParent = this.offsetParent;

while ( offsetParent && ( !jQuery.nodeName( offsetParent, "html" ) && jQuery.css( offsetParent, "position" ) === "static" ) ) { offsetParent = offsetParent.offsetParent; }			return offsetParent || documentElement; } );	} } );

// Create scrollLeft and scrollTop methods jQuery.each( { scrollLeft: "pageXOffset", scrollTop: "pageYOffset" }, function( method, prop ) {	var top = /Y/.test( prop );

jQuery.fn[ method ] = function( val ) { return access( this, function( elem, method, val ) {			var win = getWindow( elem );

if ( val === undefined ) { return win ? ( prop in win ) ? win[ prop ] : win.document.documentElement[ method ] : elem[ method ]; }

if ( win ) { win.scrollTo(					!top ? val : jQuery( win ).scrollLeft,					top ? val : jQuery( win ).scrollTop				);

} else { elem[ method ] = val; }		}, method, val, arguments.length, null );	}; } );

// Support: Safari<7-8+, Chrome<37-44+ // Add the top/left cssHooks using jQuery.fn.position // Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084 // getComputedStyle returns percent when specified for top/left/bottom/right // rather than make the css module depend on the offset module, we just check for it here jQuery.each( [ "top", "left" ], function( i, prop ) {	jQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition, function( elem, computed ) { if ( computed ) { computed = curCSS( elem, prop );

// if curCSS returns percentage, fallback to offset return rnumnonpx.test( computed ) ? jQuery( elem ).position[ prop ] + "px" : computed; }		}	); } );

// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods jQuery.each( { Height: "height", Width: "width" }, function( name, type ) {	jQuery.each( { padding: "inner" + name, content: type, "": "outer" + name }, function( defaultExtra, funcName ) {

// margin is only for outerHeight, outerWidth jQuery.fn[ funcName ] = function( margin, value ) { var chainable = arguments.length && ( defaultExtra || typeof margin !== "boolean" ), extra = defaultExtra || ( margin === true || value === true ? "margin" : "border" );

return access( this, function( elem, type, value ) {				var doc;

if ( jQuery.isWindow( elem ) ) {

// As of 5/8/2012 this will yield incorrect results for Mobile Safari, but there // isn't a whole lot we can do. See pull request at this URL for discussion: // https://github.com/jquery/jquery/pull/764 return elem.document.documentElement[ "client" + name ]; }

// Get document width or height if ( elem.nodeType === 9 ) { doc = elem.documentElement;

// Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height], // whichever is greatest // unfortunately, this causes bug #3838 in IE6/8 only, // but there is currently no good, small way to fix it. return Math.max(						elem.body[ "scroll" + name ], doc[ "scroll" + name ],						elem.body[ "offset" + name ], doc[ "offset" + name ],						doc[ "client" + name ]					); }

return value === undefined ?

// Get width or height on the element, requesting but not forcing parseFloat jQuery.css( elem, type, extra ) :

// Set width or height on the element jQuery.style( elem, type, value, extra ); }, type, chainable ? margin : undefined, chainable, null );		};	} ); } );

jQuery.fn.extend( {

bind: function( types, data, fn ) { return this.on( types, null, data, fn ); },	unbind: function( types, fn ) { return this.off( types, null, fn ); },

delegate: function( selector, types, data, fn ) { return this.on( types, selector, data, fn ); },	undelegate: function( selector, types, fn ) {

// ( namespace ) or ( selector, types [, fn] ) return arguments.length === 1 ? this.off( selector, "**" ) : this.off( types, selector || "**", fn ); } } );

// The number of elements contained in the matched element set jQuery.fn.size = function { return this.length; };

jQuery.fn.andSelf = jQuery.fn.addBack;

// Register as a named AMD module, since jQuery can be concatenated with other // files that may use define, but not via a proper concatenation script that // understands anonymous AMD modules. A named AMD is safest and most robust // way to register. Lowercase jquery is used because AMD module names are // derived from file names, and jQuery is normally delivered in a lowercase // file name. Do this after creating the global so that if an AMD module wants // to call noConflict to hide this version of jQuery, it will work.

// Note that for maximum portability, libraries that are not jQuery should // declare themselves as anonymous modules, and avoid setting a global if an // AMD loader is present. jQuery is a special case. For more information, see // https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon

if ( typeof define === "function" && define.amd ) { define( "jquery", [], function {		return jQuery;	} ); }

var

// Map over jQuery in case of overwrite _jQuery = window.jQuery,

// Map over the $ in case of overwrite _$ = window.$;

jQuery.noConflict = function( deep ) { if ( window.$ === jQuery ) { window.$ = _$; }

if ( deep && window.jQuery === jQuery ) { window.jQuery = _jQuery; }

return jQuery; };

// Expose jQuery and $ identifiers, even in // AMD (#7102#comment:10, https://github.com/jquery/jquery/pull/557) // and CommonJS for browser emulators (#13566) if ( !noGlobal ) { window.jQuery = window.$ = jQuery; }

return jQuery; }));

/*! DataTables 1.10.15 ©2008-2017 SpryMedia Ltd - datatables.net/license (function(h){"function"===typeof define&&define.amd?define(["jquery"],function(E){return h(E,window,document)}):"object"===typeof exports?module.exports=function(E,H){E||(E=window);H||(H="undefined"!==typeof window?require("jquery"):require("jquery")(E));return h(H,E,E.document)}:h(jQuery,window,document)})(function(h,E,H,k){function Y(a){var b,c,d={};h.each(a,function(e){if((b=e.match(/^([^A-Z]+?)([A-Z])/))&&-1!=="a aa ai ao as b fn i m o s ".indexOf(b[1]+" "))c=e.replace(b[0],b[2].toLowerCase), d[c]=e,"o"===b[1]&&Y(a[e])});a._hungarianMap=d}function J(a,b,c){a._hungarianMap||Y(a);var d;h.each(b,function(e){d=a._hungarianMap[e];if(d!==k&&(c||b[d]===k))"o"===d.charAt(0)?(b[d]||(b[d]={}),h.extend(!0,b[d],b[e]),J(a[d],b[d],c)):b[d]=b[e]})}function Fa(a){var b=m.defaults.oLanguage,c=a.sZeroRecords;!a.sEmptyTable&&(c&&"No data available in table"===b.sEmptyTable)&&F(a,a,"sZeroRecords","sEmptyTable");!a.sLoadingRecords&&(c&&"Loading..."===b.sLoadingRecords)&&F(a,a,"sZeroRecords","sLoadingRecords"); a.sInfoThousands&&(a.sThousands=a.sInfoThousands);(a=a.sDecimal)&&fb(a)}function gb(a){A(a,"ordering","bSort");A(a,"orderMulti","bSortMulti");A(a,"orderClasses","bSortClasses");A(a,"orderCellsTop","bSortCellsTop");A(a,"order","aaSorting");A(a,"orderFixed","aaSortingFixed");A(a,"paging","bPaginate");A(a,"pagingType","sPaginationType");A(a,"pageLength","iDisplayLength");A(a,"searching","bFilter");"boolean"===typeof a.sScrollX&&(a.sScrollX=a.sScrollX?"100%":"");"boolean"===typeof a.scrollX&&(a.scrollX= a.scrollX?"100%":"");if(a=a.aoSearchCols)for(var b=0,c=a.length;b<c;b++)a[b]&&J(m.models.oSearch,a[b])}function hb(a){A(a,"orderable","bSortable");A(a,"orderData","aDataSort");A(a,"orderSequence","asSorting");A(a,"orderDataType","sortDataType");var b=a.aDataSort;"number"===typeof b&&!h.isArray(b)&&(a.aDataSort=[b])}function ib(a){if(!m.__browser){var b={};m.__browser=b;var c=h(" ").css({position:"fixed",top:0,left:-1*h(E).scrollLeft,height:1,width:1,overflow:"hidden"}).append(h(" ").css({position:"absolute", top:1,left:1,width:100,overflow:"scroll"}).append(h(" ").css({width:"100%",height:10}))).appendTo("body"),d=c.children,e=d.children;b.barWidth=d[0].offsetWidth-d[0].clientWidth;b.bScrollOversize=100===e[0].offsetWidth&&100!==d[0].clientWidth;b.bScrollbarLeft=1!==Math.round(e.offset.left);b.bBounding=c[0].getBoundingClientRect.width?!0:!1;c.remove}h.extend(a.oBrowser,m.__browser);a.oScroll.iBarWidth=m.__browser.barWidth}function jb(a,b,c,d,e,f){var g,j=!1;c!==k&&(g=c,j=!0);for(d!== e;)a.hasOwnProperty(d)&&(g=j?b(g,a[d],d,a):a[d],j=!0,d+=f);return g}function Ga(a,b){var c=m.defaults.column,d=a.aoColumns.length,c=h.extend({},m.models.oColumn,c,{nTh:b?b:H.createElement("th"),sTitle:c.sTitle?c.sTitle:b?b.innerHTML:"",aDataSort:c.aDataSort?c.aDataSort:[d],mData:c.mData?c.mData:d,idx:d});a.aoColumns.push(c);c=a.aoPreSearchCols;c[d]=h.extend({},m.models.oSearch,c[d]);la(a,d,h(b).data)}function la(a,b,c){var b=a.aoColumns[b],d=a.oClasses,e=h(b.nTh);if(!b.sWidthOrig){b.sWidthOrig= e.attr("width")||null;var f=(e.attr("style")||"").match(/width:\s*(\d+[pxem%]+)/);f&&(b.sWidthOrig=f[1])}c!==k&&null!==c&&(hb(c),J(m.defaults.column,c),c.mDataProp!==k&&!c.mData&&(c.mData=c.mDataProp),c.sType&&(b._sManualType=c.sType),c.className&&!c.sClass&&(c.sClass=c.className),h.extend(b,c),F(b,c,"sWidth","sWidthOrig"),c.iDataSort!==k&&(b.aDataSort=[c.iDataSort]),F(b,c,"aDataSort"));var g=b.mData,j=R(g),i=b.mRender?R(b.mRender):null,c=function(a){return"string"===typeof a&&-1!==a.indexOf("@")}; b._bAttrSrc=h.isPlainObject(g)&&(c(g.sort)||c(g.type)||c(g.filter));b._setter=null;b.fnGetData=function(a,b,c){var d=j(a,b,k,c);return i&&b?i(d,b,a,c):d};b.fnSetData=function(a,b,c){return S(g)(a,b,c)};"number"!==typeof g&&(a._rowReadObject=!0);a.oFeatures.bSort||(b.bSortable=!1,e.addClass(d.sSortableNone));a=-1!==h.inArray("asc",b.asSorting);c=-1!==h.inArray("desc",b.asSorting);!b.bSortable||!a&&!c?(b.sSortingClass=d.sSortableNone,b.sSortingClassJUI=""):a&&!c?(b.sSortingClass=d.sSortableAsc,b.sSortingClassJUI= d.sSortJUIAscAllowed):!a&&c?(b.sSortingClass=d.sSortableDesc,b.sSortingClassJUI=d.sSortJUIDescAllowed):(b.sSortingClass=d.sSortable,b.sSortingClassJUI=d.sSortJUI)}function Z(a){if(!1!==a.oFeatures.bAutoWidth){var b=a.aoColumns;Ha(a);for(var c=0,d=b.length;c<d;c++)b[c].nTh.style.width=b[c].sWidth}b=a.oScroll;(""!==b.sY||""!==b.sX)&&ma(a);s(a,null,"column-sizing",[a])}function $(a,b){var c=na(a,"bVisible");return"number"===typeof c[b]?c[b]:null}function aa(a,b){var c=na(a,"bVisible"),c=h.inArray(b, c);return-1!==c?c:null}function ba(a){var b=0;h.each(a.aoColumns,function(a,d){d.bVisible&&"none"!==h(d.nTh).css("display")&&b++});return b}function na(a,b){var c=[];h.map(a.aoColumns,function(a,e){a[b]&&c.push(e)});return c}function Ia(a){var b=a.aoColumns,c=a.aoData,d=m.ext.type.detect,e,f,g,j,i,h,l,q,r;e=0;for(f=b.length;e<f;e++)if(l=b[e],r=[],!l.sType&&l._sManualType)l.sType=l._sManualType;else if(!l.sType){g=0;for(j=d.length;gq[f])d(l.length+q[f],n);else if("string"===typeof q[f]){j=0;for(i=l.length;j<i;j++)("_all"==q[f]||h(l[j].nTh).hasClass(q[f]))&& d(j,n)}}if(c){e=0;for(a=c.length;etr>th, >tr>td").addClass(n.sHeaderTH);h(j).find(">tr>th, >tr>td").addClass(n.sFooterTH); if(null!==j){a=a.aoFooter[0];b=0;for(c=a.length;b<c;b++)f=l[b],f.nTf=a[b].cell,f.sClass&&h(f.nTf).addClass(f.sClass)}}function fa(a,b,c){var d,e,f,g=[],j=[],i=a.aoColumns.length,n;if(b){c===k&&(c=!1);d=0;for(e=b.length;d<e;d++){g[d]=b[d].slice;g[d].nTr=b[d].nTr;for(f=i-1;0<=f;f--)!a.aoColumns[f].bVisible&&!c&&g[d].splice(f,1);j.push([])}d=0;for(e=g.length;d<e;d++){if(a=g[d].nTr)for(f=a.firstChild;)a.removeChild(f);f=0;for(b=g[d].length;f<b;f++)if(n=i=1,j[d][f]===k){a.appendChild(g[d][f].cell); for(j[d][f]=1;g[d+i]!==k&&g[d][f].cell==g[d+i][f].cell;)j[d+i][f]=1,i++;for(g[d][f+n]!==k&&g[d][f].cell==g[d][f+n].cell;){for(c=0;c=a.fnRecordsDisplay?0:g,a.iInitDisplayStart= -1);var g=a._iDisplayStart,n=a.fnDisplayEnd;if(a.bDeferLoading)a.bDeferLoading=!1,a.iDraw++,C(a,!1);else if(j){if(!a.bDestroying&&!nb(a))return}else a.iDraw++;if(0!==i.length){f=j?a.aoData.length:n;for(j=j?0:g;j<f;j++){var l=i[j],q=a.aoData[l];null===q.nTr&&Ja(a,l);l=q.nTr;if(0!==e){var r=d[c%e];q._sRowStripe!=r&&(h(l).removeClass(q._sRowStripe).addClass(r),q._sRowStripe=r)}s(a,"aoRowCallback",null,[l,q._aData,c,j]);b.push(l);c++}}else c=f.sZeroRecords,1==a.iDraw&&"ajax"==y(a)?c=f.sLoadingRecords: f.sEmptyTable&&0===a.fnRecordsTotal&&(c=f.sEmptyTable),b[0]=h(" ",{"class":e?d[0]:""}).append(h(" ",{valign:"top",colSpan:ba(a),"class":a.oClasses.sRowEmpty}).html(c))[0];s(a,"aoHeaderCallback","header",[h(a.nTHead).children("tr")[0],Ma(a),g,n,i]);s(a,"aoFooterCallback","footer",[h(a.nTFoot).children("tr")[0],Ma(a),g,n,i]);d=h(a.nTBody);d.children.detach;d.append(h(b));s(a,"aoDrawCallback","draw",[a]);a.bSorted=!1;a.bFiltered=!1;a.bDrawing=!1}}function T(a,b){var c=a.oFeatures,d=c.bFilter; c.bSort&&ob(a);d?ga(a,a.oPreviousSearch):a.aiDisplay=a.aiDisplayMaster.slice;!0!==b&&(a._iDisplayStart=0);a._drawHold=b;O(a);a._drawHold=!1}function pb(a){var b=a.oClasses,c=h(a.nTable),c=h(" ").insertBefore(c),d=a.oFeatures,e=h(" ",{id:a.sTableId+"_wrapper","class":b.sWrapper+(a.nTFoot?"":" "+b.sNoFooter)});a.nHolding=c[0];a.nTableWrapper=e[0];a.nTableReinsertBefore=a.nTable.nextSibling;for(var f=a.sDom.split(""),g,j,i,n,l,q,k=0;k"==j)e=e.parent;else if("l"==j&&d.bPaginate&&d.bLengthChange)g=qb(a);else if("f"==j&&d.bFilter)g=rb(a);else if("r"==j&&d.bProcessing)g=sb(a);else if("t"==j)g=tb(a);else if("i"==j&&d.bInfo)g=ub(a);else if("p"== j&&d.bPaginate)g=vb(a);else if(0!==m.ext.feature.length){i=m.ext.feature;q=0;for(n=i.length;q<n;q++)if(j==i[q].cFeature){g=i[q].fnInit(a);break}}g&&(i=a.aanFeatures,i[j]||(i[j]=[]),i[j].push(g),e.append(g))}c.replaceWith(e);a.nHolding=null}function ea(a,b){var c=h(b).children("tr"),d,e,f,g,j,i,n,l,q,k;a.splice(0,a.length);f=0;for(i=c.length;f<i;f++)a.push([]);f=0;for(i=c.length;f<i;f++){d=c[f];for(e=d.firstChild;e;){if("TD"==e.nodeName.toUpperCase||"TH"==e.nodeName.toUpperCase){l=1*e.getAttribute("colspan"); q=1*e.getAttribute("rowspan");l=!l||0===l||1===l?1:l;q=!q||0===q||1===q?1:q;g=0;for(j=a[f];j[g];)g++;n=g;k=1===l?!0:!1;for(j=0;j<l;j++)for(g=0;g<q;g++)a[f+g][n+j]={cell:e,unique:k},a[f+g].nTr=d}e=e.nextSibling}}}function ta(a,b,c){var d=[];c||(c=a.aoHeader,b&&(c=[],ea(c,b)));for(var b=0,e=c.length;b<e;b++)for(var f=0,g=c[b].length;f<g;f++)if(c[b][f].unique&&(!d[f]||!a.bSortCellsTop))d[f]=c[b][f].cell;return d}function ua(a,b,c){s(a,"aoServerParams","serverParams",[b]);if(b&&h.isArray(b)){var d={}, e=/(.*?)\[\]$/;h.each(b,function(a,b){var c=b.name.match(e);c?(c=c[0],d[c]||(d[c]=[]),d[c].push(b.value)):d[b.name]=b.value});b=d}var f,g=a.ajax,j=a.oInstance,i=function(b){s(a,null,"xhr",[a,b,a.jqXHR]);c(b)};if(h.isPlainObject(g)&&g.data){f=g.data;var n=h.isFunction(f)?f(b,a):f,b=h.isFunction(f)&&n?n:h.extend(!0,b,n);delete g.data}n={data:b,success:function(b){var c=b.error||b.sError;c&&K(a,0,c);a.json=b;i(b)},dataType:"json",cache:!1,type:a.sServerMethod,error:function(b,c){var d=s(a,null,"xhr", [a,null,a.jqXHR]);-1===h.inArray(!0,d)&&("parsererror"==c?K(a,0,"Invalid JSON response",1):4===b.readyState&&K(a,0,"Ajax error",7));C(a,!1)}};a.oAjaxData=b;s(a,null,"preXhr",[a,b]);a.fnServerData?a.fnServerData.call(j,a.sAjaxSource,h.map(b,function(a,b){return{name:b,value:a}}),i,a):a.sAjaxSource||"string"===typeof g?a.jqXHR=h.ajax(h.extend(n,{url:g||a.sAjaxSource})):h.isFunction(g)?a.jqXHR=g.call(j,b,i,a):(a.jqXHR=h.ajax(h.extend(n,g)),g.data=f)}function nb(a){return a.bAjaxDataGet?(a.iDraw++,C(a, !0),ua(a,wb(a),function(b){xb(a,b)}),!1):!0}function wb(a){var b=a.aoColumns,c=b.length,d=a.oFeatures,e=a.oPreviousSearch,f=a.aoPreSearchCols,g,j=[],i,n,l,k=W(a);g=a._iDisplayStart;i=!1!==d.bPaginate?a._iDisplayLength:-1;var r=function(a,b){j.push({name:a,value:b})};r("sEcho",a.iDraw);r("iColumns",c);r("sColumns",D(b,"sName").join(","));r("iDisplayStart",g);r("iDisplayLength",i);var ra={draw:a.iDraw,columns:[],order:[],start:g,length:i,search:{value:e.sSearch,regex:e.bRegex}};for(g=0;g<c;g++)n=b[g], l=f[g],i="function"==typeof n.mData?"function":n.mData,ra.columns.push({data:i,name:n.sName,searchable:n.bSearchable,orderable:n.bSortable,search:{value:l.sSearch,regex:l.bRegex}}),r("mDataProp_"+g,i),d.bFilter&&(r("sSearch_"+g,l.sSearch),r("bRegex_"+g,l.bRegex),r("bSearchable_"+g,n.bSearchable)),d.bSort&&r("bSortable_"+g,n.bSortable);d.bFilter&&(r("sSearch",e.sSearch),r("bRegex",e.bRegex));d.bSort&&(h.each(k,function(a,b){ra.order.push({column:b.col,dir:b.dir});r("iSortCol_"+a,b.col);r("sSortDir_"+ a,b.dir)}),r("iSortingCols",k.length));b=m.ext.legacy.ajax;return null===b?a.sAjaxSource?j:ra:b?j:ra}function xb(a,b){var c=va(a,b),d=b.sEcho!==k?b.sEcho:b.draw,e=b.iTotalRecords!==k?b.iTotalRecords:b.recordsTotal,f=b.iTotalDisplayRecords!==k?b.iTotalDisplayRecords:b.recordsFiltered;if(d){if(1*db.length||0!==b.indexOf(f)||a.bSorted)a.aiDisplay=g.slice;b=a.aiDisplay;for(c=0;c<b.length;c++)d.test(a.aoData[b[c]]._sFilterRow)&&e.push(b[c]);a.aiDisplay=e}}function Ra(a,b,c,d){a=b?a:Sa(a);c&&(a="^(?=.*?"+h.map(a.match(/"[^"]+"|[^ ]+/g)||[""],function(a){if('"'===a.charAt(0))var b=a.match(/^"(.*)"$/),a=b?b[1]:a;return a.replace('"',"")}).join(")(?=.*?")+").*$");return RegExp(a,d?"i":"")}function Bb(a){var b=a.aoColumns,c,d,e,f,g,j,i,h,l=m.ext.type.search;c=!1; d=0;for(f=a.aoData.length;d<f;d++)if(h=a.aoData[d],!h._aFilterData){j=[];e=0;for(g=b.length;e<g;e++)c=b[e],c.bSearchable?(i=B(a,d,e,"filter"),l[c.sType]&&(i=l[c.sType](i)),null===i&&(i=""),"string"!==typeof i&&i.toString&&(i=i.toString)):i="",i.indexOf&&-1!==i.indexOf("&")&&(xa.innerHTML=i,i=$b?xa.textContent:xa.innerText),i.replace&&(i=i.replace(/[\r\n]/g,"")),j.push(i);h._aFilterData=j;h._sFilterRow=j.join(" ");c=!0}return c}function Cb(a){return{search:a.sSearch,smart:a.bSmart,regex:a.bRegex, caseInsensitive:a.bCaseInsensitive}}function Db(a){return{sSearch:a.search,bSmart:a.smart,bRegex:a.regex,bCaseInsensitive:a.caseInsensitive}}function ub(a){var b=a.sTableId,c=a.aanFeatures.i,d=h(" ",{"class":a.oClasses.sInfo,id:!c?b+"_info":null});c||(a.aoDrawCallback.push({fn:Eb,sName:"information"}),d.attr("role","status").attr("aria-live","polite"),h(a.nTable).attr("aria-describedby",b+"_info"));return d[0]}function Eb(a){var b=a.aanFeatures.i;if(0!==b.length){var c=a.oLanguage,d=a._iDisplayStart+ 1,e=a.fnDisplayEnd,f=a.fnRecordsTotal,g=a.fnRecordsDisplay,j=g?c.sInfo:c.sInfoEmpty;g!==f&&(j+=" "+c.sInfoFiltered);j+=c.sInfoPostFix;j=Fb(a,j);c=c.fnInfoCallback;null!==c&&(j=c.call(a.oInstance,a,d,e,f,g,j));h(b).html(j)}}function Fb(a,b){var c=a.fnFormatNumber,d=a._iDisplayStart+1,e=a._iDisplayLength,f=a.fnRecordsDisplay,g=-1===e;return b.replace(/_START_/g,c.call(a,d)).replace(/_END_/g,c.call(a,a.fnDisplayEnd)).replace(/_MAX_/g,c.call(a,a.fnRecordsTotal)).replace(/_TOTAL_/g,c.call(a, f)).replace(/_PAGE_/g,c.call(a,g?1:Math.ceil(d/e))).replace(/_PAGES_/g,c.call(a,g?1:Math.ceil(f/e)))}function ha(a){var b,c,d=a.iInitDisplayStart,e=a.aoColumns,f;c=a.oFeatures;var g=a.bDeferLoading;if(a.bInitialised){pb(a);mb(a);fa(a,a.aoHeader);fa(a,a.aoFooter);C(a,!0);c.bAutoWidth&&Ha(a);b=0;for(c=e.length;b<c;b++)f=e[b],f.sWidth&&(f.nTh.style.width=v(f.sWidth));s(a,null,"preInit",[a]);T(a);e=y(a);if("ssp"!=e||g)"ajax"==e?ua(a,[],function(c){var f=va(a,c);for(b=0;b<f.length;b++)N(a,f[b]);a.iInitDisplayStart= d;T(a);C(a,!1);wa(a,c)},a):(C(a,!1),wa(a))}else setTimeout(function{ha(a)},200)}function wa(a,b){a._bInitComplete=!0;(b||a.oInit.aaData)&&Z(a);s(a,null,"plugin-init",[a,b]);s(a,"aoInitComplete","init",[a,b])}function Ta(a,b){var c=parseInt(b,10);a._iDisplayLength=c;Ua(a);s(a,null,"length",[a,c])}function qb(a){for(var b=a.oClasses,c=a.sTableId,d=a.aLengthMenu,e=h.isArray(d[0]),f=e?d[0]:d,d=e?d[1]:d,e=h(" ",{name:c+"_length","aria-controls":c,"class":b.sLengthSelect}),g=0,j=f.length;g<j;g++)e[0][g]= new Option(d[g],f[g]);var i=h(" ").addClass(b.sLength);a.aanFeatures.l||(i[0].id=c+"_length");i.children.append(a.oLanguage.sLengthMenu.replace("_MENU_",e[0].outerHTML));h("select",i).val(a._iDisplayLength).on("change.DT",function{Ta(a,h(this).val);O(a)});h(a.nTable).on("length.dt.DT",function(b,c,d){a===c&&h("select",i).val(d)});return i[0]}function vb(a){var b=a.sPaginationType,c=m.ext.pager[b],d="function"===typeof c,e=function(a){O(a)},b=h(" ").addClass(a.oClasses.sPaging+ b)[0],f=a.aanFeatures;d||c.fnInit(a,b,e);f.p||(b.id=a.sTableId+"_paginate",a.aoDrawCallback.push({fn:function(a){if(d){var b=a._iDisplayStart,i=a._iDisplayLength,h=a.fnRecordsDisplay,l=-1===i,b=l?0:Math.ceil(b/i),i=l?1:Math.ceil(h/i),h=c(b,i),k,l=0;for(k=f.p.length;l<k;l++)Pa(a,"pageButton")(a,f.p[l],l,h,b,i)}else c.fnUpdate(a,e)},sName:"pagination"}));return b}function Va(a,b,c){var d=a._iDisplayStart,e=a._iDisplayLength,f=a.fnRecordsDisplay;0===f||-1===e?d=0:"number"===typeof b?(d=b*e,d>f&& (d=0)):"first"==b?d=0:"previous"==b?(d=0<=e?d-e:0,0>d&&(d=0)):"next"==b?d+e<f&&(d+=e):"last"==b?d=Math.floor((f-1)/e)*e:K(a,0,"Unknown paging action: "+b,5);b=a._iDisplayStart!==d;a._iDisplayStart=d;b&&(s(a,null,"page",[a]),c&&O(a));return b}function sb(a){return h(" ",{id:!a.aanFeatures.r?a.sTableId+"_processing":null,"class":a.oClasses.sProcessing}).html(a.oLanguage.sProcessing).insertBefore(a.nTable)[0]}function C(a,b){a.oFeatures.bProcessing&&h(a.aanFeatures.r).css("display",b?"block":"none"); s(a,null,"processing",[a,b])}function tb(a){var b=h(a.nTable);b.attr("role","grid");var c=a.oScroll;if(""===c.sX&&""===c.sY)return a.nTable;var d=c.sX,e=c.sY,f=a.oClasses,g=b.children("caption"),j=g.length?g[0]._captionSide:null,i=h(b[0].cloneNode(!1)),n=h(b[0].cloneNode(!1)),l=b.children("tfoot");l.length||(l=null);i=h(" ",{"class":f.sScrollWrapper}).append(h(" ",{"class":f.sScrollHead}).css({overflow:"hidden",position:"relative",border:0,width:d?!d?null:v(d):"100%"}).append(h(" ", {"class":f.sScrollHeadInner}).css({"box-sizing":"content-box",width:c.sXInner||"100%"}).append(i.removeAttr("id").css("margin-left",0).append("top"===j?g:null).append(b.children("thead"))))).append(h(" ",{"class":f.sScrollBody}).css({position:"relative",overflow:"auto",width:!d?null:v(d)}).append(b));l&&i.append(h(" ",{"class":f.sScrollFoot}).css({overflow:"hidden",border:0,width:d?!d?null:v(d):"100%"}).append(h(" ",{"class":f.sScrollFootInner}).append(n.removeAttr("id").css("margin-left", 0).append("bottom"===j?g:null).append(b.children("tfoot")))));var b=i.children,k=b[0],f=b[1],r=l?b[2]:null;if(d)h(f).on("scroll.DT",function{var a=this.scrollLeft;k.scrollLeft=a;l&&(r.scrollLeft=a)});h(f).css(e&&c.bCollapse?"max-height":"height",e);a.nScrollHead=k;a.nScrollBody=f;a.nScrollFoot=r;a.aoDrawCallback.push({fn:ma,sName:"scrolling"});return i[0]}function ma(a){var b=a.oScroll,c=b.sX,d=b.sXInner,e=b.sY,b=b.iBarWidth,f=h(a.nScrollHead),g=f[0].style,j=f.children("div"),i=j[0].style,n=j.children("table"), j=a.nScrollBody,l=h(j),q=j.style,r=h(a.nScrollFoot).children("div"),m=r.children("table"),p=h(a.nTHead),o=h(a.nTable),t=o[0],s=t.style,u=a.nTFoot?h(a.nTFoot):null,x=a.oBrowser,U=x.bScrollOversize,ac=D(a.aoColumns,"nTh"),P,L,Q,w,Wa=[],y=[],z=[],A=[],B,C=function(a){a=a.style;a.paddingTop="0";a.paddingBottom="0";a.borderTopWidth="0";a.borderBottomWidth="0";a.height=0};L=j.scrollHeight>j.clientHeight;if(a.scrollBarVis!==L&&a.scrollBarVis!==k)a.scrollBarVis=L,Z(a);else{a.scrollBarVis=L;o.children("thead, tfoot").remove; u&&(Q=u.clone.prependTo(o),P=u.find("tr"),Q=Q.find("tr"));w=p.clone.prependTo(o);p=p.find("tr");L=w.find("tr");w.find("th, td").removeAttr("tabindex");c||(q.width="100%",f[0].style.width="100%");h.each(ta(a,w),function(b,c){B=$(a,b);c.style.width=a.aoColumns[B].sWidth});u&&I(function(a){a.style.width=""},Q);f=o.outerWidth;if(""===c){s.width="100%";if(U&&(o.find("tbody").height>j.offsetHeight||"scroll"==l.css("overflow-y")))s.width=v(o.outerWidth-b);f=o.outerWidth}else""!==d&&(s.width= v(d),f=o.outerWidth);I(C,L);I(function(a){z.push(a.innerHTML);Wa.push(v(h(a).css("width")))},L);I(function(a,b){if(h.inArray(a,ac)!==-1)a.style.width=Wa[b]},p);h(L).height(0);u&&(I(C,Q),I(function(a){A.push(a.innerHTML);y.push(v(h(a).css("width")))},Q),I(function(a,b){a.style.width=y[b]},P),h(Q).height(0));I(function(a,b){a.innerHTML='<div class="dataTables_sizing" style="height:0;overflow:hidden;">'+z[b]+" ";a.style.width=Wa[b]},L);u&&I(function(a,b){a.innerHTML='<div class="dataTables_sizing" style="height:0;overflow:hidden;">'+ A[b]+" ";a.style.width=y[b]},Q);if(o.outerWidth<f){P=j.scrollHeight>j.offsetHeight||"scroll"==l.css("overflow-y")?f+b:f;if(U&&(j.scrollHeight>j.offsetHeight||"scroll"==l.css("overflow-y")))s.width=v(P-b);(""===c||""!==d)&&K(a,1,"Possible column misalignment",6)}else P="100%";q.width=v(P);g.width=v(P);u&&(a.nScrollFoot.style.width=v(P));!e&&U&&(q.height=v(t.offsetHeight+b));c=o.outerWidth;n[0].style.width=v(c);i.width=v(c);d=o.height>j.clientHeight||"scroll"==l.css("overflow-y");e="padding"+ (x.bScrollbarLeft?"Left":"Right");i[e]=d?b+"px":"0px";u&&(m[0].style.width=v(c),r[0].style.width=v(c),r[0].style[e]=d?b+"px":"0px");o.children("colgroup").insertBefore(o.children("thead"));l.scroll;if((a.bSorted||a.bFiltered)&&!a._drawHold)j.scrollTop=0}}function I(a,b,c){for(var d=0,e=0,f=b.length,g,j;e<f;){g=b[e].firstChild;for(j=c?c[e].firstChild:null;g;)1===g.nodeType&&(c?a(g,j,d):a(g,d),d++),g=g.nextSibling,j=c?j.nextSibling:null;e++}}function Ha(a){var b=a.nTable,c=a.aoColumns,d=a.oScroll, e=d.sY,f=d.sX,g=d.sXInner,j=c.length,i=na(a,"bVisible"),n=h("th",a.nTHead),l=b.getAttribute("width"),k=b.parentNode,r=!1,m,p,o=a.oBrowser,d=o.bScrollOversize;(m=b.style.width)&&-1!==m.indexOf("%")&&(l=m);for(m=0;m<i.length;m++)p=c[i[m]],null!==p.sWidth&&(p.sWidth=Gb(p.sWidthOrig,k),r=!0);if(d||!r&&!f&&!e&&j==ba(a)&&j==n.length)for(m=0;m<j;m++)i=$(a,m),null!==i&&(c[i].sWidth=v(n.eq(m).width));else{j=h(b).clone.css("visibility","hidden").removeAttr("id");j.find("tbody tr").remove;var t=h(" ").appendTo(j.find("tbody")); j.find("thead, tfoot").remove;j.append(h(a.nTHead).clone).append(h(a.nTFoot).clone);j.find("tfoot th, tfoot td").css("width","");n=ta(a,j.find("thead")[0]);for(m=0;m<i.length;m++)p=c[i[m]],n[m].style.width=null!==p.sWidthOrig&&""!==p.sWidthOrig?v(p.sWidthOrig):"",p.sWidthOrig&&f&&h(n[m]).append(h(" ").css({width:p.sWidthOrig,margin:0,padding:0,border:0,height:1}));if(a.aoData.length)for(m=0;m<i.length;m++)r=i[m],p=c[r],h(Hb(a,r)).clone(!1).append(p.sContentPadding).appendTo(t);h("[name]", j).removeAttr("name");p=h(" ").css(f||e?{position:"absolute",top:0,left:0,height:1,right:0,overflow:"hidden"}:{}).append(j).appendTo(k);f&&g?j.width(g):f?(j.css("width","auto"),j.removeAttr("width"),j.width<k.clientWidth&&l&&j.width(k.clientWidth)):e?j.width(k.clientWidth):l&&j.width(l);for(m=e=0;m<i.length;m++)k=h(n[m]),g=k.outerWidth-k.width,k=o.bBounding?Math.ceil(n[m].getBoundingClientRect.width):k.outerWidth,e+=k,c[i[m]].sWidth=v(k-g);b.style.width=v(e);p.remove}l&&(b.style.width= v(l));if((l||f)&&!a._reszEvt)b=function{h(E).on("resize.DT-"+a.sInstance,Qa(function{Z(a)}))},d?setTimeout(b,1E3):b,a._reszEvt=!0}function Gb(a,b){if(!a)return 0;var c=h(" ").css("width",v(a)).appendTo(b||H.body),d=c[0].offsetWidth;c.remove;return d}function Hb(a,b){var c=Ib(a,b);if(0>c)return null;var d=a.aoData[c];return!d.nTr?h(" ").html(B(a,c,b,"display"))[0]:d.anCells[b]}function Ib(a,b){for(var c,d=-1,e=-1,f=0,g=a.aoData.length;f<g;f++)c=B(a,f,b,"display")+"",c=c.replace(bc, ""),c=c.replace(/ /g," "),c.length>d&&(d=c.length,e=f);return e}function v(a){return null===a?"0px":"number"==typeof a?0>a?"0px":a+"px":a.match(/\d$/)?a+"px":a}function W(a){var b,c,d=[],e=a.aoColumns,f,g,j,i;b=a.aaSortingFixed;c=h.isPlainObject(b);var n=[];f=function(a){a.length&&!h.isArray(a[0])?n.push(a):h.merge(n,a)};h.isArray(b)&&f(b);c&&b.pre&&f(b.pre);f(a.aaSorting);c&&b.post&&f(b.post);for(a=0;a<n.length;a++){i=n[a][0];f=e[i].aDataSort;b=0;for(c=f.length;b<c;b++)g=f[b],j=e[g].sType|| "string",n[a]._idx===k&&(n[a]._idx=h.inArray(n[a][1],e[g].asSorting)),d.push({src:i,col:g,dir:n[a][1],index:n[a]._idx,type:j,formatter:m.ext.type.order[j+"-pre"]})}return d}function ob(a){var b,c,d=[],e=m.ext.type.order,f=a.aoData,g=0,j,i=a.aiDisplayMaster,h;Ia(a);h=W(a);b=0;for(c=h.length;b<c;b++)j=h[b],j.formatter&&g++,Jb(a,j.col);if("ssp"!=y(a)&&0!==h.length){b=0;for(c=i.length;b<c;b++)d[i[b]]=b;g===h.length?i.sort(function(a,b){var c,e,g,j,i=h.length,k=f[a]._aSortData,m=f[b]._aSortData;for(g= 0;g<i;g++)if(j=h[g],c=k[j.col],e=m[j.col],c=c<e?-1:c>e?1:0,0!==c)return"asc"===j.dir?c:-c;c=d[a];e=d[b];return c<e?-1:c>e?1:0}):i.sort(function(a,b){var c,g,j,i,k=h.length,m=f[a]._aSortData,p=f[b]._aSortData;for(j=0;j<k;j++)if(i=h[j],c=m[i.col],g=p[i.col],i=e[i.type+"-"+i.dir]||e["string-"+i.dir],c=i(c,g),0!==c)return c;c=d[a];g=d[b];return c<g?-1:c>g?1:0})}a.bSorted=!0}function Kb(a){for(var b,c,d=a.aoColumns,e=W(a),a=a.oLanguage.oAria,f=0,g=d.length;f<g;f++){c=d[f];var j=c.asSorting;b=c.sTitle.replace(/<.*?>/g, "");var i=c.nTh;i.removeAttribute("aria-sort");c.bSortable&&(0<e.length&&e[0].col==f?(i.setAttribute("aria-sort","asc"==e[0].dir?"ascending":"descending"),c=j[e[0].index+1]||j[0]):c=j[0],b+="asc"===c?a.sSortAscending:a.sSortDescending);i.setAttribute("aria-label",b)}}function Xa(a,b,c,d){var e=a.aaSorting,f=a.aoColumns[b].asSorting,g=function(a,b){var c=a._idx;c===k&&(c=h.inArray(a[1],f));return c+1<f.length?c+1:b?null:0};"number"===typeof e[0]&&(e=a.aaSorting=[e]);c&&a.oFeatures.bSortMulti?(c=h.inArray(b, D(e,"0")),-1!==c?(b=g(e[c],!0),null===b&&1===e.length&&(b=0),null===b?e.splice(c,1):(e[c][1]=f[b],e[c]._idx=b)):(e.push([b,f[0],0]),e[e.length-1]._idx=0)):e.length&&e[0][0]==b?(b=g(e[0]),e.length=1,e[0][1]=f[b],e[0]._idx=b):(e.length=0,e.push([b,f[0]]),e[0]._idx=0);T(a);"function"==typeof d&&d(a)}function Oa(a,b,c,d){var e=a.aoColumns[c];Ya(b,{},function(b){!1!==e.bSortable&&(a.oFeatures.bProcessing?(C(a,!0),setTimeout(function{Xa(a,c,b.shiftKey,d);"ssp"!==y(a)&&C(a,!1)},0)):Xa(a,c,b.shiftKey,d))})} function ya(a){var b=a.aLastSort,c=a.oClasses.sSortColumn,d=W(a),e=a.oFeatures,f,g;if(e.bSort&&e.bSortClasses){e=0;for(f=b.length;e<f;e++)g=b[e].src,h(D(a.aoData,"anCells",g)).removeClass(c+(2>e?e+1:3));e=0;for(f=d.length;e<f;e++)g=d[e].src,h(D(a.aoData,"anCells",g)).addClass(c+(2>e?e+1:3))}a.aLastSort=d}function Jb(a,b){var c=a.aoColumns[b],d=m.ext.order[c.sSortDataType],e;d&&(e=d.call(a.oInstance,a,b,aa(a,b)));for(var f,g=m.ext.type.order[c.sType+"-pre"],j=0,i=a.aoData.length;j<i;j++)if(c=a.aoData[j], c._aSortData||(c._aSortData=[]),!c._aSortData[b]||d)f=d?e[j]:B(a,j,b,"sort"),c._aSortData[b]=g?g(f):f}function za(a){if(a.oFeatures.bStateSave&&!a.bDestroying){var b={time:+new Date,start:a._iDisplayStart,length:a._iDisplayLength,order:h.extend(!0,[],a.aaSorting),search:Cb(a.oPreviousSearch),columns:h.map(a.aoColumns,function(b,d){return{visible:b.bVisible,search:Cb(a.aoPreSearchCols[d])}})};s(a,"aoStateSaveParams","stateSaveParams",[a,b]);a.oSavedState=b;a.fnStateSaveCallback.call(a.oInstance,a, b)}}function Lb(a,b,c){var d,e,f=a.aoColumns,b=function(b){if(b&&b.time){var g=s(a,"aoStateLoadParams","stateLoadParams",[a,b]);if(-1===h.inArray(!1,g)&&(g=a.iStateDuration,!(0<g&&b.time<+new Date-1E3*g)&&!(b.columns&&f.length!==b.columns.length))){a.oLoadedState=h.extend(!0,{},b);b.start!==k&&(a._iDisplayStart=b.start,a.iInitDisplayStart=b.start);b.length!==k&&(a._iDisplayLength=b.length);b.order!==k&&(a.aaSorting=[],h.each(b.order,function(b,c){a.aaSorting.push(c[0]>=f.length?[0,c[1]]:c)}));b.search!== k&&h.extend(a.oPreviousSearch,Db(b.search));if(b.columns){d=0;for(e=b.columns.length;d<e;d++)g=b.columns[d],g.visible!==k&&(f[d].bVisible=g.visible),g.search!==k&&h.extend(a.aoPreSearchCols[d],Db(g.search))}s(a,"aoStateLoaded","stateLoaded",[a,b])}}c};if(a.oFeatures.bStateSave){var g=a.fnStateLoadCallback.call(a.oInstance,a,b);g!==k&&b(g)}else c}function Aa(a){var b=m.settings,a=h.inArray(a,D(b,"nTable"));return-1!==a?b[a]:null}function K(a,b,c,d){c="DataTables warning: "+(a?"table id="+a.sTableId+ " - ":"")+c;d&&(c+=". For more information about this error, please see http://datatables.net/tn/"+d);if(b)E.console&&console.log&&console.log(c);else if(b=m.ext,b=b.sErrMode||b.errMode,a&&s(a,null,"error",[a,d,c]),"alert"==b)alert(c);else{if("throw"==b)throw Error(c);"function"==typeof b&&b(a,d,c)}}function F(a,b,c,d){h.isArray(c)?h.each(c,function(c,d){h.isArray(d)?F(a,b,d[0],d[1]):F(a,b,d)}):(d===k&&(d=c),b[c]!==k&&(a[d]=b[c]))}function Mb(a,b,c){var d,e;for(e in b)b.hasOwnProperty(e)&&(d=b[e], h.isPlainObject(d)?(h.isPlainObject(a[e])||(a[e]={}),h.extend(!0,a[e],d)):a[e]=c&&"data"!==e&&"aaData"!==e&&h.isArray(d)?d.slice:d);return a}function Ya(a,b,c){h(a).on("click.DT",b,function(b){a.blur;c(b)}).on("keypress.DT",b,function(a){13===a.which&&(a.preventDefault,c(a))}).on("selectstart.DT",function{return!1})}function z(a,b,c,d){c&&a[b].push({fn:c,sName:d})}function s(a,b,c,d){var e=[];b&&(e=h.map(a[b].slice.reverse,function(b){return b.fn.apply(a.oInstance,d)}));null!==c&&(b=h.Event(c+ ".dt"),h(a.nTable).trigger(b,d),e.push(b.result));return e}function Ua(a){var b=a._iDisplayStart,c=a.fnDisplayEnd,d=a._iDisplayLength;b>=c&&(b=c-d);b-=b%d;if(-1===d||0>b)b=0;a._iDisplayStart=b}function Pa(a,b){var c=a.renderer,d=m.ext.renderer[b];return h.isPlainObject(c)&&c[b]?d[c[b]]||d._:"string"===typeof c?d[c]||d._:d._}function y(a){return a.oFeatures.bServerSide?"ssp":a.ajax||a.sAjaxSource?"ajax":"dom"}function ia(a,b){var c=[],c=Nb.numbers_length,d=Math.floor(c/2);b<=c?c=X(0,b):a<=d?(c=X(0, c-2),c.push("ellipsis"),c.push(b-1)):(a>=b-1-d?c=X(b-(c-2),b):(c=X(a-d+2,a+d-1),c.push("ellipsis"),c.push(b-1)),c.splice(0,0,"ellipsis"),c.splice(0,0,0));c.DT_el="span";return c}function fb(a){h.each({num:function(b){return Ba(b,a)},"num-fmt":function(b){return Ba(b,a,Za)},"html-num":function(b){return Ba(b,a,Ca)},"html-num-fmt":function(b){return Ba(b,a,Ca,Za)}},function(b,c){x.type.order[b+a+"-pre"]=c;b.match(/^html\-/)&&(x.type.search[b+a]=x.type.search.html)})}function Ob(a){return function{var b= [Aa(this[m.ext.iApiIndex])].concat(Array.prototype.slice.call(arguments));return m.ext.internal[a].apply(this,b)}}var m=function(a){this.$=function(a,b){return this.api(!0).$(a,b)};this._=function(a,b){return this.api(!0).rows(a,b).data};this.api=function(a){return a?new t(Aa(this[x.iApiIndex])):new t(this)};this.fnAddData=function(a,b){var c=this.api(!0),d=h.isArray(a)&&(h.isArray(a[0])||h.isPlainObject(a[0]))?c.rows.add(a):c.row.add(a);(b===k||b)&&c.draw;return d.flatten.toArray};this.fnAdjustColumnSizing= function(a){var b=this.api(!0).columns.adjust,c=b.settings[0],d=c.oScroll;a===k||a?b.draw(!1):(""!==d.sX||""!==d.sY)&&ma(c)};this.fnClearTable=function(a){var b=this.api(!0).clear;(a===k||a)&&b.draw};this.fnClose=function(a){this.api(!0).row(a).child.hide};this.fnDeleteRow=function(a,b,c){var d=this.api(!0),a=d.rows(a),e=a.settings[0],h=e.aoData[a[0][0]];a.remove;b&&b.call(this,e,h);(c===k||c)&&d.draw;return h};this.fnDestroy=function(a){this.api(!0).destroy(a)};this.fnDraw=function(a){this.api(!0).draw(a)}; this.fnFilter=function(a,b,c,d,e,h){e=this.api(!0);null===b||b===k?e.search(a,c,d,h):e.column(b).search(a,c,d,h);e.draw};this.fnGetData=function(a,b){var c=this.api(!0);if(a!==k){var d=a.nodeName?a.nodeName.toLowerCase:"";return b!==k||"td"==d||"th"==d?c.cell(a,b).data:c.row(a).data||null}return c.data.toArray};this.fnGetNodes=function(a){var b=this.api(!0);return a!==k?b.row(a).node:b.rows.nodes.flatten.toArray};this.fnGetPosition=function(a){var b=this.api(!0),c=a.nodeName.toUpperCase; return"TR"==c?b.row(a).index:"TD"==c||"TH"==c?(a=b.cell(a).index,[a.row,a.columnVisible,a.column]):null};this.fnIsOpen=function(a){return this.api(!0).row(a).child.isShown};this.fnOpen=function(a,b,c){return this.api(!0).row(a).child(b,c).show.child[0]};this.fnPageChange=function(a,b){var c=this.api(!0).page(a);(b===k||b)&&c.draw(!1)};this.fnSetColumnVis=function(a,b,c){a=this.api(!0).column(a).visible(b);(c===k||c)&&a.columns.adjust.draw};this.fnSettings=function{return Aa(this[x.iApiIndex])}; this.fnSort=function(a){this.api(!0).order(a).draw};this.fnSortListener=function(a,b,c){this.api(!0).order.listener(a,b,c)};this.fnUpdate=function(a,b,c,d,e){var h=this.api(!0);c===k||null===c?h.row(b).data(a):h.cell(b,c).data(a);(e===k||e)&&h.columns.adjust;(d===k||d)&&h.draw;return 0};this.fnVersionCheck=x.fnVersionCheck;var b=this,c=a===k,d=this.length;c&&(a={});this.oApi=this.internal=x.internal;for(var e in m.ext.internal)e&&(this[e]=Ob(e));this.each(function{var e={},g=1<d?Mb(e,a,!0): a,j=0,i,e=this.getAttribute("id"),n=!1,l=m.defaults,q=h(this);if("table"!=this.nodeName.toLowerCase)K(null,0,"Non-table node initialisation ("+this.nodeName+")",2);else{gb(l);hb(l.column);J(l,l,!0);J(l.column,l.column,!0);J(l,h.extend(g,q.data));var r=m.settings,j=0;for(i=r.length;j<i;j++){var p=r[j];if(p.nTable==this||p.nTHead.parentNode==this||p.nTFoot&&p.nTFoot.parentNode==this){var t=g.bRetrieve!==k?g.bRetrieve:l.bRetrieve;if(c||t)return p.oInstance;if(g.bDestroy!==k?g.bDestroy:l.bDestroy){p.oInstance.fnDestroy; break}else{K(p,0,"Cannot reinitialise DataTable",3);return}}if(p.sTableId==this.id){r.splice(j,1);break}}if(null===e||""===e)this.id=e="DataTables_Table_"+m.ext._unique++;var o=h.extend(!0,{},m.models.oSettings,{sDestroyWidth:q[0].style.width,sInstance:e,sTableId:e});o.nTable=this;o.oApi=b.internal;o.oInit=g;r.push(o);o.oInstance=1===b.length?b:q.dataTable;gb(g);g.oLanguage&&Fa(g.oLanguage);g.aLengthMenu&&!g.iDisplayLength&&(g.iDisplayLength=h.isArray(g.aLengthMenu[0])?g.aLengthMenu[0][0]:g.aLengthMenu[0]); g=Mb(h.extend(!0,{},l),g);F(o.oFeatures,g,"bPaginate bLengthChange bFilter bSort bSortMulti bInfo bProcessing bAutoWidth bSortClasses bServerSide bDeferRender".split(" "));F(o,g,["asStripeClasses","ajax","fnServerData","fnFormatNumber","sServerMethod","aaSorting","aaSortingFixed","aLengthMenu","sPaginationType","sAjaxSource","sAjaxDataProp","iStateDuration","sDom","bSortCellsTop","iTabIndex","fnStateLoadCallback","fnStateSaveCallback","renderer","searchDelay","rowId",["iCookieDuration","iStateDuration"], ["oSearch","oPreviousSearch"],["aoSearchCols","aoPreSearchCols"],["iDisplayLength","_iDisplayLength"],["bJQueryUI","bJUI"]]);F(o.oScroll,g,"sScrollX","sX"],["sScrollXInner","sXInner"],["sScrollY","sY"],["bScrollCollapse","bCollapse");F(o.oLanguage,g,"fnInfoCallback");z(o,"aoDrawCallback",g.fnDrawCallback,"user");z(o,"aoServerParams",g.fnServerParams,"user");z(o,"aoStateSaveParams",g.fnStateSaveParams,"user");z(o,"aoStateLoadParams",g.fnStateLoadParams,"user");z(o,"aoStateLoaded",g.fnStateLoaded, "user");z(o,"aoRowCallback",g.fnRowCallback,"user");z(o,"aoRowCreatedCallback",g.fnCreatedRow,"user");z(o,"aoHeaderCallback",g.fnHeaderCallback,"user");z(o,"aoFooterCallback",g.fnFooterCallback,"user");z(o,"aoInitComplete",g.fnInitComplete,"user");z(o,"aoPreDrawCallback",g.fnPreDrawCallback,"user");o.rowIdFn=R(g.rowId);ib(o);var u=o.oClasses;g.bJQueryUI?(h.extend(u,m.ext.oJUIClasses,g.oClasses),g.sDom===l.sDom&&"lfrtip"===l.sDom&&(o.sDom='<"H"lfr>t<"F"ip>'),o.renderer)?h.isPlainObject(o.renderer)&& !o.renderer.header&&(o.renderer.header="jqueryui"):o.renderer="jqueryui":h.extend(u,m.ext.classes,g.oClasses);q.addClass(u.sTable);o.iInitDisplayStart===k&&(o.iInitDisplayStart=g.iDisplayStart,o._iDisplayStart=g.iDisplayStart);null!==g.iDeferLoading&&(o.bDeferLoading=!0,e=h.isArray(g.iDeferLoading),o._iRecordsDisplay=e?g.iDeferLoading[0]:g.iDeferLoading,o._iRecordsTotal=e?g.iDeferLoading[1]:g.iDeferLoading);var v=o.oLanguage;h.extend(!0,v,g.oLanguage);v.sUrl&&(h.ajax({dataType:"json",url:v.sUrl,success:function(a){Fa(a); J(l.oLanguage,a);h.extend(true,v,a);ha(o)},error:function{ha(o)}}),n=!0);null===g.asStripeClasses&&(o.asStripeClasses=[u.sStripeOdd,u.sStripeEven]);var e=o.asStripeClasses,x=q.children("tbody").find("tr").eq(0);-1!==h.inArray(!0,h.map(e,function(a){return x.hasClass(a)}))&&(h("tbody tr",this).removeClass(e.join(" ")),o.asDestroyStripes=e.slice);e=[];r=this.getElementsByTagName("thead");0!==r.length&&(ea(o.aoHeader,r[0]),e=ta(o));if(null===g.aoColumns){r=[];j=0;for(i=e.length;j<i;j++)r.push(null)}else r= g.aoColumns;j=0;for(i=r.length;j<i;j++)Ga(o,e?e[j]:null);kb(o,g.aoColumnDefs,r,function(a,b){la(o,a,b)});if(x.length){var w=function(a,b){return a.getAttribute("data-"+b)!==null?b:null};h(x[0]).children("th, td").each(function(a,b){var c=o.aoColumns[a];if(c.mData===a){var d=w(b,"sort")||w(b,"order"),e=w(b,"filter")||w(b,"search");if(d!==null||e!==null){c.mData={_:a+".display",sort:d!==null?a+".@data-"+d:k,type:d!==null?a+".@data-"+d:k,filter:e!==null?a+".@data-"+e:k};la(o,a)}}})}var U=o.oFeatures, e=function{if(g.aaSorting===k){var a=o.aaSorting;j=0;for(i=a.length;j<i;j++)a[j][1]=o.aoColumns[j].asSorting[0]}ya(o);U.bSort&&z(o,"aoDrawCallback",function{if(o.bSorted){var a=W(o),b={};h.each(a,function(a,c){b[c.src]=c.dir});s(o,null,"order",[o,a,b]);Kb(o)}});z(o,"aoDrawCallback",function{(o.bSorted||y(o)==="ssp"||U.bDeferRender)&&ya(o)},"sc");var a=q.children("caption").each(function{this._captionSide=h(this).css("caption-side")}),b=q.children("thead");b.length===0&&(b=h(" ").appendTo(q)); o.nTHead=b[0];b=q.children("tbody");b.length===0&&(b=h(" ").appendTo(q));o.nTBody=b[0];b=q.children("tfoot");if(b.length===0&&a.length>0&&(o.oScroll.sX!==""||o.oScroll.sY!==""))b=h(" ").appendTo(q);if(b.length===0||b.children.length===0)q.addClass(u.sNoFooter);else if(b.length>0){o.nTFoot=b[0];ea(o.aoFooter,o.nTFoot)}if(g.aaData)for(j=0;j<g.aaData.length;j++)N(o,g.aaData[j]);else(o.bDeferLoading||y(o)=="dom")&&oa(o,h(o.nTBody).children("tr"));o.aiDisplay=o.aiDisplayMaster.slice; o.bInitialised=true;n===false&&ha(o)};g.bStateSave?(U.bStateSave=!0,z(o,"aoDrawCallback",za,"state_save"),Lb(o,g,e)):e}});b=null;return this},x,t,p,u,$a={},Pb=/[\r\n]/g,Ca=/<.*?>/g,cc=/^\d{2,4}[\.\/\-]\d{1,2}[\.\/\-]\d{1,2}([T ]{1}\d{1,2}[:\.]\d{2}([\.:]\d{2})?)?$/,dc=RegExp("(\\/|\\.|\\*|\\+|\\?|\\||\\(|\\)|\\[|\\]|\\{|\\}|\\\\|\\$|\\^|\\-)","g"),Za=/[',$£€¥%\u2009\u202F\u20BD\u20a9\u20BArfk]/gi,M=function(a){return!a||!0===a||"-"===a?!0:!1},Qb=function(a){var b=parseInt(a,10);return!isNaN(b)&& isFinite(a)?b:null},Rb=function(a,b){$a[b]||($a[b]=RegExp(Sa(b),"g"));return"string"===typeof a&&"."!==b?a.replace(/\./g,"").replace($a[b],"."):a},ab=function(a,b,c){var d="string"===typeof a;if(M(a))return!0;b&&d&&(a=Rb(a,b));c&&d&&(a=a.replace(Za,""));return!isNaN(parseFloat(a))&&isFinite(a)},Sb=function(a,b,c){return M(a)?!0:!(M(a)||"string"===typeof a)?null:ab(a.replace(Ca,""),b,c)?!0:null},D=function(a,b,c){var d=[],e=0,f=a.length;if(c!==k)for(e<f;e++)a[e]&&a[e][b]&&d.push(a[e][b][c]);else for(e< f;e++)a[e]&&d.push(a[e][b]);return d},ja=function(a,b,c,d){var e=[],f=0,g=b.length;if(d!==k)for(f<g;f++)a[b[f]][c]&&e.push(a[b[f]][c][d]);else for(f<g;f++)e.push(a[b[f]][c]);return e},X=function(a,b){var c=[],d;b===k?(b=0,d=a):(d=b,b=a);for(var e=b;e<d;e++)c.push(e);return c},Tb=function(a){for(var b=[],c=0,d=a.length;c<d;c++)a[c]&&b.push(a[c]);return b},sa=function(a){var b;a:{if(!(2>a.length)){b=a.slice.sort;for(var c=b[0],d=1,e=b.length;d<e;d++){if(b[d]===c){b=!1;break a}c=b[d]}}b=!0}if(b)return a.slice; b=[];var e=a.length,f,g=0,d=0;a:for(d<e;d++){c=a[d];for(f=0;f<g;f++)if(b[f]===c)continue a;b.push(c);g++}return b};m.util={throttle:function(a,b){var c=b!==k?b:200,d,e;return function{var b=this,g=+new Date,h=arguments;d&&g<d+c?(clearTimeout(e),e=setTimeout(function{d=k;a.apply(b,h)},c)):(d=g,a.apply(b,h))}},escapeRegex:function(a){return a.replace(dc,"\\$1")}};var A=function(a,b,c){a[b]!==k&&(a[c]=a[b])},ca=/\[.*?\]$/,V=/\(\)$/,Sa=m.util.escapeRegex,xa=h(" ")[0],$b=xa.textContent!==k,bc= /<.*?>/g,Qa=m.util.throttle,Ub=[],w=Array.prototype,ec=function(a){var b,c,d=m.settings,e=h.map(d,function(a){return a.nTable});if(a){if(a.nTable&&a.oApi)return[a];if(a.nodeName&&"table"===a.nodeName.toLowerCase)return b=h.inArray(a,e),-1!==b?[d[b]]:null;if(a&&"function"===typeof a.settings)return a.settings.toArray;"string"===typeof a?c=h(a):a instanceof h&&(c=a)}else return[];if(c)return c.map(function{b=h.inArray(this,e);return-1!==b?d[b]:null}).toArray};t=function(a,b){if(!(this instanceof t))return new t(a,b);var c=[],d=function(a){(a=ec(a))&&(c=c.concat(a))};if(h.isArray(a))for(var e=0,f=a.length;e<f;e++)d(a[e]);else d(a);this.context=sa(c);b&&h.merge(this,b);this.selector={rows:null,cols:null,opts:null};t.extend(this,this,Ub)};m.Api=t;h.extend(t.prototype,{any:function{return 0!==this.count},concat:w.concat,context:[],count:function{return this.flatten.length},each:function(a){for(var b=0,c=this.length;b<c;b++)a.call(this,this[b],b,this);return this},eq:function(a){var b= this.context;return b.length>a?new t(b[a],this[a]):null},filter:function(a){var b=[];if(w.filter)b=w.filter.call(this,a,this);else for(var c=0,d=this.length;c<d;c++)a.call(this,this[c],c,this)&&b.push(this[c]);return new t(this.context,b)},flatten:function{var a=[];return new t(this.context,a.concat.apply(a,this.toArray))},join:w.join,indexOf:w.indexOf||function(a,b){for(var c=b||0,d=this.length;c<d;c++)if(this[c]===a)return c;return-1},iterator:function(a,b,c,d){var e=[],f,g,h,i,n,l=this.context, m,p,u=this.selector;"string"===typeof a&&(d=c,c=b,b=a,a=!1);g=0;for(h=l.length;g<h;g++){var s=new t(l[g]);if("table"===b)f=c.call(s,l[g],g),f!==k&&e.push(f);else if("columns"===b||"rows"===b)f=c.call(s,l[g],this[g],g),f!==k&&e.push(f);else if("column"===b||"column-rows"===b||"row"===b||"cell"===b){p=this[g];"column-rows"===b&&(m=Da(l[g],u.opts));i=0;for(n=p.length;i<n;i++)f=p[i],f="cell"===b?c.call(s,l[g],f.row,f.column,g,i):c.call(s,l[g],f,g,i,m),f!==k&&e.push(f)}}return e.length||d?(a=new t(l,a? e.concat.apply([],e):e),b=a.selector,b.rows=u.rows,b.cols=u.cols,b.opts=u.opts,a):this},lastIndexOf:w.lastIndexOf||function(a,b){return this.indexOf.apply(this.toArray.reverse,arguments)},length:0,map:function(a){var b=[];if(w.map)b=w.map.call(this,a,this);else for(var c=0,d=this.length;c<d;c++)b.push(a.call(this,this[c],c));return new t(this.context,b)},pluck:function(a){return this.map(function(b){return b[a]})},pop:w.pop,push:w.push,reduce:w.reduce||function(a,b){return jb(this,a,b,0,this.length, 1)},reduceRight:w.reduceRight||function(a,b){return jb(this,a,b,this.length-1,-1,-1)},reverse:w.reverse,selector:null,shift:w.shift,slice:function{return new t(this.context,this)},sort:w.sort,splice:w.splice,toArray:function{return w.slice.call(this)},to$:function{return h(this)},toJQuery:function{return h(this)},unique:function{return new t(this.context,sa(this))},unshift:w.unshift});t.extend=function(a,b,c){if(c.length&&b&&(b instanceof t||b.__dt_wrapper)){var d,e,f,g=function(a,b,c){return function{var d= b.apply(a,arguments);t.extend(d,d,c.methodExt);return d}};d=0;for(e=c.length;d<e;d++)f=c[d],b[f.name]="function"===typeof f.val?g(a,f.val,f):h.isPlainObject(f.val)?{}:f.val,b[f.name].__dt_wrapper=!0,t.extend(a,b[f.name],f.propExt)}};t.register=p=function(a,b){if(h.isArray(a))for(var c=0,d=a.length;c<d;c++)t.register(a[c],b);else for(var e=a.split("."),f=Ub,g,j,c=0,d=e.length;c<d;c++){g=(j=-1!==e[c].indexOf(""))?e[c].replace("",""):e[c];var i;a:{i=0;for(var n=f.length;i<n;i++)if(f[i].name===g){i= f[i];break a}i=null}i||(i={name:g,val:{},methodExt:[],propExt:[]},f.push(i));c===d-1?i.val=b:f=j?i.methodExt:i.propExt}};t.registerPlural=u=function(a,b,c){t.register(a,c);t.register(b,function{var a=c.apply(this,arguments);return a===this?this:a instanceof t?a.length?h.isArray(a[0])?new t(a.context,a[0]):a[0]:k:a})};p("tables",function(a){var b;if(a){b=t;var c=this.context;if("number"===typeof a)a=[c[a]];else var d=h.map(c,function(a){return a.nTable}),a=h(d).filter(a).map(function{var a=h.inArray(this, d);return c[a]}).toArray;b=new b(a)}else b=this;return b});p("table",function(a){var a=this.tables(a),b=a.context;return b.length?new t(b[0]):a});u("tables.nodes","table.node",function{return this.iterator("table",function(a){return a.nTable},1)});u("tables.body","table.body",function{return this.iterator("table",function(a){return a.nTBody},1)});u("tables.header","table.header",function{return this.iterator("table",function(a){return a.nTHead},1)});u("tables.footer", "table.footer",function{return this.iterator("table",function(a){return a.nTFoot},1)});u("tables.containers","table.container",function{return this.iterator("table",function(a){return a.nTableWrapper},1)});p("draw",function(a){return this.iterator("table",function(b){"page"===a?O(b):("string"===typeof a&&(a="full-hold"===a?!1:!0),T(b,!1===a))})});p("page",function(a){return a===k?this.page.info.page:this.iterator("table",function(b){Va(b,a)})});p("page.info",function{if(0=== this.context.length)return k;var a=this.context[0],b=a._iDisplayStart,c=a.oFeatures.bPaginate?a._iDisplayLength:-1,d=a.fnRecordsDisplay,e=-1===c;return{page:e?0:Math.floor(b/c),pages:e?1:Math.ceil(d/c),start:b,end:a.fnDisplayEnd,length:c,recordsTotal:a.fnRecordsTotal,recordsDisplay:d,serverSide:"ssp"===y(a)}});p("page.len",function(a){return a===k?0!==this.context.length?this.context[0]._iDisplayLength:k:this.iterator("table",function(b){Ta(b,a)})});var Vb=function(a,b,c){if(c){var d=new t(a); d.one("draw",function{c(d.ajax.json)})}if("ssp"==y(a))T(a,b);else{C(a,!0);var e=a.jqXHR;e&&4!==e.readyState&&e.abort;ua(a,[],function(c){pa(a);for(var c=va(a,c),d=0,e=c.length;d<e;d++)N(a,c[d]);T(a,b);C(a,!1)})}};p("ajax.json",function{var a=this.context;if(0=0?b:g.length+b];if(typeof a==="function"){var e=Da(c,f);return h.map(g,function(b,f){return a(f,Xb(c,f,0,0,e),i[f])?f:null})}var k=typeof a==="string"?a.match(fc):"";if(k)switch(k[2]){case "visIdx":case "visible":b=parseInt(k[1],10);if(b<0){var m=h.map(g,function(a,b){return a.bVisible?b:null});return[m[m.length+b]]}return[$(c,b)];case "name":return h.map(j,function(a,b){return a=== k[1]?b:null});default:return[]}if(a.nodeName&&a._DT_CellIndex)return[a._DT_CellIndex.column];b=h(i).filter(a).map(function{return h.inArray(this,i)}).toArray;if(b.length||!a.nodeName)return b;b=h(a).closest("*[data-dt-column]");return b.length?[b.data("dt-column")]:[]},c,f)},1);c.selector.cols=a;c.selector.opts=b;return c});u("columns.header","column.header",function{return this.iterator("column",function(a,b){return a.aoColumns[b].nTh},1)});u("columns.footer","column.footer", function{return this.iterator("column",function(a,b){return a.aoColumns[b].nTf},1)});u("columns.data","column.data",function{return this.iterator("column-rows",Xb,1)});u("columns.dataSrc","column.dataSrc",function{return this.iterator("column",function(a,b){return a.aoColumns[b].mData},1)});u("columns.cache","column.cache",function(a){return this.iterator("column-rows",function(b,c,d,e,f){return ja(b.aoData,f,"search"===a?"_aFilterData":"_aSortData",c)},1)});u("columns.nodes", "column.nodes",function{return this.iterator("column-rows",function(a,b,c,d,e){return ja(a.aoData,e,"anCells",b)},1)});u("columns.visible","column.visible",function(a,b){var c=this.iterator("column",function(b,c){if(a===k)return b.aoColumns[c].bVisible;var f=b.aoColumns,g=f[c],j=b.aoData,i,n,l;if(a!==k&&g.bVisible!==a){if(a){var m=h.inArray(!0,D(f,"bVisible"),c+1);i=0;for(n=j.length;i<n;i++)l=j[i].nTr,f=j[i].anCells,l&&l.insertBefore(f[c],f[m]||null)}else h(D(b.aoData,"anCells",c)).detach; g.bVisible=a;fa(b,b.aoHeader);fa(b,b.aoFooter);za(b)}});a!==k&&(this.iterator("column",function(c,e){s(c,null,"column-visibility",[c,e,a,b])}),(b===k||b)&&this.columns.adjust);return c});u("columns.indexes","column.index",function(a){return this.iterator("column",function(b,c){return"visible"===a?aa(b,c):c},1)});p("columns.adjust",function{return this.iterator("table",function(a){Z(a)},1)});p("column.index",function(a,b){if(0!==this.context.length){var c=this.context[0];if("fromVisible"=== a||"toData"===a)return $(c,b);if("fromData"===a||"toVisible"===a)return aa(c,b)}});p("column",function(a,b){return db(this.columns(a,b))});p("cells",function(a,b,c){h.isPlainObject(a)&&(a.row===k?(c=a,a=null):(c=b,b=null));h.isPlainObject(b)&&(c=b,b=null);if(null===b||b===k)return this.iterator("table",function(b){var d=a,e=cb(c),f=b.aoData,g=Da(b,e),j=Tb(ja(f,g,"anCells")),i=h([].concat.apply([],j)),l,n=b.aoColumns.length,m,p,u,t,s,v;return bb("cell",d,function(a){var c=typeof a==="function"; if(a===null||a===k||c){m=[];p=0;for(u=g.length;p<u;p++){l=g[p];for(t=0;t<n;t++){s={row:l,column:t};if(c){v=f[l];a(s,B(b,l,t),v.anCells?v.anCells[t]:null)&&m.push(s)}else m.push(s)}}return m}if(h.isPlainObject(a))return[a];c=i.filter(a).map(function(a,b){return{row:b._DT_CellIndex.row,column:b._DT_CellIndex.column}}).toArray;if(c.length||!a.nodeName)return c;v=h(a).closest("*[data-dt-row]");return v.length?[{row:v.data("dt-row"),column:v.data("dt-column")}]:[]},b,e)});var d=this.columns(b,c),e=this.rows(a, c),f,g,j,i,n,l=this.iterator("table",function(a,b){f=[];g=0;for(j=e[b].length;g<j;g++){i=0;for(n=d[b].length;i<n;i++)f.push({row:e[b][g],column:d[b][i]})}return f},1);h.extend(l.selector,{cols:b,rows:a,opts:c});return l});u("cells.nodes","cell.node",function{return this.iterator("cell",function(a,b,c){return(a=a.aoData[b])&&a.anCells?a.anCells[c]:k},1)});p("cells.data",function{return this.iterator("cell",function(a,b,c){return B(a,b,c)},1)});u("cells.cache","cell.cache",function(a){a= "search"===a?"_aFilterData":"_aSortData";return this.iterator("cell",function(b,c,d){return b.aoData[c][a][d]},1)});u("cells.render","cell.render",function(a){return this.iterator("cell",function(b,c,d){return B(b,c,d,a)},1)});u("cells.indexes","cell.index",function{return this.iterator("cell",function(a,b,c){return{row:b,column:c,columnVisible:aa(a,c)}},1)});u("cells.invalidate","cell.invalidate",function(a){return this.iterator("cell",function(b,c,d){da(b,c,a,d)})});p("cell", function(a,b,c){return db(this.cells(a,b,c))});p("cell.data",function(a){var b=this.context,c=this[0];if(a===k)return b.length&&c.length?B(b[0],c[0].row,c[0].column):k;lb(b[0],c[0].row,c[0].column,a);da(b[0],c[0].row,"data",c[0].column);return this});p("order",function(a,b){var c=this.context;if(a===k)return 0!==c.length?c[0].aaSorting:k;"number"===typeof a?a=a,b:a.length&&!h.isArray(a[0])&&(a=Array.prototype.slice.call(arguments));return this.iterator("table",function(b){b.aaSorting=a.slice})}); p("order.listener",function(a,b,c){return this.iterator("table",function(d){Oa(d,a,b,c)})});p("order.fixed",function(a){if(!a){var b=this.context,b=b.length?b[0].aaSortingFixed:k;return h.isArray(b)?{pre:b}:b}return this.iterator("table",function(b){b.aaSortingFixed=h.extend(!0,{},a)})});p(["columns.order","column.order"],function(a){var b=this;return this.iterator("table",function(c,d){var e=[];h.each(b[d],function(b,c){e.push([c,a])});c.aaSorting=e})});p("search",function(a,b,c,d){var e= this.context;return a===k?0!==e.length?e[0].oPreviousSearch.sSearch:k:this.iterator("table",function(e){e.oFeatures.bFilter&&ga(e,h.extend({},e.oPreviousSearch,{sSearch:a+"",bRegex:null===b?!1:b,bSmart:null===c?!0:c,bCaseInsensitive:null===d?!0:d}),1)})});u("columns.search","column.search",function(a,b,c,d){return this.iterator("column",function(e,f){var g=e.aoPreSearchCols;if(a===k)return g[f].sSearch;e.oFeatures.bFilter&&(h.extend(g[f],{sSearch:a+"",bRegex:null===b?!1:b,bSmart:null===c? !0:c,bCaseInsensitive:null===d?!0:d}),ga(e,e.oPreviousSearch,1))})});p("state",function{return this.context.length?this.context[0].oSavedState:null});p("state.clear",function{return this.iterator("table",function(a){a.fnStateSaveCallback.call(a.oInstance,a,{})})});p("state.loaded",function{return this.context.length?this.context[0].oLoadedState:null});p("state.save",function{return this.iterator("table",function(a){za(a)})});m.versionCheck=m.fnVersionCheck=function(a){for(var b=m.version.split("."), a=a.split("."),c,d,e=0,f=a.length;e<f;e++)if(c=parseInt(b[e],10)||0,d=parseInt(a[e],10)||0,c!==d)return c>d;return!0};m.isDataTable=m.fnIsDataTable=function(a){var b=h(a).get(0),c=!1;if(a instanceof m.Api)return!0;h.each(m.settings,function(a,e){var f=e.nScrollHead?h("table",e.nScrollHead)[0]:null,g=e.nScrollFoot?h("table",e.nScrollFoot)[0]:null;if(e.nTable===b||f===b||g===b)c=!0});return c};m.tables=m.fnTables=function(a){var b=!1;h.isPlainObject(a)&&(b=a.api,a=a.visible);var c=h.map(m.settings, function(b){if(!a||a&&h(b.nTable).is(":visible"))return b.nTable});return b?new t(c):c};m.camelToHungarian=J;p("$",function(a,b){var c=this.rows(b).nodes,c=h(c);return h([].concat(c.filter(a).toArray,c.find(a).toArray))});h.each(["on","one","off"],function(a,b){p(b+"",function{var a=Array.prototype.slice.call(arguments);a[0]=h.map(a[0].split(/\s/),function(a){return!a.match(/\.dt\b/)?a+".dt":a}).join(" ");var d=h(this.tables.nodes);d[b].apply(d,a);return this})});p("clear",function{return this.iterator("table", function(a){pa(a)})});p("settings",function{return new t(this.context,this.context)});p("init",function{var a=this.context;return a.length?a[0].oInit:null});p("data",function{return this.iterator("table",function(a){return D(a.aoData,"_aData")}).flatten});p("destroy",function(a){a=a||!1;return this.iterator("table",function(b){var c=b.nTableWrapper.parentNode,d=b.oClasses,e=b.nTable,f=b.nTBody,g=b.nTHead,j=b.nTFoot,i=h(e),f=h(f),k=h(b.nTableWrapper),l=h.map(b.aoData,function(a){return a.nTr}), p;b.bDestroying=!0;s(b,"aoDestroyCallback","destroy",[b]);a||(new t(b)).columns.visible(!0);k.off(".DT").find(":not(tbody *)").off(".DT");h(E).off(".DT-"+b.sInstance);e!=g.parentNode&&(i.children("thead").detach,i.append(g));j&&e!=j.parentNode&&(i.children("tfoot").detach,i.append(j));b.aaSorting=[];b.aaSortingFixed=[];ya(b);h(l).removeClass(b.asStripeClasses.join(" "));h("th, td",g).removeClass(d.sSortable+" "+d.sSortableAsc+" "+d.sSortableDesc+" "+d.sSortableNone);b.bJUI&&(h("th span."+d.sSortIcon+ ", td span."+d.sSortIcon,g).detach,h("th, td",g).each(function{var a=h("div."+d.sSortJUIWrapper,this);h(this).append(a.contents);a.detach}));f.children.detach;f.append(l);g=a?"remove":"detach";i[g];k[g];!a&&c&&(c.insertBefore(e,b.nTableReinsertBefore),i.css("width",b.sDestroyWidth).removeClass(d.sTable),(p=b.asDestroyStripes.length)&&f.children.each(function(a){h(this).addClass(b.asDestroyStripes[a%p])}));c=h.inArray(b,m.settings);-1!==c&&m.settings.splice(c,1)})});h.each(["column", "row","cell"],function(a,b){p(b+"s.every",function(a){var d=this.selector.opts,e=this;return this.iterator(b,function(f,g,h,i,m){a.call(e[b](g,"cell"===b?h:d,"cell"===b?d:k),g,h,i,m)})})});p("i18n",function(a,b,c){var d=this.context[0],a=R(a)(d.oLanguage);a===k&&(a=b);c!==k&&h.isPlainObject(a)&&(a=a[c]!==k?a[c]:a._);return a.replace("%d",c)});m.version="1.10.15";m.settings=[];m.models={};m.models.oSearch={bCaseInsensitive:!0,sSearch:"",bRegex:!1,bSmart:!0};m.models.oRow={nTr:null,anCells:null, _aData:[],_aSortData:null,_aFilterData:null,_sFilterRow:null,_sRowStripe:"",src:null,idx:-1};m.models.oColumn={idx:null,aDataSort:null,asSorting:null,bSearchable:null,bSortable:null,bVisible:null,_sManualType:null,_bAttrSrc:!1,fnCreatedCell:null,fnGetData:null,fnSetData:null,mData:null,mRender:null,nTh:null,nTf:null,sClass:null,sContentPadding:null,sDefaultContent:null,sName:null,sSortDataType:"std",sSortingClass:null,sSortingClassJUI:null,sTitle:null,sType:null,sWidth:null,sWidthOrig:null};m.defaults= {aaData:null,aaSorting:0,"asc",aaSortingFixed:[],ajax:null,aLengthMenu:[10,25,50,100],aoColumns:null,aoColumnDefs:null,aoSearchCols:[],asStripeClasses:null,bAutoWidth:!0,bDeferRender:!1,bDestroy:!1,bFilter:!0,bInfo:!0,bJQueryUI:!1,bLengthChange:!0,bPaginate:!0,bProcessing:!1,bRetrieve:!1,bScrollCollapse:!1,bServerSide:!1,bSort:!0,bSortMulti:!0,bSortCellsTop:!1,bSortClasses:!0,bStateSave:!1,fnCreatedRow:null,fnDrawCallback:null,fnFooterCallback:null,fnFormatNumber:function(a){return a.toString.replace(/\B(?=(\d{3})+(?!\d))/g, this.oLanguage.sThousands)},fnHeaderCallback:null,fnInfoCallback:null,fnInitComplete:null,fnPreDrawCallback:null,fnRowCallback:null,fnServerData:null,fnServerParams:null,fnStateLoadCallback:function(a){try{return JSON.parse((-1===a.iStateDuration?sessionStorage:localStorage).getItem("DataTables_"+a.sInstance+"_"+location.pathname))}catch(b){}},fnStateLoadParams:null,fnStateLoaded:null,fnStateSaveCallback:function(a,b){try{(-1===a.iStateDuration?sessionStorage:localStorage).setItem("DataTables_"+a.sInstance+ "_"+location.pathname,JSON.stringify(b))}catch(c){}},fnStateSaveParams:null,iStateDuration:7200,iDeferLoading:null,iDisplayLength:10,iDisplayStart:0,iTabIndex:0,oClasses:{},oLanguage:{oAria:{sSortAscending:": activate to sort column ascending",sSortDescending:": activate to sort column descending"},oPaginate:{sFirst:"First",sLast:"Last",sNext:"Next",sPrevious:"Previous"},sEmptyTable:"No data available in table",sInfo:"Showing _START_ to _END_ of _TOTAL_ entries",sInfoEmpty:"Showing 0 to 0 of 0 entries", sInfoFiltered:"(filtered from _MAX_ total entries)",sInfoPostFix:"",sDecimal:"",sThousands:",",sLengthMenu:"Show _MENU_ entries",sLoadingRecords:"Loading...",sProcessing:"Processing...",sSearch:"Search:",sSearchPlaceholder:"",sUrl:"",sZeroRecords:"No matching records found"},oSearch:h.extend({},m.models.oSearch),sAjaxDataProp:"data",sAjaxSource:null,sDom:"lfrtip",searchDelay:null,sPaginationType:"simple_numbers",sScrollX:"",sScrollXInner:"",sScrollY:"",sServerMethod:"GET",renderer:null,rowId:"DT_RowId"}; Y(m.defaults);m.defaults.column={aDataSort:null,iDataSort:-1,asSorting:["asc","desc"],bSearchable:!0,bSortable:!0,bVisible:!0,fnCreatedCell:null,mData:null,mRender:null,sCellType:"td",sClass:"",sContentPadding:"",sDefaultContent:null,sName:"",sSortDataType:"std",sTitle:null,sType:null,sWidth:null};Y(m.defaults.column);m.models.oSettings={oFeatures:{bAutoWidth:null,bDeferRender:null,bFilter:null,bInfo:null,bLengthChange:null,bPaginate:null,bProcessing:null,bServerSide:null,bSort:null,bSortMulti:null, bSortClasses:null,bStateSave:null},oScroll:{bCollapse:null,iBarWidth:0,sX:null,sXInner:null,sY:null},oLanguage:{fnInfoCallback:null},oBrowser:{bScrollOversize:!1,bScrollbarLeft:!1,bBounding:!1,barWidth:0},ajax:null,aanFeatures:[],aoData:[],aiDisplay:[],aiDisplayMaster:[],aIds:{},aoColumns:[],aoHeader:[],aoFooter:[],oPreviousSearch:{},aoPreSearchCols:[],aaSorting:null,aaSortingFixed:[],asStripeClasses:null,asDestroyStripes:[],sDestroyWidth:0,aoRowCallback:[],aoHeaderCallback:[],aoFooterCallback:[], aoDrawCallback:[],aoRowCreatedCallback:[],aoPreDrawCallback:[],aoInitComplete:[],aoStateSaveParams:[],aoStateLoadParams:[],aoStateLoaded:[],sTableId:"",nTable:null,nTHead:null,nTFoot:null,nTBody:null,nTableWrapper:null,bDeferLoading:!1,bInitialised:!1,aoOpenRows:[],sDom:null,searchDelay:null,sPaginationType:"two_button",iStateDuration:0,aoStateSave:[],aoStateLoad:[],oSavedState:null,oLoadedState:null,sAjaxSource:null,sAjaxDataProp:null,bAjaxDataGet:!0,jqXHR:null,json:k,oAjaxData:k,fnServerData:null, aoServerParams:[],sServerMethod:null,fnFormatNumber:null,aLengthMenu:null,iDraw:0,bDrawing:!1,iDrawError:-1,_iDisplayLength:10,_iDisplayStart:0,_iRecordsTotal:0,_iRecordsDisplay:0,bJUI:null,oClasses:{},bFiltered:!1,bSorted:!1,bSortCellsTop:null,oInit:null,aoDestroyCallback:[],fnRecordsTotal:function{return"ssp"==y(this)?1*this._iRecordsTotal:this.aiDisplayMaster.length},fnRecordsDisplay:function{return"ssp"==y(this)?1*this._iRecordsDisplay:this.aiDisplay.length},fnDisplayEnd:function{var a= this._iDisplayLength,b=this._iDisplayStart,c=b+a,d=this.aiDisplay.length,e=this.oFeatures,f=e.bPaginate;return e.bServerSide?!1===f||-1===a?b+d:Math.min(b+a,this._iRecordsDisplay):!f||c>d||-1===a?d:c},oInstance:null,sInstance:null,iTabIndex:0,nScrollHead:null,nScrollFoot:null,aLastSort:[],oPlugins:{},rowIdFn:null,rowId:null};m.ext=x={buttons:{},classes:{},builder:"-source-",errMode:"alert",feature:[],search:[],selector:{cell:[],column:[],row:[]},internal:{},legacy:{ajax:null},pager:{},renderer:{pageButton:{}, header:{}},order:{},type:{detect:[],search:{},order:{}},_unique:0,fnVersionCheck:m.fnVersionCheck,iApiIndex:0,oJUIClasses:{},sVersion:m.version};h.extend(x,{afnFiltering:x.search,aTypes:x.type.detect,ofnSearch:x.type.search,oSort:x.type.order,afnSortData:x.order,aoFeatures:x.feature,oApi:x.internal,oStdClasses:x.classes,oPagination:x.pager});h.extend(m.ext.classes,{sTable:"dataTable",sNoFooter:"no-footer",sPageButton:"paginate_button",sPageButtonActive:"current",sPageButtonDisabled:"disabled",sStripeOdd:"odd", sStripeEven:"even",sRowEmpty:"dataTables_empty",sWrapper:"dataTables_wrapper",sFilter:"dataTables_filter",sInfo:"dataTables_info",sPaging:"dataTables_paginate paging_",sLength:"dataTables_length",sProcessing:"dataTables_processing",sSortAsc:"sorting_asc",sSortDesc:"sorting_desc",sSortable:"sorting",sSortableAsc:"sorting_asc_disabled",sSortableDesc:"sorting_desc_disabled",sSortableNone:"sorting_disabled",sSortColumn:"sorting_",sFilterInput:"",sLengthSelect:"",sScrollWrapper:"dataTables_scroll",sScrollHead:"dataTables_scrollHead", sScrollHeadInner:"dataTables_scrollHeadInner",sScrollBody:"dataTables_scrollBody",sScrollFoot:"dataTables_scrollFoot",sScrollFootInner:"dataTables_scrollFootInner",sHeaderTH:"",sFooterTH:"",sSortJUIAsc:"",sSortJUIDesc:"",sSortJUI:"",sSortJUIAscAllowed:"",sSortJUIDescAllowed:"",sSortJUIWrapper:"",sSortIcon:"",sJUIHeader:"",sJUIFooter:""});var Ea="",Ea="",G=Ea+"ui-state-default",ka=Ea+"css_right ui-icon ui-icon-",Yb=Ea+"fg-toolbar ui-toolbar ui-widget-header ui-helper-clearfix";h.extend(m.ext.oJUIClasses, m.ext.classes,{sPageButton:"fg-button ui-button "+G,sPageButtonActive:"ui-state-disabled",sPageButtonDisabled:"ui-state-disabled",sPaging:"dataTables_paginate fg-buttonset ui-buttonset fg-buttonset-multi ui-buttonset-multi paging_",sSortAsc:G+" sorting_asc",sSortDesc:G+" sorting_desc",sSortable:G+" sorting",sSortableAsc:G+" sorting_asc_disabled",sSortableDesc:G+" sorting_desc_disabled",sSortableNone:G+" sorting_disabled",sSortJUIAsc:ka+"triangle-1-n",sSortJUIDesc:ka+"triangle-1-s",sSortJUI:ka+"carat-2-n-s", sSortJUIAscAllowed:ka+"carat-1-n",sSortJUIDescAllowed:ka+"carat-1-s",sSortJUIWrapper:"DataTables_sort_wrapper",sSortIcon:"DataTables_sort_icon",sScrollHead:"dataTables_scrollHead "+G,sScrollFoot:"dataTables_scrollFoot "+G,sHeaderTH:G,sFooterTH:G,sJUIHeader:Yb+" ui-corner-tl ui-corner-tr",sJUIFooter:Yb+" ui-corner-bl ui-corner-br"});var Nb=m.ext.pager;h.extend(Nb,{simple:function{return["previous","next"]},full:function{return["first","previous","next","last"]},numbers:function(a,b){return[ia(a, b)]},simple_numbers:function(a,b){return["previous",ia(a,b),"next"]},full_numbers:function(a,b){return["first","previous",ia(a,b),"next","last"]},first_last_numbers:function(a,b){return["first",ia(a,b),"last"]},_numbers:ia,numbers_length:7});h.extend(!0,m.ext.renderer,{pageButton:{_:function(a,b,c,d,e,f){var g=a.oClasses,j=a.oLanguage.oPaginate,i=a.oLanguage.oAria.paginate||{},m,l,p=0,r=function(b,d){var k,t,u,s,v=function(b){Va(a,b.data.action,true)};k=0;for(t=d.length;k<t;k++){s=d[k];if(h.isArray(s)){u= h("<"+(s.DT_el||"div")+"/>").appendTo(b);r(u,s)}else{m=null;l="";switch(s){case "ellipsis":b.append(' &#x2026; ');break;case "first":m=j.sFirst;l=s+(e>0?"":" "+g.sPageButtonDisabled);break;case "previous":m=j.sPrevious;l=s+(e>0?"":" "+g.sPageButtonDisabled);break;case "next":m=j.sNext;l=s+(e<f-1?"":" "+g.sPageButtonDisabled);break;case "last":m=j.sLast;l=s+(e<f-1?"":" "+g.sPageButtonDisabled);break;default:m=s+1;l=e===s?g.sPageButtonActive:""}if(m!==null){u=h("",{"class":g.sPageButton+ " "+l,"aria-controls":a.sTableId,"aria-label":i[s],"data-dt-idx":p,tabindex:a.iTabIndex,id:c===0&&typeof s==="string"?a.sTableId+"_"+s:null}).html(m).appendTo(b);Ya(u,{action:s},v);p++}}}},t;try{t=h(b).find(H.activeElement).data("dt-idx")}catch(u){}r(h(b).empty,d);t!==k&&h(b).find("[data-dt-idx="+t+"]").focus}}});h.extend(m.ext.type.detect,[function(a,b){var c=b.oLanguage.sDecimal;return ab(a,c)?"num"+c:null},function(a){if(a&&!(a instanceof Date)&&!cc.test(a))return null;var b=Date.parse(a); return null!==b&&!isNaN(b)||M(a)?"date":null},function(a,b){var c=b.oLanguage.sDecimal;return ab(a,c,!0)?"num-fmt"+c:null},function(a,b){var c=b.oLanguage.sDecimal;return Sb(a,c)?"html-num"+c:null},function(a,b){var c=b.oLanguage.sDecimal;return Sb(a,c,!0)?"html-num-fmt"+c:null},function(a){return M(a)||"string"===typeof a&&-1!==a.indexOf("<")?"html":null}]);h.extend(m.ext.type.search,{html:function(a){return M(a)?a:"string"===typeof a?a.replace(Pb," ").replace(Ca,""):""},string:function(a){return M(a)? a:"string"===typeof a?a.replace(Pb," "):a}});var Ba=function(a,b,c,d){if(0!==a&&(!a||"-"===a))return-Infinity;b&&(a=Rb(a,b));a.replace&&(c&&(a=a.replace(c,"")),d&&(a=a.replace(d,"")));return 1*a};h.extend(x.type.order,{"date-pre":function(a){return Date.parse(a)||-Infinity},"html-pre":function(a){return M(a)?"":a.replace?a.replace(/<.*?>/g,"").toLowerCase:a+""},"string-pre":function(a){return M(a)?"":"string"===typeof a?a.toLowerCase:!a.toString?"":a.toString},"string-asc":function(a,b){return a< b?-1:a>b?1:0},"string-desc":function(a,b){return a<b?1:a>b?-1:0}});fb("");h.extend(!0,m.ext.renderer,{header:{_:function(a,b,c,d){h(a.nTable).on("order.dt.DT",function(e,f,g,h){if(a===f){e=c.idx;b.removeClass(c.sSortingClass+" "+d.sSortAsc+" "+d.sSortDesc).addClass(h[e]=="asc"?d.sSortAsc:h[e]=="desc"?d.sSortDesc:c.sSortingClass)}})},jqueryui:function(a,b,c,d){h(" ").addClass(d.sSortJUIWrapper).append(b.contents).append(h(" ").addClass(d.sSortIcon+" "+c.sSortingClassJUI)).appendTo(b); h(a.nTable).on("order.dt.DT",function(e,f,g,h){if(a===f){e=c.idx;b.removeClass(d.sSortAsc+" "+d.sSortDesc).addClass(h[e]=="asc"?d.sSortAsc:h[e]=="desc"?d.sSortDesc:c.sSortingClass);b.find("span."+d.sSortIcon).removeClass(d.sSortJUIAsc+" "+d.sSortJUIDesc+" "+d.sSortJUI+" "+d.sSortJUIAscAllowed+" "+d.sSortJUIDescAllowed).addClass(h[e]=="asc"?d.sSortJUIAsc:h[e]=="desc"?d.sSortJUIDesc:c.sSortingClassJUI)}})}}});var Zb=function(a){return"string"===typeof a?a.replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g, "&quot;"):a};m.render={number:function(a,b,c,d,e){return{display:function(f){if("number"!==typeof f&&"string"!==typeof f)return f;var g=0>f?"-":"",h=parseFloat(f);if(isNaN(h))return Zb(f);h=h.toFixed(c);f=Math.abs(h);h=parseInt(f,10);f=c?b+(f-h).toFixed(c).substring(2):"";return g+(d||"")+h.toString.replace(/\B(?=(\d{3})+(?!\d))/g,a)+f+(e||"")}}},text:function{return{display:Zb}}};h.extend(m.ext.internal,{_fnExternApiFunc:Ob,_fnBuildAjax:ua,_fnAjaxUpdate:nb,_fnAjaxParameters:wb,_fnAjaxUpdateDraw:xb, _fnAjaxDataSrc:va,_fnAddColumn:Ga,_fnColumnOptions:la,_fnAdjustColumnSizing:Z,_fnVisibleToColumnIndex:$,_fnColumnIndexToVisible:aa,_fnVisbleColumns:ba,_fnGetColumns:na,_fnColumnTypes:Ia,_fnApplyColumnDefs:kb,_fnHungarianMap:Y,_fnCamelToHungarian:J,_fnLanguageCompat:Fa,_fnBrowserDetect:ib,_fnAddData:N,_fnAddTr:oa,_fnNodeToDataIndex:function(a,b){return b._DT_RowIndex!==k?b._DT_RowIndex:null},_fnNodeToColumnIndex:function(a,b,c){return h.inArray(c,a.aoData[b].anCells)},_fnGetCellData:B,_fnSetCellData:lb, _fnSplitObjNotation:La,_fnGetObjectDataFn:R,_fnSetObjectDataFn:S,_fnGetDataMaster:Ma,_fnClearTable:pa,_fnDeleteIndex:qa,_fnInvalidate:da,_fnGetRowElements:Ka,_fnCreateTr:Ja,_fnBuildHead:mb,_fnDrawHead:fa,_fnDraw:O,_fnReDraw:T,_fnAddOptionsHtml:pb,_fnDetectHeader:ea,_fnGetUniqueThs:ta,_fnFeatureHtmlFilter:rb,_fnFilterComplete:ga,_fnFilterCustom:Ab,_fnFilterColumn:zb,_fnFilter:yb,_fnFilterCreateSearch:Ra,_fnEscapeRegex:Sa,_fnFilterData:Bb,_fnFeatureHtmlInfo:ub,_fnUpdateInfo:Eb,_fnInfoMacros:Fb,_fnInitialise:ha, _fnInitComplete:wa,_fnLengthChange:Ta,_fnFeatureHtmlLength:qb,_fnFeatureHtmlPaginate:vb,_fnPageChange:Va,_fnFeatureHtmlProcessing:sb,_fnProcessingDisplay:C,_fnFeatureHtmlTable:tb,_fnScrollDraw:ma,_fnApplyToChildren:I,_fnCalculateColumnWidths:Ha,_fnThrottle:Qa,_fnConvertToWidth:Gb,_fnGetWidestNode:Hb,_fnGetMaxLenString:Ib,_fnStringToCss:v,_fnSortFlatten:W,_fnSort:ob,_fnSortAria:Kb,_fnSortListener:Xa,_fnSortAttachListener:Oa,_fnSortingClasses:ya,_fnSortData:Jb,_fnSaveState:za,_fnLoadState:Lb,_fnSettingsFromNode:Aa, _fnLog:K,_fnMap:F,_fnBindAction:Ya,_fnCallbackReg:z,_fnCallbackFire:s,_fnLengthOverflow:Ua,_fnRenderer:Pa,_fnDataSource:y,_fnRowAttributes:Na,_fnCalculateEnd:function{}});h.fn.dataTable=m;m.$=h;h.fn.dataTableSettings=m.settings;h.fn.dataTableExt=m.ext;h.fn.DataTable=function(a){return h(this).dataTable(a).api};h.each(m,function(a,b){h.fn.DataTable[a]=b});return h.fn.dataTable});

}