/*!

* jQuery JavaScript Library v1.9.0

* http://jquery.com/

*

* Includes Sizzle.js

* http://sizzlejs.com/

*

* Copyright 2005, 2012 jQuery Foundation, Inc. and other contributors

* Released under the MIT license

* http://jquery.org/license

*

* Date: 2013-1-14

*/

(function( window, undefined ) {

"use strict";

var

// A central reference to the root jQuery(document)

rootjQuery,

// The deferred used on DOM ready

readyList,

// Use the correct document accordingly with window argument (sandbox)

document = window.document,

location = window.location,

// Map over jQuery in case of overwrite

_jQuery = window.jQuery,

// Map over the $ in case of overwrite

_$ = window.$,

// [[Class]] -> type pairs

class2type = {},

// List of deleted data cache ids, so we can reuse them

core_deletedIds = [],

core_version = "1.9.0",

// Save a reference to some core methods

core_concat = core_deletedIds.concat,

core_push = core_deletedIds.push,

core_slice = core_deletedIds.slice,

core_indexOf = core_deletedIds.indexOf,

core_toString = class2type.toString,

core_hasOwn = class2type.hasOwnProperty,

core_trim = core_version.trim,

// Define a local copy of jQuery

jQuery = function( selector, context ) {

// The jQuery object is actually just the init constructor 'enhanced'

return new jQuery.fn.init( selector, context, rootjQuery );

},

// Used for matching numbers

core_pnum = /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,

// Used for splitting on whitespace

core_rnotwhite = /\S+/g,

// Make sure we trim BOM and NBSP (here's looking at you, Safari 5.0 and IE)

rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,

// A simple way to check for HTML strings

// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)

// Strict HTML recognition (#11290: must start with <)

rquickExpr = /^(?:(<[\w\W]+>)[^>]*|#([\w-]*))$/,

// Match a standalone tag

rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>|)$/,

// JSON RegExp

rvalidchars = /^[\],:{}\s]*$/,

rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,

rvalidescape = /\\(?:["\\\/bfnrt]|u[\da-fA-F]{4})/g,

rvalidtokens = /"[^"\\\r\n]*"|true|false|null|-?(?:\d+\.|)\d+(?:[eE][+-]?\d+|)/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();

},

// The ready event handler and self cleanup method

DOMContentLoaded = function() {

if ( document.addEventListener ) {

document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );

jQuery.ready();

} else if ( document.readyState === "complete" ) {

// we're here because readyState === "complete" in oldIE

// which is good enough for us to call the dom ready!

document.detachEvent( "onreadystatechange", DOMContentLoaded );

jQuery.ready();

}

};

jQuery.fn = jQuery.prototype = {

// The current version of jQuery being used

jquery: core_version,

constructor: jQuery,

init: function( selector, context, rootjQuery ) {

var match, elem;

// HANDLE: $(""), $(null), $(undefined), $(false)

if ( !selector ) {

return this;

}

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

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 || rootjQuery ).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 rootjQuery.ready( selector );

}

if ( selector.selector !== undefined ) {

this.selector = selector.selector;

this.context = selector.context;

}

return jQuery.makeArray( selector, this );

},

// Start with an empty selector

selector: "",

// The default length of a jQuery object is 0

length: 0,

// The number of elements contained in the matched element set

size: function() {

return this.length;

},

toArray: function() {

return core_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 a 'clean' array

this.toArray() :

// Return just the object

( num < 0 ? this[ this.length + num ] : this[ num ] );

},

// Take an array of elements and push it onto the stack

// (returning the new matched element set)

pushStack: function( elems ) {

// 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.

// (You can seed the arguments with an array of args, but this is

// only used internally.)

each: function( callback, args ) {

return jQuery.each( this, callback, args );

},

ready: function( fn ) {

// Add the callback

jQuery.ready.promise().done( fn );

return this;

},

slice: function() {

return this.pushStack( core_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] ] : [] );

},

map: function( callback ) {

return this.pushStack( jQuery.map(this, function( elem, i ) {

return callback.call( elem, i, elem );

}));

},

end: function() {

return this.prevObject || this.constructor(null);

},

// For internal use only.

// Behaves like an Array's method, not like a jQuery method.

push: core_push,

sort: [].sort,

splice: [].splice

};

// Give the init function the jQuery prototype for later instantiation

jQuery.fn.init.prototype = jQuery.fn;

jQuery.extend = jQuery.fn.extend = function() {

var options, name, src, copy, copyIsArray, clone,

target = arguments[0] || {},

i = 1,

length = arguments.length,

deep = false;

// Handle a deep copy situation

if ( typeof target === "boolean" ) {

deep = target;

target = arguments[1] || {};

// skip the boolean and the target

i = 2;

}

// Handle case when target is a string or something (possible in deep copy)

if ( typeof target !== "object" && !jQuery.isFunction(target) ) {

target = {};

}

// extend jQuery itself if only one argument is passed

if ( length === i ) {

target = this;

--i;

}

for ( ; i < length; i++ ) {

// Only deal with non-null/undefined values

if ( (options = arguments[ i ]) != null ) {

// Extend the base object

for ( name in options ) {

src = target[ name ];

copy = options[ name ];

// Prevent never-ending loop

if ( target === copy ) {

continue;

}

// Recurse if we're merging plain objects or arrays

if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {

if ( copyIsArray ) {

copyIsArray = false;

clone = src && jQuery.isArray(src) ? src : [];

} else {

clone = src && jQuery.isPlainObject(src) ? src : {};

}

// Never move original objects, clone them

target[ name ] = jQuery.extend( deep, clone, copy );

// Don't bring in undefined values

} else if ( copy !== undefined ) {

target[ name ] = copy;

}

}

}

}

// Return the modified object

return target;

};

jQuery.extend({

noConflict: function( deep ) {

if ( window.$ === jQuery ) {

window.$ = _$;

}

if ( deep && window.jQuery === jQuery ) {

window.jQuery = _jQuery;

}

return jQuery;

},

// Is the DOM ready to be used? Set to true once it occurs.

isReady: false,

// A counter to track how many items to wait for before

// the ready event fires. See #6781

readyWait: 1,

// Hold (or release) the ready event

holdReady: function( hold ) {

if ( hold ) {

jQuery.readyWait++;

} else {

jQuery.ready( true );

}

},

// Handle when the DOM is ready

ready: function( wait ) {

// Abort if there are pending holds or we're already ready

if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {

return;

}

// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).

if ( !document.body ) {

return setTimeout( jQuery.ready );

}

// Remember that the DOM is ready

jQuery.isReady = true;

// If a normal DOM Ready event fired, decrement, and wait if need be

if ( wait !== true && --jQuery.readyWait > 0 ) {

return;

}

// If there are functions bound, to execute

readyList.resolveWith( document, [ jQuery ] );

// Trigger any bound ready events

if ( jQuery.fn.trigger ) {

jQuery( document ).trigger("ready").off("ready");

}

},

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

return obj != null && obj == obj.window;

},

isNumeric: function( obj ) {

return !isNaN( parseFloat(obj) ) && isFinite( obj );

},

type: function( obj ) {

if ( obj == null ) {

return String( obj );

}

return typeof obj === "object" || typeof obj === "function" ?

class2type[ core_toString.call(obj) ] || "object" :

typeof obj;

},

isPlainObject: function( obj ) {

// Must be an Object.

// Because of IE, we also have to check the presence of the constructor property.

// Make sure that DOM nodes and window objects don't pass through, as well

if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {

return false;

}

try {

// Not own constructor property must be Object

if ( obj.constructor &&

!core_hasOwn.call(obj, "constructor") &&

!core_hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {

return false;

}

} catch ( e ) {

// IE8,9 Will throw exceptions on certain host objects #9897

return false;

}

// Own properties are enumerated firstly, so to speed up,

// if last one is own, then all properties are own.

var key;

for ( key in obj ) {}

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

},

isEmptyObject: function( obj ) {

var name;

for ( name in obj ) {

return false;

}

return true;

},

error: function( msg ) {

throw new Error( msg );

},

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

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 = jQuery.buildFragment( [ data ], context, scripts );

if ( scripts ) {

jQuery( scripts ).remove();

}

return jQuery.merge( [], parsed.childNodes );

},

parseJSON: function( data ) {

// Attempt to parse using the native JSON parser first

if ( window.JSON && window.JSON.parse ) {

return window.JSON.parse( data );

}

if ( data === null ) {

return data;

}

if ( typeof data === "string" ) {

// Make sure leading/trailing whitespace is removed (IE can't handle it)

data = jQuery.trim( data );

if ( data ) {

// Make sure the incoming data is actual JSON

// Logic borrowed from http://json.org/json2.js

if ( rvalidchars.test( data.replace( rvalidescape, "@" )

.replace( rvalidtokens, "]" )

.replace( rvalidbraces, "")) ) {

return ( new Function( "return " + data ) )();

}

}

}

jQuery.error( "Invalid JSON: " + data );

},

// Cross-browser xml parsing

parseXML: function( data ) {

var xml, tmp;

if ( !data || typeof data !== "string" ) {

return null;

}

try {

if ( window.DOMParser ) { // Standard

tmp = new DOMParser();

xml = tmp.parseFromString( data , "text/xml" );

} else { // IE

xml = new ActiveXObject( "Microsoft.XMLDOM" );

xml.async = "false";

xml.loadXML( data );

}

} catch( e ) {

xml = undefined;

}

if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) {

jQuery.error( "Invalid XML: " + data );

}

return xml;

},

noop: function() {},

// Evaluates a script in a global context

// Workarounds based on findings by Jim Driscoll

// http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context

globalEval: function( data ) {

if ( data && 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 );

} )( 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();

},

// args is for internal usage only

each: function( obj, callback, args ) {

var value,

i = 0,

length = obj.length,

isArray = isArraylike( obj );

if ( args ) {

if ( isArray ) {

for ( ; i < length; i++ ) {

value = callback.apply( obj[ i ], args );

if ( value === false ) {

break;

}

}

} else {

for ( i in obj ) {

value = callback.apply( obj[ i ], args );

if ( value === false ) {

break;

}

}

}

// A special, fast, case for the most common use of each

} else {

if ( isArray ) {

for ( ; i < length; i++ ) {

value = callback.call( obj[ i ], i, obj[ i ] );

if ( value === false ) {

break;

}

}

} else {

for ( i in obj ) {

value = callback.call( obj[ i ], i, obj[ i ] );

if ( value === false ) {

break;

}

}

}

}

return obj;

},

// Use native String.trim function wherever possible

trim: core_trim && !core_trim.call("\uFEFF\xA0") ?

function( text ) {

return text == null ?

"" :

core_trim.call( text );

} :

// Otherwise use our own trimming functionality

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 {

core_push.call( ret, arr );

}

}

return ret;

},

inArray: function( elem, arr, i ) {

var len;

if ( arr ) {

if ( core_indexOf ) {

return core_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 l = second.length,

i = first.length,

j = 0;

if ( typeof l === "number" ) {

for ( ; j < l; j++ ) {

first[ i++ ] = second[ j ];

}

} else {

while ( second[j] !== undefined ) {

first[ i++ ] = second[ j++ ];

}

}

first.length = i;

return first;

},

grep: function( elems, callback, inv ) {

var retVal,

ret = [],

i = 0,

length = elems.length;

inv = !!inv;

// Go through the array, only saving the items

// that pass the validator function

for ( ; i < length; i++ ) {

retVal = !!callback( elems[ i ], i );

if ( inv !== retVal ) {

ret.push( elems[ i ] );

}

}

return ret;

},

// arg is for internal usage only

map: function( elems, callback, arg ) {

var value,

i = 0,

length = elems.length,

isArray = isArraylike( elems ),

ret = [];

// Go through the array, translating each of the items to their

if ( isArray ) {

for ( ; i < length; i++ ) {

value = callback( elems[ i ], i, arg );

if ( value != null ) {

ret[ ret.length ] = value;

}

}

// Go through every key on the object,

} else {

for ( i in elems ) {

value = callback( elems[ i ], i, arg );

if ( value != null ) {

ret[ ret.length ] = value;

}

}

}

// Flatten any nested arrays

return core_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 tmp, args, proxy;

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 = core_slice.call( arguments, 2 );

proxy = function() {

return fn.apply( context || this, args.concat( core_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;

},

// Multifunctional method to get and set values of a collection

// The value/s can optionally be executed if it's a function

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

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

},

now: function() {

return ( new Date() ).getTime();

}

});

jQuery.ready.promise = function( obj ) {

if ( !readyList ) {

readyList = jQuery.Deferred();

// Catch cases where $(document).ready() is called after the browser event has already occurred.

// we once tried to use readyState "interactive" here, but it caused issues like the one

// discovered by ChrisS here: http://bugs.jquery.com/ticket/12282#comment:15

if ( document.readyState === "complete" ) {

// Handle it asynchronously to allow scripts the opportunity to delay ready

setTimeout( jQuery.ready );

// Standards-based browsers support DOMContentLoaded

} else if ( document.addEventListener ) {

// Use the handy event callback

document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );

// A fallback to window.onload, that will always work

window.addEventListener( "load", jQuery.ready, false );

// If IE event model is used

} else {

// Ensure firing before onload, maybe late but safe also for iframes

document.attachEvent( "onreadystatechange", DOMContentLoaded );

// A fallback to window.onload, that will always work

window.attachEvent( "onload", jQuery.ready );

// If IE and not a frame

// continually check to see if the document is ready

var 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 setTimeout( doScrollCheck, 50 );

}

// and execute any waiting functions

jQuery.ready();

}

})();

}

}

}

return readyList.promise( obj );

};

// Populate the class2type map

jQuery.each("Boolean Number String Function Array Date RegExp Object Error".split(" "), function(i, name) {

class2type[ "[object " + name + "]" ] = name.toLowerCase();

});

function isArraylike( obj ) {

var length = obj.length,

type = jQuery.type( obj );

if ( jQuery.isWindow( obj ) ) {

return false;

}

if ( obj.nodeType === 1 && length ) {

return true;

}

return type === "array" || type !== "function" &&

( length === 0 ||

typeof length === "number" && length > 0 && ( length - 1 ) in obj );

}

// All jQuery objects should point back to these

rootjQuery = jQuery(document);

// String to Object options format cache

var optionsCache = {};

// Convert String-formatted options into Object-formatted ones and store in cache

function createOptions( options ) {

var object = optionsCache[ options ] = {};

jQuery.each( options.match( core_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" ?

( optionsCache[ options ] || createOptions( options ) ) :

jQuery.extend( {}, options );

var // Last fire value (for non-forgettable lists)

memory,

// Flag to know if list was already fired

fired,

// Flag to know if list is currently firing

firing,

// First callback to fire (used internally by add and fireWith)

firingStart,

// End of the loop when firing