{"version":3,"sources":["fetch.js","promise.js","jquery.js","jquery.zoom.js","hammer.js","webfontloader.js"],"names":["self","normalizeName","name","String","test","TypeError","toLowerCase","normalizeValue","value","iteratorFor","items","iterator","next","shift","done","undefined","support","iterable","Symbol","Headers","headers","this","map","forEach","append","Array","isArray","header","Object","getOwnPropertyNames","consumed","body","bodyUsed","Promise","reject","fileReaderReady","reader","resolve","onload","result","onerror","error","readBlobAsArrayBuffer","blob","FileReader","promise","readAsArrayBuffer","readBlobAsText","readAsText","readArrayBufferAsText","buf","view","Uint8Array","chars","length","i","fromCharCode","join","bufferClone","slice","byteLength","set","buffer","Body","_initBody","_bodyInit","_bodyText","Blob","prototype","isPrototypeOf","_bodyBlob","formData","FormData","_bodyFormData","searchParams","URLSearchParams","toString","arrayBuffer","isDataView","_bodyArrayBuffer","ArrayBuffer","isArrayBufferView","Error","get","type","rejected","then","text","decode","json","JSON","parse","normalizeMethod","method","upcased","toUpperCase","methods","indexOf","Request","input","options","url","credentials","mode","referrer","form","trim","split","bytes","replace","decodeURIComponent","parseHeaders","rawHeaders","line","parts","key","Response","bodyInit","status","ok","statusText","fetch","e","viewClasses","obj","DataView","isView","call","oldValue","has","hasOwnProperty","callback","thisArg","keys","push","values","entries","clone","response","redirectStatuses","redirect","RangeError","location","init","request","xhr","XMLHttpRequest","getAllResponseHeaders","responseURL","responseText","ontimeout","open","withCredentials","responseType","setRequestHeader","send","polyfill","root","noop","bind","fn","apply","arguments","_state","_handled","_value","_deferreds","doResolve","handle","deferred","_immediateFn","cb","onFulfilled","onRejected","ret","newValue","finale","_unhandledRejectionFn","len","Handler","reason","ex","setTimeoutFunc","setTimeout","prom","all","arr","res","val","args","remaining","constructor","race","setImmediate","err","console","warn","_setImmediateFn","_setUnhandledRejectionFn","module","exports","global","factory","document","w","window","noGlobal","isArrayLike","jQuery","isWindow","winnow","elements","qualifier","not","isFunction","grep","elem","nodeType","risSimple","filter","sibling","cur","dir","createOptions","object","each","match","rnotwhite","_","flag","completed","removeEventListener","ready","Data","expando","uid","dataAttr","data","rmultiDash","getAttribute","rbrace","parseJSON","dataUser","adjustCSS","prop","valueParts","tween","adjusted","scale","maxIterations","currentValue","css","initial","unit","cssNumber","initialInUnit","rcssNum","exec","style","start","end","getAll","context","tag","getElementsByTagName","querySelectorAll","nodeName","merge","setGlobalEval","elems","refElements","l","dataPriv","buildFragment","scripts","selection","ignored","tmp","wrap","contains","j","fragment","createDocumentFragment","nodes","rhtml","appendChild","createElement","rtagName","wrapMap","_default","innerHTML","htmlPrefilter","lastChild","childNodes","firstChild","textContent","createTextNode","inArray","ownerDocument","rscriptType","returnTrue","returnFalse","safeActiveElement","activeElement","on","types","selector","one","origFn","event","off","guid","add","manipulationTarget","content","disableScript","restoreScript","rscriptTypeMasked","removeAttribute","cloneCopyEvent","src","dest","pdataOld","pdataCur","udataOld","udataCur","events","hasData","access","extend","fixInput","rcheckableType","checked","defaultValue","domManip","collection","concat","first","hasScripts","node","doc","iNoClone","checkClone","rchecked","index","eq","html","_evalUrl","globalEval","rcleanScript","remove","keepData","cleanData","parentNode","removeChild","actualDisplay","appendTo","display","detach","defaultDisplay","elemdisplay","iframe","documentElement","contentDocument","write","close","curCSS","computed","width","minWidth","maxWidth","getStyles","getPropertyValue","pixelMarginRight","rnumnonpx","rmargin","addGetHookIf","conditionFn","hookFn","vendorPropName","emptyStyle","capName","cssPrefixes","setPositiveNumber","subtract","matches","Math","max","augmentWidthOrHeight","extra","isBorderBox","styles","cssExpand","getWidthOrHeight","valueIsBorderBox","offsetWidth","offsetHeight","boxSizingReliable","parseFloat","showHide","show","hidden","isHidden","Tween","easing","createFxNow","fxNow","now","genFx","includeWidth","which","attrs","height","opacity","createTween","animation","Animation","tweeners","defaultPrefilter","props","opts","toggle","hooks","oldfire","anim","orig","dataShow","queue","_queueHooks","unqueued","empty","fire","always","overflow","overflowX","overflowY","rfxtypes","isEmptyObject","hide","propFilter","specialEasing","camelCase","cssHooks","expand","properties","stopped","prefilters","Deferred","tick","currentTime","startTime","duration","temp","percent","tweens","run","notifyWith","resolveWith","originalProperties","originalOptions","stop","gotoEnd","rejectWith","proxy","fx","timer","progress","complete","fail","getClass","addToPrefiltersOrTransports","structure","dataTypeExpression","func","dataType","dataTypes","unshift","inspectPrefiltersOrTransports","jqXHR","inspect","selected","inspected","prefilterOrFactory","dataTypeOrTransport","seekingTransport","transports","ajaxExtend","target","deep","flatOptions","ajaxSettings","ajaxHandleResponses","s","responses","ct","finalDataType","firstDataType","contents","mimeType","getResponseHeader","converters","ajaxConvert","isSuccess","conv2","current","conv","prev","responseFields","dataFilter","throws","state","buildParams","prefix","traditional","v","rbracket","getWindow","defaultView","class2type","hasOwn","rtrim","rmsPrefix","rdashAlpha","fcamelCase","letter","jquery","toArray","num","pushStack","prevObject","last","sort","splice","copy","copyIsArray","isPlainObject","random","isReady","msg","isNumeric","realStringObj","code","script","indirect","eval","head","string","makeArray","results","second","invert","callbackExpect","arg","Date","Sizzle","seed","m","nid","nidselect","groups","newSelector","newContext","preferredDoc","setDocument","documentIsHTML","rquickExpr","getElementById","id","getElementsByClassName","qsa","compilerCache","rbuggyQSA","rescape","setAttribute","tokenize","ridentifier","toSelector","rsibling","testContext","qsaError","select","createCache","cache","Expr","cacheLength","markFunction","assert","div","addHandle","handler","attrHandle","siblingCheck","a","b","diff","sourceIndex","MAX_NEGATIVE","nextSibling","createPositionalPseudo","argument","matchIndexes","setFilters","tokens","addCombinator","matcher","combinator","base","checkNonElements","doneName","xml","oldCache","uniqueCache","outerCache","newCache","dirruns","uniqueID","elementMatcher","matchers","multipleContexts","contexts","condense","unmatched","newUnmatched","mapped","setMatcher","preFilter","postFilter","postFinder","postSelector","preMap","postMap","preexisting","matcherIn","matcherOut","matcherFromTokens","checkContext","leadingRelative","relative","implicitRelative","matchContext","matchAnyContext","outermostContext","matcherFromGroupMatchers","elementMatchers","setMatchers","bySet","byElement","superMatcher","outermost","matchedCount","setMatched","contextBackup","find","dirrunsUnique","pop","uniqueSort","getText","isXML","compile","sortInput","hasDuplicate","docElem","rbuggyMatches","classCache","tokenCache","sortOrder","push_native","list","booleans","whitespace","identifier","attributes","pseudos","rwhitespace","RegExp","rcomma","rcombinators","rattributeQuotes","rpseudo","matchExpr","ID","CLASS","TAG","ATTR","PSEUDO","CHILD","bool","needsContext","rinputs","rheader","rnative","runescape","funescape","escaped","escapedWhitespace","high","unloadHandler","els","hasCompare","parent","top","addEventListener","attachEvent","className","createComment","getById","getElementsByName","attrId","getAttributeNode","matchesSelector","webkitMatchesSelector","mozMatchesSelector","oMatchesSelector","msMatchesSelector","disconnectedMatch","compareDocumentPosition","adown","bup","compare","sortDetached","aup","ap","bp","expr","attr","specified","duplicates","detectDuplicates","sortStable","nodeValue","selectors","createPseudo",">"," ","+","~","excess","unquoted","nodeNameSelector","pattern","operator","check","what","simple","forward","ofType","nodeIndex","useCache","pseudo","idx","matched","innerText","lang","elemLang","hash","focus","hasFocus","href","tabIndex","enabled","disabled","selectedIndex","button","even","odd","lt","gt","radio","checkbox","file","password","image","submit","reset","filters","parseOnly","soFar","preFilters","cached","token","compiled","div1","unique","isXMLDoc","until","truncate","is","siblings","n","rneedsContext","rsingleTag","rootjQuery","parseHTML","rparentsprev","guaranteedUnique","children","targets","closest","pos","prevAll","addBack","parents","parentsUntil","nextAll","nextUntil","prevUntil","reverse","Callbacks","firing","memory","fired","locked","firingIndex","once","stopOnFalse","disable","lock","fireWith","tuples","fns","newDefer","tuple","returned","notify","pipe","stateString","when","subordinate","progressValues","progressContexts","resolveContexts","resolveValues","updateFunc","readyList","readyWait","holdReady","hold","wait","triggerHandler","readyState","doScroll","chainable","emptyGet","raw","bulk","acceptData","owner","register","defineProperty","writable","configurable","stored","camel","removeData","_data","_removeData","camelKey","dequeue","startLength","setter","clearQueue","count","defer","pnum","source","el","option","thead","col","tr","td","optgroup","tbody","tfoot","colgroup","caption","th","cloneNode","noCloneChecked","rkeyEvent","rmouseEvent","rtypenamespace","handleObjIn","eventHandle","t","handleObj","special","handlers","namespaces","origType","elemData","triggered","dispatch","delegateType","bindType","namespace","delegateCount","setup","mappedTypes","origCount","teardown","removeEvent","fix","handlerQueue","delegateTarget","preDispatch","isPropagationStopped","currentTarget","isImmediatePropagationStopped","rnamespace","preventDefault","stopPropagation","postDispatch","sel","isNaN","fixHooks","keyHooks","original","charCode","keyCode","mouseHooks","eventDoc","pageX","clientX","scrollLeft","clientLeft","pageY","clientY","scrollTop","clientTop","originalEvent","fixHook","Event","load","noBubble","trigger","blur","click","beforeunload","returnValue","isDefaultPrevented","defaultPrevented","timeStamp","isSimulated","stopImmediatePropagation","mouseenter","mouseleave","pointerenter","pointerleave","related","relatedTarget","rxhtmlTag","rnoInnerhtml","dataAndEvents","deepDataAndEvents","srcElements","destElements","inPage","prepend","insertBefore","before","after","replaceWith","replaceChild","prependTo","insertAfter","replaceAll","insert","HTML","BODY","opener","getComputedStyle","swap","old","computeStyleTests","cssText","container","divStyle","pixelPositionVal","reliableMarginLeftVal","marginLeft","boxSizingReliableVal","marginRight","pixelMarginRightVal","backgroundClip","clearCloneStyle","pixelPosition","reliableMarginLeft","reliableMarginRight","marginDiv","rdisplayswap","cssShow","position","visibility","cssNormalTransform","letterSpacing","fontWeight","animationIterationCount","columnCount","fillOpacity","flexGrow","flexShrink","lineHeight","order","orphans","widows","zIndex","zoom","cssProps","float","origName","isFinite","getBoundingClientRect","left","margin","padding","border","suffix","expanded","propHooks","eased","step","linear","p","swing","cos","PI","timerId","rrun","*","tweener","prefilter","speed","opt","speeds","fadeTo","to","animate","optall","doAnimation","finish","stopQueue","timers","cssFn","slideDown","slideUp","slideToggle","fadeIn","fadeOut","fadeToggle","interval","setInterval","clearInterval","slow","fast","delay","time","timeout","clearTimeout","checkOn","optSelected","optDisabled","radioValue","boolHook","removeAttr","nType","attrHooks","propName","attrNames","propFix","getter","rfocusable","rclickable","removeProp","tabindex","parseInt","for","class","rclass","addClass","classes","curValue","clazz","finalValue","removeClass","toggleClass","stateVal","classNames","hasClass","rreturn","rspaces","valHooks","optionSet","rfocusMorph","onlyHandlers","bubbleType","ontype","eventPath","isTrigger","parentWindow","simulate","hover","fnOver","fnOut","focusin","attaches","nonce","rquery","parseXML","DOMParser","parseFromString","rhash","rts","rheaders","rlocalProtocol","rnoContent","rprotocol","allTypes","originAnchor","active","lastModified","etag","isLocal","protocol","processData","async","contentType","accepts","* text","text html","text json","text xml","ajaxSetup","settings","ajaxPrefilter","ajaxTransport","ajax","nativeStatusText","success","modified","timeoutTimer","transport","responseHeadersString","ifModified","cacheURL","callbackContext","statusCode","fireGlobals","globalEventContext","completeDeferred","responseHeaders","urlAnchor","requestHeaders","requestHeadersNames","strAbort","lname","overrideMimeType","abort","finalText","crossDomain","host","param","hasContent","beforeSend","getJSON","getScript","wrapAll","firstElementChild","wrapInner","unwrap","visible","getClientRects","r20","rCRLF","rsubmitterTypes","rsubmittable","encodeURIComponent","serialize","serializeArray","xhrSuccessStatus","0","1223","xhrSupported","cors","errorCallback","username","xhrFields","onabort","onreadystatechange","binary","text script","charset","scriptCharset","evt","oldCallbacks","rjsonp","jsonp","jsonpCallback","originalSettings","callbackName","overwritten","responseContainer","jsonProp","keepScripts","parsed","_load","params","animated","offset","setOffset","curPosition","curLeft","curCSSTop","curTop","curOffset","curCSSLeft","calculatePosition","curElem","using","win","box","pageYOffset","pageXOffset","offsetParent","parentOffset","scrollTo","Height","Width","","defaultExtra","funcName","unbind","delegate","undelegate","size","andSelf","define","amd","_jQuery","_$","$","noConflict","defaults","touch","onZoomIn","onZoomOut","magnify","img","targetHeight","targetWidth","sourceHeight","sourceWidth","xRatio","yRatio","$target","$source","maxHeight","outerWidth","outerHeight","move","min","$img","mousemove","clicked","touched","srcElement","querySelector","currentSrc","touches","changedTouches","alt","exportName","setTimeoutContext","bindFn","invokeArrayArg","deprecate","message","deprecationMessage","stack","log","inherit","child","childP","baseP","create","_super","assign","boolOrFn","TYPE_FUNCTION","ifUndefined","val1","val2","addEventListeners","splitStr","removeEventListeners","hasParent","inStr","str","findByKey","uniqueArray","prefixed","property","camelProp","VENDOR_PREFIXES","uniqueId","_uniqueId","getWindowForElement","element","Input","manager","inputTarget","domHandler","ev","enable","createInputInstance","inputClass","SUPPORT_POINTER_EVENTS","PointerEventInput","SUPPORT_ONLY_TOUCH","TouchInput","SUPPORT_TOUCH","TouchMouseInput","MouseInput","inputHandler","eventType","pointersLen","pointers","changedPointersLen","changedPointers","isFirst","INPUT_START","isFinal","INPUT_END","INPUT_CANCEL","session","computeInputData","emit","recognize","prevInput","pointersLength","firstInput","simpleCloneInputData","firstMultiple","offsetCenter","center","getCenter","deltaTime","angle","getAngle","distance","getDistance","computeDeltaXY","offsetDirection","getDirection","deltaX","deltaY","overallVelocity","getVelocity","overallVelocityX","x","overallVelocityY","y","abs","getScale","rotation","getRotation","maxPointers","computeIntervalInputData","srcEvent","offsetDelta","prevDelta","velocity","velocityX","velocityY","direction","lastInterval","COMPUTE_INTERVAL","round","DIRECTION_NONE","DIRECTION_LEFT","DIRECTION_RIGHT","DIRECTION_UP","DIRECTION_DOWN","p1","p2","PROPS_XY","sqrt","atan2","PROPS_CLIENT_XY","evEl","MOUSE_ELEMENT_EVENTS","evWin","MOUSE_WINDOW_EVENTS","pressed","POINTER_ELEMENT_EVENTS","POINTER_WINDOW_EVENTS","store","pointerEvents","SingleTouchInput","evTarget","SINGLE_TOUCH_TARGET_EVENTS","SINGLE_TOUCH_WINDOW_EVENTS","started","normalizeSingleTouches","changed","TOUCH_TARGET_EVENTS","targetIds","getTouches","allTouches","INPUT_MOVE","targetTouches","changedTargetTouches","mouse","primaryTouch","lastTouches","recordTouches","eventData","setLastTouch","lastTouch","lts","removeLastTouch","DEDUP_TIMEOUT","isSyntheticEvent","dx","dy","DEDUP_DISTANCE","TouchAction","cleanTouchActions","actions","TOUCH_ACTION_NONE","hasPanX","TOUCH_ACTION_PAN_X","hasPanY","TOUCH_ACTION_PAN_Y","TOUCH_ACTION_MANIPULATION","TOUCH_ACTION_AUTO","Recognizer","STATE_POSSIBLE","simultaneous","requireFail","stateStr","STATE_CANCELLED","STATE_ENDED","STATE_CHANGED","STATE_BEGAN","directionStr","getRecognizerByNameIfManager","otherRecognizer","recognizer","AttrRecognizer","PanRecognizer","pX","pY","PinchRecognizer","PressRecognizer","_timer","_input","RotateRecognizer","SwipeRecognizer","TapRecognizer","pTime","pCenter","Hammer","recognizers","preset","Manager","oldCssProps","touchAction","toggleCssProps","item","recognizeWith","requireFailure","triggerDomEvent","gestureEvent","createEvent","initEvent","gesture","dispatchEvent","TEST_ELEMENT","output","nextKey","MOBILE_REGEX","navigator","userAgent","DIRECTION_HORIZONTAL","DIRECTION_VERTICAL","DIRECTION_ALL","destroy","MOUSE_INPUT_MAP","mousedown","mouseup","pointerType","POINTER_INPUT_MAP","pointerdown","pointermove","pointerup","pointercancel","pointerout","IE10_POINTER_TYPE_ENUM","2","3","4","5","MSPointerEvent","PointerEvent","removePointer","eventTypeNormalized","isTouch","storeIndex","pointerId","SINGLE_TOUCH_INPUT_MAP","touchstart","touchmove","touchend","touchcancel","TOUCH_INPUT_MAP","inputEvent","inputData","isMouse","sourceCapabilities","firesTouchEvents","PREFIXED_TOUCH_ACTION","NATIVE_TOUCH_ACTION","TOUCH_ACTION_MAP","touchMap","cssSupports","CSS","supports","compute","update","getTouchAction","preventDefaults","prevented","hasNone","isTapPointer","isTapMovement","isTapTouchTime","preventSrc","STATE_RECOGNIZED","dropRecognizeWith","dropRequireFailure","hasRequireFailures","canRecognizeWith","additionalEvent","tryEmit","canEmit","inputDataClone","process","attrTest","optionPointers","isRecognized","isValid","threshold","directionTest","hasMoved","inOut","validPointers","validMovement","validTime","taps","posThreshold","validTouchTime","failTimeout","validInterval","validMultiTap","tapCount","VERSION","domEvents","userSelect","touchSelect","touchCallout","contentZooming","userDrag","tapHighlightColor","force","curRecognizer","existing","STATE_FAILED","Tap","Pan","Swipe","Pinch","Rotate","Press","aa","c","ba","d","Function","ca","o","u","f","g","ea","hostname","z","rel","media","da","A","tagName","B","C","D","E","F","G","fa","H","I","J","ga","substr","ha","h","ia","K","L","ja","ka","M","aria-hidden","N","O","P","Q","T","S","la","R","U","serif","q","V","ma","W","na","oa","qa","k","r","X","FontFace","xa","vendor","pa","ra","sa","ta","ua","va","wa","ya","Da","Ca","Ba","Aa","za","Ea","Ga","Ha","fonts","fontfamily","fontStyle","projectId","version","api","urls","families","testStrings","latin","latin-ext","cyrillic","greek","khmer","Hanuman","thin","extralight","extra-light","ultralight","ultra-light","light","regular","book","medium","semi-bold","semibold","demi-bold","demibold","bold","extra-bold","extrabold","ultra-bold","ultrabold","black","heavy","italic","normal","Fa","Arimo","Cousine","Tinos","Typekit","config","__webfontfontdeckmodule__","weight","Y","custom","fontdeck","monotype","typekit","google","Z","WebFont","WebFontConfig"],"mappings":"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","file":"lib.js","sourcesContent":["(function(self) {\n  'use strict';\n\n  if (self.fetch) {\n    return\n  }\n\n  var support = {\n    searchParams: 'URLSearchParams' in self,\n    iterable: 'Symbol' in self && 'iterator' in Symbol,\n    blob: 'FileReader' in self && 'Blob' in self && (function() {\n      try {\n        new Blob()\n        return true\n      } catch(e) {\n        return false\n      }\n    })(),\n    formData: 'FormData' in self,\n    arrayBuffer: 'ArrayBuffer' in self\n  }\n\n  if (support.arrayBuffer) {\n    var viewClasses = [\n      '[object Int8Array]',\n      '[object Uint8Array]',\n      '[object Uint8ClampedArray]',\n      '[object Int16Array]',\n      '[object Uint16Array]',\n      '[object Int32Array]',\n      '[object Uint32Array]',\n      '[object Float32Array]',\n      '[object Float64Array]'\n    ]\n\n    var isDataView = function(obj) {\n      return obj && DataView.prototype.isPrototypeOf(obj)\n    }\n\n    var isArrayBufferView = ArrayBuffer.isView || function(obj) {\n      return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1\n    }\n  }\n\n  function normalizeName(name) {\n    if (typeof name !== 'string') {\n      name = String(name)\n    }\n    if (/[^a-z0-9\\-#$%&'*+.\\^_`|~]/i.test(name)) {\n      throw new TypeError('Invalid character in header field name')\n    }\n    return name.toLowerCase()\n  }\n\n  function normalizeValue(value) {\n    if (typeof value !== 'string') {\n      value = String(value)\n    }\n    return value\n  }\n\n  // Build a destructive iterator for the value list\n  function iteratorFor(items) {\n    var iterator = {\n      next: function() {\n        var value = items.shift()\n        return {done: value === undefined, value: value}\n      }\n    }\n\n    if (support.iterable) {\n      iterator[Symbol.iterator] = function() {\n        return iterator\n      }\n    }\n\n    return iterator\n  }\n\n  function Headers(headers) {\n    this.map = {}\n\n    if (headers instanceof Headers) {\n      headers.forEach(function(value, name) {\n        this.append(name, value)\n      }, this)\n    } else if (Array.isArray(headers)) {\n      headers.forEach(function(header) {\n        this.append(header[0], header[1])\n      }, this)\n    } else if (headers) {\n      Object.getOwnPropertyNames(headers).forEach(function(name) {\n        this.append(name, headers[name])\n      }, this)\n    }\n  }\n\n  Headers.prototype.append = function(name, value) {\n    name = normalizeName(name)\n    value = normalizeValue(value)\n    var oldValue = this.map[name]\n    this.map[name] = oldValue ? oldValue+','+value : value\n  }\n\n  Headers.prototype['delete'] = function(name) {\n    delete this.map[normalizeName(name)]\n  }\n\n  Headers.prototype.get = function(name) {\n    name = normalizeName(name)\n    return this.has(name) ? this.map[name] : null\n  }\n\n  Headers.prototype.has = function(name) {\n    return this.map.hasOwnProperty(normalizeName(name))\n  }\n\n  Headers.prototype.set = function(name, value) {\n    this.map[normalizeName(name)] = normalizeValue(value)\n  }\n\n  Headers.prototype.forEach = function(callback, thisArg) {\n    for (var name in this.map) {\n      if (this.map.hasOwnProperty(name)) {\n        callback.call(thisArg, this.map[name], name, this)\n      }\n    }\n  }\n\n  Headers.prototype.keys = function() {\n    var items = []\n    this.forEach(function(value, name) { items.push(name) })\n    return iteratorFor(items)\n  }\n\n  Headers.prototype.values = function() {\n    var items = []\n    this.forEach(function(value) { items.push(value) })\n    return iteratorFor(items)\n  }\n\n  Headers.prototype.entries = function() {\n    var items = []\n    this.forEach(function(value, name) { items.push([name, value]) })\n    return iteratorFor(items)\n  }\n\n  if (support.iterable) {\n    Headers.prototype[Symbol.iterator] = Headers.prototype.entries\n  }\n\n  function consumed(body) {\n    if (body.bodyUsed) {\n      return Promise.reject(new TypeError('Already read'))\n    }\n    body.bodyUsed = true\n  }\n\n  function fileReaderReady(reader) {\n    return new Promise(function(resolve, reject) {\n      reader.onload = function() {\n        resolve(reader.result)\n      }\n      reader.onerror = function() {\n        reject(reader.error)\n      }\n    })\n  }\n\n  function readBlobAsArrayBuffer(blob) {\n    var reader = new FileReader()\n    var promise = fileReaderReady(reader)\n    reader.readAsArrayBuffer(blob)\n    return promise\n  }\n\n  function readBlobAsText(blob) {\n    var reader = new FileReader()\n    var promise = fileReaderReady(reader)\n    reader.readAsText(blob)\n    return promise\n  }\n\n  function readArrayBufferAsText(buf) {\n    var view = new Uint8Array(buf)\n    var chars = new Array(view.length)\n\n    for (var i = 0; i < view.length; i++) {\n      chars[i] = String.fromCharCode(view[i])\n    }\n    return chars.join('')\n  }\n\n  function bufferClone(buf) {\n    if (buf.slice) {\n      return buf.slice(0)\n    } else {\n      var view = new Uint8Array(buf.byteLength)\n      view.set(new Uint8Array(buf))\n      return view.buffer\n    }\n  }\n\n  function Body() {\n    this.bodyUsed = false\n\n    this._initBody = function(body) {\n      this._bodyInit = body\n      if (!body) {\n        this._bodyText = ''\n      } else if (typeof body === 'string') {\n        this._bodyText = body\n      } else if (support.blob && Blob.prototype.isPrototypeOf(body)) {\n        this._bodyBlob = body\n      } else if (support.formData && FormData.prototype.isPrototypeOf(body)) {\n        this._bodyFormData = body\n      } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {\n        this._bodyText = body.toString()\n      } else if (support.arrayBuffer && support.blob && isDataView(body)) {\n        this._bodyArrayBuffer = bufferClone(body.buffer)\n        // IE 10-11 can't handle a DataView body.\n        this._bodyInit = new Blob([this._bodyArrayBuffer])\n      } else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) {\n        this._bodyArrayBuffer = bufferClone(body)\n      } else {\n        throw new Error('unsupported BodyInit type')\n      }\n\n      if (!this.headers.get('content-type')) {\n        if (typeof body === 'string') {\n          this.headers.set('content-type', 'text/plain;charset=UTF-8')\n        } else if (this._bodyBlob && this._bodyBlob.type) {\n          this.headers.set('content-type', this._bodyBlob.type)\n        } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {\n          this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8')\n        }\n      }\n    }\n\n    if (support.blob) {\n      this.blob = function() {\n        var rejected = consumed(this)\n        if (rejected) {\n          return rejected\n        }\n\n        if (this._bodyBlob) {\n          return Promise.resolve(this._bodyBlob)\n        } else if (this._bodyArrayBuffer) {\n          return Promise.resolve(new Blob([this._bodyArrayBuffer]))\n        } else if (this._bodyFormData) {\n          throw new Error('could not read FormData body as blob')\n        } else {\n          return Promise.resolve(new Blob([this._bodyText]))\n        }\n      }\n\n      this.arrayBuffer = function() {\n        if (this._bodyArrayBuffer) {\n          return consumed(this) || Promise.resolve(this._bodyArrayBuffer)\n        } else {\n          return this.blob().then(readBlobAsArrayBuffer)\n        }\n      }\n    }\n\n    this.text = function() {\n      var rejected = consumed(this)\n      if (rejected) {\n        return rejected\n      }\n\n      if (this._bodyBlob) {\n        return readBlobAsText(this._bodyBlob)\n      } else if (this._bodyArrayBuffer) {\n        return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer))\n      } else if (this._bodyFormData) {\n        throw new Error('could not read FormData body as text')\n      } else {\n        return Promise.resolve(this._bodyText)\n      }\n    }\n\n    if (support.formData) {\n      this.formData = function() {\n        return this.text().then(decode)\n      }\n    }\n\n    this.json = function() {\n      return this.text().then(JSON.parse)\n    }\n\n    return this\n  }\n\n  // HTTP methods whose capitalization should be normalized\n  var methods = ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST', 'PUT']\n\n  function normalizeMethod(method) {\n    var upcased = method.toUpperCase()\n    return (methods.indexOf(upcased) > -1) ? upcased : method\n  }\n\n  function Request(input, options) {\n    options = options || {}\n    var body = options.body\n\n    if (input instanceof Request) {\n      if (input.bodyUsed) {\n        throw new TypeError('Already read')\n      }\n      this.url = input.url\n      this.credentials = input.credentials\n      if (!options.headers) {\n        this.headers = new Headers(input.headers)\n      }\n      this.method = input.method\n      this.mode = input.mode\n      if (!body && input._bodyInit != null) {\n        body = input._bodyInit\n        input.bodyUsed = true\n      }\n    } else {\n      this.url = String(input)\n    }\n\n    this.credentials = options.credentials || this.credentials || 'omit'\n    if (options.headers || !this.headers) {\n      this.headers = new Headers(options.headers)\n    }\n    this.method = normalizeMethod(options.method || this.method || 'GET')\n    this.mode = options.mode || this.mode || null\n    this.referrer = null\n\n    if ((this.method === 'GET' || this.method === 'HEAD') && body) {\n      throw new TypeError('Body not allowed for GET or HEAD requests')\n    }\n    this._initBody(body)\n  }\n\n  Request.prototype.clone = function() {\n    return new Request(this, { body: this._bodyInit })\n  }\n\n  function decode(body) {\n    var form = new FormData()\n    body.trim().split('&').forEach(function(bytes) {\n      if (bytes) {\n        var split = bytes.split('=')\n        var name = split.shift().replace(/\\+/g, ' ')\n        var value = split.join('=').replace(/\\+/g, ' ')\n        form.append(decodeURIComponent(name), decodeURIComponent(value))\n      }\n    })\n    return form\n  }\n\n  function parseHeaders(rawHeaders) {\n    var headers = new Headers()\n    // Replace instances of \\r\\n and \\n followed by at least one space or horizontal tab with a space\n    // https://tools.ietf.org/html/rfc7230#section-3.2\n    var preProcessedHeaders = rawHeaders.replace(/\\r?\\n[\\t ]+/g, ' ')\n    preProcessedHeaders.split(/\\r?\\n/).forEach(function(line) {\n      var parts = line.split(':')\n      var key = parts.shift().trim()\n      if (key) {\n        var value = parts.join(':').trim()\n        headers.append(key, value)\n      }\n    })\n    return headers\n  }\n\n  Body.call(Request.prototype)\n\n  function Response(bodyInit, options) {\n    if (!options) {\n      options = {}\n    }\n\n    this.type = 'default'\n    this.status = options.status === undefined ? 200 : options.status\n    this.ok = this.status >= 200 && this.status < 300\n    this.statusText = 'statusText' in options ? options.statusText : 'OK'\n    this.headers = new Headers(options.headers)\n    this.url = options.url || ''\n    this._initBody(bodyInit)\n  }\n\n  Body.call(Response.prototype)\n\n  Response.prototype.clone = function() {\n    return new Response(this._bodyInit, {\n      status: this.status,\n      statusText: this.statusText,\n      headers: new Headers(this.headers),\n      url: this.url\n    })\n  }\n\n  Response.error = function() {\n    var response = new Response(null, {status: 0, statusText: ''})\n    response.type = 'error'\n    return response\n  }\n\n  var redirectStatuses = [301, 302, 303, 307, 308]\n\n  Response.redirect = function(url, status) {\n    if (redirectStatuses.indexOf(status) === -1) {\n      throw new RangeError('Invalid status code')\n    }\n\n    return new Response(null, {status: status, headers: {location: url}})\n  }\n\n  self.Headers = Headers\n  self.Request = Request\n  self.Response = Response\n\n  self.fetch = function(input, init) {\n    return new Promise(function(resolve, reject) {\n      var request = new Request(input, init)\n      var xhr = new XMLHttpRequest()\n\n      xhr.onload = function() {\n        var options = {\n          status: xhr.status,\n          statusText: xhr.statusText,\n          headers: parseHeaders(xhr.getAllResponseHeaders() || '')\n        }\n        options.url = 'responseURL' in xhr ? xhr.responseURL : options.headers.get('X-Request-URL')\n        var body = 'response' in xhr ? xhr.response : xhr.responseText\n        resolve(new Response(body, options))\n      }\n\n      xhr.onerror = function() {\n        reject(new TypeError('Network request failed'))\n      }\n\n      xhr.ontimeout = function() {\n        reject(new TypeError('Network request failed'))\n      }\n\n      xhr.open(request.method, request.url, true)\n\n      if (request.credentials === 'include') {\n        xhr.withCredentials = true\n      } else if (request.credentials === 'omit') {\n        xhr.withCredentials = false\n      }\n\n      if ('responseType' in xhr && support.blob) {\n        xhr.responseType = 'blob'\n      }\n\n      request.headers.forEach(function(value, name) {\n        xhr.setRequestHeader(name, value)\n      })\n\n      xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit)\n    })\n  }\n  self.fetch.polyfill = true\n})(typeof self !== 'undefined' ? self : this);\n","(function (root) {\n\n  // Store setTimeout reference so promise-polyfill will be unaffected by\n  // other code modifying setTimeout (like sinon.useFakeTimers())\n  var setTimeoutFunc = setTimeout;\n\n  function noop() {}\n  \n  // Polyfill for Function.prototype.bind\n  function bind(fn, thisArg) {\n    return function () {\n      fn.apply(thisArg, arguments);\n    };\n  }\n\n  function Promise(fn) {\n    if (!(this instanceof Promise)) throw new TypeError('Promises must be constructed via new');\n    if (typeof fn !== 'function') throw new TypeError('not a function');\n    this._state = 0;\n    this._handled = false;\n    this._value = undefined;\n    this._deferreds = [];\n\n    doResolve(fn, this);\n  }\n\n  function handle(self, deferred) {\n    while (self._state === 3) {\n      self = self._value;\n    }\n    if (self._state === 0) {\n      self._deferreds.push(deferred);\n      return;\n    }\n    self._handled = true;\n    Promise._immediateFn(function () {\n      var cb = self._state === 1 ? deferred.onFulfilled : deferred.onRejected;\n      if (cb === null) {\n        (self._state === 1 ? resolve : reject)(deferred.promise, self._value);\n        return;\n      }\n      var ret;\n      try {\n        ret = cb(self._value);\n      } catch (e) {\n        reject(deferred.promise, e);\n        return;\n      }\n      resolve(deferred.promise, ret);\n    });\n  }\n\n  function resolve(self, newValue) {\n    try {\n      // Promise Resolution Procedure: https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure\n      if (newValue === self) throw new TypeError('A promise cannot be resolved with itself.');\n      if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) {\n        var then = newValue.then;\n        if (newValue instanceof Promise) {\n          self._state = 3;\n          self._value = newValue;\n          finale(self);\n          return;\n        } else if (typeof then === 'function') {\n          doResolve(bind(then, newValue), self);\n          return;\n        }\n      }\n      self._state = 1;\n      self._value = newValue;\n      finale(self);\n    } catch (e) {\n      reject(self, e);\n    }\n  }\n\n  function reject(self, newValue) {\n    self._state = 2;\n    self._value = newValue;\n    finale(self);\n  }\n\n  function finale(self) {\n    if (self._state === 2 && self._deferreds.length === 0) {\n      Promise._immediateFn(function() {\n        if (!self._handled) {\n          Promise._unhandledRejectionFn(self._value);\n        }\n      });\n    }\n\n    for (var i = 0, len = self._deferreds.length; i < len; i++) {\n      handle(self, self._deferreds[i]);\n    }\n    self._deferreds = null;\n  }\n\n  function Handler(onFulfilled, onRejected, promise) {\n    this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null;\n    this.onRejected = typeof onRejected === 'function' ? onRejected : null;\n    this.promise = promise;\n  }\n\n  /**\n   * Take a potentially misbehaving resolver function and make sure\n   * onFulfilled and onRejected are only called once.\n   *\n   * Makes no guarantees about asynchrony.\n   */\n  function doResolve(fn, self) {\n    var done = false;\n    try {\n      fn(function (value) {\n        if (done) return;\n        done = true;\n        resolve(self, value);\n      }, function (reason) {\n        if (done) return;\n        done = true;\n        reject(self, reason);\n      });\n    } catch (ex) {\n      if (done) return;\n      done = true;\n      reject(self, ex);\n    }\n  }\n\n  Promise.prototype['catch'] = function (onRejected) {\n    return this.then(null, onRejected);\n  };\n\n  Promise.prototype.then = function (onFulfilled, onRejected) {\n    var prom = new (this.constructor)(noop);\n\n    handle(this, new Handler(onFulfilled, onRejected, prom));\n    return prom;\n  };\n\n  Promise.all = function (arr) {\n    return new Promise(function (resolve, reject) {\n      if (!arr || typeof arr.length === 'undefined') throw new TypeError('Promise.all accepts an array');\n      var args = Array.prototype.slice.call(arr);\n      if (args.length === 0) return resolve([]);\n      var remaining = args.length;\n\n      function res(i, val) {\n        try {\n          if (val && (typeof val === 'object' || typeof val === 'function')) {\n            var then = val.then;\n            if (typeof then === 'function') {\n              then.call(val, function (val) {\n                res(i, val);\n              }, reject);\n              return;\n            }\n          }\n          args[i] = val;\n          if (--remaining === 0) {\n            resolve(args);\n          }\n        } catch (ex) {\n          reject(ex);\n        }\n      }\n\n      for (var i = 0; i < args.length; i++) {\n        res(i, args[i]);\n      }\n    });\n  };\n\n  Promise.resolve = function (value) {\n    if (value && typeof value === 'object' && value.constructor === Promise) {\n      return value;\n    }\n\n    return new Promise(function (resolve) {\n      resolve(value);\n    });\n  };\n\n  Promise.reject = function (value) {\n    return new Promise(function (resolve, reject) {\n      reject(value);\n    });\n  };\n\n  Promise.race = function (values) {\n    return new Promise(function (resolve, reject) {\n      for (var i = 0, len = values.length; i < len; i++) {\n        values[i].then(resolve, reject);\n      }\n    });\n  };\n\n  // Use polyfill for setImmediate for performance gains\n  Promise._immediateFn = (typeof setImmediate === 'function' && function (fn) { setImmediate(fn); }) ||\n    function (fn) {\n      setTimeoutFunc(fn, 0);\n    };\n\n  Promise._unhandledRejectionFn = function _unhandledRejectionFn(err) {\n    if (typeof console !== 'undefined' && console) {\n      console.warn('Possible Unhandled Promise Rejection:', err); // eslint-disable-line no-console\n    }\n  };\n\n  /**\n   * Set the immediate function to execute callbacks\n   * @param fn {function} Function to execute\n   * @deprecated\n   */\n  Promise._setImmediateFn = function _setImmediateFn(fn) {\n    Promise._immediateFn = fn;\n  };\n\n  /**\n   * Change the function to execute on unhandled rejection\n   * @param {function} fn Function to execute on unhandled rejection\n   * @deprecated\n   */\n  Promise._setUnhandledRejectionFn = function _setUnhandledRejectionFn(fn) {\n    Promise._unhandledRejectionFn = fn;\n  };\n  \n  if (typeof module !== 'undefined' && module.exports) {\n    module.exports = Promise;\n  } else if (!root.Promise) {\n    root.Promise = Promise;\n  }\n\n})(this);\n","/*!\n * jQuery JavaScript Library v2.2.4\n * http://jquery.com/\n *\n * Includes Sizzle.js\n * http://sizzlejs.com/\n *\n * Copyright jQuery Foundation and other contributors\n * Released under the MIT license\n * http://jquery.org/license\n *\n * Date: 2016-05-20T17:23Z\n */\n\n(function( global, factory ) {\n\n\tif ( typeof module === \"object\" && typeof module.exports === \"object\" ) {\n\t\t// For CommonJS and CommonJS-like environments where a proper `window`\n\t\t// is present, execute the factory and get jQuery.\n\t\t// For environments that do not have a `window` with a `document`\n\t\t// (such as Node.js), expose a factory as module.exports.\n\t\t// This accentuates the need for the creation of a real `window`.\n\t\t// e.g. var jQuery = require(\"jquery\")(window);\n\t\t// See ticket #14549 for more info.\n\t\tmodule.exports = global.document ?\n\t\t\tfactory( global, true ) :\n\t\t\tfunction( w ) {\n\t\t\t\tif ( !w.document ) {\n\t\t\t\t\tthrow new Error( \"jQuery requires a window with a document\" );\n\t\t\t\t}\n\t\t\t\treturn factory( w );\n\t\t\t};\n\t} else {\n\t\tfactory( global );\n\t}\n\n// Pass this if window is not defined yet\n}(typeof window !== \"undefined\" ? window : this, function( window, noGlobal ) {\n\n// Support: Firefox 18+\n// Can't be in strict mode, several libs including ASP.NET trace\n// the stack via arguments.caller.callee and Firefox dies if\n// you try to trace through \"use strict\" call chains. (#13335)\n//\"use strict\";\nvar arr = [];\n\nvar document = window.document;\n\nvar slice = arr.slice;\n\nvar concat = arr.concat;\n\nvar push = arr.push;\n\nvar indexOf = arr.indexOf;\n\nvar class2type = {};\n\nvar toString = class2type.toString;\n\nvar hasOwn = class2type.hasOwnProperty;\n\nvar support = {};\n\n\n\nvar\n\tversion = \"2.2.4\",\n\n\t// Define a local copy of jQuery\n\tjQuery = function( selector, context ) {\n\n\t\t// The jQuery object is actually just the init constructor 'enhanced'\n\t\t// Need init if jQuery is called (just allow error to be thrown if not included)\n\t\treturn new jQuery.fn.init( selector, context );\n\t},\n\n\t// Support: Android<4.1\n\t// Make sure we trim BOM and NBSP\n\trtrim = /^[\\s\\uFEFF\\xA0]+|[\\s\\uFEFF\\xA0]+$/g,\n\n\t// Matches dashed string for camelizing\n\trmsPrefix = /^-ms-/,\n\trdashAlpha = /-([\\da-z])/gi,\n\n\t// Used by jQuery.camelCase as callback to replace()\n\tfcamelCase = function( all, letter ) {\n\t\treturn letter.toUpperCase();\n\t};\n\njQuery.fn = jQuery.prototype = {\n\n\t// The current version of jQuery being used\n\tjquery: version,\n\n\tconstructor: jQuery,\n\n\t// Start with an empty selector\n\tselector: \"\",\n\n\t// The default length of a jQuery object is 0\n\tlength: 0,\n\n\ttoArray: function() {\n\t\treturn slice.call( this );\n\t},\n\n\t// Get the Nth element in the matched element set OR\n\t// Get the whole matched element set as a clean array\n\tget: function( num ) {\n\t\treturn num != null ?\n\n\t\t\t// Return just the one element from the set\n\t\t\t( num < 0 ? this[ num + this.length ] : this[ num ] ) :\n\n\t\t\t// Return all the elements in a clean array\n\t\t\tslice.call( this );\n\t},\n\n\t// Take an array of elements and push it onto the stack\n\t// (returning the new matched element set)\n\tpushStack: function( elems ) {\n\n\t\t// Build a new jQuery matched element set\n\t\tvar ret = jQuery.merge( this.constructor(), elems );\n\n\t\t// Add the old object onto the stack (as a reference)\n\t\tret.prevObject = this;\n\t\tret.context = this.context;\n\n\t\t// Return the newly-formed element set\n\t\treturn ret;\n\t},\n\n\t// Execute a callback for every element in the matched set.\n\teach: function( callback ) {\n\t\treturn jQuery.each( this, callback );\n\t},\n\n\tmap: function( callback ) {\n\t\treturn this.pushStack( jQuery.map( this, function( elem, i ) {\n\t\t\treturn callback.call( elem, i, elem );\n\t\t} ) );\n\t},\n\n\tslice: function() {\n\t\treturn this.pushStack( slice.apply( this, arguments ) );\n\t},\n\n\tfirst: function() {\n\t\treturn this.eq( 0 );\n\t},\n\n\tlast: function() {\n\t\treturn this.eq( -1 );\n\t},\n\n\teq: function( i ) {\n\t\tvar len = this.length,\n\t\t\tj = +i + ( i < 0 ? len : 0 );\n\t\treturn this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );\n\t},\n\n\tend: function() {\n\t\treturn this.prevObject || this.constructor();\n\t},\n\n\t// For internal use only.\n\t// Behaves like an Array's method, not like a jQuery method.\n\tpush: push,\n\tsort: arr.sort,\n\tsplice: arr.splice\n};\n\njQuery.extend = jQuery.fn.extend = function() {\n\tvar options, name, src, copy, copyIsArray, clone,\n\t\ttarget = arguments[ 0 ] || {},\n\t\ti = 1,\n\t\tlength = arguments.length,\n\t\tdeep = false;\n\n\t// Handle a deep copy situation\n\tif ( typeof target === \"boolean\" ) {\n\t\tdeep = target;\n\n\t\t// Skip the boolean and the target\n\t\ttarget = arguments[ i ] || {};\n\t\ti++;\n\t}\n\n\t// Handle case when target is a string or something (possible in deep copy)\n\tif ( typeof target !== \"object\" && !jQuery.isFunction( target ) ) {\n\t\ttarget = {};\n\t}\n\n\t// Extend jQuery itself if only one argument is passed\n\tif ( i === length ) {\n\t\ttarget = this;\n\t\ti--;\n\t}\n\n\tfor ( ; i < length; i++ ) {\n\n\t\t// Only deal with non-null/undefined values\n\t\tif ( ( options = arguments[ i ] ) != null ) {\n\n\t\t\t// Extend the base object\n\t\t\tfor ( name in options ) {\n\t\t\t\tsrc = target[ name ];\n\t\t\t\tcopy = options[ name ];\n\n\t\t\t\t// Prevent never-ending loop\n\t\t\t\tif ( target === copy ) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\t// Recurse if we're merging plain objects or arrays\n\t\t\t\tif ( deep && copy && ( jQuery.isPlainObject( copy ) ||\n\t\t\t\t\t( copyIsArray = jQuery.isArray( copy ) ) ) ) {\n\n\t\t\t\t\tif ( copyIsArray ) {\n\t\t\t\t\t\tcopyIsArray = false;\n\t\t\t\t\t\tclone = src && jQuery.isArray( src ) ? src : [];\n\n\t\t\t\t\t} else {\n\t\t\t\t\t\tclone = src && jQuery.isPlainObject( src ) ? src : {};\n\t\t\t\t\t}\n\n\t\t\t\t\t// Never move original objects, clone them\n\t\t\t\t\ttarget[ name ] = jQuery.extend( deep, clone, copy );\n\n\t\t\t\t// Don't bring in undefined values\n\t\t\t\t} else if ( copy !== undefined ) {\n\t\t\t\t\ttarget[ name ] = copy;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Return the modified object\n\treturn target;\n};\n\njQuery.extend( {\n\n\t// Unique for each copy of jQuery on the page\n\texpando: \"jQuery\" + ( version + Math.random() ).replace( /\\D/g, \"\" ),\n\n\t// Assume jQuery is ready without the ready module\n\tisReady: true,\n\n\terror: function( msg ) {\n\t\tthrow new Error( msg );\n\t},\n\n\tnoop: function() {},\n\n\tisFunction: function( obj ) {\n\t\treturn jQuery.type( obj ) === \"function\";\n\t},\n\n\tisArray: Array.isArray,\n\n\tisWindow: function( obj ) {\n\t\treturn obj != null && obj === obj.window;\n\t},\n\n\tisNumeric: function( obj ) {\n\n\t\t// parseFloat NaNs numeric-cast false positives (null|true|false|\"\")\n\t\t// ...but misinterprets leading-number strings, particularly hex literals (\"0x...\")\n\t\t// subtraction forces infinities to NaN\n\t\t// adding 1 corrects loss of precision from parseFloat (#15100)\n\t\tvar realStringObj = obj && obj.toString();\n\t\treturn !jQuery.isArray( obj ) && ( realStringObj - parseFloat( realStringObj ) + 1 ) >= 0;\n\t},\n\n\tisPlainObject: function( obj ) {\n\t\tvar key;\n\n\t\t// Not plain objects:\n\t\t// - Any object or value whose internal [[Class]] property is not \"[object Object]\"\n\t\t// - DOM nodes\n\t\t// - window\n\t\tif ( jQuery.type( obj ) !== \"object\" || obj.nodeType || jQuery.isWindow( obj ) ) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Not own constructor property must be Object\n\t\tif ( obj.constructor &&\n\t\t\t\t!hasOwn.call( obj, \"constructor\" ) &&\n\t\t\t\t!hasOwn.call( obj.constructor.prototype || {}, \"isPrototypeOf\" ) ) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Own properties are enumerated firstly, so to speed up,\n\t\t// if last one is own, then all properties are own\n\t\tfor ( key in obj ) {}\n\n\t\treturn key === undefined || hasOwn.call( obj, key );\n\t},\n\n\tisEmptyObject: function( obj ) {\n\t\tvar name;\n\t\tfor ( name in obj ) {\n\t\t\treturn false;\n\t\t}\n\t\treturn true;\n\t},\n\n\ttype: function( obj ) {\n\t\tif ( obj == null ) {\n\t\t\treturn obj + \"\";\n\t\t}\n\n\t\t// Support: Android<4.0, iOS<6 (functionish RegExp)\n\t\treturn typeof obj === \"object\" || typeof obj === \"function\" ?\n\t\t\tclass2type[ toString.call( obj ) ] || \"object\" :\n\t\t\ttypeof obj;\n\t},\n\n\t// Evaluates a script in a global context\n\tglobalEval: function( code ) {\n\t\tvar script,\n\t\t\tindirect = eval;\n\n\t\tcode = jQuery.trim( code );\n\n\t\tif ( code ) {\n\n\t\t\t// If the code includes a valid, prologue position\n\t\t\t// strict mode pragma, execute code by injecting a\n\t\t\t// script tag into the document.\n\t\t\tif ( code.indexOf( \"use strict\" ) === 1 ) {\n\t\t\t\tscript = document.createElement( \"script\" );\n\t\t\t\tscript.text = code;\n\t\t\t\tdocument.head.appendChild( script ).parentNode.removeChild( script );\n\t\t\t} else {\n\n\t\t\t\t// Otherwise, avoid the DOM node creation, insertion\n\t\t\t\t// and removal by using an indirect global eval\n\n\t\t\t\tindirect( code );\n\t\t\t}\n\t\t}\n\t},\n\n\t// Convert dashed to camelCase; used by the css and data modules\n\t// Support: IE9-11+\n\t// Microsoft forgot to hump their vendor prefix (#9572)\n\tcamelCase: function( string ) {\n\t\treturn string.replace( rmsPrefix, \"ms-\" ).replace( rdashAlpha, fcamelCase );\n\t},\n\n\tnodeName: function( elem, name ) {\n\t\treturn elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();\n\t},\n\n\teach: function( obj, callback ) {\n\t\tvar length, i = 0;\n\n\t\tif ( isArrayLike( obj ) ) {\n\t\t\tlength = obj.length;\n\t\t\tfor ( ; i < length; i++ ) {\n\t\t\t\tif ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tfor ( i in obj ) {\n\t\t\t\tif ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn obj;\n\t},\n\n\t// Support: Android<4.1\n\ttrim: function( text ) {\n\t\treturn text == null ?\n\t\t\t\"\" :\n\t\t\t( text + \"\" ).replace( rtrim, \"\" );\n\t},\n\n\t// results is for internal usage only\n\tmakeArray: function( arr, results ) {\n\t\tvar ret = results || [];\n\n\t\tif ( arr != null ) {\n\t\t\tif ( isArrayLike( Object( arr ) ) ) {\n\t\t\t\tjQuery.merge( ret,\n\t\t\t\t\ttypeof arr === \"string\" ?\n\t\t\t\t\t[ arr ] : arr\n\t\t\t\t);\n\t\t\t} else {\n\t\t\t\tpush.call( ret, arr );\n\t\t\t}\n\t\t}\n\n\t\treturn ret;\n\t},\n\n\tinArray: function( elem, arr, i ) {\n\t\treturn arr == null ? -1 : indexOf.call( arr, elem, i );\n\t},\n\n\tmerge: function( first, second ) {\n\t\tvar len = +second.length,\n\t\t\tj = 0,\n\t\t\ti = first.length;\n\n\t\tfor ( ; j < len; j++ ) {\n\t\t\tfirst[ i++ ] = second[ j ];\n\t\t}\n\n\t\tfirst.length = i;\n\n\t\treturn first;\n\t},\n\n\tgrep: function( elems, callback, invert ) {\n\t\tvar callbackInverse,\n\t\t\tmatches = [],\n\t\t\ti = 0,\n\t\t\tlength = elems.length,\n\t\t\tcallbackExpect = !invert;\n\n\t\t// Go through the array, only saving the items\n\t\t// that pass the validator function\n\t\tfor ( ; i < length; i++ ) {\n\t\t\tcallbackInverse = !callback( elems[ i ], i );\n\t\t\tif ( callbackInverse !== callbackExpect ) {\n\t\t\t\tmatches.push( elems[ i ] );\n\t\t\t}\n\t\t}\n\n\t\treturn matches;\n\t},\n\n\t// arg is for internal usage only\n\tmap: function( elems, callback, arg ) {\n\t\tvar length, value,\n\t\t\ti = 0,\n\t\t\tret = [];\n\n\t\t// Go through the array, translating each of the items to their new values\n\t\tif ( isArrayLike( elems ) ) {\n\t\t\tlength = elems.length;\n\t\t\tfor ( ; i < length; i++ ) {\n\t\t\t\tvalue = callback( elems[ i ], i, arg );\n\n\t\t\t\tif ( value != null ) {\n\t\t\t\t\tret.push( value );\n\t\t\t\t}\n\t\t\t}\n\n\t\t// Go through every key on the object,\n\t\t} else {\n\t\t\tfor ( i in elems ) {\n\t\t\t\tvalue = callback( elems[ i ], i, arg );\n\n\t\t\t\tif ( value != null ) {\n\t\t\t\t\tret.push( value );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Flatten any nested arrays\n\t\treturn concat.apply( [], ret );\n\t},\n\n\t// A global GUID counter for objects\n\tguid: 1,\n\n\t// Bind a function to a context, optionally partially applying any\n\t// arguments.\n\tproxy: function( fn, context ) {\n\t\tvar tmp, args, proxy;\n\n\t\tif ( typeof context === \"string\" ) {\n\t\t\ttmp = fn[ context ];\n\t\t\tcontext = fn;\n\t\t\tfn = tmp;\n\t\t}\n\n\t\t// Quick check to determine if target is callable, in the spec\n\t\t// this throws a TypeError, but we will just return undefined.\n\t\tif ( !jQuery.isFunction( fn ) ) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\t// Simulated bind\n\t\targs = slice.call( arguments, 2 );\n\t\tproxy = function() {\n\t\t\treturn fn.apply( context || this, args.concat( slice.call( arguments ) ) );\n\t\t};\n\n\t\t// Set the guid of unique handler to the same of original handler, so it can be removed\n\t\tproxy.guid = fn.guid = fn.guid || jQuery.guid++;\n\n\t\treturn proxy;\n\t},\n\n\tnow: Date.now,\n\n\t// jQuery.support is not used in Core but other projects attach their\n\t// properties to it so it needs to exist.\n\tsupport: support\n} );\n\n// JSHint would error on this code due to the Symbol not being defined in ES5.\n// Defining this global in .jshintrc would create a danger of using the global\n// unguarded in another place, it seems safer to just disable JSHint for these\n// three lines.\n/* jshint ignore: start */\nif ( typeof Symbol === \"function\" ) {\n\tjQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];\n}\n/* jshint ignore: end */\n\n// Populate the class2type map\njQuery.each( \"Boolean Number String Function Array Date RegExp Object Error Symbol\".split( \" \" ),\nfunction( i, name ) {\n\tclass2type[ \"[object \" + name + \"]\" ] = name.toLowerCase();\n} );\n\nfunction isArrayLike( obj ) {\n\n\t// Support: iOS 8.2 (not reproducible in simulator)\n\t// `in` check used to prevent JIT error (gh-2145)\n\t// hasOwn isn't used here due to false negatives\n\t// regarding Nodelist length in IE\n\tvar length = !!obj && \"length\" in obj && obj.length,\n\t\ttype = jQuery.type( obj );\n\n\tif ( type === \"function\" || jQuery.isWindow( obj ) ) {\n\t\treturn false;\n\t}\n\n\treturn type === \"array\" || length === 0 ||\n\t\ttypeof length === \"number\" && length > 0 && ( length - 1 ) in obj;\n}\nvar Sizzle =\n/*!\n * Sizzle CSS Selector Engine v2.2.1\n * http://sizzlejs.com/\n *\n * Copyright jQuery Foundation and other contributors\n * Released under the MIT license\n * http://jquery.org/license\n *\n * Date: 2015-10-17\n */\n(function( window ) {\n\nvar i,\n\tsupport,\n\tExpr,\n\tgetText,\n\tisXML,\n\ttokenize,\n\tcompile,\n\tselect,\n\toutermostContext,\n\tsortInput,\n\thasDuplicate,\n\n\t// Local document vars\n\tsetDocument,\n\tdocument,\n\tdocElem,\n\tdocumentIsHTML,\n\trbuggyQSA,\n\trbuggyMatches,\n\tmatches,\n\tcontains,\n\n\t// Instance-specific data\n\texpando = \"sizzle\" + 1 * new Date(),\n\tpreferredDoc = window.document,\n\tdirruns = 0,\n\tdone = 0,\n\tclassCache = createCache(),\n\ttokenCache = createCache(),\n\tcompilerCache = createCache(),\n\tsortOrder = function( a, b ) {\n\t\tif ( a === b ) {\n\t\t\thasDuplicate = true;\n\t\t}\n\t\treturn 0;\n\t},\n\n\t// General-purpose constants\n\tMAX_NEGATIVE = 1 << 31,\n\n\t// Instance methods\n\thasOwn = ({}).hasOwnProperty,\n\tarr = [],\n\tpop = arr.pop,\n\tpush_native = arr.push,\n\tpush = arr.push,\n\tslice = arr.slice,\n\t// Use a stripped-down indexOf as it's faster than native\n\t// http://jsperf.com/thor-indexof-vs-for/5\n\tindexOf = function( list, elem ) {\n\t\tvar i = 0,\n\t\t\tlen = list.length;\n\t\tfor ( ; i < len; i++ ) {\n\t\t\tif ( list[i] === elem ) {\n\t\t\t\treturn i;\n\t\t\t}\n\t\t}\n\t\treturn -1;\n\t},\n\n\tbooleans = \"checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped\",\n\n\t// Regular expressions\n\n\t// http://www.w3.org/TR/css3-selectors/#whitespace\n\twhitespace = \"[\\\\x20\\\\t\\\\r\\\\n\\\\f]\",\n\n\t// http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier\n\tidentifier = \"(?:\\\\\\\\.|[\\\\w-]|[^\\\\x00-\\\\xa0])+\",\n\n\t// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors\n\tattributes = \"\\\\[\" + whitespace + \"*(\" + identifier + \")(?:\" + whitespace +\n\t\t// Operator (capture 2)\n\t\t\"*([*^$|!~]?=)\" + whitespace +\n\t\t// \"Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]\"\n\t\t\"*(?:'((?:\\\\\\\\.|[^\\\\\\\\'])*)'|\\\"((?:\\\\\\\\.|[^\\\\\\\\\\\"])*)\\\"|(\" + identifier + \"))|)\" + whitespace +\n\t\t\"*\\\\]\",\n\n\tpseudos = \":(\" + identifier + \")(?:\\\\((\" +\n\t\t// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:\n\t\t// 1. quoted (capture 3; capture 4 or capture 5)\n\t\t\"('((?:\\\\\\\\.|[^\\\\\\\\'])*)'|\\\"((?:\\\\\\\\.|[^\\\\\\\\\\\"])*)\\\")|\" +\n\t\t// 2. simple (capture 6)\n\t\t\"((?:\\\\\\\\.|[^\\\\\\\\()[\\\\]]|\" + attributes + \")*)|\" +\n\t\t// 3. anything else (capture 2)\n\t\t\".*\" +\n\t\t\")\\\\)|)\",\n\n\t// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter\n\trwhitespace = new RegExp( whitespace + \"+\", \"g\" ),\n\trtrim = new RegExp( \"^\" + whitespace + \"+|((?:^|[^\\\\\\\\])(?:\\\\\\\\.)*)\" + whitespace + \"+$\", \"g\" ),\n\n\trcomma = new RegExp( \"^\" + whitespace + \"*,\" + whitespace + \"*\" ),\n\trcombinators = new RegExp( \"^\" + whitespace + \"*([>+~]|\" + whitespace + \")\" + whitespace + \"*\" ),\n\n\trattributeQuotes = new RegExp( \"=\" + whitespace + \"*([^\\\\]'\\\"]*?)\" + whitespace + \"*\\\\]\", \"g\" ),\n\n\trpseudo = new RegExp( pseudos ),\n\tridentifier = new RegExp( \"^\" + identifier + \"$\" ),\n\n\tmatchExpr = {\n\t\t\"ID\": new RegExp( \"^#(\" + identifier + \")\" ),\n\t\t\"CLASS\": new RegExp( \"^\\\\.(\" + identifier + \")\" ),\n\t\t\"TAG\": new RegExp( \"^(\" + identifier + \"|[*])\" ),\n\t\t\"ATTR\": new RegExp( \"^\" + attributes ),\n\t\t\"PSEUDO\": new RegExp( \"^\" + pseudos ),\n\t\t\"CHILD\": new RegExp( \"^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\\\(\" + whitespace +\n\t\t\t\"*(even|odd|(([+-]|)(\\\\d*)n|)\" + whitespace + \"*(?:([+-]|)\" + whitespace +\n\t\t\t\"*(\\\\d+)|))\" + whitespace + \"*\\\\)|)\", \"i\" ),\n\t\t\"bool\": new RegExp( \"^(?:\" + booleans + \")$\", \"i\" ),\n\t\t// For use in libraries implementing .is()\n\t\t// We use this for POS matching in `select`\n\t\t\"needsContext\": new RegExp( \"^\" + whitespace + \"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\\\(\" +\n\t\t\twhitespace + \"*((?:-\\\\d)?\\\\d*)\" + whitespace + \"*\\\\)|)(?=[^-]|$)\", \"i\" )\n\t},\n\n\trinputs = /^(?:input|select|textarea|button)$/i,\n\trheader = /^h\\d$/i,\n\n\trnative = /^[^{]+\\{\\s*\\[native \\w/,\n\n\t// Easily-parseable/retrievable ID or TAG or CLASS selectors\n\trquickExpr = /^(?:#([\\w-]+)|(\\w+)|\\.([\\w-]+))$/,\n\n\trsibling = /[+~]/,\n\trescape = /'|\\\\/g,\n\n\t// CSS escapes http://www.w3.org/TR/CSS21/syndata.html#escaped-characters\n\trunescape = new RegExp( \"\\\\\\\\([\\\\da-f]{1,6}\" + whitespace + \"?|(\" + whitespace + \")|.)\", \"ig\" ),\n\tfunescape = function( _, escaped, escapedWhitespace ) {\n\t\tvar high = \"0x\" + escaped - 0x10000;\n\t\t// NaN means non-codepoint\n\t\t// Support: Firefox<24\n\t\t// Workaround erroneous numeric interpretation of +\"0x\"\n\t\treturn high !== high || escapedWhitespace ?\n\t\t\tescaped :\n\t\t\thigh < 0 ?\n\t\t\t\t// BMP codepoint\n\t\t\t\tString.fromCharCode( high + 0x10000 ) :\n\t\t\t\t// Supplemental Plane codepoint (surrogate pair)\n\t\t\t\tString.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );\n\t},\n\n\t// Used for iframes\n\t// See setDocument()\n\t// Removing the function wrapper causes a \"Permission Denied\"\n\t// error in IE\n\tunloadHandler = function() {\n\t\tsetDocument();\n\t};\n\n// Optimize for push.apply( _, NodeList )\ntry {\n\tpush.apply(\n\t\t(arr = slice.call( preferredDoc.childNodes )),\n\t\tpreferredDoc.childNodes\n\t);\n\t// Support: Android<4.0\n\t// Detect silently failing push.apply\n\tarr[ preferredDoc.childNodes.length ].nodeType;\n} catch ( e ) {\n\tpush = { apply: arr.length ?\n\n\t\t// Leverage slice if possible\n\t\tfunction( target, els ) {\n\t\t\tpush_native.apply( target, slice.call(els) );\n\t\t} :\n\n\t\t// Support: IE<9\n\t\t// Otherwise append directly\n\t\tfunction( target, els ) {\n\t\t\tvar j = target.length,\n\t\t\t\ti = 0;\n\t\t\t// Can't trust NodeList.length\n\t\t\twhile ( (target[j++] = els[i++]) ) {}\n\t\t\ttarget.length = j - 1;\n\t\t}\n\t};\n}\n\nfunction Sizzle( selector, context, results, seed ) {\n\tvar m, i, elem, nid, nidselect, match, groups, newSelector,\n\t\tnewContext = context && context.ownerDocument,\n\n\t\t// nodeType defaults to 9, since context defaults to document\n\t\tnodeType = context ? context.nodeType : 9;\n\n\tresults = results || [];\n\n\t// Return early from calls with invalid selector or context\n\tif ( typeof selector !== \"string\" || !selector ||\n\t\tnodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {\n\n\t\treturn results;\n\t}\n\n\t// Try to shortcut find operations (as opposed to filters) in HTML documents\n\tif ( !seed ) {\n\n\t\tif ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {\n\t\t\tsetDocument( context );\n\t\t}\n\t\tcontext = context || document;\n\n\t\tif ( documentIsHTML ) {\n\n\t\t\t// If the selector is sufficiently simple, try using a \"get*By*\" DOM method\n\t\t\t// (excepting DocumentFragment context, where the methods don't exist)\n\t\t\tif ( nodeType !== 11 && (match = rquickExpr.exec( selector )) ) {\n\n\t\t\t\t// ID selector\n\t\t\t\tif ( (m = match[1]) ) {\n\n\t\t\t\t\t// Document context\n\t\t\t\t\tif ( nodeType === 9 ) {\n\t\t\t\t\t\tif ( (elem = context.getElementById( m )) ) {\n\n\t\t\t\t\t\t\t// Support: IE, Opera, Webkit\n\t\t\t\t\t\t\t// TODO: identify versions\n\t\t\t\t\t\t\t// getElementById can match elements by name instead of ID\n\t\t\t\t\t\t\tif ( elem.id === m ) {\n\t\t\t\t\t\t\t\tresults.push( elem );\n\t\t\t\t\t\t\t\treturn results;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\treturn results;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t// Element context\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\t// Support: IE, Opera, Webkit\n\t\t\t\t\t\t// TODO: identify versions\n\t\t\t\t\t\t// getElementById can match elements by name instead of ID\n\t\t\t\t\t\tif ( newContext && (elem = newContext.getElementById( m )) &&\n\t\t\t\t\t\t\tcontains( context, elem ) &&\n\t\t\t\t\t\t\telem.id === m ) {\n\n\t\t\t\t\t\t\tresults.push( elem );\n\t\t\t\t\t\t\treturn results;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t// Type selector\n\t\t\t\t} else if ( match[2] ) {\n\t\t\t\t\tpush.apply( results, context.getElementsByTagName( selector ) );\n\t\t\t\t\treturn results;\n\n\t\t\t\t// Class selector\n\t\t\t\t} else if ( (m = match[3]) && support.getElementsByClassName &&\n\t\t\t\t\tcontext.getElementsByClassName ) {\n\n\t\t\t\t\tpush.apply( results, context.getElementsByClassName( m ) );\n\t\t\t\t\treturn results;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Take advantage of querySelectorAll\n\t\t\tif ( support.qsa &&\n\t\t\t\t!compilerCache[ selector + \" \" ] &&\n\t\t\t\t(!rbuggyQSA || !rbuggyQSA.test( selector )) ) {\n\n\t\t\t\tif ( nodeType !== 1 ) {\n\t\t\t\t\tnewContext = context;\n\t\t\t\t\tnewSelector = selector;\n\n\t\t\t\t// qSA looks outside Element context, which is not what we want\n\t\t\t\t// Thanks to Andrew Dupont for this workaround technique\n\t\t\t\t// Support: IE <=8\n\t\t\t\t// Exclude object elements\n\t\t\t\t} else if ( context.nodeName.toLowerCase() !== \"object\" ) {\n\n\t\t\t\t\t// Capture the context ID, setting it first if necessary\n\t\t\t\t\tif ( (nid = context.getAttribute( \"id\" )) ) {\n\t\t\t\t\t\tnid = nid.replace( rescape, \"\\\\$&\" );\n\t\t\t\t\t} else {\n\t\t\t\t\t\tcontext.setAttribute( \"id\", (nid = expando) );\n\t\t\t\t\t}\n\n\t\t\t\t\t// Prefix every selector in the list\n\t\t\t\t\tgroups = tokenize( selector );\n\t\t\t\t\ti = groups.length;\n\t\t\t\t\tnidselect = ridentifier.test( nid ) ? \"#\" + nid : \"[id='\" + nid + \"']\";\n\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\tgroups[i] = nidselect + \" \" + toSelector( groups[i] );\n\t\t\t\t\t}\n\t\t\t\t\tnewSelector = groups.join( \",\" );\n\n\t\t\t\t\t// Expand context for sibling selectors\n\t\t\t\t\tnewContext = rsibling.test( selector ) && testContext( context.parentNode ) ||\n\t\t\t\t\t\tcontext;\n\t\t\t\t}\n\n\t\t\t\tif ( newSelector ) {\n\t\t\t\t\ttry {\n\t\t\t\t\t\tpush.apply( results,\n\t\t\t\t\t\t\tnewContext.querySelectorAll( newSelector )\n\t\t\t\t\t\t);\n\t\t\t\t\t\treturn results;\n\t\t\t\t\t} catch ( qsaError ) {\n\t\t\t\t\t} finally {\n\t\t\t\t\t\tif ( nid === expando ) {\n\t\t\t\t\t\t\tcontext.removeAttribute( \"id\" );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// All others\n\treturn select( selector.replace( rtrim, \"$1\" ), context, results, seed );\n}\n\n/**\n * Create key-value caches of limited size\n * @returns {function(string, object)} Returns the Object data after storing it on itself with\n *\tproperty name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)\n *\tdeleting the oldest entry\n */\nfunction createCache() {\n\tvar keys = [];\n\n\tfunction cache( key, value ) {\n\t\t// Use (key + \" \") to avoid collision with native prototype properties (see Issue #157)\n\t\tif ( keys.push( key + \" \" ) > Expr.cacheLength ) {\n\t\t\t// Only keep the most recent entries\n\t\t\tdelete cache[ keys.shift() ];\n\t\t}\n\t\treturn (cache[ key + \" \" ] = value);\n\t}\n\treturn cache;\n}\n\n/**\n * Mark a function for special use by Sizzle\n * @param {Function} fn The function to mark\n */\nfunction markFunction( fn ) {\n\tfn[ expando ] = true;\n\treturn fn;\n}\n\n/**\n * Support testing using an element\n * @param {Function} fn Passed the created div and expects a boolean result\n */\nfunction assert( fn ) {\n\tvar div = document.createElement(\"div\");\n\n\ttry {\n\t\treturn !!fn( div );\n\t} catch (e) {\n\t\treturn false;\n\t} finally {\n\t\t// Remove from its parent by default\n\t\tif ( div.parentNode ) {\n\t\t\tdiv.parentNode.removeChild( div );\n\t\t}\n\t\t// release memory in IE\n\t\tdiv = null;\n\t}\n}\n\n/**\n * Adds the same handler for all of the specified attrs\n * @param {String} attrs Pipe-separated list of attributes\n * @param {Function} handler The method that will be applied\n */\nfunction addHandle( attrs, handler ) {\n\tvar arr = attrs.split(\"|\"),\n\t\ti = arr.length;\n\n\twhile ( i-- ) {\n\t\tExpr.attrHandle[ arr[i] ] = handler;\n\t}\n}\n\n/**\n * Checks document order of two siblings\n * @param {Element} a\n * @param {Element} b\n * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b\n */\nfunction siblingCheck( a, b ) {\n\tvar cur = b && a,\n\t\tdiff = cur && a.nodeType === 1 && b.nodeType === 1 &&\n\t\t\t( ~b.sourceIndex || MAX_NEGATIVE ) -\n\t\t\t( ~a.sourceIndex || MAX_NEGATIVE );\n\n\t// Use IE sourceIndex if available on both nodes\n\tif ( diff ) {\n\t\treturn diff;\n\t}\n\n\t// Check if b follows a\n\tif ( cur ) {\n\t\twhile ( (cur = cur.nextSibling) ) {\n\t\t\tif ( cur === b ) {\n\t\t\t\treturn -1;\n\t\t\t}\n\t\t}\n\t}\n\n\treturn a ? 1 : -1;\n}\n\n/**\n * Returns a function to use in pseudos for input types\n * @param {String} type\n */\nfunction createInputPseudo( type ) {\n\treturn function( elem ) {\n\t\tvar name = elem.nodeName.toLowerCase();\n\t\treturn name === \"input\" && elem.type === type;\n\t};\n}\n\n/**\n * Returns a function to use in pseudos for buttons\n * @param {String} type\n */\nfunction createButtonPseudo( type ) {\n\treturn function( elem ) {\n\t\tvar name = elem.nodeName.toLowerCase();\n\t\treturn (name === \"input\" || name === \"button\") && elem.type === type;\n\t};\n}\n\n/**\n * Returns a function to use in pseudos for positionals\n * @param {Function} fn\n */\nfunction createPositionalPseudo( fn ) {\n\treturn markFunction(function( argument ) {\n\t\targument = +argument;\n\t\treturn markFunction(function( seed, matches ) {\n\t\t\tvar j,\n\t\t\t\tmatchIndexes = fn( [], seed.length, argument ),\n\t\t\t\ti = matchIndexes.length;\n\n\t\t\t// Match elements found at the specified indexes\n\t\t\twhile ( i-- ) {\n\t\t\t\tif ( seed[ (j = matchIndexes[i]) ] ) {\n\t\t\t\t\tseed[j] = !(matches[j] = seed[j]);\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\t});\n}\n\n/**\n * Checks a node for validity as a Sizzle context\n * @param {Element|Object=} context\n * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value\n */\nfunction testContext( context ) {\n\treturn context && typeof context.getElementsByTagName !== \"undefined\" && context;\n}\n\n// Expose support vars for convenience\nsupport = Sizzle.support = {};\n\n/**\n * Detects XML nodes\n * @param {Element|Object} elem An element or a document\n * @returns {Boolean} True iff elem is a non-HTML XML node\n */\nisXML = Sizzle.isXML = function( elem ) {\n\t// documentElement is verified for cases where it doesn't yet exist\n\t// (such as loading iframes in IE - #4833)\n\tvar documentElement = elem && (elem.ownerDocument || elem).documentElement;\n\treturn documentElement ? documentElement.nodeName !== \"HTML\" : false;\n};\n\n/**\n * Sets document-related variables once based on the current document\n * @param {Element|Object} [doc] An element or document object to use to set the document\n * @returns {Object} Returns the current document\n */\nsetDocument = Sizzle.setDocument = function( node ) {\n\tvar hasCompare, parent,\n\t\tdoc = node ? node.ownerDocument || node : preferredDoc;\n\n\t// Return early if doc is invalid or already selected\n\tif ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {\n\t\treturn document;\n\t}\n\n\t// Update global variables\n\tdocument = doc;\n\tdocElem = document.documentElement;\n\tdocumentIsHTML = !isXML( document );\n\n\t// Support: IE 9-11, Edge\n\t// Accessing iframe documents after unload throws \"permission denied\" errors (jQuery #13936)\n\tif ( (parent = document.defaultView) && parent.top !== parent ) {\n\t\t// Support: IE 11\n\t\tif ( parent.addEventListener ) {\n\t\t\tparent.addEventListener( \"unload\", unloadHandler, false );\n\n\t\t// Support: IE 9 - 10 only\n\t\t} else if ( parent.attachEvent ) {\n\t\t\tparent.attachEvent( \"onunload\", unloadHandler );\n\t\t}\n\t}\n\n\t/* Attributes\n\t---------------------------------------------------------------------- */\n\n\t// Support: IE<8\n\t// Verify that getAttribute really returns attributes and not properties\n\t// (excepting IE8 booleans)\n\tsupport.attributes = assert(function( div ) {\n\t\tdiv.className = \"i\";\n\t\treturn !div.getAttribute(\"className\");\n\t});\n\n\t/* getElement(s)By*\n\t---------------------------------------------------------------------- */\n\n\t// Check if getElementsByTagName(\"*\") returns only elements\n\tsupport.getElementsByTagName = assert(function( div ) {\n\t\tdiv.appendChild( document.createComment(\"\") );\n\t\treturn !div.getElementsByTagName(\"*\").length;\n\t});\n\n\t// Support: IE<9\n\tsupport.getElementsByClassName = rnative.test( document.getElementsByClassName );\n\n\t// Support: IE<10\n\t// Check if getElementById returns elements by name\n\t// The broken getElementById methods don't pick up programatically-set names,\n\t// so use a roundabout getElementsByName test\n\tsupport.getById = assert(function( div ) {\n\t\tdocElem.appendChild( div ).id = expando;\n\t\treturn !document.getElementsByName || !document.getElementsByName( expando ).length;\n\t});\n\n\t// ID find and filter\n\tif ( support.getById ) {\n\t\tExpr.find[\"ID\"] = function( id, context ) {\n\t\t\tif ( typeof context.getElementById !== \"undefined\" && documentIsHTML ) {\n\t\t\t\tvar m = context.getElementById( id );\n\t\t\t\treturn m ? [ m ] : [];\n\t\t\t}\n\t\t};\n\t\tExpr.filter[\"ID\"] = function( id ) {\n\t\t\tvar attrId = id.replace( runescape, funescape );\n\t\t\treturn function( elem ) {\n\t\t\t\treturn elem.getAttribute(\"id\") === attrId;\n\t\t\t};\n\t\t};\n\t} else {\n\t\t// Support: IE6/7\n\t\t// getElementById is not reliable as a find shortcut\n\t\tdelete Expr.find[\"ID\"];\n\n\t\tExpr.filter[\"ID\"] =  function( id ) {\n\t\t\tvar attrId = id.replace( runescape, funescape );\n\t\t\treturn function( elem ) {\n\t\t\t\tvar node = typeof elem.getAttributeNode !== \"undefined\" &&\n\t\t\t\t\telem.getAttributeNode(\"id\");\n\t\t\t\treturn node && node.value === attrId;\n\t\t\t};\n\t\t};\n\t}\n\n\t// Tag\n\tExpr.find[\"TAG\"] = support.getElementsByTagName ?\n\t\tfunction( tag, context ) {\n\t\t\tif ( typeof context.getElementsByTagName !== \"undefined\" ) {\n\t\t\t\treturn context.getElementsByTagName( tag );\n\n\t\t\t// DocumentFragment nodes don't have gEBTN\n\t\t\t} else if ( support.qsa ) {\n\t\t\t\treturn context.querySelectorAll( tag );\n\t\t\t}\n\t\t} :\n\n\t\tfunction( tag, context ) {\n\t\t\tvar elem,\n\t\t\t\ttmp = [],\n\t\t\t\ti = 0,\n\t\t\t\t// By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too\n\t\t\t\tresults = context.getElementsByTagName( tag );\n\n\t\t\t// Filter out possible comments\n\t\t\tif ( tag === \"*\" ) {\n\t\t\t\twhile ( (elem = results[i++]) ) {\n\t\t\t\t\tif ( elem.nodeType === 1 ) {\n\t\t\t\t\t\ttmp.push( elem );\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\treturn tmp;\n\t\t\t}\n\t\t\treturn results;\n\t\t};\n\n\t// Class\n\tExpr.find[\"CLASS\"] = support.getElementsByClassName && function( className, context ) {\n\t\tif ( typeof context.getElementsByClassName !== \"undefined\" && documentIsHTML ) {\n\t\t\treturn context.getElementsByClassName( className );\n\t\t}\n\t};\n\n\t/* QSA/matchesSelector\n\t---------------------------------------------------------------------- */\n\n\t// QSA and matchesSelector support\n\n\t// matchesSelector(:active) reports false when true (IE9/Opera 11.5)\n\trbuggyMatches = [];\n\n\t// qSa(:focus) reports false when true (Chrome 21)\n\t// We allow this because of a bug in IE8/9 that throws an error\n\t// whenever `document.activeElement` is accessed on an iframe\n\t// So, we allow :focus to pass through QSA all the time to avoid the IE error\n\t// See http://bugs.jquery.com/ticket/13378\n\trbuggyQSA = [];\n\n\tif ( (support.qsa = rnative.test( document.querySelectorAll )) ) {\n\t\t// Build QSA regex\n\t\t// Regex strategy adopted from Diego Perini\n\t\tassert(function( div ) {\n\t\t\t// Select is set to empty string on purpose\n\t\t\t// This is to test IE's treatment of not explicitly\n\t\t\t// setting a boolean content attribute,\n\t\t\t// since its presence should be enough\n\t\t\t// http://bugs.jquery.com/ticket/12359\n\t\t\tdocElem.appendChild( div ).innerHTML = \"<a id='\" + expando + \"'></a>\" +\n\t\t\t\t\"<select id='\" + expando + \"-\\r\\\\' msallowcapture=''>\" +\n\t\t\t\t\"<option selected=''></option></select>\";\n\n\t\t\t// Support: IE8, Opera 11-12.16\n\t\t\t// Nothing should be selected when empty strings follow ^= or $= or *=\n\t\t\t// The test attribute must be unknown in Opera but \"safe\" for WinRT\n\t\t\t// http://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section\n\t\t\tif ( div.querySelectorAll(\"[msallowcapture^='']\").length ) {\n\t\t\t\trbuggyQSA.push( \"[*^$]=\" + whitespace + \"*(?:''|\\\"\\\")\" );\n\t\t\t}\n\n\t\t\t// Support: IE8\n\t\t\t// Boolean attributes and \"value\" are not treated correctly\n\t\t\tif ( !div.querySelectorAll(\"[selected]\").length ) {\n\t\t\t\trbuggyQSA.push( \"\\\\[\" + whitespace + \"*(?:value|\" + booleans + \")\" );\n\t\t\t}\n\n\t\t\t// Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+\n\t\t\tif ( !div.querySelectorAll( \"[id~=\" + expando + \"-]\" ).length ) {\n\t\t\t\trbuggyQSA.push(\"~=\");\n\t\t\t}\n\n\t\t\t// Webkit/Opera - :checked should return selected option elements\n\t\t\t// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked\n\t\t\t// IE8 throws error here and will not see later tests\n\t\t\tif ( !div.querySelectorAll(\":checked\").length ) {\n\t\t\t\trbuggyQSA.push(\":checked\");\n\t\t\t}\n\n\t\t\t// Support: Safari 8+, iOS 8+\n\t\t\t// https://bugs.webkit.org/show_bug.cgi?id=136851\n\t\t\t// In-page `selector#id sibing-combinator selector` fails\n\t\t\tif ( !div.querySelectorAll( \"a#\" + expando + \"+*\" ).length ) {\n\t\t\t\trbuggyQSA.push(\".#.+[+~]\");\n\t\t\t}\n\t\t});\n\n\t\tassert(function( div ) {\n\t\t\t// Support: Windows 8 Native Apps\n\t\t\t// The type and name attributes are restricted during .innerHTML assignment\n\t\t\tvar input = document.createElement(\"input\");\n\t\t\tinput.setAttribute( \"type\", \"hidden\" );\n\t\t\tdiv.appendChild( input ).setAttribute( \"name\", \"D\" );\n\n\t\t\t// Support: IE8\n\t\t\t// Enforce case-sensitivity of name attribute\n\t\t\tif ( div.querySelectorAll(\"[name=d]\").length ) {\n\t\t\t\trbuggyQSA.push( \"name\" + whitespace + \"*[*^$|!~]?=\" );\n\t\t\t}\n\n\t\t\t// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)\n\t\t\t// IE8 throws error here and will not see later tests\n\t\t\tif ( !div.querySelectorAll(\":enabled\").length ) {\n\t\t\t\trbuggyQSA.push( \":enabled\", \":disabled\" );\n\t\t\t}\n\n\t\t\t// Opera 10-11 does not throw on post-comma invalid pseudos\n\t\t\tdiv.querySelectorAll(\"*,:x\");\n\t\t\trbuggyQSA.push(\",.*:\");\n\t\t});\n\t}\n\n\tif ( (support.matchesSelector = rnative.test( (matches = docElem.matches ||\n\t\tdocElem.webkitMatchesSelector ||\n\t\tdocElem.mozMatchesSelector ||\n\t\tdocElem.oMatchesSelector ||\n\t\tdocElem.msMatchesSelector) )) ) {\n\n\t\tassert(function( div ) {\n\t\t\t// Check to see if it's possible to do matchesSelector\n\t\t\t// on a disconnected node (IE 9)\n\t\t\tsupport.disconnectedMatch = matches.call( div, \"div\" );\n\n\t\t\t// This should fail with an exception\n\t\t\t// Gecko does not error, returns false instead\n\t\t\tmatches.call( div, \"[s!='']:x\" );\n\t\t\trbuggyMatches.push( \"!=\", pseudos );\n\t\t});\n\t}\n\n\trbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join(\"|\") );\n\trbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join(\"|\") );\n\n\t/* Contains\n\t---------------------------------------------------------------------- */\n\thasCompare = rnative.test( docElem.compareDocumentPosition );\n\n\t// Element contains another\n\t// Purposefully self-exclusive\n\t// As in, an element does not contain itself\n\tcontains = hasCompare || rnative.test( docElem.contains ) ?\n\t\tfunction( a, b ) {\n\t\t\tvar adown = a.nodeType === 9 ? a.documentElement : a,\n\t\t\t\tbup = b && b.parentNode;\n\t\t\treturn a === bup || !!( bup && bup.nodeType === 1 && (\n\t\t\t\tadown.contains ?\n\t\t\t\t\tadown.contains( bup ) :\n\t\t\t\t\ta.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16\n\t\t\t));\n\t\t} :\n\t\tfunction( a, b ) {\n\t\t\tif ( b ) {\n\t\t\t\twhile ( (b = b.parentNode) ) {\n\t\t\t\t\tif ( b === a ) {\n\t\t\t\t\t\treturn true;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn false;\n\t\t};\n\n\t/* Sorting\n\t---------------------------------------------------------------------- */\n\n\t// Document order sorting\n\tsortOrder = hasCompare ?\n\tfunction( a, b ) {\n\n\t\t// Flag for duplicate removal\n\t\tif ( a === b ) {\n\t\t\thasDuplicate = true;\n\t\t\treturn 0;\n\t\t}\n\n\t\t// Sort on method existence if only one input has compareDocumentPosition\n\t\tvar compare = !a.compareDocumentPosition - !b.compareDocumentPosition;\n\t\tif ( compare ) {\n\t\t\treturn compare;\n\t\t}\n\n\t\t// Calculate position if both inputs belong to the same document\n\t\tcompare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?\n\t\t\ta.compareDocumentPosition( b ) :\n\n\t\t\t// Otherwise we know they are disconnected\n\t\t\t1;\n\n\t\t// Disconnected nodes\n\t\tif ( compare & 1 ||\n\t\t\t(!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {\n\n\t\t\t// Choose the first element that is related to our preferred document\n\t\t\tif ( a === document || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) {\n\t\t\t\treturn -1;\n\t\t\t}\n\t\t\tif ( b === document || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) {\n\t\t\t\treturn 1;\n\t\t\t}\n\n\t\t\t// Maintain original order\n\t\t\treturn sortInput ?\n\t\t\t\t( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :\n\t\t\t\t0;\n\t\t}\n\n\t\treturn compare & 4 ? -1 : 1;\n\t} :\n\tfunction( a, b ) {\n\t\t// Exit early if the nodes are identical\n\t\tif ( a === b ) {\n\t\t\thasDuplicate = true;\n\t\t\treturn 0;\n\t\t}\n\n\t\tvar cur,\n\t\t\ti = 0,\n\t\t\taup = a.parentNode,\n\t\t\tbup = b.parentNode,\n\t\t\tap = [ a ],\n\t\t\tbp = [ b ];\n\n\t\t// Parentless nodes are either documents or disconnected\n\t\tif ( !aup || !bup ) {\n\t\t\treturn a === document ? -1 :\n\t\t\t\tb === document ? 1 :\n\t\t\t\taup ? -1 :\n\t\t\t\tbup ? 1 :\n\t\t\t\tsortInput ?\n\t\t\t\t( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :\n\t\t\t\t0;\n\n\t\t// If the nodes are siblings, we can do a quick check\n\t\t} else if ( aup === bup ) {\n\t\t\treturn siblingCheck( a, b );\n\t\t}\n\n\t\t// Otherwise we need full lists of their ancestors for comparison\n\t\tcur = a;\n\t\twhile ( (cur = cur.parentNode) ) {\n\t\t\tap.unshift( cur );\n\t\t}\n\t\tcur = b;\n\t\twhile ( (cur = cur.parentNode) ) {\n\t\t\tbp.unshift( cur );\n\t\t}\n\n\t\t// Walk down the tree looking for a discrepancy\n\t\twhile ( ap[i] === bp[i] ) {\n\t\t\ti++;\n\t\t}\n\n\t\treturn i ?\n\t\t\t// Do a sibling check if the nodes have a common ancestor\n\t\t\tsiblingCheck( ap[i], bp[i] ) :\n\n\t\t\t// Otherwise nodes in our document sort first\n\t\t\tap[i] === preferredDoc ? -1 :\n\t\t\tbp[i] === preferredDoc ? 1 :\n\t\t\t0;\n\t};\n\n\treturn document;\n};\n\nSizzle.matches = function( expr, elements ) {\n\treturn Sizzle( expr, null, null, elements );\n};\n\nSizzle.matchesSelector = function( elem, expr ) {\n\t// Set document vars if needed\n\tif ( ( elem.ownerDocument || elem ) !== document ) {\n\t\tsetDocument( elem );\n\t}\n\n\t// Make sure that attribute selectors are quoted\n\texpr = expr.replace( rattributeQuotes, \"='$1']\" );\n\n\tif ( support.matchesSelector && documentIsHTML &&\n\t\t!compilerCache[ expr + \" \" ] &&\n\t\t( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&\n\t\t( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {\n\n\t\ttry {\n\t\t\tvar ret = matches.call( elem, expr );\n\n\t\t\t// IE 9's matchesSelector returns false on disconnected nodes\n\t\t\tif ( ret || support.disconnectedMatch ||\n\t\t\t\t\t// As well, disconnected nodes are said to be in a document\n\t\t\t\t\t// fragment in IE 9\n\t\t\t\t\telem.document && elem.document.nodeType !== 11 ) {\n\t\t\t\treturn ret;\n\t\t\t}\n\t\t} catch (e) {}\n\t}\n\n\treturn Sizzle( expr, document, null, [ elem ] ).length > 0;\n};\n\nSizzle.contains = function( context, elem ) {\n\t// Set document vars if needed\n\tif ( ( context.ownerDocument || context ) !== document ) {\n\t\tsetDocument( context );\n\t}\n\treturn contains( context, elem );\n};\n\nSizzle.attr = function( elem, name ) {\n\t// Set document vars if needed\n\tif ( ( elem.ownerDocument || elem ) !== document ) {\n\t\tsetDocument( elem );\n\t}\n\n\tvar fn = Expr.attrHandle[ name.toLowerCase() ],\n\t\t// Don't get fooled by Object.prototype properties (jQuery #13807)\n\t\tval = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?\n\t\t\tfn( elem, name, !documentIsHTML ) :\n\t\t\tundefined;\n\n\treturn val !== undefined ?\n\t\tval :\n\t\tsupport.attributes || !documentIsHTML ?\n\t\t\telem.getAttribute( name ) :\n\t\t\t(val = elem.getAttributeNode(name)) && val.specified ?\n\t\t\t\tval.value :\n\t\t\t\tnull;\n};\n\nSizzle.error = function( msg ) {\n\tthrow new Error( \"Syntax error, unrecognized expression: \" + msg );\n};\n\n/**\n * Document sorting and removing duplicates\n * @param {ArrayLike} results\n */\nSizzle.uniqueSort = function( results ) {\n\tvar elem,\n\t\tduplicates = [],\n\t\tj = 0,\n\t\ti = 0;\n\n\t// Unless we *know* we can detect duplicates, assume their presence\n\thasDuplicate = !support.detectDuplicates;\n\tsortInput = !support.sortStable && results.slice( 0 );\n\tresults.sort( sortOrder );\n\n\tif ( hasDuplicate ) {\n\t\twhile ( (elem = results[i++]) ) {\n\t\t\tif ( elem === results[ i ] ) {\n\t\t\t\tj = duplicates.push( i );\n\t\t\t}\n\t\t}\n\t\twhile ( j-- ) {\n\t\t\tresults.splice( duplicates[ j ], 1 );\n\t\t}\n\t}\n\n\t// Clear input after sorting to release objects\n\t// See https://github.com/jquery/sizzle/pull/225\n\tsortInput = null;\n\n\treturn results;\n};\n\n/**\n * Utility function for retrieving the text value of an array of DOM nodes\n * @param {Array|Element} elem\n */\ngetText = Sizzle.getText = function( elem ) {\n\tvar node,\n\t\tret = \"\",\n\t\ti = 0,\n\t\tnodeType = elem.nodeType;\n\n\tif ( !nodeType ) {\n\t\t// If no nodeType, this is expected to be an array\n\t\twhile ( (node = elem[i++]) ) {\n\t\t\t// Do not traverse comment nodes\n\t\t\tret += getText( node );\n\t\t}\n\t} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {\n\t\t// Use textContent for elements\n\t\t// innerText usage removed for consistency of new lines (jQuery #11153)\n\t\tif ( typeof elem.textContent === \"string\" ) {\n\t\t\treturn elem.textContent;\n\t\t} else {\n\t\t\t// Traverse its children\n\t\t\tfor ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {\n\t\t\t\tret += getText( elem );\n\t\t\t}\n\t\t}\n\t} else if ( nodeType === 3 || nodeType === 4 ) {\n\t\treturn elem.nodeValue;\n\t}\n\t// Do not include comment or processing instruction nodes\n\n\treturn ret;\n};\n\nExpr = Sizzle.selectors = {\n\n\t// Can be adjusted by the user\n\tcacheLength: 50,\n\n\tcreatePseudo: markFunction,\n\n\tmatch: matchExpr,\n\n\tattrHandle: {},\n\n\tfind: {},\n\n\trelative: {\n\t\t\">\": { dir: \"parentNode\", first: true },\n\t\t\" \": { dir: \"parentNode\" },\n\t\t\"+\": { dir: \"previousSibling\", first: true },\n\t\t\"~\": { dir: \"previousSibling\" }\n\t},\n\n\tpreFilter: {\n\t\t\"ATTR\": function( match ) {\n\t\t\tmatch[1] = match[1].replace( runescape, funescape );\n\n\t\t\t// Move the given value to match[3] whether quoted or unquoted\n\t\t\tmatch[3] = ( match[3] || match[4] || match[5] || \"\" ).replace( runescape, funescape );\n\n\t\t\tif ( match[2] === \"~=\" ) {\n\t\t\t\tmatch[3] = \" \" + match[3] + \" \";\n\t\t\t}\n\n\t\t\treturn match.slice( 0, 4 );\n\t\t},\n\n\t\t\"CHILD\": function( match ) {\n\t\t\t/* matches from matchExpr[\"CHILD\"]\n\t\t\t\t1 type (only|nth|...)\n\t\t\t\t2 what (child|of-type)\n\t\t\t\t3 argument (even|odd|\\d*|\\d*n([+-]\\d+)?|...)\n\t\t\t\t4 xn-component of xn+y argument ([+-]?\\d*n|)\n\t\t\t\t5 sign of xn-component\n\t\t\t\t6 x of xn-component\n\t\t\t\t7 sign of y-component\n\t\t\t\t8 y of y-component\n\t\t\t*/\n\t\t\tmatch[1] = match[1].toLowerCase();\n\n\t\t\tif ( match[1].slice( 0, 3 ) === \"nth\" ) {\n\t\t\t\t// nth-* requires argument\n\t\t\t\tif ( !match[3] ) {\n\t\t\t\t\tSizzle.error( match[0] );\n\t\t\t\t}\n\n\t\t\t\t// numeric x and y parameters for Expr.filter.CHILD\n\t\t\t\t// remember that false/true cast respectively to 0/1\n\t\t\t\tmatch[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === \"even\" || match[3] === \"odd\" ) );\n\t\t\t\tmatch[5] = +( ( match[7] + match[8] ) || match[3] === \"odd\" );\n\n\t\t\t// other types prohibit arguments\n\t\t\t} else if ( match[3] ) {\n\t\t\t\tSizzle.error( match[0] );\n\t\t\t}\n\n\t\t\treturn match;\n\t\t},\n\n\t\t\"PSEUDO\": function( match ) {\n\t\t\tvar excess,\n\t\t\t\tunquoted = !match[6] && match[2];\n\n\t\t\tif ( matchExpr[\"CHILD\"].test( match[0] ) ) {\n\t\t\t\treturn null;\n\t\t\t}\n\n\t\t\t// Accept quoted arguments as-is\n\t\t\tif ( match[3] ) {\n\t\t\t\tmatch[2] = match[4] || match[5] || \"\";\n\n\t\t\t// Strip excess characters from unquoted arguments\n\t\t\t} else if ( unquoted && rpseudo.test( unquoted ) &&\n\t\t\t\t// Get excess from tokenize (recursively)\n\t\t\t\t(excess = tokenize( unquoted, true )) &&\n\t\t\t\t// advance to the next closing parenthesis\n\t\t\t\t(excess = unquoted.indexOf( \")\", unquoted.length - excess ) - unquoted.length) ) {\n\n\t\t\t\t// excess is a negative index\n\t\t\t\tmatch[0] = match[0].slice( 0, excess );\n\t\t\t\tmatch[2] = unquoted.slice( 0, excess );\n\t\t\t}\n\n\t\t\t// Return only captures needed by the pseudo filter method (type and argument)\n\t\t\treturn match.slice( 0, 3 );\n\t\t}\n\t},\n\n\tfilter: {\n\n\t\t\"TAG\": function( nodeNameSelector ) {\n\t\t\tvar nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();\n\t\t\treturn nodeNameSelector === \"*\" ?\n\t\t\t\tfunction() { return true; } :\n\t\t\t\tfunction( elem ) {\n\t\t\t\t\treturn elem.nodeName && elem.nodeName.toLowerCase() === nodeName;\n\t\t\t\t};\n\t\t},\n\n\t\t\"CLASS\": function( className ) {\n\t\t\tvar pattern = classCache[ className + \" \" ];\n\n\t\t\treturn pattern ||\n\t\t\t\t(pattern = new RegExp( \"(^|\" + whitespace + \")\" + className + \"(\" + whitespace + \"|$)\" )) &&\n\t\t\t\tclassCache( className, function( elem ) {\n\t\t\t\t\treturn pattern.test( typeof elem.className === \"string\" && elem.className || typeof elem.getAttribute !== \"undefined\" && elem.getAttribute(\"class\") || \"\" );\n\t\t\t\t});\n\t\t},\n\n\t\t\"ATTR\": function( name, operator, check ) {\n\t\t\treturn function( elem ) {\n\t\t\t\tvar result = Sizzle.attr( elem, name );\n\n\t\t\t\tif ( result == null ) {\n\t\t\t\t\treturn operator === \"!=\";\n\t\t\t\t}\n\t\t\t\tif ( !operator ) {\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\n\t\t\t\tresult += \"\";\n\n\t\t\t\treturn operator === \"=\" ? result === check :\n\t\t\t\t\toperator === \"!=\" ? result !== check :\n\t\t\t\t\toperator === \"^=\" ? check && result.indexOf( check ) === 0 :\n\t\t\t\t\toperator === \"*=\" ? check && result.indexOf( check ) > -1 :\n\t\t\t\t\toperator === \"$=\" ? check && result.slice( -check.length ) === check :\n\t\t\t\t\toperator === \"~=\" ? ( \" \" + result.replace( rwhitespace, \" \" ) + \" \" ).indexOf( check ) > -1 :\n\t\t\t\t\toperator === \"|=\" ? result === check || result.slice( 0, check.length + 1 ) === check + \"-\" :\n\t\t\t\t\tfalse;\n\t\t\t};\n\t\t},\n\n\t\t\"CHILD\": function( type, what, argument, first, last ) {\n\t\t\tvar simple = type.slice( 0, 3 ) !== \"nth\",\n\t\t\t\tforward = type.slice( -4 ) !== \"last\",\n\t\t\t\tofType = what === \"of-type\";\n\n\t\t\treturn first === 1 && last === 0 ?\n\n\t\t\t\t// Shortcut for :nth-*(n)\n\t\t\t\tfunction( elem ) {\n\t\t\t\t\treturn !!elem.parentNode;\n\t\t\t\t} :\n\n\t\t\t\tfunction( elem, context, xml ) {\n\t\t\t\t\tvar cache, uniqueCache, outerCache, node, nodeIndex, start,\n\t\t\t\t\t\tdir = simple !== forward ? \"nextSibling\" : \"previousSibling\",\n\t\t\t\t\t\tparent = elem.parentNode,\n\t\t\t\t\t\tname = ofType && elem.nodeName.toLowerCase(),\n\t\t\t\t\t\tuseCache = !xml && !ofType,\n\t\t\t\t\t\tdiff = false;\n\n\t\t\t\t\tif ( parent ) {\n\n\t\t\t\t\t\t// :(first|last|only)-(child|of-type)\n\t\t\t\t\t\tif ( simple ) {\n\t\t\t\t\t\t\twhile ( dir ) {\n\t\t\t\t\t\t\t\tnode = elem;\n\t\t\t\t\t\t\t\twhile ( (node = node[ dir ]) ) {\n\t\t\t\t\t\t\t\t\tif ( ofType ?\n\t\t\t\t\t\t\t\t\t\tnode.nodeName.toLowerCase() === name :\n\t\t\t\t\t\t\t\t\t\tnode.nodeType === 1 ) {\n\n\t\t\t\t\t\t\t\t\t\treturn false;\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t// Reverse direction for :only-* (if we haven't yet done so)\n\t\t\t\t\t\t\t\tstart = dir = type === \"only\" && !start && \"nextSibling\";\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tstart = [ forward ? parent.firstChild : parent.lastChild ];\n\n\t\t\t\t\t\t// non-xml :nth-child(...) stores cache data on `parent`\n\t\t\t\t\t\tif ( forward && useCache ) {\n\n\t\t\t\t\t\t\t// Seek `elem` from a previously-cached index\n\n\t\t\t\t\t\t\t// ...in a gzip-friendly way\n\t\t\t\t\t\t\tnode = parent;\n\t\t\t\t\t\t\touterCache = node[ expando ] || (node[ expando ] = {});\n\n\t\t\t\t\t\t\t// Support: IE <9 only\n\t\t\t\t\t\t\t// Defend against cloned attroperties (jQuery gh-1709)\n\t\t\t\t\t\t\tuniqueCache = outerCache[ node.uniqueID ] ||\n\t\t\t\t\t\t\t\t(outerCache[ node.uniqueID ] = {});\n\n\t\t\t\t\t\t\tcache = uniqueCache[ type ] || [];\n\t\t\t\t\t\t\tnodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];\n\t\t\t\t\t\t\tdiff = nodeIndex && cache[ 2 ];\n\t\t\t\t\t\t\tnode = nodeIndex && parent.childNodes[ nodeIndex ];\n\n\t\t\t\t\t\t\twhile ( (node = ++nodeIndex && node && node[ dir ] ||\n\n\t\t\t\t\t\t\t\t// Fallback to seeking `elem` from the start\n\t\t\t\t\t\t\t\t(diff = nodeIndex = 0) || start.pop()) ) {\n\n\t\t\t\t\t\t\t\t// When found, cache indexes on `parent` and break\n\t\t\t\t\t\t\t\tif ( node.nodeType === 1 && ++diff && node === elem ) {\n\t\t\t\t\t\t\t\t\tuniqueCache[ type ] = [ dirruns, nodeIndex, diff ];\n\t\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t// Use previously-cached element index if available\n\t\t\t\t\t\t\tif ( useCache ) {\n\t\t\t\t\t\t\t\t// ...in a gzip-friendly way\n\t\t\t\t\t\t\t\tnode = elem;\n\t\t\t\t\t\t\t\touterCache = node[ expando ] || (node[ expando ] = {});\n\n\t\t\t\t\t\t\t\t// Support: IE <9 only\n\t\t\t\t\t\t\t\t// Defend against cloned attroperties (jQuery gh-1709)\n\t\t\t\t\t\t\t\tuniqueCache = outerCache[ node.uniqueID ] ||\n\t\t\t\t\t\t\t\t\t(outerCache[ node.uniqueID ] = {});\n\n\t\t\t\t\t\t\t\tcache = uniqueCache[ type ] || [];\n\t\t\t\t\t\t\t\tnodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];\n\t\t\t\t\t\t\t\tdiff = nodeIndex;\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t// xml :nth-child(...)\n\t\t\t\t\t\t\t// or :nth-last-child(...) or :nth(-last)?-of-type(...)\n\t\t\t\t\t\t\tif ( diff === false ) {\n\t\t\t\t\t\t\t\t// Use the same loop as above to seek `elem` from the start\n\t\t\t\t\t\t\t\twhile ( (node = ++nodeIndex && node && node[ dir ] ||\n\t\t\t\t\t\t\t\t\t(diff = nodeIndex = 0) || start.pop()) ) {\n\n\t\t\t\t\t\t\t\t\tif ( ( ofType ?\n\t\t\t\t\t\t\t\t\t\tnode.nodeName.toLowerCase() === name :\n\t\t\t\t\t\t\t\t\t\tnode.nodeType === 1 ) &&\n\t\t\t\t\t\t\t\t\t\t++diff ) {\n\n\t\t\t\t\t\t\t\t\t\t// Cache the index of each encountered element\n\t\t\t\t\t\t\t\t\t\tif ( useCache ) {\n\t\t\t\t\t\t\t\t\t\t\touterCache = node[ expando ] || (node[ expando ] = {});\n\n\t\t\t\t\t\t\t\t\t\t\t// Support: IE <9 only\n\t\t\t\t\t\t\t\t\t\t\t// Defend against cloned attroperties (jQuery gh-1709)\n\t\t\t\t\t\t\t\t\t\t\tuniqueCache = outerCache[ node.uniqueID ] ||\n\t\t\t\t\t\t\t\t\t\t\t\t(outerCache[ node.uniqueID ] = {});\n\n\t\t\t\t\t\t\t\t\t\t\tuniqueCache[ type ] = [ dirruns, diff ];\n\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t\tif ( node === elem ) {\n\t\t\t\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Incorporate the offset, then check against cycle size\n\t\t\t\t\t\tdiff -= last;\n\t\t\t\t\t\treturn diff === first || ( diff % first === 0 && diff / first >= 0 );\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t},\n\n\t\t\"PSEUDO\": function( pseudo, argument ) {\n\t\t\t// pseudo-class names are case-insensitive\n\t\t\t// http://www.w3.org/TR/selectors/#pseudo-classes\n\t\t\t// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters\n\t\t\t// Remember that setFilters inherits from pseudos\n\t\t\tvar args,\n\t\t\t\tfn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||\n\t\t\t\t\tSizzle.error( \"unsupported pseudo: \" + pseudo );\n\n\t\t\t// The user may use createPseudo to indicate that\n\t\t\t// arguments are needed to create the filter function\n\t\t\t// just as Sizzle does\n\t\t\tif ( fn[ expando ] ) {\n\t\t\t\treturn fn( argument );\n\t\t\t}\n\n\t\t\t// But maintain support for old signatures\n\t\t\tif ( fn.length > 1 ) {\n\t\t\t\targs = [ pseudo, pseudo, \"\", argument ];\n\t\t\t\treturn Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?\n\t\t\t\t\tmarkFunction(function( seed, matches ) {\n\t\t\t\t\t\tvar idx,\n\t\t\t\t\t\t\tmatched = fn( seed, argument ),\n\t\t\t\t\t\t\ti = matched.length;\n\t\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\t\tidx = indexOf( seed, matched[i] );\n\t\t\t\t\t\t\tseed[ idx ] = !( matches[ idx ] = matched[i] );\n\t\t\t\t\t\t}\n\t\t\t\t\t}) :\n\t\t\t\t\tfunction( elem ) {\n\t\t\t\t\t\treturn fn( elem, 0, args );\n\t\t\t\t\t};\n\t\t\t}\n\n\t\t\treturn fn;\n\t\t}\n\t},\n\n\tpseudos: {\n\t\t// Potentially complex pseudos\n\t\t\"not\": markFunction(function( selector ) {\n\t\t\t// Trim the selector passed to compile\n\t\t\t// to avoid treating leading and trailing\n\t\t\t// spaces as combinators\n\t\t\tvar input = [],\n\t\t\t\tresults = [],\n\t\t\t\tmatcher = compile( selector.replace( rtrim, \"$1\" ) );\n\n\t\t\treturn matcher[ expando ] ?\n\t\t\t\tmarkFunction(function( seed, matches, context, xml ) {\n\t\t\t\t\tvar elem,\n\t\t\t\t\t\tunmatched = matcher( seed, null, xml, [] ),\n\t\t\t\t\t\ti = seed.length;\n\n\t\t\t\t\t// Match elements unmatched by `matcher`\n\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\tif ( (elem = unmatched[i]) ) {\n\t\t\t\t\t\t\tseed[i] = !(matches[i] = elem);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}) :\n\t\t\t\tfunction( elem, context, xml ) {\n\t\t\t\t\tinput[0] = elem;\n\t\t\t\t\tmatcher( input, null, xml, results );\n\t\t\t\t\t// Don't keep the element (issue #299)\n\t\t\t\t\tinput[0] = null;\n\t\t\t\t\treturn !results.pop();\n\t\t\t\t};\n\t\t}),\n\n\t\t\"has\": markFunction(function( selector ) {\n\t\t\treturn function( elem ) {\n\t\t\t\treturn Sizzle( selector, elem ).length > 0;\n\t\t\t};\n\t\t}),\n\n\t\t\"contains\": markFunction(function( text ) {\n\t\t\ttext = text.replace( runescape, funescape );\n\t\t\treturn function( elem ) {\n\t\t\t\treturn ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1;\n\t\t\t};\n\t\t}),\n\n\t\t// \"Whether an element is represented by a :lang() selector\n\t\t// is based solely on the element's language value\n\t\t// being equal to the identifier C,\n\t\t// or beginning with the identifier C immediately followed by \"-\".\n\t\t// The matching of C against the element's language value is performed case-insensitively.\n\t\t// The identifier C does not have to be a valid language name.\"\n\t\t// http://www.w3.org/TR/selectors/#lang-pseudo\n\t\t\"lang\": markFunction( function( lang ) {\n\t\t\t// lang value must be a valid identifier\n\t\t\tif ( !ridentifier.test(lang || \"\") ) {\n\t\t\t\tSizzle.error( \"unsupported lang: \" + lang );\n\t\t\t}\n\t\t\tlang = lang.replace( runescape, funescape ).toLowerCase();\n\t\t\treturn function( elem ) {\n\t\t\t\tvar elemLang;\n\t\t\t\tdo {\n\t\t\t\t\tif ( (elemLang = documentIsHTML ?\n\t\t\t\t\t\telem.lang :\n\t\t\t\t\t\telem.getAttribute(\"xml:lang\") || elem.getAttribute(\"lang\")) ) {\n\n\t\t\t\t\t\telemLang = elemLang.toLowerCase();\n\t\t\t\t\t\treturn elemLang === lang || elemLang.indexOf( lang + \"-\" ) === 0;\n\t\t\t\t\t}\n\t\t\t\t} while ( (elem = elem.parentNode) && elem.nodeType === 1 );\n\t\t\t\treturn false;\n\t\t\t};\n\t\t}),\n\n\t\t// Miscellaneous\n\t\t\"target\": function( elem ) {\n\t\t\tvar hash = window.location && window.location.hash;\n\t\t\treturn hash && hash.slice( 1 ) === elem.id;\n\t\t},\n\n\t\t\"root\": function( elem ) {\n\t\t\treturn elem === docElem;\n\t\t},\n\n\t\t\"focus\": function( elem ) {\n\t\t\treturn elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);\n\t\t},\n\n\t\t// Boolean properties\n\t\t\"enabled\": function( elem ) {\n\t\t\treturn elem.disabled === false;\n\t\t},\n\n\t\t\"disabled\": function( elem ) {\n\t\t\treturn elem.disabled === true;\n\t\t},\n\n\t\t\"checked\": function( elem ) {\n\t\t\t// In CSS3, :checked should return both checked and selected elements\n\t\t\t// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked\n\t\t\tvar nodeName = elem.nodeName.toLowerCase();\n\t\t\treturn (nodeName === \"input\" && !!elem.checked) || (nodeName === \"option\" && !!elem.selected);\n\t\t},\n\n\t\t\"selected\": function( elem ) {\n\t\t\t// Accessing this property makes selected-by-default\n\t\t\t// options in Safari work properly\n\t\t\tif ( elem.parentNode ) {\n\t\t\t\telem.parentNode.selectedIndex;\n\t\t\t}\n\n\t\t\treturn elem.selected === true;\n\t\t},\n\n\t\t// Contents\n\t\t\"empty\": function( elem ) {\n\t\t\t// http://www.w3.org/TR/selectors/#empty-pseudo\n\t\t\t// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),\n\t\t\t//   but not by others (comment: 8; processing instruction: 7; etc.)\n\t\t\t// nodeType < 6 works because attributes (2) do not appear as children\n\t\t\tfor ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {\n\t\t\t\tif ( elem.nodeType < 6 ) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn true;\n\t\t},\n\n\t\t\"parent\": function( elem ) {\n\t\t\treturn !Expr.pseudos[\"empty\"]( elem );\n\t\t},\n\n\t\t// Element/input types\n\t\t\"header\": function( elem ) {\n\t\t\treturn rheader.test( elem.nodeName );\n\t\t},\n\n\t\t\"input\": function( elem ) {\n\t\t\treturn rinputs.test( elem.nodeName );\n\t\t},\n\n\t\t\"button\": function( elem ) {\n\t\t\tvar name = elem.nodeName.toLowerCase();\n\t\t\treturn name === \"input\" && elem.type === \"button\" || name === \"button\";\n\t\t},\n\n\t\t\"text\": function( elem ) {\n\t\t\tvar attr;\n\t\t\treturn elem.nodeName.toLowerCase() === \"input\" &&\n\t\t\t\telem.type === \"text\" &&\n\n\t\t\t\t// Support: IE<8\n\t\t\t\t// New HTML5 attribute values (e.g., \"search\") appear with elem.type === \"text\"\n\t\t\t\t( (attr = elem.getAttribute(\"type\")) == null || attr.toLowerCase() === \"text\" );\n\t\t},\n\n\t\t// Position-in-collection\n\t\t\"first\": createPositionalPseudo(function() {\n\t\t\treturn [ 0 ];\n\t\t}),\n\n\t\t\"last\": createPositionalPseudo(function( matchIndexes, length ) {\n\t\t\treturn [ length - 1 ];\n\t\t}),\n\n\t\t\"eq\": createPositionalPseudo(function( matchIndexes, length, argument ) {\n\t\t\treturn [ argument < 0 ? argument + length : argument ];\n\t\t}),\n\n\t\t\"even\": createPositionalPseudo(function( matchIndexes, length ) {\n\t\t\tvar i = 0;\n\t\t\tfor ( ; i < length; i += 2 ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t}),\n\n\t\t\"odd\": createPositionalPseudo(function( matchIndexes, length ) {\n\t\t\tvar i = 1;\n\t\t\tfor ( ; i < length; i += 2 ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t}),\n\n\t\t\"lt\": createPositionalPseudo(function( matchIndexes, length, argument ) {\n\t\t\tvar i = argument < 0 ? argument + length : argument;\n\t\t\tfor ( ; --i >= 0; ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t}),\n\n\t\t\"gt\": createPositionalPseudo(function( matchIndexes, length, argument ) {\n\t\t\tvar i = argument < 0 ? argument + length : argument;\n\t\t\tfor ( ; ++i < length; ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t})\n\t}\n};\n\nExpr.pseudos[\"nth\"] = Expr.pseudos[\"eq\"];\n\n// Add button/input type pseudos\nfor ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {\n\tExpr.pseudos[ i ] = createInputPseudo( i );\n}\nfor ( i in { submit: true, reset: true } ) {\n\tExpr.pseudos[ i ] = createButtonPseudo( i );\n}\n\n// Easy API for creating new setFilters\nfunction setFilters() {}\nsetFilters.prototype = Expr.filters = Expr.pseudos;\nExpr.setFilters = new setFilters();\n\ntokenize = Sizzle.tokenize = function( selector, parseOnly ) {\n\tvar matched, match, tokens, type,\n\t\tsoFar, groups, preFilters,\n\t\tcached = tokenCache[ selector + \" \" ];\n\n\tif ( cached ) {\n\t\treturn parseOnly ? 0 : cached.slice( 0 );\n\t}\n\n\tsoFar = selector;\n\tgroups = [];\n\tpreFilters = Expr.preFilter;\n\n\twhile ( soFar ) {\n\n\t\t// Comma and first run\n\t\tif ( !matched || (match = rcomma.exec( soFar )) ) {\n\t\t\tif ( match ) {\n\t\t\t\t// Don't consume trailing commas as valid\n\t\t\t\tsoFar = soFar.slice( match[0].length ) || soFar;\n\t\t\t}\n\t\t\tgroups.push( (tokens = []) );\n\t\t}\n\n\t\tmatched = false;\n\n\t\t// Combinators\n\t\tif ( (match = rcombinators.exec( soFar )) ) {\n\t\t\tmatched = match.shift();\n\t\t\ttokens.push({\n\t\t\t\tvalue: matched,\n\t\t\t\t// Cast descendant combinators to space\n\t\t\t\ttype: match[0].replace( rtrim, \" \" )\n\t\t\t});\n\t\t\tsoFar = soFar.slice( matched.length );\n\t\t}\n\n\t\t// Filters\n\t\tfor ( type in Expr.filter ) {\n\t\t\tif ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||\n\t\t\t\t(match = preFilters[ type ]( match ))) ) {\n\t\t\t\tmatched = match.shift();\n\t\t\t\ttokens.push({\n\t\t\t\t\tvalue: matched,\n\t\t\t\t\ttype: type,\n\t\t\t\t\tmatches: match\n\t\t\t\t});\n\t\t\t\tsoFar = soFar.slice( matched.length );\n\t\t\t}\n\t\t}\n\n\t\tif ( !matched ) {\n\t\t\tbreak;\n\t\t}\n\t}\n\n\t// Return the length of the invalid excess\n\t// if we're just parsing\n\t// Otherwise, throw an error or return tokens\n\treturn parseOnly ?\n\t\tsoFar.length :\n\t\tsoFar ?\n\t\t\tSizzle.error( selector ) :\n\t\t\t// Cache the tokens\n\t\t\ttokenCache( selector, groups ).slice( 0 );\n};\n\nfunction toSelector( tokens ) {\n\tvar i = 0,\n\t\tlen = tokens.length,\n\t\tselector = \"\";\n\tfor ( ; i < len; i++ ) {\n\t\tselector += tokens[i].value;\n\t}\n\treturn selector;\n}\n\nfunction addCombinator( matcher, combinator, base ) {\n\tvar dir = combinator.dir,\n\t\tcheckNonElements = base && dir === \"parentNode\",\n\t\tdoneName = done++;\n\n\treturn combinator.first ?\n\t\t// Check against closest ancestor/preceding element\n\t\tfunction( elem, context, xml ) {\n\t\t\twhile ( (elem = elem[ dir ]) ) {\n\t\t\t\tif ( elem.nodeType === 1 || checkNonElements ) {\n\t\t\t\t\treturn matcher( elem, context, xml );\n\t\t\t\t}\n\t\t\t}\n\t\t} :\n\n\t\t// Check against all ancestor/preceding elements\n\t\tfunction( elem, context, xml ) {\n\t\t\tvar oldCache, uniqueCache, outerCache,\n\t\t\t\tnewCache = [ dirruns, doneName ];\n\n\t\t\t// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching\n\t\t\tif ( xml ) {\n\t\t\t\twhile ( (elem = elem[ dir ]) ) {\n\t\t\t\t\tif ( elem.nodeType === 1 || checkNonElements ) {\n\t\t\t\t\t\tif ( matcher( elem, context, xml ) ) {\n\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\twhile ( (elem = elem[ dir ]) ) {\n\t\t\t\t\tif ( elem.nodeType === 1 || checkNonElements ) {\n\t\t\t\t\t\touterCache = elem[ expando ] || (elem[ expando ] = {});\n\n\t\t\t\t\t\t// Support: IE <9 only\n\t\t\t\t\t\t// Defend against cloned attroperties (jQuery gh-1709)\n\t\t\t\t\t\tuniqueCache = outerCache[ elem.uniqueID ] || (outerCache[ elem.uniqueID ] = {});\n\n\t\t\t\t\t\tif ( (oldCache = uniqueCache[ dir ]) &&\n\t\t\t\t\t\t\toldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {\n\n\t\t\t\t\t\t\t// Assign to newCache so results back-propagate to previous elements\n\t\t\t\t\t\t\treturn (newCache[ 2 ] = oldCache[ 2 ]);\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t// Reuse newcache so results back-propagate to previous elements\n\t\t\t\t\t\t\tuniqueCache[ dir ] = newCache;\n\n\t\t\t\t\t\t\t// A match means we're done; a fail means we have to keep checking\n\t\t\t\t\t\t\tif ( (newCache[ 2 ] = matcher( elem, context, xml )) ) {\n\t\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t};\n}\n\nfunction elementMatcher( matchers ) {\n\treturn matchers.length > 1 ?\n\t\tfunction( elem, context, xml ) {\n\t\t\tvar i = matchers.length;\n\t\t\twhile ( i-- ) {\n\t\t\t\tif ( !matchers[i]( elem, context, xml ) ) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn true;\n\t\t} :\n\t\tmatchers[0];\n}\n\nfunction multipleContexts( selector, contexts, results ) {\n\tvar i = 0,\n\t\tlen = contexts.length;\n\tfor ( ; i < len; i++ ) {\n\t\tSizzle( selector, contexts[i], results );\n\t}\n\treturn results;\n}\n\nfunction condense( unmatched, map, filter, context, xml ) {\n\tvar elem,\n\t\tnewUnmatched = [],\n\t\ti = 0,\n\t\tlen = unmatched.length,\n\t\tmapped = map != null;\n\n\tfor ( ; i < len; i++ ) {\n\t\tif ( (elem = unmatched[i]) ) {\n\t\t\tif ( !filter || filter( elem, context, xml ) ) {\n\t\t\t\tnewUnmatched.push( elem );\n\t\t\t\tif ( mapped ) {\n\t\t\t\t\tmap.push( i );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn newUnmatched;\n}\n\nfunction setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {\n\tif ( postFilter && !postFilter[ expando ] ) {\n\t\tpostFilter = setMatcher( postFilter );\n\t}\n\tif ( postFinder && !postFinder[ expando ] ) {\n\t\tpostFinder = setMatcher( postFinder, postSelector );\n\t}\n\treturn markFunction(function( seed, results, context, xml ) {\n\t\tvar temp, i, elem,\n\t\t\tpreMap = [],\n\t\t\tpostMap = [],\n\t\t\tpreexisting = results.length,\n\n\t\t\t// Get initial elements from seed or context\n\t\t\telems = seed || multipleContexts( selector || \"*\", context.nodeType ? [ context ] : context, [] ),\n\n\t\t\t// Prefilter to get matcher input, preserving a map for seed-results synchronization\n\t\t\tmatcherIn = preFilter && ( seed || !selector ) ?\n\t\t\t\tcondense( elems, preMap, preFilter, context, xml ) :\n\t\t\t\telems,\n\n\t\t\tmatcherOut = matcher ?\n\t\t\t\t// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,\n\t\t\t\tpostFinder || ( seed ? preFilter : preexisting || postFilter ) ?\n\n\t\t\t\t\t// ...intermediate processing is necessary\n\t\t\t\t\t[] :\n\n\t\t\t\t\t// ...otherwise use results directly\n\t\t\t\t\tresults :\n\t\t\t\tmatcherIn;\n\n\t\t// Find primary matches\n\t\tif ( matcher ) {\n\t\t\tmatcher( matcherIn, matcherOut, context, xml );\n\t\t}\n\n\t\t// Apply postFilter\n\t\tif ( postFilter ) {\n\t\t\ttemp = condense( matcherOut, postMap );\n\t\t\tpostFilter( temp, [], context, xml );\n\n\t\t\t// Un-match failing elements by moving them back to matcherIn\n\t\t\ti = temp.length;\n\t\t\twhile ( i-- ) {\n\t\t\t\tif ( (elem = temp[i]) ) {\n\t\t\t\t\tmatcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif ( seed ) {\n\t\t\tif ( postFinder || preFilter ) {\n\t\t\t\tif ( postFinder ) {\n\t\t\t\t\t// Get the final matcherOut by condensing this intermediate into postFinder contexts\n\t\t\t\t\ttemp = [];\n\t\t\t\t\ti = matcherOut.length;\n\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\tif ( (elem = matcherOut[i]) ) {\n\t\t\t\t\t\t\t// Restore matcherIn since elem is not yet a final match\n\t\t\t\t\t\t\ttemp.push( (matcherIn[i] = elem) );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tpostFinder( null, (matcherOut = []), temp, xml );\n\t\t\t\t}\n\n\t\t\t\t// Move matched elements from seed to results to keep them synchronized\n\t\t\t\ti = matcherOut.length;\n\t\t\t\twhile ( i-- ) {\n\t\t\t\t\tif ( (elem = matcherOut[i]) &&\n\t\t\t\t\t\t(temp = postFinder ? indexOf( seed, elem ) : preMap[i]) > -1 ) {\n\n\t\t\t\t\t\tseed[temp] = !(results[temp] = elem);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t// Add elements to results, through postFinder if defined\n\t\t} else {\n\t\t\tmatcherOut = condense(\n\t\t\t\tmatcherOut === results ?\n\t\t\t\t\tmatcherOut.splice( preexisting, matcherOut.length ) :\n\t\t\t\t\tmatcherOut\n\t\t\t);\n\t\t\tif ( postFinder ) {\n\t\t\t\tpostFinder( null, results, matcherOut, xml );\n\t\t\t} else {\n\t\t\t\tpush.apply( results, matcherOut );\n\t\t\t}\n\t\t}\n\t});\n}\n\nfunction matcherFromTokens( tokens ) {\n\tvar checkContext, matcher, j,\n\t\tlen = tokens.length,\n\t\tleadingRelative = Expr.relative[ tokens[0].type ],\n\t\timplicitRelative = leadingRelative || Expr.relative[\" \"],\n\t\ti = leadingRelative ? 1 : 0,\n\n\t\t// The foundational matcher ensures that elements are reachable from top-level context(s)\n\t\tmatchContext = addCombinator( function( elem ) {\n\t\t\treturn elem === checkContext;\n\t\t}, implicitRelative, true ),\n\t\tmatchAnyContext = addCombinator( function( elem ) {\n\t\t\treturn indexOf( checkContext, elem ) > -1;\n\t\t}, implicitRelative, true ),\n\t\tmatchers = [ function( elem, context, xml ) {\n\t\t\tvar ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (\n\t\t\t\t(checkContext = context).nodeType ?\n\t\t\t\t\tmatchContext( elem, context, xml ) :\n\t\t\t\t\tmatchAnyContext( elem, context, xml ) );\n\t\t\t// Avoid hanging onto element (issue #299)\n\t\t\tcheckContext = null;\n\t\t\treturn ret;\n\t\t} ];\n\n\tfor ( ; i < len; i++ ) {\n\t\tif ( (matcher = Expr.relative[ tokens[i].type ]) ) {\n\t\t\tmatchers = [ addCombinator(elementMatcher( matchers ), matcher) ];\n\t\t} else {\n\t\t\tmatcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );\n\n\t\t\t// Return special upon seeing a positional matcher\n\t\t\tif ( matcher[ expando ] ) {\n\t\t\t\t// Find the next relative operator (if any) for proper handling\n\t\t\t\tj = ++i;\n\t\t\t\tfor ( ; j < len; j++ ) {\n\t\t\t\t\tif ( Expr.relative[ tokens[j].type ] ) {\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn setMatcher(\n\t\t\t\t\ti > 1 && elementMatcher( matchers ),\n\t\t\t\t\ti > 1 && toSelector(\n\t\t\t\t\t\t// If the preceding token was a descendant combinator, insert an implicit any-element `*`\n\t\t\t\t\t\ttokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === \" \" ? \"*\" : \"\" })\n\t\t\t\t\t).replace( rtrim, \"$1\" ),\n\t\t\t\t\tmatcher,\n\t\t\t\t\ti < j && matcherFromTokens( tokens.slice( i, j ) ),\n\t\t\t\t\tj < len && matcherFromTokens( (tokens = tokens.slice( j )) ),\n\t\t\t\t\tj < len && toSelector( tokens )\n\t\t\t\t);\n\t\t\t}\n\t\t\tmatchers.push( matcher );\n\t\t}\n\t}\n\n\treturn elementMatcher( matchers );\n}\n\nfunction matcherFromGroupMatchers( elementMatchers, setMatchers ) {\n\tvar bySet = setMatchers.length > 0,\n\t\tbyElement = elementMatchers.length > 0,\n\t\tsuperMatcher = function( seed, context, xml, results, outermost ) {\n\t\t\tvar elem, j, matcher,\n\t\t\t\tmatchedCount = 0,\n\t\t\t\ti = \"0\",\n\t\t\t\tunmatched = seed && [],\n\t\t\t\tsetMatched = [],\n\t\t\t\tcontextBackup = outermostContext,\n\t\t\t\t// We must always have either seed elements or outermost context\n\t\t\t\telems = seed || byElement && Expr.find[\"TAG\"]( \"*\", outermost ),\n\t\t\t\t// Use integer dirruns iff this is the outermost matcher\n\t\t\t\tdirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1),\n\t\t\t\tlen = elems.length;\n\n\t\t\tif ( outermost ) {\n\t\t\t\toutermostContext = context === document || context || outermost;\n\t\t\t}\n\n\t\t\t// Add elements passing elementMatchers directly to results\n\t\t\t// Support: IE<9, Safari\n\t\t\t// Tolerate NodeList properties (IE: \"length\"; Safari: <number>) matching elements by id\n\t\t\tfor ( ; i !== len && (elem = elems[i]) != null; i++ ) {\n\t\t\t\tif ( byElement && elem ) {\n\t\t\t\t\tj = 0;\n\t\t\t\t\tif ( !context && elem.ownerDocument !== document ) {\n\t\t\t\t\t\tsetDocument( elem );\n\t\t\t\t\t\txml = !documentIsHTML;\n\t\t\t\t\t}\n\t\t\t\t\twhile ( (matcher = elementMatchers[j++]) ) {\n\t\t\t\t\t\tif ( matcher( elem, context || document, xml) ) {\n\t\t\t\t\t\t\tresults.push( elem );\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tif ( outermost ) {\n\t\t\t\t\t\tdirruns = dirrunsUnique;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Track unmatched elements for set filters\n\t\t\t\tif ( bySet ) {\n\t\t\t\t\t// They will have gone through all possible matchers\n\t\t\t\t\tif ( (elem = !matcher && elem) ) {\n\t\t\t\t\t\tmatchedCount--;\n\t\t\t\t\t}\n\n\t\t\t\t\t// Lengthen the array for every element, matched or not\n\t\t\t\t\tif ( seed ) {\n\t\t\t\t\t\tunmatched.push( elem );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// `i` is now the count of elements visited above, and adding it to `matchedCount`\n\t\t\t// makes the latter nonnegative.\n\t\t\tmatchedCount += i;\n\n\t\t\t// Apply set filters to unmatched elements\n\t\t\t// NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`\n\t\t\t// equals `i`), unless we didn't visit _any_ elements in the above loop because we have\n\t\t\t// no element matchers and no seed.\n\t\t\t// Incrementing an initially-string \"0\" `i` allows `i` to remain a string only in that\n\t\t\t// case, which will result in a \"00\" `matchedCount` that differs from `i` but is also\n\t\t\t// numerically zero.\n\t\t\tif ( bySet && i !== matchedCount ) {\n\t\t\t\tj = 0;\n\t\t\t\twhile ( (matcher = setMatchers[j++]) ) {\n\t\t\t\t\tmatcher( unmatched, setMatched, context, xml );\n\t\t\t\t}\n\n\t\t\t\tif ( seed ) {\n\t\t\t\t\t// Reintegrate element matches to eliminate the need for sorting\n\t\t\t\t\tif ( matchedCount > 0 ) {\n\t\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\t\tif ( !(unmatched[i] || setMatched[i]) ) {\n\t\t\t\t\t\t\t\tsetMatched[i] = pop.call( results );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Discard index placeholder values to get only actual matches\n\t\t\t\t\tsetMatched = condense( setMatched );\n\t\t\t\t}\n\n\t\t\t\t// Add matches to results\n\t\t\t\tpush.apply( results, setMatched );\n\n\t\t\t\t// Seedless set matches succeeding multiple successful matchers stipulate sorting\n\t\t\t\tif ( outermost && !seed && setMatched.length > 0 &&\n\t\t\t\t\t( matchedCount + setMatchers.length ) > 1 ) {\n\n\t\t\t\t\tSizzle.uniqueSort( results );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Override manipulation of globals by nested matchers\n\t\t\tif ( outermost ) {\n\t\t\t\tdirruns = dirrunsUnique;\n\t\t\t\toutermostContext = contextBackup;\n\t\t\t}\n\n\t\t\treturn unmatched;\n\t\t};\n\n\treturn bySet ?\n\t\tmarkFunction( superMatcher ) :\n\t\tsuperMatcher;\n}\n\ncompile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {\n\tvar i,\n\t\tsetMatchers = [],\n\t\telementMatchers = [],\n\t\tcached = compilerCache[ selector + \" \" ];\n\n\tif ( !cached ) {\n\t\t// Generate a function of recursive functions that can be used to check each element\n\t\tif ( !match ) {\n\t\t\tmatch = tokenize( selector );\n\t\t}\n\t\ti = match.length;\n\t\twhile ( i-- ) {\n\t\t\tcached = matcherFromTokens( match[i] );\n\t\t\tif ( cached[ expando ] ) {\n\t\t\t\tsetMatchers.push( cached );\n\t\t\t} else {\n\t\t\t\telementMatchers.push( cached );\n\t\t\t}\n\t\t}\n\n\t\t// Cache the compiled function\n\t\tcached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );\n\n\t\t// Save selector and tokenization\n\t\tcached.selector = selector;\n\t}\n\treturn cached;\n};\n\n/**\n * A low-level selection function that works with Sizzle's compiled\n *  selector functions\n * @param {String|Function} selector A selector or a pre-compiled\n *  selector function built with Sizzle.compile\n * @param {Element} context\n * @param {Array} [results]\n * @param {Array} [seed] A set of elements to match against\n */\nselect = Sizzle.select = function( selector, context, results, seed ) {\n\tvar i, tokens, token, type, find,\n\t\tcompiled = typeof selector === \"function\" && selector,\n\t\tmatch = !seed && tokenize( (selector = compiled.selector || selector) );\n\n\tresults = results || [];\n\n\t// Try to minimize operations if there is only one selector in the list and no seed\n\t// (the latter of which guarantees us context)\n\tif ( match.length === 1 ) {\n\n\t\t// Reduce context if the leading compound selector is an ID\n\t\ttokens = match[0] = match[0].slice( 0 );\n\t\tif ( tokens.length > 2 && (token = tokens[0]).type === \"ID\" &&\n\t\t\t\tsupport.getById && context.nodeType === 9 && documentIsHTML &&\n\t\t\t\tExpr.relative[ tokens[1].type ] ) {\n\n\t\t\tcontext = ( Expr.find[\"ID\"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0];\n\t\t\tif ( !context ) {\n\t\t\t\treturn results;\n\n\t\t\t// Precompiled matchers will still verify ancestry, so step up a level\n\t\t\t} else if ( compiled ) {\n\t\t\t\tcontext = context.parentNode;\n\t\t\t}\n\n\t\t\tselector = selector.slice( tokens.shift().value.length );\n\t\t}\n\n\t\t// Fetch a seed set for right-to-left matching\n\t\ti = matchExpr[\"needsContext\"].test( selector ) ? 0 : tokens.length;\n\t\twhile ( i-- ) {\n\t\t\ttoken = tokens[i];\n\n\t\t\t// Abort if we hit a combinator\n\t\t\tif ( Expr.relative[ (type = token.type) ] ) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tif ( (find = Expr.find[ type ]) ) {\n\t\t\t\t// Search, expanding context for leading sibling combinators\n\t\t\t\tif ( (seed = find(\n\t\t\t\t\ttoken.matches[0].replace( runescape, funescape ),\n\t\t\t\t\trsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context\n\t\t\t\t)) ) {\n\n\t\t\t\t\t// If seed is empty or no tokens remain, we can return early\n\t\t\t\t\ttokens.splice( i, 1 );\n\t\t\t\t\tselector = seed.length && toSelector( tokens );\n\t\t\t\t\tif ( !selector ) {\n\t\t\t\t\t\tpush.apply( results, seed );\n\t\t\t\t\t\treturn results;\n\t\t\t\t\t}\n\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Compile and execute a filtering function if one is not provided\n\t// Provide `match` to avoid retokenization if we modified the selector above\n\t( compiled || compile( selector, match ) )(\n\t\tseed,\n\t\tcontext,\n\t\t!documentIsHTML,\n\t\tresults,\n\t\t!context || rsibling.test( selector ) && testContext( context.parentNode ) || context\n\t);\n\treturn results;\n};\n\n// One-time assignments\n\n// Sort stability\nsupport.sortStable = expando.split(\"\").sort( sortOrder ).join(\"\") === expando;\n\n// Support: Chrome 14-35+\n// Always assume duplicates if they aren't passed to the comparison function\nsupport.detectDuplicates = !!hasDuplicate;\n\n// Initialize against the default document\nsetDocument();\n\n// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)\n// Detached nodes confoundingly follow *each other*\nsupport.sortDetached = assert(function( div1 ) {\n\t// Should return 1, but returns 4 (following)\n\treturn div1.compareDocumentPosition( document.createElement(\"div\") ) & 1;\n});\n\n// Support: IE<8\n// Prevent attribute/property \"interpolation\"\n// http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx\nif ( !assert(function( div ) {\n\tdiv.innerHTML = \"<a href='#'></a>\";\n\treturn div.firstChild.getAttribute(\"href\") === \"#\" ;\n}) ) {\n\taddHandle( \"type|href|height|width\", function( elem, name, isXML ) {\n\t\tif ( !isXML ) {\n\t\t\treturn elem.getAttribute( name, name.toLowerCase() === \"type\" ? 1 : 2 );\n\t\t}\n\t});\n}\n\n// Support: IE<9\n// Use defaultValue in place of getAttribute(\"value\")\nif ( !support.attributes || !assert(function( div ) {\n\tdiv.innerHTML = \"<input/>\";\n\tdiv.firstChild.setAttribute( \"value\", \"\" );\n\treturn div.firstChild.getAttribute( \"value\" ) === \"\";\n}) ) {\n\taddHandle( \"value\", function( elem, name, isXML ) {\n\t\tif ( !isXML && elem.nodeName.toLowerCase() === \"input\" ) {\n\t\t\treturn elem.defaultValue;\n\t\t}\n\t});\n}\n\n// Support: IE<9\n// Use getAttributeNode to fetch booleans when getAttribute lies\nif ( !assert(function( div ) {\n\treturn div.getAttribute(\"disabled\") == null;\n}) ) {\n\taddHandle( booleans, function( elem, name, isXML ) {\n\t\tvar val;\n\t\tif ( !isXML ) {\n\t\t\treturn elem[ name ] === true ? name.toLowerCase() :\n\t\t\t\t\t(val = elem.getAttributeNode( name )) && val.specified ?\n\t\t\t\t\tval.value :\n\t\t\t\tnull;\n\t\t}\n\t});\n}\n\nreturn Sizzle;\n\n})( window );\n\n\n\njQuery.find = Sizzle;\njQuery.expr = Sizzle.selectors;\njQuery.expr[ \":\" ] = jQuery.expr.pseudos;\njQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;\njQuery.text = Sizzle.getText;\njQuery.isXMLDoc = Sizzle.isXML;\njQuery.contains = Sizzle.contains;\n\n\n\nvar dir = function( elem, dir, until ) {\n\tvar matched = [],\n\t\ttruncate = until !== undefined;\n\n\twhile ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) {\n\t\tif ( elem.nodeType === 1 ) {\n\t\t\tif ( truncate && jQuery( elem ).is( until ) ) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tmatched.push( elem );\n\t\t}\n\t}\n\treturn matched;\n};\n\n\nvar siblings = function( n, elem ) {\n\tvar matched = [];\n\n\tfor ( ; n; n = n.nextSibling ) {\n\t\tif ( n.nodeType === 1 && n !== elem ) {\n\t\t\tmatched.push( n );\n\t\t}\n\t}\n\n\treturn matched;\n};\n\n\nvar rneedsContext = jQuery.expr.match.needsContext;\n\nvar rsingleTag = ( /^<([\\w-]+)\\s*\\/?>(?:<\\/\\1>|)$/ );\n\n\n\nvar risSimple = /^.[^:#\\[\\.,]*$/;\n\n// Implement the identical functionality for filter and not\nfunction winnow( elements, qualifier, not ) {\n\tif ( jQuery.isFunction( qualifier ) ) {\n\t\treturn jQuery.grep( elements, function( elem, i ) {\n\t\t\t/* jshint -W018 */\n\t\t\treturn !!qualifier.call( elem, i, elem ) !== not;\n\t\t} );\n\n\t}\n\n\tif ( qualifier.nodeType ) {\n\t\treturn jQuery.grep( elements, function( elem ) {\n\t\t\treturn ( elem === qualifier ) !== not;\n\t\t} );\n\n\t}\n\n\tif ( typeof qualifier === \"string\" ) {\n\t\tif ( risSimple.test( qualifier ) ) {\n\t\t\treturn jQuery.filter( qualifier, elements, not );\n\t\t}\n\n\t\tqualifier = jQuery.filter( qualifier, elements );\n\t}\n\n\treturn jQuery.grep( elements, function( elem ) {\n\t\treturn ( indexOf.call( qualifier, elem ) > -1 ) !== not;\n\t} );\n}\n\njQuery.filter = function( expr, elems, not ) {\n\tvar elem = elems[ 0 ];\n\n\tif ( not ) {\n\t\texpr = \":not(\" + expr + \")\";\n\t}\n\n\treturn elems.length === 1 && elem.nodeType === 1 ?\n\t\tjQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [] :\n\t\tjQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {\n\t\t\treturn elem.nodeType === 1;\n\t\t} ) );\n};\n\njQuery.fn.extend( {\n\tfind: function( selector ) {\n\t\tvar i,\n\t\t\tlen = this.length,\n\t\t\tret = [],\n\t\t\tself = this;\n\n\t\tif ( typeof selector !== \"string\" ) {\n\t\t\treturn this.pushStack( jQuery( selector ).filter( function() {\n\t\t\t\tfor ( i = 0; i < len; i++ ) {\n\t\t\t\t\tif ( jQuery.contains( self[ i ], this ) ) {\n\t\t\t\t\t\treturn true;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} ) );\n\t\t}\n\n\t\tfor ( i = 0; i < len; i++ ) {\n\t\t\tjQuery.find( selector, self[ i ], ret );\n\t\t}\n\n\t\t// Needed because $( selector, context ) becomes $( context ).find( selector )\n\t\tret = this.pushStack( len > 1 ? jQuery.unique( ret ) : ret );\n\t\tret.selector = this.selector ? this.selector + \" \" + selector : selector;\n\t\treturn ret;\n\t},\n\tfilter: function( selector ) {\n\t\treturn this.pushStack( winnow( this, selector || [], false ) );\n\t},\n\tnot: function( selector ) {\n\t\treturn this.pushStack( winnow( this, selector || [], true ) );\n\t},\n\tis: function( selector ) {\n\t\treturn !!winnow(\n\t\t\tthis,\n\n\t\t\t// If this is a positional/relative selector, check membership in the returned set\n\t\t\t// so $(\"p:first\").is(\"p:last\") won't return true for a doc with two \"p\".\n\t\t\ttypeof selector === \"string\" && rneedsContext.test( selector ) ?\n\t\t\t\tjQuery( selector ) :\n\t\t\t\tselector || [],\n\t\t\tfalse\n\t\t).length;\n\t}\n} );\n\n\n// Initialize a jQuery object\n\n\n// A central reference to the root jQuery(document)\nvar rootjQuery,\n\n\t// A simple way to check for HTML strings\n\t// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)\n\t// Strict HTML recognition (#11290: must start with <)\n\trquickExpr = /^(?:\\s*(<[\\w\\W]+>)[^>]*|#([\\w-]*))$/,\n\n\tinit = jQuery.fn.init = function( selector, context, root ) {\n\t\tvar match, elem;\n\n\t\t// HANDLE: $(\"\"), $(null), $(undefined), $(false)\n\t\tif ( !selector ) {\n\t\t\treturn this;\n\t\t}\n\n\t\t// Method init() accepts an alternate rootjQuery\n\t\t// so migrate can support jQuery.sub (gh-2101)\n\t\troot = root || rootjQuery;\n\n\t\t// Handle HTML strings\n\t\tif ( typeof selector === \"string\" ) {\n\t\t\tif ( selector[ 0 ] === \"<\" &&\n\t\t\t\tselector[ selector.length - 1 ] === \">\" &&\n\t\t\t\tselector.length >= 3 ) {\n\n\t\t\t\t// Assume that strings that start and end with <> are HTML and skip the regex check\n\t\t\t\tmatch = [ null, selector, null ];\n\n\t\t\t} else {\n\t\t\t\tmatch = rquickExpr.exec( selector );\n\t\t\t}\n\n\t\t\t// Match html or make sure no context is specified for #id\n\t\t\tif ( match && ( match[ 1 ] || !context ) ) {\n\n\t\t\t\t// HANDLE: $(html) -> $(array)\n\t\t\t\tif ( match[ 1 ] ) {\n\t\t\t\t\tcontext = context instanceof jQuery ? context[ 0 ] : context;\n\n\t\t\t\t\t// Option to run scripts is true for back-compat\n\t\t\t\t\t// Intentionally let the error be thrown if parseHTML is not present\n\t\t\t\t\tjQuery.merge( this, jQuery.parseHTML(\n\t\t\t\t\t\tmatch[ 1 ],\n\t\t\t\t\t\tcontext && context.nodeType ? context.ownerDocument || context : document,\n\t\t\t\t\t\ttrue\n\t\t\t\t\t) );\n\n\t\t\t\t\t// HANDLE: $(html, props)\n\t\t\t\t\tif ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) {\n\t\t\t\t\t\tfor ( match in context ) {\n\n\t\t\t\t\t\t\t// Properties of context are called as methods if possible\n\t\t\t\t\t\t\tif ( jQuery.isFunction( this[ match ] ) ) {\n\t\t\t\t\t\t\t\tthis[ match ]( context[ match ] );\n\n\t\t\t\t\t\t\t// ...and otherwise set as attributes\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tthis.attr( match, context[ match ] );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\treturn this;\n\n\t\t\t\t// HANDLE: $(#id)\n\t\t\t\t} else {\n\t\t\t\t\telem = document.getElementById( match[ 2 ] );\n\n\t\t\t\t\t// Support: Blackberry 4.6\n\t\t\t\t\t// gEBID returns nodes no longer in the document (#6963)\n\t\t\t\t\tif ( elem && elem.parentNode ) {\n\n\t\t\t\t\t\t// Inject the element directly into the jQuery object\n\t\t\t\t\t\tthis.length = 1;\n\t\t\t\t\t\tthis[ 0 ] = elem;\n\t\t\t\t\t}\n\n\t\t\t\t\tthis.context = document;\n\t\t\t\t\tthis.selector = selector;\n\t\t\t\t\treturn this;\n\t\t\t\t}\n\n\t\t\t// HANDLE: $(expr, $(...))\n\t\t\t} else if ( !context || context.jquery ) {\n\t\t\t\treturn ( context || root ).find( selector );\n\n\t\t\t// HANDLE: $(expr, context)\n\t\t\t// (which is just equivalent to: $(context).find(expr)\n\t\t\t} else {\n\t\t\t\treturn this.constructor( context ).find( selector );\n\t\t\t}\n\n\t\t// HANDLE: $(DOMElement)\n\t\t} else if ( selector.nodeType ) {\n\t\t\tthis.context = this[ 0 ] = selector;\n\t\t\tthis.length = 1;\n\t\t\treturn this;\n\n\t\t// HANDLE: $(function)\n\t\t// Shortcut for document ready\n\t\t} else if ( jQuery.isFunction( selector ) ) {\n\t\t\treturn root.ready !== undefined ?\n\t\t\t\troot.ready( selector ) :\n\n\t\t\t\t// Execute immediately if ready is not present\n\t\t\t\tselector( jQuery );\n\t\t}\n\n\t\tif ( selector.selector !== undefined ) {\n\t\t\tthis.selector = selector.selector;\n\t\t\tthis.context = selector.context;\n\t\t}\n\n\t\treturn jQuery.makeArray( selector, this );\n\t};\n\n// Give the init function the jQuery prototype for later instantiation\ninit.prototype = jQuery.fn;\n\n// Initialize central reference\nrootjQuery = jQuery( document );\n\n\nvar rparentsprev = /^(?:parents|prev(?:Until|All))/,\n\n\t// Methods guaranteed to produce a unique set when starting from a unique set\n\tguaranteedUnique = {\n\t\tchildren: true,\n\t\tcontents: true,\n\t\tnext: true,\n\t\tprev: true\n\t};\n\njQuery.fn.extend( {\n\thas: function( target ) {\n\t\tvar targets = jQuery( target, this ),\n\t\t\tl = targets.length;\n\n\t\treturn this.filter( function() {\n\t\t\tvar i = 0;\n\t\t\tfor ( ; i < l; i++ ) {\n\t\t\t\tif ( jQuery.contains( this, targets[ i ] ) ) {\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t}\n\t\t} );\n\t},\n\n\tclosest: function( selectors, context ) {\n\t\tvar cur,\n\t\t\ti = 0,\n\t\t\tl = this.length,\n\t\t\tmatched = [],\n\t\t\tpos = rneedsContext.test( selectors ) || typeof selectors !== \"string\" ?\n\t\t\t\tjQuery( selectors, context || this.context ) :\n\t\t\t\t0;\n\n\t\tfor ( ; i < l; i++ ) {\n\t\t\tfor ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) {\n\n\t\t\t\t// Always skip document fragments\n\t\t\t\tif ( cur.nodeType < 11 && ( pos ?\n\t\t\t\t\tpos.index( cur ) > -1 :\n\n\t\t\t\t\t// Don't pass non-elements to Sizzle\n\t\t\t\t\tcur.nodeType === 1 &&\n\t\t\t\t\t\tjQuery.find.matchesSelector( cur, selectors ) ) ) {\n\n\t\t\t\t\tmatched.push( cur );\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched );\n\t},\n\n\t// Determine the position of an element within the set\n\tindex: function( elem ) {\n\n\t\t// No argument, return index in parent\n\t\tif ( !elem ) {\n\t\t\treturn ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;\n\t\t}\n\n\t\t// Index in selector\n\t\tif ( typeof elem === \"string\" ) {\n\t\t\treturn indexOf.call( jQuery( elem ), this[ 0 ] );\n\t\t}\n\n\t\t// Locate the position of the desired element\n\t\treturn indexOf.call( this,\n\n\t\t\t// If it receives a jQuery object, the first element is used\n\t\t\telem.jquery ? elem[ 0 ] : elem\n\t\t);\n\t},\n\n\tadd: function( selector, context ) {\n\t\treturn this.pushStack(\n\t\t\tjQuery.uniqueSort(\n\t\t\t\tjQuery.merge( this.get(), jQuery( selector, context ) )\n\t\t\t)\n\t\t);\n\t},\n\n\taddBack: function( selector ) {\n\t\treturn this.add( selector == null ?\n\t\t\tthis.prevObject : this.prevObject.filter( selector )\n\t\t);\n\t}\n} );\n\nfunction sibling( cur, dir ) {\n\twhile ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {}\n\treturn cur;\n}\n\njQuery.each( {\n\tparent: function( elem ) {\n\t\tvar parent = elem.parentNode;\n\t\treturn parent && parent.nodeType !== 11 ? parent : null;\n\t},\n\tparents: function( elem ) {\n\t\treturn dir( elem, \"parentNode\" );\n\t},\n\tparentsUntil: function( elem, i, until ) {\n\t\treturn dir( elem, \"parentNode\", until );\n\t},\n\tnext: function( elem ) {\n\t\treturn sibling( elem, \"nextSibling\" );\n\t},\n\tprev: function( elem ) {\n\t\treturn sibling( elem, \"previousSibling\" );\n\t},\n\tnextAll: function( elem ) {\n\t\treturn dir( elem, \"nextSibling\" );\n\t},\n\tprevAll: function( elem ) {\n\t\treturn dir( elem, \"previousSibling\" );\n\t},\n\tnextUntil: function( elem, i, until ) {\n\t\treturn dir( elem, \"nextSibling\", until );\n\t},\n\tprevUntil: function( elem, i, until ) {\n\t\treturn dir( elem, \"previousSibling\", until );\n\t},\n\tsiblings: function( elem ) {\n\t\treturn siblings( ( elem.parentNode || {} ).firstChild, elem );\n\t},\n\tchildren: function( elem ) {\n\t\treturn siblings( elem.firstChild );\n\t},\n\tcontents: function( elem ) {\n\t\treturn elem.contentDocument || jQuery.merge( [], elem.childNodes );\n\t}\n}, function( name, fn ) {\n\tjQuery.fn[ name ] = function( until, selector ) {\n\t\tvar matched = jQuery.map( this, fn, until );\n\n\t\tif ( name.slice( -5 ) !== \"Until\" ) {\n\t\t\tselector = until;\n\t\t}\n\n\t\tif ( selector && typeof selector === \"string\" ) {\n\t\t\tmatched = jQuery.filter( selector, matched );\n\t\t}\n\n\t\tif ( this.length > 1 ) {\n\n\t\t\t// Remove duplicates\n\t\t\tif ( !guaranteedUnique[ name ] ) {\n\t\t\t\tjQuery.uniqueSort( matched );\n\t\t\t}\n\n\t\t\t// Reverse order for parents* and prev-derivatives\n\t\t\tif ( rparentsprev.test( name ) ) {\n\t\t\t\tmatched.reverse();\n\t\t\t}\n\t\t}\n\n\t\treturn this.pushStack( matched );\n\t};\n} );\nvar rnotwhite = ( /\\S+/g );\n\n\n\n// Convert String-formatted options into Object-formatted ones\nfunction createOptions( options ) {\n\tvar object = {};\n\tjQuery.each( options.match( rnotwhite ) || [], function( _, flag ) {\n\t\tobject[ flag ] = true;\n\t} );\n\treturn object;\n}\n\n/*\n * Create a callback list using the following parameters:\n *\n *\toptions: an optional list of space-separated options that will change how\n *\t\t\tthe callback list behaves or a more traditional option object\n *\n * By default a callback list will act like an event callback list and can be\n * \"fired\" multiple times.\n *\n * Possible options:\n *\n *\tonce:\t\t\twill ensure the callback list can only be fired once (like a Deferred)\n *\n *\tmemory:\t\t\twill keep track of previous values and will call any callback added\n *\t\t\t\t\tafter the list has been fired right away with the latest \"memorized\"\n *\t\t\t\t\tvalues (like a Deferred)\n *\n *\tunique:\t\t\twill ensure a callback can only be added once (no duplicate in the list)\n *\n *\tstopOnFalse:\tinterrupt callings when a callback returns false\n *\n */\njQuery.Callbacks = function( options ) {\n\n\t// Convert options from String-formatted to Object-formatted if needed\n\t// (we check in cache first)\n\toptions = typeof options === \"string\" ?\n\t\tcreateOptions( options ) :\n\t\tjQuery.extend( {}, options );\n\n\tvar // Flag to know if list is currently firing\n\t\tfiring,\n\n\t\t// Last fire value for non-forgettable lists\n\t\tmemory,\n\n\t\t// Flag to know if list was already fired\n\t\tfired,\n\n\t\t// Flag to prevent firing\n\t\tlocked,\n\n\t\t// Actual callback list\n\t\tlist = [],\n\n\t\t// Queue of execution data for repeatable lists\n\t\tqueue = [],\n\n\t\t// Index of currently firing callback (modified by add/remove as needed)\n\t\tfiringIndex = -1,\n\n\t\t// Fire callbacks\n\t\tfire = function() {\n\n\t\t\t// Enforce single-firing\n\t\t\tlocked = options.once;\n\n\t\t\t// Execute callbacks for all pending executions,\n\t\t\t// respecting firingIndex overrides and runtime changes\n\t\t\tfired = firing = true;\n\t\t\tfor ( ; queue.length; firingIndex = -1 ) {\n\t\t\t\tmemory = queue.shift();\n\t\t\t\twhile ( ++firingIndex < list.length ) {\n\n\t\t\t\t\t// Run callback and check for early termination\n\t\t\t\t\tif ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false &&\n\t\t\t\t\t\toptions.stopOnFalse ) {\n\n\t\t\t\t\t\t// Jump to end and forget the data so .add doesn't re-fire\n\t\t\t\t\t\tfiringIndex = list.length;\n\t\t\t\t\t\tmemory = false;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Forget the data if we're done with it\n\t\t\tif ( !options.memory ) {\n\t\t\t\tmemory = false;\n\t\t\t}\n\n\t\t\tfiring = false;\n\n\t\t\t// Clean up if we're done firing for good\n\t\t\tif ( locked ) {\n\n\t\t\t\t// Keep an empty list if we have data for future add calls\n\t\t\t\tif ( memory ) {\n\t\t\t\t\tlist = [];\n\n\t\t\t\t// Otherwise, this object is spent\n\t\t\t\t} else {\n\t\t\t\t\tlist = \"\";\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\n\t\t// Actual Callbacks object\n\t\tself = {\n\n\t\t\t// Add a callback or a collection of callbacks to the list\n\t\t\tadd: function() {\n\t\t\t\tif ( list ) {\n\n\t\t\t\t\t// If we have memory from a past run, we should fire after adding\n\t\t\t\t\tif ( memory && !firing ) {\n\t\t\t\t\t\tfiringIndex = list.length - 1;\n\t\t\t\t\t\tqueue.push( memory );\n\t\t\t\t\t}\n\n\t\t\t\t\t( function add( args ) {\n\t\t\t\t\t\tjQuery.each( args, function( _, arg ) {\n\t\t\t\t\t\t\tif ( jQuery.isFunction( arg ) ) {\n\t\t\t\t\t\t\t\tif ( !options.unique || !self.has( arg ) ) {\n\t\t\t\t\t\t\t\t\tlist.push( arg );\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} else if ( arg && arg.length && jQuery.type( arg ) !== \"string\" ) {\n\n\t\t\t\t\t\t\t\t// Inspect recursively\n\t\t\t\t\t\t\t\tadd( arg );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} );\n\t\t\t\t\t} )( arguments );\n\n\t\t\t\t\tif ( memory && !firing ) {\n\t\t\t\t\t\tfire();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// Remove a callback from the list\n\t\t\tremove: function() {\n\t\t\t\tjQuery.each( arguments, function( _, arg ) {\n\t\t\t\t\tvar index;\n\t\t\t\t\twhile ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {\n\t\t\t\t\t\tlist.splice( index, 1 );\n\n\t\t\t\t\t\t// Handle firing indexes\n\t\t\t\t\t\tif ( index <= firingIndex ) {\n\t\t\t\t\t\t\tfiringIndex--;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} );\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// Check if a given callback is in the list.\n\t\t\t// If no argument is given, return whether or not list has callbacks attached.\n\t\t\thas: function( fn ) {\n\t\t\t\treturn fn ?\n\t\t\t\t\tjQuery.inArray( fn, list ) > -1 :\n\t\t\t\t\tlist.length > 0;\n\t\t\t},\n\n\t\t\t// Remove all callbacks from the list\n\t\t\tempty: function() {\n\t\t\t\tif ( list ) {\n\t\t\t\t\tlist = [];\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// Disable .fire and .add\n\t\t\t// Abort any current/pending executions\n\t\t\t// Clear all callbacks and values\n\t\t\tdisable: function() {\n\t\t\t\tlocked = queue = [];\n\t\t\t\tlist = memory = \"\";\n\t\t\t\treturn this;\n\t\t\t},\n\t\t\tdisabled: function() {\n\t\t\t\treturn !list;\n\t\t\t},\n\n\t\t\t// Disable .fire\n\t\t\t// Also disable .add unless we have memory (since it would have no effect)\n\t\t\t// Abort any pending executions\n\t\t\tlock: function() {\n\t\t\t\tlocked = queue = [];\n\t\t\t\tif ( !memory ) {\n\t\t\t\t\tlist = memory = \"\";\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t},\n\t\t\tlocked: function() {\n\t\t\t\treturn !!locked;\n\t\t\t},\n\n\t\t\t// Call all callbacks with the given context and arguments\n\t\t\tfireWith: function( context, args ) {\n\t\t\t\tif ( !locked ) {\n\t\t\t\t\targs = args || [];\n\t\t\t\t\targs = [ context, args.slice ? args.slice() : args ];\n\t\t\t\t\tqueue.push( args );\n\t\t\t\t\tif ( !firing ) {\n\t\t\t\t\t\tfire();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// Call all the callbacks with the given arguments\n\t\t\tfire: function() {\n\t\t\t\tself.fireWith( this, arguments );\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// To know if the callbacks have already been called at least once\n\t\t\tfired: function() {\n\t\t\t\treturn !!fired;\n\t\t\t}\n\t\t};\n\n\treturn self;\n};\n\n\njQuery.extend( {\n\n\tDeferred: function( func ) {\n\t\tvar tuples = [\n\n\t\t\t\t// action, add listener, listener list, final state\n\t\t\t\t[ \"resolve\", \"done\", jQuery.Callbacks( \"once memory\" ), \"resolved\" ],\n\t\t\t\t[ \"reject\", \"fail\", jQuery.Callbacks( \"once memory\" ), \"rejected\" ],\n\t\t\t\t[ \"notify\", \"progress\", jQuery.Callbacks( \"memory\" ) ]\n\t\t\t],\n\t\t\tstate = \"pending\",\n\t\t\tpromise = {\n\t\t\t\tstate: function() {\n\t\t\t\t\treturn state;\n\t\t\t\t},\n\t\t\t\talways: function() {\n\t\t\t\t\tdeferred.done( arguments ).fail( arguments );\n\t\t\t\t\treturn this;\n\t\t\t\t},\n\t\t\t\tthen: function( /* fnDone, fnFail, fnProgress */ ) {\n\t\t\t\t\tvar fns = arguments;\n\t\t\t\t\treturn jQuery.Deferred( function( newDefer ) {\n\t\t\t\t\t\tjQuery.each( tuples, function( i, tuple ) {\n\t\t\t\t\t\t\tvar fn = jQuery.isFunction( fns[ i ] ) && fns[ i ];\n\n\t\t\t\t\t\t\t// deferred[ done | fail | progress ] for forwarding actions to newDefer\n\t\t\t\t\t\t\tdeferred[ tuple[ 1 ] ]( function() {\n\t\t\t\t\t\t\t\tvar returned = fn && fn.apply( this, arguments );\n\t\t\t\t\t\t\t\tif ( returned && jQuery.isFunction( returned.promise ) ) {\n\t\t\t\t\t\t\t\t\treturned.promise()\n\t\t\t\t\t\t\t\t\t\t.progress( newDefer.notify )\n\t\t\t\t\t\t\t\t\t\t.done( newDefer.resolve )\n\t\t\t\t\t\t\t\t\t\t.fail( newDefer.reject );\n\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\tnewDefer[ tuple[ 0 ] + \"With\" ](\n\t\t\t\t\t\t\t\t\t\tthis === promise ? newDefer.promise() : this,\n\t\t\t\t\t\t\t\t\t\tfn ? [ returned ] : arguments\n\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} );\n\t\t\t\t\t\t} );\n\t\t\t\t\t\tfns = null;\n\t\t\t\t\t} ).promise();\n\t\t\t\t},\n\n\t\t\t\t// Get a promise for this deferred\n\t\t\t\t// If obj is provided, the promise aspect is added to the object\n\t\t\t\tpromise: function( obj ) {\n\t\t\t\t\treturn obj != null ? jQuery.extend( obj, promise ) : promise;\n\t\t\t\t}\n\t\t\t},\n\t\t\tdeferred = {};\n\n\t\t// Keep pipe for back-compat\n\t\tpromise.pipe = promise.then;\n\n\t\t// Add list-specific methods\n\t\tjQuery.each( tuples, function( i, tuple ) {\n\t\t\tvar list = tuple[ 2 ],\n\t\t\t\tstateString = tuple[ 3 ];\n\n\t\t\t// promise[ done | fail | progress ] = list.add\n\t\t\tpromise[ tuple[ 1 ] ] = list.add;\n\n\t\t\t// Handle state\n\t\t\tif ( stateString ) {\n\t\t\t\tlist.add( function() {\n\n\t\t\t\t\t// state = [ resolved | rejected ]\n\t\t\t\t\tstate = stateString;\n\n\t\t\t\t// [ reject_list | resolve_list ].disable; progress_list.lock\n\t\t\t\t}, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock );\n\t\t\t}\n\n\t\t\t// deferred[ resolve | reject | notify ]\n\t\t\tdeferred[ tuple[ 0 ] ] = function() {\n\t\t\t\tdeferred[ tuple[ 0 ] + \"With\" ]( this === deferred ? promise : this, arguments );\n\t\t\t\treturn this;\n\t\t\t};\n\t\t\tdeferred[ tuple[ 0 ] + \"With\" ] = list.fireWith;\n\t\t} );\n\n\t\t// Make the deferred a promise\n\t\tpromise.promise( deferred );\n\n\t\t// Call given func if any\n\t\tif ( func ) {\n\t\t\tfunc.call( deferred, deferred );\n\t\t}\n\n\t\t// All done!\n\t\treturn deferred;\n\t},\n\n\t// Deferred helper\n\twhen: function( subordinate /* , ..., subordinateN */ ) {\n\t\tvar i = 0,\n\t\t\tresolveValues = slice.call( arguments ),\n\t\t\tlength = resolveValues.length,\n\n\t\t\t// the count of uncompleted subordinates\n\t\t\tremaining = length !== 1 ||\n\t\t\t\t( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0,\n\n\t\t\t// the master Deferred.\n\t\t\t// If resolveValues consist of only a single Deferred, just use that.\n\t\t\tdeferred = remaining === 1 ? subordinate : jQuery.Deferred(),\n\n\t\t\t// Update function for both resolve and progress values\n\t\t\tupdateFunc = function( i, contexts, values ) {\n\t\t\t\treturn function( value ) {\n\t\t\t\t\tcontexts[ i ] = this;\n\t\t\t\t\tvalues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;\n\t\t\t\t\tif ( values === progressValues ) {\n\t\t\t\t\t\tdeferred.notifyWith( contexts, values );\n\t\t\t\t\t} else if ( !( --remaining ) ) {\n\t\t\t\t\t\tdeferred.resolveWith( contexts, values );\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t\t},\n\n\t\t\tprogressValues, progressContexts, resolveContexts;\n\n\t\t// Add listeners to Deferred subordinates; treat others as resolved\n\t\tif ( length > 1 ) {\n\t\t\tprogressValues = new Array( length );\n\t\t\tprogressContexts = new Array( length );\n\t\t\tresolveContexts = new Array( length );\n\t\t\tfor ( ; i < length; i++ ) {\n\t\t\t\tif ( resolveValues[ i ] && jQuery.isFunction( resolveValues[ i ].promise ) ) {\n\t\t\t\t\tresolveValues[ i ].promise()\n\t\t\t\t\t\t.progress( updateFunc( i, progressContexts, progressValues ) )\n\t\t\t\t\t\t.done( updateFunc( i, resolveContexts, resolveValues ) )\n\t\t\t\t\t\t.fail( deferred.reject );\n\t\t\t\t} else {\n\t\t\t\t\t--remaining;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// If we're not waiting on anything, resolve the master\n\t\tif ( !remaining ) {\n\t\t\tdeferred.resolveWith( resolveContexts, resolveValues );\n\t\t}\n\n\t\treturn deferred.promise();\n\t}\n} );\n\n\n// The deferred used on DOM ready\nvar readyList;\n\njQuery.fn.ready = function( fn ) {\n\n\t// Add the callback\n\tjQuery.ready.promise().done( fn );\n\n\treturn this;\n};\n\njQuery.extend( {\n\n\t// Is the DOM ready to be used? Set to true once it occurs.\n\tisReady: false,\n\n\t// A counter to track how many items to wait for before\n\t// the ready event fires. See #6781\n\treadyWait: 1,\n\n\t// Hold (or release) the ready event\n\tholdReady: function( hold ) {\n\t\tif ( hold ) {\n\t\t\tjQuery.readyWait++;\n\t\t} else {\n\t\t\tjQuery.ready( true );\n\t\t}\n\t},\n\n\t// Handle when the DOM is ready\n\tready: function( wait ) {\n\n\t\t// Abort if there are pending holds or we're already ready\n\t\tif ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Remember that the DOM is ready\n\t\tjQuery.isReady = true;\n\n\t\t// If a normal DOM Ready event fired, decrement, and wait if need be\n\t\tif ( wait !== true && --jQuery.readyWait > 0 ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// If there are functions bound, to execute\n\t\treadyList.resolveWith( document, [ jQuery ] );\n\n\t\t// Trigger any bound ready events\n\t\tif ( jQuery.fn.triggerHandler ) {\n\t\t\tjQuery( document ).triggerHandler( \"ready\" );\n\t\t\tjQuery( document ).off( \"ready\" );\n\t\t}\n\t}\n} );\n\n/**\n * The ready event handler and self cleanup method\n */\nfunction completed() {\n\tdocument.removeEventListener( \"DOMContentLoaded\", completed );\n\twindow.removeEventListener( \"load\", completed );\n\tjQuery.ready();\n}\n\njQuery.ready.promise = function( obj ) {\n\tif ( !readyList ) {\n\n\t\treadyList = jQuery.Deferred();\n\n\t\t// Catch cases where $(document).ready() is called\n\t\t// after the browser event has already occurred.\n\t\t// Support: IE9-10 only\n\t\t// Older IE sometimes signals \"interactive\" too soon\n\t\tif ( document.readyState === \"complete\" ||\n\t\t\t( document.readyState !== \"loading\" && !document.documentElement.doScroll ) ) {\n\n\t\t\t// Handle it asynchronously to allow scripts the opportunity to delay ready\n\t\t\twindow.setTimeout( jQuery.ready );\n\n\t\t} else {\n\n\t\t\t// Use the handy event callback\n\t\t\tdocument.addEventListener( \"DOMContentLoaded\", completed );\n\n\t\t\t// A fallback to window.onload, that will always work\n\t\t\twindow.addEventListener( \"load\", completed );\n\t\t}\n\t}\n\treturn readyList.promise( obj );\n};\n\n// Kick off the DOM ready check even if the user does not\njQuery.ready.promise();\n\n\n\n\n// Multifunctional method to get and set values of a collection\n// The value/s can optionally be executed if it's a function\nvar access = function( elems, fn, key, value, chainable, emptyGet, raw ) {\n\tvar i = 0,\n\t\tlen = elems.length,\n\t\tbulk = key == null;\n\n\t// Sets many values\n\tif ( jQuery.type( key ) === \"object\" ) {\n\t\tchainable = true;\n\t\tfor ( i in key ) {\n\t\t\taccess( elems, fn, i, key[ i ], true, emptyGet, raw );\n\t\t}\n\n\t// Sets one value\n\t} else if ( value !== undefined ) {\n\t\tchainable = true;\n\n\t\tif ( !jQuery.isFunction( value ) ) {\n\t\t\traw = true;\n\t\t}\n\n\t\tif ( bulk ) {\n\n\t\t\t// Bulk operations run against the entire set\n\t\t\tif ( raw ) {\n\t\t\t\tfn.call( elems, value );\n\t\t\t\tfn = null;\n\n\t\t\t// ...except when executing function values\n\t\t\t} else {\n\t\t\t\tbulk = fn;\n\t\t\t\tfn = function( elem, key, value ) {\n\t\t\t\t\treturn bulk.call( jQuery( elem ), value );\n\t\t\t\t};\n\t\t\t}\n\t\t}\n\n\t\tif ( fn ) {\n\t\t\tfor ( ; i < len; i++ ) {\n\t\t\t\tfn(\n\t\t\t\t\telems[ i ], key, raw ?\n\t\t\t\t\tvalue :\n\t\t\t\t\tvalue.call( elems[ i ], i, fn( elems[ i ], key ) )\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\t}\n\n\treturn chainable ?\n\t\telems :\n\n\t\t// Gets\n\t\tbulk ?\n\t\t\tfn.call( elems ) :\n\t\t\tlen ? fn( elems[ 0 ], key ) : emptyGet;\n};\nvar acceptData = function( owner ) {\n\n\t// Accepts only:\n\t//  - Node\n\t//    - Node.ELEMENT_NODE\n\t//    - Node.DOCUMENT_NODE\n\t//  - Object\n\t//    - Any\n\t/* jshint -W018 */\n\treturn owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType );\n};\n\n\n\n\nfunction Data() {\n\tthis.expando = jQuery.expando + Data.uid++;\n}\n\nData.uid = 1;\n\nData.prototype = {\n\n\tregister: function( owner, initial ) {\n\t\tvar value = initial || {};\n\n\t\t// If it is a node unlikely to be stringify-ed or looped over\n\t\t// use plain assignment\n\t\tif ( owner.nodeType ) {\n\t\t\towner[ this.expando ] = value;\n\n\t\t// Otherwise secure it in a non-enumerable, non-writable property\n\t\t// configurability must be true to allow the property to be\n\t\t// deleted with the delete operator\n\t\t} else {\n\t\t\tObject.defineProperty( owner, this.expando, {\n\t\t\t\tvalue: value,\n\t\t\t\twritable: true,\n\t\t\t\tconfigurable: true\n\t\t\t} );\n\t\t}\n\t\treturn owner[ this.expando ];\n\t},\n\tcache: function( owner ) {\n\n\t\t// We can accept data for non-element nodes in modern browsers,\n\t\t// but we should not, see #8335.\n\t\t// Always return an empty object.\n\t\tif ( !acceptData( owner ) ) {\n\t\t\treturn {};\n\t\t}\n\n\t\t// Check if the owner object already has a cache\n\t\tvar value = owner[ this.expando ];\n\n\t\t// If not, create one\n\t\tif ( !value ) {\n\t\t\tvalue = {};\n\n\t\t\t// We can accept data for non-element nodes in modern browsers,\n\t\t\t// but we should not, see #8335.\n\t\t\t// Always return an empty object.\n\t\t\tif ( acceptData( owner ) ) {\n\n\t\t\t\t// If it is a node unlikely to be stringify-ed or looped over\n\t\t\t\t// use plain assignment\n\t\t\t\tif ( owner.nodeType ) {\n\t\t\t\t\towner[ this.expando ] = value;\n\n\t\t\t\t// Otherwise secure it in a non-enumerable property\n\t\t\t\t// configurable must be true to allow the property to be\n\t\t\t\t// deleted when data is removed\n\t\t\t\t} else {\n\t\t\t\t\tObject.defineProperty( owner, this.expando, {\n\t\t\t\t\t\tvalue: value,\n\t\t\t\t\t\tconfigurable: true\n\t\t\t\t\t} );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn value;\n\t},\n\tset: function( owner, data, value ) {\n\t\tvar prop,\n\t\t\tcache = this.cache( owner );\n\n\t\t// Handle: [ owner, key, value ] args\n\t\tif ( typeof data === \"string\" ) {\n\t\t\tcache[ data ] = value;\n\n\t\t// Handle: [ owner, { properties } ] args\n\t\t} else {\n\n\t\t\t// Copy the properties one-by-one to the cache object\n\t\t\tfor ( prop in data ) {\n\t\t\t\tcache[ prop ] = data[ prop ];\n\t\t\t}\n\t\t}\n\t\treturn cache;\n\t},\n\tget: function( owner, key ) {\n\t\treturn key === undefined ?\n\t\t\tthis.cache( owner ) :\n\t\t\towner[ this.expando ] && owner[ this.expando ][ key ];\n\t},\n\taccess: function( owner, key, value ) {\n\t\tvar stored;\n\n\t\t// In cases where either:\n\t\t//\n\t\t//   1. No key was specified\n\t\t//   2. A string key was specified, but no value provided\n\t\t//\n\t\t// Take the \"read\" path and allow the get method to determine\n\t\t// which value to return, respectively either:\n\t\t//\n\t\t//   1. The entire cache object\n\t\t//   2. The data stored at the key\n\t\t//\n\t\tif ( key === undefined ||\n\t\t\t\t( ( key && typeof key === \"string\" ) && value === undefined ) ) {\n\n\t\t\tstored = this.get( owner, key );\n\n\t\t\treturn stored !== undefined ?\n\t\t\t\tstored : this.get( owner, jQuery.camelCase( key ) );\n\t\t}\n\n\t\t// When the key is not a string, or both a key and value\n\t\t// are specified, set or extend (existing objects) with either:\n\t\t//\n\t\t//   1. An object of properties\n\t\t//   2. A key and value\n\t\t//\n\t\tthis.set( owner, key, value );\n\n\t\t// Since the \"set\" path can have two possible entry points\n\t\t// return the expected data based on which path was taken[*]\n\t\treturn value !== undefined ? value : key;\n\t},\n\tremove: function( owner, key ) {\n\t\tvar i, name, camel,\n\t\t\tcache = owner[ this.expando ];\n\n\t\tif ( cache === undefined ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( key === undefined ) {\n\t\t\tthis.register( owner );\n\n\t\t} else {\n\n\t\t\t// Support array or space separated string of keys\n\t\t\tif ( jQuery.isArray( key ) ) {\n\n\t\t\t\t// If \"name\" is an array of keys...\n\t\t\t\t// When data is initially created, via (\"key\", \"val\") signature,\n\t\t\t\t// keys will be converted to camelCase.\n\t\t\t\t// Since there is no way to tell _how_ a key was added, remove\n\t\t\t\t// both plain key and camelCase key. #12786\n\t\t\t\t// This will only penalize the array argument path.\n\t\t\t\tname = key.concat( key.map( jQuery.camelCase ) );\n\t\t\t} else {\n\t\t\t\tcamel = jQuery.camelCase( key );\n\n\t\t\t\t// Try the string as a key before any manipulation\n\t\t\t\tif ( key in cache ) {\n\t\t\t\t\tname = [ key, camel ];\n\t\t\t\t} else {\n\n\t\t\t\t\t// If a key with the spaces exists, use it.\n\t\t\t\t\t// Otherwise, create an array by matching non-whitespace\n\t\t\t\t\tname = camel;\n\t\t\t\t\tname = name in cache ?\n\t\t\t\t\t\t[ name ] : ( name.match( rnotwhite ) || [] );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\ti = name.length;\n\n\t\t\twhile ( i-- ) {\n\t\t\t\tdelete cache[ name[ i ] ];\n\t\t\t}\n\t\t}\n\n\t\t// Remove the expando if there's no more data\n\t\tif ( key === undefined || jQuery.isEmptyObject( cache ) ) {\n\n\t\t\t// Support: Chrome <= 35-45+\n\t\t\t// Webkit & Blink performance suffers when deleting properties\n\t\t\t// from DOM nodes, so set to undefined instead\n\t\t\t// https://code.google.com/p/chromium/issues/detail?id=378607\n\t\t\tif ( owner.nodeType ) {\n\t\t\t\towner[ this.expando ] = undefined;\n\t\t\t} else {\n\t\t\t\tdelete owner[ this.expando ];\n\t\t\t}\n\t\t}\n\t},\n\thasData: function( owner ) {\n\t\tvar cache = owner[ this.expando ];\n\t\treturn cache !== undefined && !jQuery.isEmptyObject( cache );\n\t}\n};\nvar dataPriv = new Data();\n\nvar dataUser = new Data();\n\n\n\n//\tImplementation Summary\n//\n//\t1. Enforce API surface and semantic compatibility with 1.9.x branch\n//\t2. Improve the module's maintainability by reducing the storage\n//\t\tpaths to a single mechanism.\n//\t3. Use the same single mechanism to support \"private\" and \"user\" data.\n//\t4. _Never_ expose \"private\" data to user code (TODO: Drop _data, _removeData)\n//\t5. Avoid exposing implementation details on user objects (eg. expando properties)\n//\t6. Provide a clear path for implementation upgrade to WeakMap in 2014\n\nvar rbrace = /^(?:\\{[\\w\\W]*\\}|\\[[\\w\\W]*\\])$/,\n\trmultiDash = /[A-Z]/g;\n\nfunction dataAttr( elem, key, data ) {\n\tvar name;\n\n\t// If nothing was found internally, try to fetch any\n\t// data from the HTML5 data-* attribute\n\tif ( data === undefined && elem.nodeType === 1 ) {\n\t\tname = \"data-\" + key.replace( rmultiDash, \"-$&\" ).toLowerCase();\n\t\tdata = elem.getAttribute( name );\n\n\t\tif ( typeof data === \"string\" ) {\n\t\t\ttry {\n\t\t\t\tdata = data === \"true\" ? true :\n\t\t\t\t\tdata === \"false\" ? false :\n\t\t\t\t\tdata === \"null\" ? null :\n\n\t\t\t\t\t// Only convert to a number if it doesn't change the string\n\t\t\t\t\t+data + \"\" === data ? +data :\n\t\t\t\t\trbrace.test( data ) ? jQuery.parseJSON( data ) :\n\t\t\t\t\tdata;\n\t\t\t} catch ( e ) {}\n\n\t\t\t// Make sure we set the data so it isn't changed later\n\t\t\tdataUser.set( elem, key, data );\n\t\t} else {\n\t\t\tdata = undefined;\n\t\t}\n\t}\n\treturn data;\n}\n\njQuery.extend( {\n\thasData: function( elem ) {\n\t\treturn dataUser.hasData( elem ) || dataPriv.hasData( elem );\n\t},\n\n\tdata: function( elem, name, data ) {\n\t\treturn dataUser.access( elem, name, data );\n\t},\n\n\tremoveData: function( elem, name ) {\n\t\tdataUser.remove( elem, name );\n\t},\n\n\t// TODO: Now that all calls to _data and _removeData have been replaced\n\t// with direct calls to dataPriv methods, these can be deprecated.\n\t_data: function( elem, name, data ) {\n\t\treturn dataPriv.access( elem, name, data );\n\t},\n\n\t_removeData: function( elem, name ) {\n\t\tdataPriv.remove( elem, name );\n\t}\n} );\n\njQuery.fn.extend( {\n\tdata: function( key, value ) {\n\t\tvar i, name, data,\n\t\t\telem = this[ 0 ],\n\t\t\tattrs = elem && elem.attributes;\n\n\t\t// Gets all values\n\t\tif ( key === undefined ) {\n\t\t\tif ( this.length ) {\n\t\t\t\tdata = dataUser.get( elem );\n\n\t\t\t\tif ( elem.nodeType === 1 && !dataPriv.get( elem, \"hasDataAttrs\" ) ) {\n\t\t\t\t\ti = attrs.length;\n\t\t\t\t\twhile ( i-- ) {\n\n\t\t\t\t\t\t// Support: IE11+\n\t\t\t\t\t\t// The attrs elements can be null (#14894)\n\t\t\t\t\t\tif ( attrs[ i ] ) {\n\t\t\t\t\t\t\tname = attrs[ i ].name;\n\t\t\t\t\t\t\tif ( name.indexOf( \"data-\" ) === 0 ) {\n\t\t\t\t\t\t\t\tname = jQuery.camelCase( name.slice( 5 ) );\n\t\t\t\t\t\t\t\tdataAttr( elem, name, data[ name ] );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tdataPriv.set( elem, \"hasDataAttrs\", true );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn data;\n\t\t}\n\n\t\t// Sets multiple values\n\t\tif ( typeof key === \"object\" ) {\n\t\t\treturn this.each( function() {\n\t\t\t\tdataUser.set( this, key );\n\t\t\t} );\n\t\t}\n\n\t\treturn access( this, function( value ) {\n\t\t\tvar data, camelKey;\n\n\t\t\t// The calling jQuery object (element matches) is not empty\n\t\t\t// (and therefore has an element appears at this[ 0 ]) and the\n\t\t\t// `value` parameter was not undefined. An empty jQuery object\n\t\t\t// will result in `undefined` for elem = this[ 0 ] which will\n\t\t\t// throw an exception if an attempt to read a data cache is made.\n\t\t\tif ( elem && value === undefined ) {\n\n\t\t\t\t// Attempt to get data from the cache\n\t\t\t\t// with the key as-is\n\t\t\t\tdata = dataUser.get( elem, key ) ||\n\n\t\t\t\t\t// Try to find dashed key if it exists (gh-2779)\n\t\t\t\t\t// This is for 2.2.x only\n\t\t\t\t\tdataUser.get( elem, key.replace( rmultiDash, \"-$&\" ).toLowerCase() );\n\n\t\t\t\tif ( data !== undefined ) {\n\t\t\t\t\treturn data;\n\t\t\t\t}\n\n\t\t\t\tcamelKey = jQuery.camelCase( key );\n\n\t\t\t\t// Attempt to get data from the cache\n\t\t\t\t// with the key camelized\n\t\t\t\tdata = dataUser.get( elem, camelKey );\n\t\t\t\tif ( data !== undefined ) {\n\t\t\t\t\treturn data;\n\t\t\t\t}\n\n\t\t\t\t// Attempt to \"discover\" the data in\n\t\t\t\t// HTML5 custom data-* attrs\n\t\t\t\tdata = dataAttr( elem, camelKey, undefined );\n\t\t\t\tif ( data !== undefined ) {\n\t\t\t\t\treturn data;\n\t\t\t\t}\n\n\t\t\t\t// We tried really hard, but the data doesn't exist.\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// Set the data...\n\t\t\tcamelKey = jQuery.camelCase( key );\n\t\t\tthis.each( function() {\n\n\t\t\t\t// First, attempt to store a copy or reference of any\n\t\t\t\t// data that might've been store with a camelCased key.\n\t\t\t\tvar data = dataUser.get( this, camelKey );\n\n\t\t\t\t// For HTML5 data-* attribute interop, we have to\n\t\t\t\t// store property names with dashes in a camelCase form.\n\t\t\t\t// This might not apply to all properties...*\n\t\t\t\tdataUser.set( this, camelKey, value );\n\n\t\t\t\t// *... In the case of properties that might _actually_\n\t\t\t\t// have dashes, we need to also store a copy of that\n\t\t\t\t// unchanged property.\n\t\t\t\tif ( key.indexOf( \"-\" ) > -1 && data !== undefined ) {\n\t\t\t\t\tdataUser.set( this, key, value );\n\t\t\t\t}\n\t\t\t} );\n\t\t}, null, value, arguments.length > 1, null, true );\n\t},\n\n\tremoveData: function( key ) {\n\t\treturn this.each( function() {\n\t\t\tdataUser.remove( this, key );\n\t\t} );\n\t}\n} );\n\n\njQuery.extend( {\n\tqueue: function( elem, type, data ) {\n\t\tvar queue;\n\n\t\tif ( elem ) {\n\t\t\ttype = ( type || \"fx\" ) + \"queue\";\n\t\t\tqueue = dataPriv.get( elem, type );\n\n\t\t\t// Speed up dequeue by getting out quickly if this is just a lookup\n\t\t\tif ( data ) {\n\t\t\t\tif ( !queue || jQuery.isArray( data ) ) {\n\t\t\t\t\tqueue = dataPriv.access( elem, type, jQuery.makeArray( data ) );\n\t\t\t\t} else {\n\t\t\t\t\tqueue.push( data );\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn queue || [];\n\t\t}\n\t},\n\n\tdequeue: function( elem, type ) {\n\t\ttype = type || \"fx\";\n\n\t\tvar queue = jQuery.queue( elem, type ),\n\t\t\tstartLength = queue.length,\n\t\t\tfn = queue.shift(),\n\t\t\thooks = jQuery._queueHooks( elem, type ),\n\t\t\tnext = function() {\n\t\t\t\tjQuery.dequeue( elem, type );\n\t\t\t};\n\n\t\t// If the fx queue is dequeued, always remove the progress sentinel\n\t\tif ( fn === \"inprogress\" ) {\n\t\t\tfn = queue.shift();\n\t\t\tstartLength--;\n\t\t}\n\n\t\tif ( fn ) {\n\n\t\t\t// Add a progress sentinel to prevent the fx queue from being\n\t\t\t// automatically dequeued\n\t\t\tif ( type === \"fx\" ) {\n\t\t\t\tqueue.unshift( \"inprogress\" );\n\t\t\t}\n\n\t\t\t// Clear up the last queue stop function\n\t\t\tdelete hooks.stop;\n\t\t\tfn.call( elem, next, hooks );\n\t\t}\n\n\t\tif ( !startLength && hooks ) {\n\t\t\thooks.empty.fire();\n\t\t}\n\t},\n\n\t// Not public - generate a queueHooks object, or return the current one\n\t_queueHooks: function( elem, type ) {\n\t\tvar key = type + \"queueHooks\";\n\t\treturn dataPriv.get( elem, key ) || dataPriv.access( elem, key, {\n\t\t\tempty: jQuery.Callbacks( \"once memory\" ).add( function() {\n\t\t\t\tdataPriv.remove( elem, [ type + \"queue\", key ] );\n\t\t\t} )\n\t\t} );\n\t}\n} );\n\njQuery.fn.extend( {\n\tqueue: function( type, data ) {\n\t\tvar setter = 2;\n\n\t\tif ( typeof type !== \"string\" ) {\n\t\t\tdata = type;\n\t\t\ttype = \"fx\";\n\t\t\tsetter--;\n\t\t}\n\n\t\tif ( arguments.length < setter ) {\n\t\t\treturn jQuery.queue( this[ 0 ], type );\n\t\t}\n\n\t\treturn data === undefined ?\n\t\t\tthis :\n\t\t\tthis.each( function() {\n\t\t\t\tvar queue = jQuery.queue( this, type, data );\n\n\t\t\t\t// Ensure a hooks for this queue\n\t\t\t\tjQuery._queueHooks( this, type );\n\n\t\t\t\tif ( type === \"fx\" && queue[ 0 ] !== \"inprogress\" ) {\n\t\t\t\t\tjQuery.dequeue( this, type );\n\t\t\t\t}\n\t\t\t} );\n\t},\n\tdequeue: function( type ) {\n\t\treturn this.each( function() {\n\t\t\tjQuery.dequeue( this, type );\n\t\t} );\n\t},\n\tclearQueue: function( type ) {\n\t\treturn this.queue( type || \"fx\", [] );\n\t},\n\n\t// Get a promise resolved when queues of a certain type\n\t// are emptied (fx is the type by default)\n\tpromise: function( type, obj ) {\n\t\tvar tmp,\n\t\t\tcount = 1,\n\t\t\tdefer = jQuery.Deferred(),\n\t\t\telements = this,\n\t\t\ti = this.length,\n\t\t\tresolve = function() {\n\t\t\t\tif ( !( --count ) ) {\n\t\t\t\t\tdefer.resolveWith( elements, [ elements ] );\n\t\t\t\t}\n\t\t\t};\n\n\t\tif ( typeof type !== \"string\" ) {\n\t\t\tobj = type;\n\t\t\ttype = undefined;\n\t\t}\n\t\ttype = type || \"fx\";\n\n\t\twhile ( i-- ) {\n\t\t\ttmp = dataPriv.get( elements[ i ], type + \"queueHooks\" );\n\t\t\tif ( tmp && tmp.empty ) {\n\t\t\t\tcount++;\n\t\t\t\ttmp.empty.add( resolve );\n\t\t\t}\n\t\t}\n\t\tresolve();\n\t\treturn defer.promise( obj );\n\t}\n} );\nvar pnum = ( /[+-]?(?:\\d*\\.|)\\d+(?:[eE][+-]?\\d+|)/ ).source;\n\nvar rcssNum = new RegExp( \"^(?:([+-])=|)(\" + pnum + \")([a-z%]*)$\", \"i\" );\n\n\nvar cssExpand = [ \"Top\", \"Right\", \"Bottom\", \"Left\" ];\n\nvar isHidden = function( elem, el ) {\n\n\t\t// isHidden might be called from jQuery#filter function;\n\t\t// in that case, element will be second argument\n\t\telem = el || elem;\n\t\treturn jQuery.css( elem, \"display\" ) === \"none\" ||\n\t\t\t!jQuery.contains( elem.ownerDocument, elem );\n\t};\n\n\n\nfunction adjustCSS( elem, prop, valueParts, tween ) {\n\tvar adjusted,\n\t\tscale = 1,\n\t\tmaxIterations = 20,\n\t\tcurrentValue = tween ?\n\t\t\tfunction() { return tween.cur(); } :\n\t\t\tfunction() { return jQuery.css( elem, prop, \"\" ); },\n\t\tinitial = currentValue(),\n\t\tunit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? \"\" : \"px\" ),\n\n\t\t// Starting value computation is required for potential unit mismatches\n\t\tinitialInUnit = ( jQuery.cssNumber[ prop ] || unit !== \"px\" && +initial ) &&\n\t\t\trcssNum.exec( jQuery.css( elem, prop ) );\n\n\tif ( initialInUnit && initialInUnit[ 3 ] !== unit ) {\n\n\t\t// Trust units reported by jQuery.css\n\t\tunit = unit || initialInUnit[ 3 ];\n\n\t\t// Make sure we update the tween properties later on\n\t\tvalueParts = valueParts || [];\n\n\t\t// Iteratively approximate from a nonzero starting point\n\t\tinitialInUnit = +initial || 1;\n\n\t\tdo {\n\n\t\t\t// If previous iteration zeroed out, double until we get *something*.\n\t\t\t// Use string for doubling so we don't accidentally see scale as unchanged below\n\t\t\tscale = scale || \".5\";\n\n\t\t\t// Adjust and apply\n\t\t\tinitialInUnit = initialInUnit / scale;\n\t\t\tjQuery.style( elem, prop, initialInUnit + unit );\n\n\t\t// Update scale, tolerating zero or NaN from tween.cur()\n\t\t// Break the loop if scale is unchanged or perfect, or if we've just had enough.\n\t\t} while (\n\t\t\tscale !== ( scale = currentValue() / initial ) && scale !== 1 && --maxIterations\n\t\t);\n\t}\n\n\tif ( valueParts ) {\n\t\tinitialInUnit = +initialInUnit || +initial || 0;\n\n\t\t// Apply relative offset (+=/-=) if specified\n\t\tadjusted = valueParts[ 1 ] ?\n\t\t\tinitialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] :\n\t\t\t+valueParts[ 2 ];\n\t\tif ( tween ) {\n\t\t\ttween.unit = unit;\n\t\t\ttween.start = initialInUnit;\n\t\t\ttween.end = adjusted;\n\t\t}\n\t}\n\treturn adjusted;\n}\nvar rcheckableType = ( /^(?:checkbox|radio)$/i );\n\nvar rtagName = ( /<([\\w:-]+)/ );\n\nvar rscriptType = ( /^$|\\/(?:java|ecma)script/i );\n\n\n\n// We have to close these tags to support XHTML (#13200)\nvar wrapMap = {\n\n\t// Support: IE9\n\toption: [ 1, \"<select multiple='multiple'>\", \"</select>\" ],\n\n\t// XHTML parsers do not magically insert elements in the\n\t// same way that tag soup parsers do. So we cannot shorten\n\t// this by omitting <tbody> or other required elements.\n\tthead: [ 1, \"<table>\", \"</table>\" ],\n\tcol: [ 2, \"<table><colgroup>\", \"</colgroup></table>\" ],\n\ttr: [ 2, \"<table><tbody>\", \"</tbody></table>\" ],\n\ttd: [ 3, \"<table><tbody><tr>\", \"</tr></tbody></table>\" ],\n\n\t_default: [ 0, \"\", \"\" ]\n};\n\n// Support: IE9\nwrapMap.optgroup = wrapMap.option;\n\nwrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;\nwrapMap.th = wrapMap.td;\n\n\nfunction getAll( context, tag ) {\n\n\t// Support: IE9-11+\n\t// Use typeof to avoid zero-argument method invocation on host objects (#15151)\n\tvar ret = typeof context.getElementsByTagName !== \"undefined\" ?\n\t\t\tcontext.getElementsByTagName( tag || \"*\" ) :\n\t\t\ttypeof context.querySelectorAll !== \"undefined\" ?\n\t\t\t\tcontext.querySelectorAll( tag || \"*\" ) :\n\t\t\t[];\n\n\treturn tag === undefined || tag && jQuery.nodeName( context, tag ) ?\n\t\tjQuery.merge( [ context ], ret ) :\n\t\tret;\n}\n\n\n// Mark scripts as having already been evaluated\nfunction setGlobalEval( elems, refElements ) {\n\tvar i = 0,\n\t\tl = elems.length;\n\n\tfor ( ; i < l; i++ ) {\n\t\tdataPriv.set(\n\t\t\telems[ i ],\n\t\t\t\"globalEval\",\n\t\t\t!refElements || dataPriv.get( refElements[ i ], \"globalEval\" )\n\t\t);\n\t}\n}\n\n\nvar rhtml = /<|&#?\\w+;/;\n\nfunction buildFragment( elems, context, scripts, selection, ignored ) {\n\tvar elem, tmp, tag, wrap, contains, j,\n\t\tfragment = context.createDocumentFragment(),\n\t\tnodes = [],\n\t\ti = 0,\n\t\tl = elems.length;\n\n\tfor ( ; i < l; i++ ) {\n\t\telem = elems[ i ];\n\n\t\tif ( elem || elem === 0 ) {\n\n\t\t\t// Add nodes directly\n\t\t\tif ( jQuery.type( elem ) === \"object\" ) {\n\n\t\t\t\t// Support: Android<4.1, PhantomJS<2\n\t\t\t\t// push.apply(_, arraylike) throws on ancient WebKit\n\t\t\t\tjQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );\n\n\t\t\t// Convert non-html into a text node\n\t\t\t} else if ( !rhtml.test( elem ) ) {\n\t\t\t\tnodes.push( context.createTextNode( elem ) );\n\n\t\t\t// Convert html into DOM nodes\n\t\t\t} else {\n\t\t\t\ttmp = tmp || fragment.appendChild( context.createElement( \"div\" ) );\n\n\t\t\t\t// Deserialize a standard representation\n\t\t\t\ttag = ( rtagName.exec( elem ) || [ \"\", \"\" ] )[ 1 ].toLowerCase();\n\t\t\t\twrap = wrapMap[ tag ] || wrapMap._default;\n\t\t\t\ttmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ];\n\n\t\t\t\t// Descend through wrappers to the right content\n\t\t\t\tj = wrap[ 0 ];\n\t\t\t\twhile ( j-- ) {\n\t\t\t\t\ttmp = tmp.lastChild;\n\t\t\t\t}\n\n\t\t\t\t// Support: Android<4.1, PhantomJS<2\n\t\t\t\t// push.apply(_, arraylike) throws on ancient WebKit\n\t\t\t\tjQuery.merge( nodes, tmp.childNodes );\n\n\t\t\t\t// Remember the top-level container\n\t\t\t\ttmp = fragment.firstChild;\n\n\t\t\t\t// Ensure the created nodes are orphaned (#12392)\n\t\t\t\ttmp.textContent = \"\";\n\t\t\t}\n\t\t}\n\t}\n\n\t// Remove wrapper from fragment\n\tfragment.textContent = \"\";\n\n\ti = 0;\n\twhile ( ( elem = nodes[ i++ ] ) ) {\n\n\t\t// Skip elements already in the context collection (trac-4087)\n\t\tif ( selection && jQuery.inArray( elem, selection ) > -1 ) {\n\t\t\tif ( ignored ) {\n\t\t\t\tignored.push( elem );\n\t\t\t}\n\t\t\tcontinue;\n\t\t}\n\n\t\tcontains = jQuery.contains( elem.ownerDocument, elem );\n\n\t\t// Append to fragment\n\t\ttmp = getAll( fragment.appendChild( elem ), \"script\" );\n\n\t\t// Preserve script evaluation history\n\t\tif ( contains ) {\n\t\t\tsetGlobalEval( tmp );\n\t\t}\n\n\t\t// Capture executables\n\t\tif ( scripts ) {\n\t\t\tj = 0;\n\t\t\twhile ( ( elem = tmp[ j++ ] ) ) {\n\t\t\t\tif ( rscriptType.test( elem.type || \"\" ) ) {\n\t\t\t\t\tscripts.push( elem );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn fragment;\n}\n\n\n( function() {\n\tvar fragment = document.createDocumentFragment(),\n\t\tdiv = fragment.appendChild( document.createElement( \"div\" ) ),\n\t\tinput = document.createElement( \"input\" );\n\n\t// Support: Android 4.0-4.3, Safari<=5.1\n\t// Check state lost if the name is set (#11217)\n\t// Support: Windows Web Apps (WWA)\n\t// `name` and `type` must use .setAttribute for WWA (#14901)\n\tinput.setAttribute( \"type\", \"radio\" );\n\tinput.setAttribute( \"checked\", \"checked\" );\n\tinput.setAttribute( \"name\", \"t\" );\n\n\tdiv.appendChild( input );\n\n\t// Support: Safari<=5.1, Android<4.2\n\t// Older WebKit doesn't clone checked state correctly in fragments\n\tsupport.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;\n\n\t// Support: IE<=11+\n\t// Make sure textarea (and checkbox) defaultValue is properly cloned\n\tdiv.innerHTML = \"<textarea>x</textarea>\";\n\tsupport.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;\n} )();\n\n\nvar\n\trkeyEvent = /^key/,\n\trmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/,\n\trtypenamespace = /^([^.]*)(?:\\.(.+)|)/;\n\nfunction returnTrue() {\n\treturn true;\n}\n\nfunction returnFalse() {\n\treturn false;\n}\n\n// Support: IE9\n// See #13393 for more info\nfunction safeActiveElement() {\n\ttry {\n\t\treturn document.activeElement;\n\t} catch ( err ) { }\n}\n\nfunction on( elem, types, selector, data, fn, one ) {\n\tvar origFn, type;\n\n\t// Types can be a map of types/handlers\n\tif ( typeof types === \"object\" ) {\n\n\t\t// ( types-Object, selector, data )\n\t\tif ( typeof selector !== \"string\" ) {\n\n\t\t\t// ( types-Object, data )\n\t\t\tdata = data || selector;\n\t\t\tselector = undefined;\n\t\t}\n\t\tfor ( type in types ) {\n\t\t\ton( elem, type, selector, data, types[ type ], one );\n\t\t}\n\t\treturn elem;\n\t}\n\n\tif ( data == null && fn == null ) {\n\n\t\t// ( types, fn )\n\t\tfn = selector;\n\t\tdata = selector = undefined;\n\t} else if ( fn == null ) {\n\t\tif ( typeof selector === \"string\" ) {\n\n\t\t\t// ( types, selector, fn )\n\t\t\tfn = data;\n\t\t\tdata = undefined;\n\t\t} else {\n\n\t\t\t// ( types, data, fn )\n\t\t\tfn = data;\n\t\t\tdata = selector;\n\t\t\tselector = undefined;\n\t\t}\n\t}\n\tif ( fn === false ) {\n\t\tfn = returnFalse;\n\t} else if ( !fn ) {\n\t\treturn elem;\n\t}\n\n\tif ( one === 1 ) {\n\t\torigFn = fn;\n\t\tfn = function( event ) {\n\n\t\t\t// Can use an empty set, since event contains the info\n\t\t\tjQuery().off( event );\n\t\t\treturn origFn.apply( this, arguments );\n\t\t};\n\n\t\t// Use same guid so caller can remove using origFn\n\t\tfn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );\n\t}\n\treturn elem.each( function() {\n\t\tjQuery.event.add( this, types, fn, data, selector );\n\t} );\n}\n\n/*\n * Helper functions for managing events -- not part of the public interface.\n * Props to Dean Edwards' addEvent library for many of the ideas.\n */\njQuery.event = {\n\n\tglobal: {},\n\n\tadd: function( elem, types, handler, data, selector ) {\n\n\t\tvar handleObjIn, eventHandle, tmp,\n\t\t\tevents, t, handleObj,\n\t\t\tspecial, handlers, type, namespaces, origType,\n\t\t\telemData = dataPriv.get( elem );\n\n\t\t// Don't attach events to noData or text/comment nodes (but allow plain objects)\n\t\tif ( !elemData ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Caller can pass in an object of custom data in lieu of the handler\n\t\tif ( handler.handler ) {\n\t\t\thandleObjIn = handler;\n\t\t\thandler = handleObjIn.handler;\n\t\t\tselector = handleObjIn.selector;\n\t\t}\n\n\t\t// Make sure that the handler has a unique ID, used to find/remove it later\n\t\tif ( !handler.guid ) {\n\t\t\thandler.guid = jQuery.guid++;\n\t\t}\n\n\t\t// Init the element's event structure and main handler, if this is the first\n\t\tif ( !( events = elemData.events ) ) {\n\t\t\tevents = elemData.events = {};\n\t\t}\n\t\tif ( !( eventHandle = elemData.handle ) ) {\n\t\t\teventHandle = elemData.handle = function( e ) {\n\n\t\t\t\t// Discard the second event of a jQuery.event.trigger() and\n\t\t\t\t// when an event is called after a page has unloaded\n\t\t\t\treturn typeof jQuery !== \"undefined\" && jQuery.event.triggered !== e.type ?\n\t\t\t\t\tjQuery.event.dispatch.apply( elem, arguments ) : undefined;\n\t\t\t};\n\t\t}\n\n\t\t// Handle multiple events separated by a space\n\t\ttypes = ( types || \"\" ).match( rnotwhite ) || [ \"\" ];\n\t\tt = types.length;\n\t\twhile ( t-- ) {\n\t\t\ttmp = rtypenamespace.exec( types[ t ] ) || [];\n\t\t\ttype = origType = tmp[ 1 ];\n\t\t\tnamespaces = ( tmp[ 2 ] || \"\" ).split( \".\" ).sort();\n\n\t\t\t// There *must* be a type, no attaching namespace-only handlers\n\t\t\tif ( !type ) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// If event changes its type, use the special event handlers for the changed type\n\t\t\tspecial = jQuery.event.special[ type ] || {};\n\n\t\t\t// If selector defined, determine special event api type, otherwise given type\n\t\t\ttype = ( selector ? special.delegateType : special.bindType ) || type;\n\n\t\t\t// Update special based on newly reset type\n\t\t\tspecial = jQuery.event.special[ type ] || {};\n\n\t\t\t// handleObj is passed to all event handlers\n\t\t\thandleObj = jQuery.extend( {\n\t\t\t\ttype: type,\n\t\t\t\torigType: origType,\n\t\t\t\tdata: data,\n\t\t\t\thandler: handler,\n\t\t\t\tguid: handler.guid,\n\t\t\t\tselector: selector,\n\t\t\t\tneedsContext: selector && jQuery.expr.match.needsContext.test( selector ),\n\t\t\t\tnamespace: namespaces.join( \".\" )\n\t\t\t}, handleObjIn );\n\n\t\t\t// Init the event handler queue if we're the first\n\t\t\tif ( !( handlers = events[ type ] ) ) {\n\t\t\t\thandlers = events[ type ] = [];\n\t\t\t\thandlers.delegateCount = 0;\n\n\t\t\t\t// Only use addEventListener if the special events handler returns false\n\t\t\t\tif ( !special.setup ||\n\t\t\t\t\tspecial.setup.call( elem, data, namespaces, eventHandle ) === false ) {\n\n\t\t\t\t\tif ( elem.addEventListener ) {\n\t\t\t\t\t\telem.addEventListener( type, eventHandle );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif ( special.add ) {\n\t\t\t\tspecial.add.call( elem, handleObj );\n\n\t\t\t\tif ( !handleObj.handler.guid ) {\n\t\t\t\t\thandleObj.handler.guid = handler.guid;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Add to the element's handler list, delegates in front\n\t\t\tif ( selector ) {\n\t\t\t\thandlers.splice( handlers.delegateCount++, 0, handleObj );\n\t\t\t} else {\n\t\t\t\thandlers.push( handleObj );\n\t\t\t}\n\n\t\t\t// Keep track of which events have ever been used, for event optimization\n\t\t\tjQuery.event.global[ type ] = true;\n\t\t}\n\n\t},\n\n\t// Detach an event or set of events from an element\n\tremove: function( elem, types, handler, selector, mappedTypes ) {\n\n\t\tvar j, origCount, tmp,\n\t\t\tevents, t, handleObj,\n\t\t\tspecial, handlers, type, namespaces, origType,\n\t\t\telemData = dataPriv.hasData( elem ) && dataPriv.get( elem );\n\n\t\tif ( !elemData || !( events = elemData.events ) ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Once for each type.namespace in types; type may be omitted\n\t\ttypes = ( types || \"\" ).match( rnotwhite ) || [ \"\" ];\n\t\tt = types.length;\n\t\twhile ( t-- ) {\n\t\t\ttmp = rtypenamespace.exec( types[ t ] ) || [];\n\t\t\ttype = origType = tmp[ 1 ];\n\t\t\tnamespaces = ( tmp[ 2 ] || \"\" ).split( \".\" ).sort();\n\n\t\t\t// Unbind all events (on this namespace, if provided) for the element\n\t\t\tif ( !type ) {\n\t\t\t\tfor ( type in events ) {\n\t\t\t\t\tjQuery.event.remove( elem, type + types[ t ], handler, selector, true );\n\t\t\t\t}\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tspecial = jQuery.event.special[ type ] || {};\n\t\t\ttype = ( selector ? special.delegateType : special.bindType ) || type;\n\t\t\thandlers = events[ type ] || [];\n\t\t\ttmp = tmp[ 2 ] &&\n\t\t\t\tnew RegExp( \"(^|\\\\.)\" + namespaces.join( \"\\\\.(?:.*\\\\.|)\" ) + \"(\\\\.|$)\" );\n\n\t\t\t// Remove matching events\n\t\t\torigCount = j = handlers.length;\n\t\t\twhile ( j-- ) {\n\t\t\t\thandleObj = handlers[ j ];\n\n\t\t\t\tif ( ( mappedTypes || origType === handleObj.origType ) &&\n\t\t\t\t\t( !handler || handler.guid === handleObj.guid ) &&\n\t\t\t\t\t( !tmp || tmp.test( handleObj.namespace ) ) &&\n\t\t\t\t\t( !selector || selector === handleObj.selector ||\n\t\t\t\t\t\tselector === \"**\" && handleObj.selector ) ) {\n\t\t\t\t\thandlers.splice( j, 1 );\n\n\t\t\t\t\tif ( handleObj.selector ) {\n\t\t\t\t\t\thandlers.delegateCount--;\n\t\t\t\t\t}\n\t\t\t\t\tif ( special.remove ) {\n\t\t\t\t\t\tspecial.remove.call( elem, handleObj );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Remove generic event handler if we removed something and no more handlers exist\n\t\t\t// (avoids potential for endless recursion during removal of special event handlers)\n\t\t\tif ( origCount && !handlers.length ) {\n\t\t\t\tif ( !special.teardown ||\n\t\t\t\t\tspecial.teardown.call( elem, namespaces, elemData.handle ) === false ) {\n\n\t\t\t\t\tjQuery.removeEvent( elem, type, elemData.handle );\n\t\t\t\t}\n\n\t\t\t\tdelete events[ type ];\n\t\t\t}\n\t\t}\n\n\t\t// Remove data and the expando if it's no longer used\n\t\tif ( jQuery.isEmptyObject( events ) ) {\n\t\t\tdataPriv.remove( elem, \"handle events\" );\n\t\t}\n\t},\n\n\tdispatch: function( event ) {\n\n\t\t// Make a writable jQuery.Event from the native event object\n\t\tevent = jQuery.event.fix( event );\n\n\t\tvar i, j, ret, matched, handleObj,\n\t\t\thandlerQueue = [],\n\t\t\targs = slice.call( arguments ),\n\t\t\thandlers = ( dataPriv.get( this, \"events\" ) || {} )[ event.type ] || [],\n\t\t\tspecial = jQuery.event.special[ event.type ] || {};\n\n\t\t// Use the fix-ed jQuery.Event rather than the (read-only) native event\n\t\targs[ 0 ] = event;\n\t\tevent.delegateTarget = this;\n\n\t\t// Call the preDispatch hook for the mapped type, and let it bail if desired\n\t\tif ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Determine handlers\n\t\thandlerQueue = jQuery.event.handlers.call( this, event, handlers );\n\n\t\t// Run delegates first; they may want to stop propagation beneath us\n\t\ti = 0;\n\t\twhile ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) {\n\t\t\tevent.currentTarget = matched.elem;\n\n\t\t\tj = 0;\n\t\t\twhile ( ( handleObj = matched.handlers[ j++ ] ) &&\n\t\t\t\t!event.isImmediatePropagationStopped() ) {\n\n\t\t\t\t// Triggered event must either 1) have no namespace, or 2) have namespace(s)\n\t\t\t\t// a subset or equal to those in the bound event (both can have no namespace).\n\t\t\t\tif ( !event.rnamespace || event.rnamespace.test( handleObj.namespace ) ) {\n\n\t\t\t\t\tevent.handleObj = handleObj;\n\t\t\t\t\tevent.data = handleObj.data;\n\n\t\t\t\t\tret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle ||\n\t\t\t\t\t\thandleObj.handler ).apply( matched.elem, args );\n\n\t\t\t\t\tif ( ret !== undefined ) {\n\t\t\t\t\t\tif ( ( event.result = ret ) === false ) {\n\t\t\t\t\t\t\tevent.preventDefault();\n\t\t\t\t\t\t\tevent.stopPropagation();\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Call the postDispatch hook for the mapped type\n\t\tif ( special.postDispatch ) {\n\t\t\tspecial.postDispatch.call( this, event );\n\t\t}\n\n\t\treturn event.result;\n\t},\n\n\thandlers: function( event, handlers ) {\n\t\tvar i, matches, sel, handleObj,\n\t\t\thandlerQueue = [],\n\t\t\tdelegateCount = handlers.delegateCount,\n\t\t\tcur = event.target;\n\n\t\t// Support (at least): Chrome, IE9\n\t\t// Find delegate handlers\n\t\t// Black-hole SVG <use> instance trees (#13180)\n\t\t//\n\t\t// Support: Firefox<=42+\n\t\t// Avoid non-left-click in FF but don't block IE radio events (#3861, gh-2343)\n\t\tif ( delegateCount && cur.nodeType &&\n\t\t\t( event.type !== \"click\" || isNaN( event.button ) || event.button < 1 ) ) {\n\n\t\t\tfor ( ; cur !== this; cur = cur.parentNode || this ) {\n\n\t\t\t\t// Don't check non-elements (#13208)\n\t\t\t\t// Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)\n\t\t\t\tif ( cur.nodeType === 1 && ( cur.disabled !== true || event.type !== \"click\" ) ) {\n\t\t\t\t\tmatches = [];\n\t\t\t\t\tfor ( i = 0; i < delegateCount; i++ ) {\n\t\t\t\t\t\thandleObj = handlers[ i ];\n\n\t\t\t\t\t\t// Don't conflict with Object.prototype properties (#13203)\n\t\t\t\t\t\tsel = handleObj.selector + \" \";\n\n\t\t\t\t\t\tif ( matches[ sel ] === undefined ) {\n\t\t\t\t\t\t\tmatches[ sel ] = handleObj.needsContext ?\n\t\t\t\t\t\t\t\tjQuery( sel, this ).index( cur ) > -1 :\n\t\t\t\t\t\t\t\tjQuery.find( sel, this, null, [ cur ] ).length;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif ( matches[ sel ] ) {\n\t\t\t\t\t\t\tmatches.push( handleObj );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tif ( matches.length ) {\n\t\t\t\t\t\thandlerQueue.push( { elem: cur, handlers: matches } );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Add the remaining (directly-bound) handlers\n\t\tif ( delegateCount < handlers.length ) {\n\t\t\thandlerQueue.push( { elem: this, handlers: handlers.slice( delegateCount ) } );\n\t\t}\n\n\t\treturn handlerQueue;\n\t},\n\n\t// Includes some event props shared by KeyEvent and MouseEvent\n\tprops: ( \"altKey bubbles cancelable ctrlKey currentTarget detail eventPhase \" +\n\t\t\"metaKey relatedTarget shiftKey target timeStamp view which\" ).split( \" \" ),\n\n\tfixHooks: {},\n\n\tkeyHooks: {\n\t\tprops: \"char charCode key keyCode\".split( \" \" ),\n\t\tfilter: function( event, original ) {\n\n\t\t\t// Add which for key events\n\t\t\tif ( event.which == null ) {\n\t\t\t\tevent.which = original.charCode != null ? original.charCode : original.keyCode;\n\t\t\t}\n\n\t\t\treturn event;\n\t\t}\n\t},\n\n\tmouseHooks: {\n\t\tprops: ( \"button buttons clientX clientY offsetX offsetY pageX pageY \" +\n\t\t\t\"screenX screenY toElement\" ).split( \" \" ),\n\t\tfilter: function( event, original ) {\n\t\t\tvar eventDoc, doc, body,\n\t\t\t\tbutton = original.button;\n\n\t\t\t// Calculate pageX/Y if missing and clientX/Y available\n\t\t\tif ( event.pageX == null && original.clientX != null ) {\n\t\t\t\teventDoc = event.target.ownerDocument || document;\n\t\t\t\tdoc = eventDoc.documentElement;\n\t\t\t\tbody = eventDoc.body;\n\n\t\t\t\tevent.pageX = original.clientX +\n\t\t\t\t\t( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) -\n\t\t\t\t\t( doc && doc.clientLeft || body && body.clientLeft || 0 );\n\t\t\t\tevent.pageY = original.clientY +\n\t\t\t\t\t( doc && doc.scrollTop  || body && body.scrollTop  || 0 ) -\n\t\t\t\t\t( doc && doc.clientTop  || body && body.clientTop  || 0 );\n\t\t\t}\n\n\t\t\t// Add which for click: 1 === left; 2 === middle; 3 === right\n\t\t\t// Note: button is not normalized, so don't use it\n\t\t\tif ( !event.which && button !== undefined ) {\n\t\t\t\tevent.which = ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) );\n\t\t\t}\n\n\t\t\treturn event;\n\t\t}\n\t},\n\n\tfix: function( event ) {\n\t\tif ( event[ jQuery.expando ] ) {\n\t\t\treturn event;\n\t\t}\n\n\t\t// Create a writable copy of the event object and normalize some properties\n\t\tvar i, prop, copy,\n\t\t\ttype = event.type,\n\t\t\toriginalEvent = event,\n\t\t\tfixHook = this.fixHooks[ type ];\n\n\t\tif ( !fixHook ) {\n\t\t\tthis.fixHooks[ type ] = fixHook =\n\t\t\t\trmouseEvent.test( type ) ? this.mouseHooks :\n\t\t\t\trkeyEvent.test( type ) ? this.keyHooks :\n\t\t\t\t{};\n\t\t}\n\t\tcopy = fixHook.props ? this.props.concat( fixHook.props ) : this.props;\n\n\t\tevent = new jQuery.Event( originalEvent );\n\n\t\ti = copy.length;\n\t\twhile ( i-- ) {\n\t\t\tprop = copy[ i ];\n\t\t\tevent[ prop ] = originalEvent[ prop ];\n\t\t}\n\n\t\t// Support: Cordova 2.5 (WebKit) (#13255)\n\t\t// All events should have a target; Cordova deviceready doesn't\n\t\tif ( !event.target ) {\n\t\t\tevent.target = document;\n\t\t}\n\n\t\t// Support: Safari 6.0+, Chrome<28\n\t\t// Target should not be a text node (#504, #13143)\n\t\tif ( event.target.nodeType === 3 ) {\n\t\t\tevent.target = event.target.parentNode;\n\t\t}\n\n\t\treturn fixHook.filter ? fixHook.filter( event, originalEvent ) : event;\n\t},\n\n\tspecial: {\n\t\tload: {\n\n\t\t\t// Prevent triggered image.load events from bubbling to window.load\n\t\t\tnoBubble: true\n\t\t},\n\t\tfocus: {\n\n\t\t\t// Fire native event if possible so blur/focus sequence is correct\n\t\t\ttrigger: function() {\n\t\t\t\tif ( this !== safeActiveElement() && this.focus ) {\n\t\t\t\t\tthis.focus();\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t},\n\t\t\tdelegateType: \"focusin\"\n\t\t},\n\t\tblur: {\n\t\t\ttrigger: function() {\n\t\t\t\tif ( this === safeActiveElement() && this.blur ) {\n\t\t\t\t\tthis.blur();\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t},\n\t\t\tdelegateType: \"focusout\"\n\t\t},\n\t\tclick: {\n\n\t\t\t// For checkbox, fire native event so checked state will be right\n\t\t\ttrigger: function() {\n\t\t\t\tif ( this.type === \"checkbox\" && this.click && jQuery.nodeName( this, \"input\" ) ) {\n\t\t\t\t\tthis.click();\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t},\n\n\t\t\t// For cross-browser consistency, don't fire native .click() on links\n\t\t\t_default: function( event ) {\n\t\t\t\treturn jQuery.nodeName( event.target, \"a\" );\n\t\t\t}\n\t\t},\n\n\t\tbeforeunload: {\n\t\t\tpostDispatch: function( event ) {\n\n\t\t\t\t// Support: Firefox 20+\n\t\t\t\t// Firefox doesn't alert if the returnValue field is not set.\n\t\t\t\tif ( event.result !== undefined && event.originalEvent ) {\n\t\t\t\t\tevent.originalEvent.returnValue = event.result;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n};\n\njQuery.removeEvent = function( elem, type, handle ) {\n\n\t// This \"if\" is needed for plain objects\n\tif ( elem.removeEventListener ) {\n\t\telem.removeEventListener( type, handle );\n\t}\n};\n\njQuery.Event = function( src, props ) {\n\n\t// Allow instantiation without the 'new' keyword\n\tif ( !( this instanceof jQuery.Event ) ) {\n\t\treturn new jQuery.Event( src, props );\n\t}\n\n\t// Event object\n\tif ( src && src.type ) {\n\t\tthis.originalEvent = src;\n\t\tthis.type = src.type;\n\n\t\t// Events bubbling up the document may have been marked as prevented\n\t\t// by a handler lower down the tree; reflect the correct value.\n\t\tthis.isDefaultPrevented = src.defaultPrevented ||\n\t\t\t\tsrc.defaultPrevented === undefined &&\n\n\t\t\t\t// Support: Android<4.0\n\t\t\t\tsrc.returnValue === false ?\n\t\t\treturnTrue :\n\t\t\treturnFalse;\n\n\t// Event type\n\t} else {\n\t\tthis.type = src;\n\t}\n\n\t// Put explicitly provided properties onto the event object\n\tif ( props ) {\n\t\tjQuery.extend( this, props );\n\t}\n\n\t// Create a timestamp if incoming event doesn't have one\n\tthis.timeStamp = src && src.timeStamp || jQuery.now();\n\n\t// Mark it as fixed\n\tthis[ jQuery.expando ] = true;\n};\n\n// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding\n// http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html\njQuery.Event.prototype = {\n\tconstructor: jQuery.Event,\n\tisDefaultPrevented: returnFalse,\n\tisPropagationStopped: returnFalse,\n\tisImmediatePropagationStopped: returnFalse,\n\tisSimulated: false,\n\n\tpreventDefault: function() {\n\t\tvar e = this.originalEvent;\n\n\t\tthis.isDefaultPrevented = returnTrue;\n\n\t\tif ( e && !this.isSimulated ) {\n\t\t\te.preventDefault();\n\t\t}\n\t},\n\tstopPropagation: function() {\n\t\tvar e = this.originalEvent;\n\n\t\tthis.isPropagationStopped = returnTrue;\n\n\t\tif ( e && !this.isSimulated ) {\n\t\t\te.stopPropagation();\n\t\t}\n\t},\n\tstopImmediatePropagation: function() {\n\t\tvar e = this.originalEvent;\n\n\t\tthis.isImmediatePropagationStopped = returnTrue;\n\n\t\tif ( e && !this.isSimulated ) {\n\t\t\te.stopImmediatePropagation();\n\t\t}\n\n\t\tthis.stopPropagation();\n\t}\n};\n\n// Create mouseenter/leave events using mouseover/out and event-time checks\n// so that event delegation works in jQuery.\n// Do the same for pointerenter/pointerleave and pointerover/pointerout\n//\n// Support: Safari 7 only\n// Safari sends mouseenter too often; see:\n// https://code.google.com/p/chromium/issues/detail?id=470258\n// for the description of the bug (it existed in older Chrome versions as well).\njQuery.each( {\n\tmouseenter: \"mouseover\",\n\tmouseleave: \"mouseout\",\n\tpointerenter: \"pointerover\",\n\tpointerleave: \"pointerout\"\n}, function( orig, fix ) {\n\tjQuery.event.special[ orig ] = {\n\t\tdelegateType: fix,\n\t\tbindType: fix,\n\n\t\thandle: function( event ) {\n\t\t\tvar ret,\n\t\t\t\ttarget = this,\n\t\t\t\trelated = event.relatedTarget,\n\t\t\t\thandleObj = event.handleObj;\n\n\t\t\t// For mouseenter/leave call the handler if related is outside the target.\n\t\t\t// NB: No relatedTarget if the mouse left/entered the browser window\n\t\t\tif ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) {\n\t\t\t\tevent.type = handleObj.origType;\n\t\t\t\tret = handleObj.handler.apply( this, arguments );\n\t\t\t\tevent.type = fix;\n\t\t\t}\n\t\t\treturn ret;\n\t\t}\n\t};\n} );\n\njQuery.fn.extend( {\n\ton: function( types, selector, data, fn ) {\n\t\treturn on( this, types, selector, data, fn );\n\t},\n\tone: function( types, selector, data, fn ) {\n\t\treturn on( this, types, selector, data, fn, 1 );\n\t},\n\toff: function( types, selector, fn ) {\n\t\tvar handleObj, type;\n\t\tif ( types && types.preventDefault && types.handleObj ) {\n\n\t\t\t// ( event )  dispatched jQuery.Event\n\t\t\thandleObj = types.handleObj;\n\t\t\tjQuery( types.delegateTarget ).off(\n\t\t\t\thandleObj.namespace ?\n\t\t\t\t\thandleObj.origType + \".\" + handleObj.namespace :\n\t\t\t\t\thandleObj.origType,\n\t\t\t\thandleObj.selector,\n\t\t\t\thandleObj.handler\n\t\t\t);\n\t\t\treturn this;\n\t\t}\n\t\tif ( typeof types === \"object\" ) {\n\n\t\t\t// ( types-object [, selector] )\n\t\t\tfor ( type in types ) {\n\t\t\t\tthis.off( type, selector, types[ type ] );\n\t\t\t}\n\t\t\treturn this;\n\t\t}\n\t\tif ( selector === false || typeof selector === \"function\" ) {\n\n\t\t\t// ( types [, fn] )\n\t\t\tfn = selector;\n\t\t\tselector = undefined;\n\t\t}\n\t\tif ( fn === false ) {\n\t\t\tfn = returnFalse;\n\t\t}\n\t\treturn this.each( function() {\n\t\t\tjQuery.event.remove( this, types, fn, selector );\n\t\t} );\n\t}\n} );\n\n\nvar\n\trxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\\w:-]+)[^>]*)\\/>/gi,\n\n\t// Support: IE 10-11, Edge 10240+\n\t// In IE/Edge using regex groups here causes severe slowdowns.\n\t// See https://connect.microsoft.com/IE/feedback/details/1736512/\n\trnoInnerhtml = /<script|<style|<link/i,\n\n\t// checked=\"checked\" or checked\n\trchecked = /checked\\s*(?:[^=]|=\\s*.checked.)/i,\n\trscriptTypeMasked = /^true\\/(.*)/,\n\trcleanScript = /^\\s*<!(?:\\[CDATA\\[|--)|(?:\\]\\]|--)>\\s*$/g;\n\n// Manipulating tables requires a tbody\nfunction manipulationTarget( elem, content ) {\n\treturn jQuery.nodeName( elem, \"table\" ) &&\n\t\tjQuery.nodeName( content.nodeType !== 11 ? content : content.firstChild, \"tr\" ) ?\n\n\t\telem.getElementsByTagName( \"tbody\" )[ 0 ] ||\n\t\t\telem.appendChild( elem.ownerDocument.createElement( \"tbody\" ) ) :\n\t\telem;\n}\n\n// Replace/restore the type attribute of script elements for safe DOM manipulation\nfunction disableScript( elem ) {\n\telem.type = ( elem.getAttribute( \"type\" ) !== null ) + \"/\" + elem.type;\n\treturn elem;\n}\nfunction restoreScript( elem ) {\n\tvar match = rscriptTypeMasked.exec( elem.type );\n\n\tif ( match ) {\n\t\telem.type = match[ 1 ];\n\t} else {\n\t\telem.removeAttribute( \"type\" );\n\t}\n\n\treturn elem;\n}\n\nfunction cloneCopyEvent( src, dest ) {\n\tvar i, l, type, pdataOld, pdataCur, udataOld, udataCur, events;\n\n\tif ( dest.nodeType !== 1 ) {\n\t\treturn;\n\t}\n\n\t// 1. Copy private data: events, handlers, etc.\n\tif ( dataPriv.hasData( src ) ) {\n\t\tpdataOld = dataPriv.access( src );\n\t\tpdataCur = dataPriv.set( dest, pdataOld );\n\t\tevents = pdataOld.events;\n\n\t\tif ( events ) {\n\t\t\tdelete pdataCur.handle;\n\t\t\tpdataCur.events = {};\n\n\t\t\tfor ( type in events ) {\n\t\t\t\tfor ( i = 0, l = events[ type ].length; i < l; i++ ) {\n\t\t\t\t\tjQuery.event.add( dest, type, events[ type ][ i ] );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// 2. Copy user data\n\tif ( dataUser.hasData( src ) ) {\n\t\tudataOld = dataUser.access( src );\n\t\tudataCur = jQuery.extend( {}, udataOld );\n\n\t\tdataUser.set( dest, udataCur );\n\t}\n}\n\n// Fix IE bugs, see support tests\nfunction fixInput( src, dest ) {\n\tvar nodeName = dest.nodeName.toLowerCase();\n\n\t// Fails to persist the checked state of a cloned checkbox or radio button.\n\tif ( nodeName === \"input\" && rcheckableType.test( src.type ) ) {\n\t\tdest.checked = src.checked;\n\n\t// Fails to return the selected option to the default selected state when cloning options\n\t} else if ( nodeName === \"input\" || nodeName === \"textarea\" ) {\n\t\tdest.defaultValue = src.defaultValue;\n\t}\n}\n\nfunction domManip( collection, args, callback, ignored ) {\n\n\t// Flatten any nested arrays\n\targs = concat.apply( [], args );\n\n\tvar fragment, first, scripts, hasScripts, node, doc,\n\t\ti = 0,\n\t\tl = collection.length,\n\t\tiNoClone = l - 1,\n\t\tvalue = args[ 0 ],\n\t\tisFunction = jQuery.isFunction( value );\n\n\t// We can't cloneNode fragments that contain checked, in WebKit\n\tif ( isFunction ||\n\t\t\t( l > 1 && typeof value === \"string\" &&\n\t\t\t\t!support.checkClone && rchecked.test( value ) ) ) {\n\t\treturn collection.each( function( index ) {\n\t\t\tvar self = collection.eq( index );\n\t\t\tif ( isFunction ) {\n\t\t\t\targs[ 0 ] = value.call( this, index, self.html() );\n\t\t\t}\n\t\t\tdomManip( self, args, callback, ignored );\n\t\t} );\n\t}\n\n\tif ( l ) {\n\t\tfragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored );\n\t\tfirst = fragment.firstChild;\n\n\t\tif ( fragment.childNodes.length === 1 ) {\n\t\t\tfragment = first;\n\t\t}\n\n\t\t// Require either new content or an interest in ignored elements to invoke the callback\n\t\tif ( first || ignored ) {\n\t\t\tscripts = jQuery.map( getAll( fragment, \"script\" ), disableScript );\n\t\t\thasScripts = scripts.length;\n\n\t\t\t// Use the original fragment for the last item\n\t\t\t// instead of the first because it can end up\n\t\t\t// being emptied incorrectly in certain situations (#8070).\n\t\t\tfor ( ; i < l; i++ ) {\n\t\t\t\tnode = fragment;\n\n\t\t\t\tif ( i !== iNoClone ) {\n\t\t\t\t\tnode = jQuery.clone( node, true, true );\n\n\t\t\t\t\t// Keep references to cloned scripts for later restoration\n\t\t\t\t\tif ( hasScripts ) {\n\n\t\t\t\t\t\t// Support: Android<4.1, PhantomJS<2\n\t\t\t\t\t\t// push.apply(_, arraylike) throws on ancient WebKit\n\t\t\t\t\t\tjQuery.merge( scripts, getAll( node, \"script\" ) );\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tcallback.call( collection[ i ], node, i );\n\t\t\t}\n\n\t\t\tif ( hasScripts ) {\n\t\t\t\tdoc = scripts[ scripts.length - 1 ].ownerDocument;\n\n\t\t\t\t// Reenable scripts\n\t\t\t\tjQuery.map( scripts, restoreScript );\n\n\t\t\t\t// Evaluate executable scripts on first document insertion\n\t\t\t\tfor ( i = 0; i < hasScripts; i++ ) {\n\t\t\t\t\tnode = scripts[ i ];\n\t\t\t\t\tif ( rscriptType.test( node.type || \"\" ) &&\n\t\t\t\t\t\t!dataPriv.access( node, \"globalEval\" ) &&\n\t\t\t\t\t\tjQuery.contains( doc, node ) ) {\n\n\t\t\t\t\t\tif ( node.src ) {\n\n\t\t\t\t\t\t\t// Optional AJAX dependency, but won't run scripts if not present\n\t\t\t\t\t\t\tif ( jQuery._evalUrl ) {\n\t\t\t\t\t\t\t\tjQuery._evalUrl( node.src );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tjQuery.globalEval( node.textContent.replace( rcleanScript, \"\" ) );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn collection;\n}\n\nfunction remove( elem, selector, keepData ) {\n\tvar node,\n\t\tnodes = selector ? jQuery.filter( selector, elem ) : elem,\n\t\ti = 0;\n\n\tfor ( ; ( node = nodes[ i ] ) != null; i++ ) {\n\t\tif ( !keepData && node.nodeType === 1 ) {\n\t\t\tjQuery.cleanData( getAll( node ) );\n\t\t}\n\n\t\tif ( node.parentNode ) {\n\t\t\tif ( keepData && jQuery.contains( node.ownerDocument, node ) ) {\n\t\t\t\tsetGlobalEval( getAll( node, \"script\" ) );\n\t\t\t}\n\t\t\tnode.parentNode.removeChild( node );\n\t\t}\n\t}\n\n\treturn elem;\n}\n\njQuery.extend( {\n\thtmlPrefilter: function( html ) {\n\t\treturn html.replace( rxhtmlTag, \"<$1></$2>\" );\n\t},\n\n\tclone: function( elem, dataAndEvents, deepDataAndEvents ) {\n\t\tvar i, l, srcElements, destElements,\n\t\t\tclone = elem.cloneNode( true ),\n\t\t\tinPage = jQuery.contains( elem.ownerDocument, elem );\n\n\t\t// Fix IE cloning issues\n\t\tif ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) &&\n\t\t\t\t!jQuery.isXMLDoc( elem ) ) {\n\n\t\t\t// We eschew Sizzle here for performance reasons: http://jsperf.com/getall-vs-sizzle/2\n\t\t\tdestElements = getAll( clone );\n\t\t\tsrcElements = getAll( elem );\n\n\t\t\tfor ( i = 0, l = srcElements.length; i < l; i++ ) {\n\t\t\t\tfixInput( srcElements[ i ], destElements[ i ] );\n\t\t\t}\n\t\t}\n\n\t\t// Copy the events from the original to the clone\n\t\tif ( dataAndEvents ) {\n\t\t\tif ( deepDataAndEvents ) {\n\t\t\t\tsrcElements = srcElements || getAll( elem );\n\t\t\t\tdestElements = destElements || getAll( clone );\n\n\t\t\t\tfor ( i = 0, l = srcElements.length; i < l; i++ ) {\n\t\t\t\t\tcloneCopyEvent( srcElements[ i ], destElements[ i ] );\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tcloneCopyEvent( elem, clone );\n\t\t\t}\n\t\t}\n\n\t\t// Preserve script evaluation history\n\t\tdestElements = getAll( clone, \"script\" );\n\t\tif ( destElements.length > 0 ) {\n\t\t\tsetGlobalEval( destElements, !inPage && getAll( elem, \"script\" ) );\n\t\t}\n\n\t\t// Return the cloned set\n\t\treturn clone;\n\t},\n\n\tcleanData: function( elems ) {\n\t\tvar data, elem, type,\n\t\t\tspecial = jQuery.event.special,\n\t\t\ti = 0;\n\n\t\tfor ( ; ( elem = elems[ i ] ) !== undefined; i++ ) {\n\t\t\tif ( acceptData( elem ) ) {\n\t\t\t\tif ( ( data = elem[ dataPriv.expando ] ) ) {\n\t\t\t\t\tif ( data.events ) {\n\t\t\t\t\t\tfor ( type in data.events ) {\n\t\t\t\t\t\t\tif ( special[ type ] ) {\n\t\t\t\t\t\t\t\tjQuery.event.remove( elem, type );\n\n\t\t\t\t\t\t\t// This is a shortcut to avoid jQuery.event.remove's overhead\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tjQuery.removeEvent( elem, type, data.handle );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Support: Chrome <= 35-45+\n\t\t\t\t\t// Assign undefined instead of using delete, see Data#remove\n\t\t\t\t\telem[ dataPriv.expando ] = undefined;\n\t\t\t\t}\n\t\t\t\tif ( elem[ dataUser.expando ] ) {\n\n\t\t\t\t\t// Support: Chrome <= 35-45+\n\t\t\t\t\t// Assign undefined instead of using delete, see Data#remove\n\t\t\t\t\telem[ dataUser.expando ] = undefined;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n} );\n\njQuery.fn.extend( {\n\n\t// Keep domManip exposed until 3.0 (gh-2225)\n\tdomManip: domManip,\n\n\tdetach: function( selector ) {\n\t\treturn remove( this, selector, true );\n\t},\n\n\tremove: function( selector ) {\n\t\treturn remove( this, selector );\n\t},\n\n\ttext: function( value ) {\n\t\treturn access( this, function( value ) {\n\t\t\treturn value === undefined ?\n\t\t\t\tjQuery.text( this ) :\n\t\t\t\tthis.empty().each( function() {\n\t\t\t\t\tif ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {\n\t\t\t\t\t\tthis.textContent = value;\n\t\t\t\t\t}\n\t\t\t\t} );\n\t\t}, null, value, arguments.length );\n\t},\n\n\tappend: function() {\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tif ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {\n\t\t\t\tvar target = manipulationTarget( this, elem );\n\t\t\t\ttarget.appendChild( elem );\n\t\t\t}\n\t\t} );\n\t},\n\n\tprepend: function() {\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tif ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {\n\t\t\t\tvar target = manipulationTarget( this, elem );\n\t\t\t\ttarget.insertBefore( elem, target.firstChild );\n\t\t\t}\n\t\t} );\n\t},\n\n\tbefore: function() {\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tif ( this.parentNode ) {\n\t\t\t\tthis.parentNode.insertBefore( elem, this );\n\t\t\t}\n\t\t} );\n\t},\n\n\tafter: function() {\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tif ( this.parentNode ) {\n\t\t\t\tthis.parentNode.insertBefore( elem, this.nextSibling );\n\t\t\t}\n\t\t} );\n\t},\n\n\tempty: function() {\n\t\tvar elem,\n\t\t\ti = 0;\n\n\t\tfor ( ; ( elem = this[ i ] ) != null; i++ ) {\n\t\t\tif ( elem.nodeType === 1 ) {\n\n\t\t\t\t// Prevent memory leaks\n\t\t\t\tjQuery.cleanData( getAll( elem, false ) );\n\n\t\t\t\t// Remove any remaining nodes\n\t\t\t\telem.textContent = \"\";\n\t\t\t}\n\t\t}\n\n\t\treturn this;\n\t},\n\n\tclone: function( dataAndEvents, deepDataAndEvents ) {\n\t\tdataAndEvents = dataAndEvents == null ? false : dataAndEvents;\n\t\tdeepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;\n\n\t\treturn this.map( function() {\n\t\t\treturn jQuery.clone( this, dataAndEvents, deepDataAndEvents );\n\t\t} );\n\t},\n\n\thtml: function( value ) {\n\t\treturn access( this, function( value ) {\n\t\t\tvar elem = this[ 0 ] || {},\n\t\t\t\ti = 0,\n\t\t\t\tl = this.length;\n\n\t\t\tif ( value === undefined && elem.nodeType === 1 ) {\n\t\t\t\treturn elem.innerHTML;\n\t\t\t}\n\n\t\t\t// See if we can take a shortcut and just use innerHTML\n\t\t\tif ( typeof value === \"string\" && !rnoInnerhtml.test( value ) &&\n\t\t\t\t!wrapMap[ ( rtagName.exec( value ) || [ \"\", \"\" ] )[ 1 ].toLowerCase() ] ) {\n\n\t\t\t\tvalue = jQuery.htmlPrefilter( value );\n\n\t\t\t\ttry {\n\t\t\t\t\tfor ( ; i < l; i++ ) {\n\t\t\t\t\t\telem = this[ i ] || {};\n\n\t\t\t\t\t\t// Remove element nodes and prevent memory leaks\n\t\t\t\t\t\tif ( elem.nodeType === 1 ) {\n\t\t\t\t\t\t\tjQuery.cleanData( getAll( elem, false ) );\n\t\t\t\t\t\t\telem.innerHTML = value;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\telem = 0;\n\n\t\t\t\t// If using innerHTML throws an exception, use the fallback method\n\t\t\t\t} catch ( e ) {}\n\t\t\t}\n\n\t\t\tif ( elem ) {\n\t\t\t\tthis.empty().append( value );\n\t\t\t}\n\t\t}, null, value, arguments.length );\n\t},\n\n\treplaceWith: function() {\n\t\tvar ignored = [];\n\n\t\t// Make the changes, replacing each non-ignored context element with the new content\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tvar parent = this.parentNode;\n\n\t\t\tif ( jQuery.inArray( this, ignored ) < 0 ) {\n\t\t\t\tjQuery.cleanData( getAll( this ) );\n\t\t\t\tif ( parent ) {\n\t\t\t\t\tparent.replaceChild( elem, this );\n\t\t\t\t}\n\t\t\t}\n\n\t\t// Force callback invocation\n\t\t}, ignored );\n\t}\n} );\n\njQuery.each( {\n\tappendTo: \"append\",\n\tprependTo: \"prepend\",\n\tinsertBefore: \"before\",\n\tinsertAfter: \"after\",\n\treplaceAll: \"replaceWith\"\n}, function( name, original ) {\n\tjQuery.fn[ name ] = function( selector ) {\n\t\tvar elems,\n\t\t\tret = [],\n\t\t\tinsert = jQuery( selector ),\n\t\t\tlast = insert.length - 1,\n\t\t\ti = 0;\n\n\t\tfor ( ; i <= last; i++ ) {\n\t\t\telems = i === last ? this : this.clone( true );\n\t\t\tjQuery( insert[ i ] )[ original ]( elems );\n\n\t\t\t// Support: QtWebKit\n\t\t\t// .get() because push.apply(_, arraylike) throws\n\t\t\tpush.apply( ret, elems.get() );\n\t\t}\n\n\t\treturn this.pushStack( ret );\n\t};\n} );\n\n\nvar iframe,\n\telemdisplay = {\n\n\t\t// Support: Firefox\n\t\t// We have to pre-define these values for FF (#10227)\n\t\tHTML: \"block\",\n\t\tBODY: \"block\"\n\t};\n\n/**\n * Retrieve the actual display of a element\n * @param {String} name nodeName of the element\n * @param {Object} doc Document object\n */\n\n// Called only from within defaultDisplay\nfunction actualDisplay( name, doc ) {\n\tvar elem = jQuery( doc.createElement( name ) ).appendTo( doc.body ),\n\n\t\tdisplay = jQuery.css( elem[ 0 ], \"display\" );\n\n\t// We don't have any data stored on the element,\n\t// so use \"detach\" method as fast way to get rid of the element\n\telem.detach();\n\n\treturn display;\n}\n\n/**\n * Try to determine the default display value of an element\n * @param {String} nodeName\n */\nfunction defaultDisplay( nodeName ) {\n\tvar doc = document,\n\t\tdisplay = elemdisplay[ nodeName ];\n\n\tif ( !display ) {\n\t\tdisplay = actualDisplay( nodeName, doc );\n\n\t\t// If the simple way fails, read from inside an iframe\n\t\tif ( display === \"none\" || !display ) {\n\n\t\t\t// Use the already-created iframe if possible\n\t\t\tiframe = ( iframe || jQuery( \"<iframe frameborder='0' width='0' height='0'/>\" ) )\n\t\t\t\t.appendTo( doc.documentElement );\n\n\t\t\t// Always write a new HTML skeleton so Webkit and Firefox don't choke on reuse\n\t\t\tdoc = iframe[ 0 ].contentDocument;\n\n\t\t\t// Support: IE\n\t\t\tdoc.write();\n\t\t\tdoc.close();\n\n\t\t\tdisplay = actualDisplay( nodeName, doc );\n\t\t\tiframe.detach();\n\t\t}\n\n\t\t// Store the correct default display\n\t\telemdisplay[ nodeName ] = display;\n\t}\n\n\treturn display;\n}\nvar rmargin = ( /^margin/ );\n\nvar rnumnonpx = new RegExp( \"^(\" + pnum + \")(?!px)[a-z%]+$\", \"i\" );\n\nvar getStyles = function( elem ) {\n\n\t\t// Support: IE<=11+, Firefox<=30+ (#15098, #14150)\n\t\t// IE throws on elements created in popups\n\t\t// FF meanwhile throws on frame elements through \"defaultView.getComputedStyle\"\n\t\tvar view = elem.ownerDocument.defaultView;\n\n\t\tif ( !view || !view.opener ) {\n\t\t\tview = window;\n\t\t}\n\n\t\treturn view.getComputedStyle( elem );\n\t};\n\nvar swap = function( elem, options, callback, args ) {\n\tvar ret, name,\n\t\told = {};\n\n\t// Remember the old values, and insert the new ones\n\tfor ( name in options ) {\n\t\told[ name ] = elem.style[ name ];\n\t\telem.style[ name ] = options[ name ];\n\t}\n\n\tret = callback.apply( elem, args || [] );\n\n\t// Revert the old values\n\tfor ( name in options ) {\n\t\telem.style[ name ] = old[ name ];\n\t}\n\n\treturn ret;\n};\n\n\nvar documentElement = document.documentElement;\n\n\n\n( function() {\n\tvar pixelPositionVal, boxSizingReliableVal, pixelMarginRightVal, reliableMarginLeftVal,\n\t\tcontainer = document.createElement( \"div\" ),\n\t\tdiv = document.createElement( \"div\" );\n\n\t// Finish early in limited (non-browser) environments\n\tif ( !div.style ) {\n\t\treturn;\n\t}\n\n\t// Support: IE9-11+\n\t// Style of cloned element affects source element cloned (#8908)\n\tdiv.style.backgroundClip = \"content-box\";\n\tdiv.cloneNode( true ).style.backgroundClip = \"\";\n\tsupport.clearCloneStyle = div.style.backgroundClip === \"content-box\";\n\n\tcontainer.style.cssText = \"border:0;width:8px;height:0;top:0;left:-9999px;\" +\n\t\t\"padding:0;margin-top:1px;position:absolute\";\n\tcontainer.appendChild( div );\n\n\t// Executing both pixelPosition & boxSizingReliable tests require only one layout\n\t// so they're executed at the same time to save the second computation.\n\tfunction computeStyleTests() {\n\t\tdiv.style.cssText =\n\n\t\t\t// Support: Firefox<29, Android 2.3\n\t\t\t// Vendor-prefix box-sizing\n\t\t\t\"-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;\" +\n\t\t\t\"position:relative;display:block;\" +\n\t\t\t\"margin:auto;border:1px;padding:1px;\" +\n\t\t\t\"top:1%;width:50%\";\n\t\tdiv.innerHTML = \"\";\n\t\tdocumentElement.appendChild( container );\n\n\t\tvar divStyle = window.getComputedStyle( div );\n\t\tpixelPositionVal = divStyle.top !== \"1%\";\n\t\treliableMarginLeftVal = divStyle.marginLeft === \"2px\";\n\t\tboxSizingReliableVal = divStyle.width === \"4px\";\n\n\t\t// Support: Android 4.0 - 4.3 only\n\t\t// Some styles come back with percentage values, even though they shouldn't\n\t\tdiv.style.marginRight = \"50%\";\n\t\tpixelMarginRightVal = divStyle.marginRight === \"4px\";\n\n\t\tdocumentElement.removeChild( container );\n\t}\n\n\tjQuery.extend( support, {\n\t\tpixelPosition: function() {\n\n\t\t\t// This test is executed only once but we still do memoizing\n\t\t\t// since we can use the boxSizingReliable pre-computing.\n\t\t\t// No need to check if the test was already performed, though.\n\t\t\tcomputeStyleTests();\n\t\t\treturn pixelPositionVal;\n\t\t},\n\t\tboxSizingReliable: function() {\n\t\t\tif ( boxSizingReliableVal == null ) {\n\t\t\t\tcomputeStyleTests();\n\t\t\t}\n\t\t\treturn boxSizingReliableVal;\n\t\t},\n\t\tpixelMarginRight: function() {\n\n\t\t\t// Support: Android 4.0-4.3\n\t\t\t// We're checking for boxSizingReliableVal here instead of pixelMarginRightVal\n\t\t\t// since that compresses better and they're computed together anyway.\n\t\t\tif ( boxSizingReliableVal == null ) {\n\t\t\t\tcomputeStyleTests();\n\t\t\t}\n\t\t\treturn pixelMarginRightVal;\n\t\t},\n\t\treliableMarginLeft: function() {\n\n\t\t\t// Support: IE <=8 only, Android 4.0 - 4.3 only, Firefox <=3 - 37\n\t\t\tif ( boxSizingReliableVal == null ) {\n\t\t\t\tcomputeStyleTests();\n\t\t\t}\n\t\t\treturn reliableMarginLeftVal;\n\t\t},\n\t\treliableMarginRight: function() {\n\n\t\t\t// Support: Android 2.3\n\t\t\t// Check if div with explicit width and no margin-right incorrectly\n\t\t\t// gets computed margin-right based on width of container. (#3333)\n\t\t\t// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right\n\t\t\t// This support function is only executed once so no memoizing is needed.\n\t\t\tvar ret,\n\t\t\t\tmarginDiv = div.appendChild( document.createElement( \"div\" ) );\n\n\t\t\t// Reset CSS: box-sizing; display; margin; border; padding\n\t\t\tmarginDiv.style.cssText = div.style.cssText =\n\n\t\t\t\t// Support: Android 2.3\n\t\t\t\t// Vendor-prefix box-sizing\n\t\t\t\t\"-webkit-box-sizing:content-box;box-sizing:content-box;\" +\n\t\t\t\t\"display:block;margin:0;border:0;padding:0\";\n\t\t\tmarginDiv.style.marginRight = marginDiv.style.width = \"0\";\n\t\t\tdiv.style.width = \"1px\";\n\t\t\tdocumentElement.appendChild( container );\n\n\t\t\tret = !parseFloat( window.getComputedStyle( marginDiv ).marginRight );\n\n\t\t\tdocumentElement.removeChild( container );\n\t\t\tdiv.removeChild( marginDiv );\n\n\t\t\treturn ret;\n\t\t}\n\t} );\n} )();\n\n\nfunction curCSS( elem, name, computed ) {\n\tvar width, minWidth, maxWidth, ret,\n\t\tstyle = elem.style;\n\n\tcomputed = computed || getStyles( elem );\n\tret = computed ? computed.getPropertyValue( name ) || computed[ name ] : undefined;\n\n\t// Support: Opera 12.1x only\n\t// Fall back to style even without computed\n\t// computed is undefined for elems on document fragments\n\tif ( ( ret === \"\" || ret === undefined ) && !jQuery.contains( elem.ownerDocument, elem ) ) {\n\t\tret = jQuery.style( elem, name );\n\t}\n\n\t// Support: IE9\n\t// getPropertyValue is only needed for .css('filter') (#12537)\n\tif ( computed ) {\n\n\t\t// A tribute to the \"awesome hack by Dean Edwards\"\n\t\t// Android Browser returns percentage for some values,\n\t\t// but width seems to be reliably pixels.\n\t\t// This is against the CSSOM draft spec:\n\t\t// http://dev.w3.org/csswg/cssom/#resolved-values\n\t\tif ( !support.pixelMarginRight() && rnumnonpx.test( ret ) && rmargin.test( name ) ) {\n\n\t\t\t// Remember the original values\n\t\t\twidth = style.width;\n\t\t\tminWidth = style.minWidth;\n\t\t\tmaxWidth = style.maxWidth;\n\n\t\t\t// Put in the new values to get a computed value out\n\t\t\tstyle.minWidth = style.maxWidth = style.width = ret;\n\t\t\tret = computed.width;\n\n\t\t\t// Revert the changed values\n\t\t\tstyle.width = width;\n\t\t\tstyle.minWidth = minWidth;\n\t\t\tstyle.maxWidth = maxWidth;\n\t\t}\n\t}\n\n\treturn ret !== undefined ?\n\n\t\t// Support: IE9-11+\n\t\t// IE returns zIndex value as an integer.\n\t\tret + \"\" :\n\t\tret;\n}\n\n\nfunction addGetHookIf( conditionFn, hookFn ) {\n\n\t// Define the hook, we'll check on the first run if it's really needed.\n\treturn {\n\t\tget: function() {\n\t\t\tif ( conditionFn() ) {\n\n\t\t\t\t// Hook not needed (or it's not possible to use it due\n\t\t\t\t// to missing dependency), remove it.\n\t\t\t\tdelete this.get;\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// Hook needed; redefine it so that the support test is not executed again.\n\t\t\treturn ( this.get = hookFn ).apply( this, arguments );\n\t\t}\n\t};\n}\n\n\nvar\n\n\t// Swappable if display is none or starts with table\n\t// except \"table\", \"table-cell\", or \"table-caption\"\n\t// See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display\n\trdisplayswap = /^(none|table(?!-c[ea]).+)/,\n\n\tcssShow = { position: \"absolute\", visibility: \"hidden\", display: \"block\" },\n\tcssNormalTransform = {\n\t\tletterSpacing: \"0\",\n\t\tfontWeight: \"400\"\n\t},\n\n\tcssPrefixes = [ \"Webkit\", \"O\", \"Moz\", \"ms\" ],\n\temptyStyle = document.createElement( \"div\" ).style;\n\n// Return a css property mapped to a potentially vendor prefixed property\nfunction vendorPropName( name ) {\n\n\t// Shortcut for names that are not vendor prefixed\n\tif ( name in emptyStyle ) {\n\t\treturn name;\n\t}\n\n\t// Check for vendor prefixed names\n\tvar capName = name[ 0 ].toUpperCase() + name.slice( 1 ),\n\t\ti = cssPrefixes.length;\n\n\twhile ( i-- ) {\n\t\tname = cssPrefixes[ i ] + capName;\n\t\tif ( name in emptyStyle ) {\n\t\t\treturn name;\n\t\t}\n\t}\n}\n\nfunction setPositiveNumber( elem, value, subtract ) {\n\n\t// Any relative (+/-) values have already been\n\t// normalized at this point\n\tvar matches = rcssNum.exec( value );\n\treturn matches ?\n\n\t\t// Guard against undefined \"subtract\", e.g., when used as in cssHooks\n\t\tMath.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || \"px\" ) :\n\t\tvalue;\n}\n\nfunction augmentWidthOrHeight( elem, name, extra, isBorderBox, styles ) {\n\tvar i = extra === ( isBorderBox ? \"border\" : \"content\" ) ?\n\n\t\t// If we already have the right measurement, avoid augmentation\n\t\t4 :\n\n\t\t// Otherwise initialize for horizontal or vertical properties\n\t\tname === \"width\" ? 1 : 0,\n\n\t\tval = 0;\n\n\tfor ( ; i < 4; i += 2 ) {\n\n\t\t// Both box models exclude margin, so add it if we want it\n\t\tif ( extra === \"margin\" ) {\n\t\t\tval += jQuery.css( elem, extra + cssExpand[ i ], true, styles );\n\t\t}\n\n\t\tif ( isBorderBox ) {\n\n\t\t\t// border-box includes padding, so remove it if we want content\n\t\t\tif ( extra === \"content\" ) {\n\t\t\t\tval -= jQuery.css( elem, \"padding\" + cssExpand[ i ], true, styles );\n\t\t\t}\n\n\t\t\t// At this point, extra isn't border nor margin, so remove border\n\t\t\tif ( extra !== \"margin\" ) {\n\t\t\t\tval -= jQuery.css( elem, \"border\" + cssExpand[ i ] + \"Width\", true, styles );\n\t\t\t}\n\t\t} else {\n\n\t\t\t// At this point, extra isn't content, so add padding\n\t\t\tval += jQuery.css( elem, \"padding\" + cssExpand[ i ], true, styles );\n\n\t\t\t// At this point, extra isn't content nor padding, so add border\n\t\t\tif ( extra !== \"padding\" ) {\n\t\t\t\tval += jQuery.css( elem, \"border\" + cssExpand[ i ] + \"Width\", true, styles );\n\t\t\t}\n\t\t}\n\t}\n\n\treturn val;\n}\n\nfunction getWidthOrHeight( elem, name, extra ) {\n\n\t// Start with offset property, which is equivalent to the border-box value\n\tvar valueIsBorderBox = true,\n\t\tval = name === \"width\" ? elem.offsetWidth : elem.offsetHeight,\n\t\tstyles = getStyles( elem ),\n\t\tisBorderBox = jQuery.css( elem, \"boxSizing\", false, styles ) === \"border-box\";\n\n\t// Some non-html elements return undefined for offsetWidth, so check for null/undefined\n\t// svg - https://bugzilla.mozilla.org/show_bug.cgi?id=649285\n\t// MathML - https://bugzilla.mozilla.org/show_bug.cgi?id=491668\n\tif ( val <= 0 || val == null ) {\n\n\t\t// Fall back to computed then uncomputed css if necessary\n\t\tval = curCSS( elem, name, styles );\n\t\tif ( val < 0 || val == null ) {\n\t\t\tval = elem.style[ name ];\n\t\t}\n\n\t\t// Computed unit is not pixels. Stop here and return.\n\t\tif ( rnumnonpx.test( val ) ) {\n\t\t\treturn val;\n\t\t}\n\n\t\t// Check for style in case a browser which returns unreliable values\n\t\t// for getComputedStyle silently falls back to the reliable elem.style\n\t\tvalueIsBorderBox = isBorderBox &&\n\t\t\t( support.boxSizingReliable() || val === elem.style[ name ] );\n\n\t\t// Normalize \"\", auto, and prepare for extra\n\t\tval = parseFloat( val ) || 0;\n\t}\n\n\t// Use the active box-sizing model to add/subtract irrelevant styles\n\treturn ( val +\n\t\taugmentWidthOrHeight(\n\t\t\telem,\n\t\t\tname,\n\t\t\textra || ( isBorderBox ? \"border\" : \"content\" ),\n\t\t\tvalueIsBorderBox,\n\t\t\tstyles\n\t\t)\n\t) + \"px\";\n}\n\nfunction showHide( elements, show ) {\n\tvar display, elem, hidden,\n\t\tvalues = [],\n\t\tindex = 0,\n\t\tlength = elements.length;\n\n\tfor ( ; index < length; index++ ) {\n\t\telem = elements[ index ];\n\t\tif ( !elem.style ) {\n\t\t\tcontinue;\n\t\t}\n\n\t\tvalues[ index ] = dataPriv.get( elem, \"olddisplay\" );\n\t\tdisplay = elem.style.display;\n\t\tif ( show ) {\n\n\t\t\t// Reset the inline display of this element to learn if it is\n\t\t\t// being hidden by cascaded rules or not\n\t\t\tif ( !values[ index ] && display === \"none\" ) {\n\t\t\t\telem.style.display = \"\";\n\t\t\t}\n\n\t\t\t// Set elements which have been overridden with display: none\n\t\t\t// in a stylesheet to whatever the default browser style is\n\t\t\t// for such an element\n\t\t\tif ( elem.style.display === \"\" && isHidden( elem ) ) {\n\t\t\t\tvalues[ index ] = dataPriv.access(\n\t\t\t\t\telem,\n\t\t\t\t\t\"olddisplay\",\n\t\t\t\t\tdefaultDisplay( elem.nodeName )\n\t\t\t\t);\n\t\t\t}\n\t\t} else {\n\t\t\thidden = isHidden( elem );\n\n\t\t\tif ( display !== \"none\" || !hidden ) {\n\t\t\t\tdataPriv.set(\n\t\t\t\t\telem,\n\t\t\t\t\t\"olddisplay\",\n\t\t\t\t\thidden ? display : jQuery.css( elem, \"display\" )\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\t}\n\n\t// Set the display of most of the elements in a second loop\n\t// to avoid the constant reflow\n\tfor ( index = 0; index < length; index++ ) {\n\t\telem = elements[ index ];\n\t\tif ( !elem.style ) {\n\t\t\tcontinue;\n\t\t}\n\t\tif ( !show || elem.style.display === \"none\" || elem.style.display === \"\" ) {\n\t\t\telem.style.display = show ? values[ index ] || \"\" : \"none\";\n\t\t}\n\t}\n\n\treturn elements;\n}\n\njQuery.extend( {\n\n\t// Add in style property hooks for overriding the default\n\t// behavior of getting and setting a style property\n\tcssHooks: {\n\t\topacity: {\n\t\t\tget: function( elem, computed ) {\n\t\t\t\tif ( computed ) {\n\n\t\t\t\t\t// We should always get a number back from opacity\n\t\t\t\t\tvar ret = curCSS( elem, \"opacity\" );\n\t\t\t\t\treturn ret === \"\" ? \"1\" : ret;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t},\n\n\t// Don't automatically add \"px\" to these possibly-unitless properties\n\tcssNumber: {\n\t\t\"animationIterationCount\": true,\n\t\t\"columnCount\": true,\n\t\t\"fillOpacity\": true,\n\t\t\"flexGrow\": true,\n\t\t\"flexShrink\": true,\n\t\t\"fontWeight\": true,\n\t\t\"lineHeight\": true,\n\t\t\"opacity\": true,\n\t\t\"order\": true,\n\t\t\"orphans\": true,\n\t\t\"widows\": true,\n\t\t\"zIndex\": true,\n\t\t\"zoom\": true\n\t},\n\n\t// Add in properties whose names you wish to fix before\n\t// setting or getting the value\n\tcssProps: {\n\t\t\"float\": \"cssFloat\"\n\t},\n\n\t// Get and set the style property on a DOM Node\n\tstyle: function( elem, name, value, extra ) {\n\n\t\t// Don't set styles on text and comment nodes\n\t\tif ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Make sure that we're working with the right name\n\t\tvar ret, type, hooks,\n\t\t\torigName = jQuery.camelCase( name ),\n\t\t\tstyle = elem.style;\n\n\t\tname = jQuery.cssProps[ origName ] ||\n\t\t\t( jQuery.cssProps[ origName ] = vendorPropName( origName ) || origName );\n\n\t\t// Gets hook for the prefixed version, then unprefixed version\n\t\thooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];\n\n\t\t// Check if we're setting a value\n\t\tif ( value !== undefined ) {\n\t\t\ttype = typeof value;\n\n\t\t\t// Convert \"+=\" or \"-=\" to relative numbers (#7345)\n\t\t\tif ( type === \"string\" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) {\n\t\t\t\tvalue = adjustCSS( elem, name, ret );\n\n\t\t\t\t// Fixes bug #9237\n\t\t\t\ttype = \"number\";\n\t\t\t}\n\n\t\t\t// Make sure that null and NaN values aren't set (#7116)\n\t\t\tif ( value == null || value !== value ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// If a number was passed in, add the unit (except for certain CSS properties)\n\t\t\tif ( type === \"number\" ) {\n\t\t\t\tvalue += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? \"\" : \"px\" );\n\t\t\t}\n\n\t\t\t// Support: IE9-11+\n\t\t\t// background-* props affect original clone's values\n\t\t\tif ( !support.clearCloneStyle && value === \"\" && name.indexOf( \"background\" ) === 0 ) {\n\t\t\t\tstyle[ name ] = \"inherit\";\n\t\t\t}\n\n\t\t\t// If a hook was provided, use that value, otherwise just set the specified value\n\t\t\tif ( !hooks || !( \"set\" in hooks ) ||\n\t\t\t\t( value = hooks.set( elem, value, extra ) ) !== undefined ) {\n\n\t\t\t\tstyle[ name ] = value;\n\t\t\t}\n\n\t\t} else {\n\n\t\t\t// If a hook was provided get the non-computed value from there\n\t\t\tif ( hooks && \"get\" in hooks &&\n\t\t\t\t( ret = hooks.get( elem, false, extra ) ) !== undefined ) {\n\n\t\t\t\treturn ret;\n\t\t\t}\n\n\t\t\t// Otherwise just get the value from the style object\n\t\t\treturn style[ name ];\n\t\t}\n\t},\n\n\tcss: function( elem, name, extra, styles ) {\n\t\tvar val, num, hooks,\n\t\t\torigName = jQuery.camelCase( name );\n\n\t\t// Make sure that we're working with the right name\n\t\tname = jQuery.cssProps[ origName ] ||\n\t\t\t( jQuery.cssProps[ origName ] = vendorPropName( origName ) || origName );\n\n\t\t// Try prefixed name followed by the unprefixed name\n\t\thooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];\n\n\t\t// If a hook was provided get the computed value from there\n\t\tif ( hooks && \"get\" in hooks ) {\n\t\t\tval = hooks.get( elem, true, extra );\n\t\t}\n\n\t\t// Otherwise, if a way to get the computed value exists, use that\n\t\tif ( val === undefined ) {\n\t\t\tval = curCSS( elem, name, styles );\n\t\t}\n\n\t\t// Convert \"normal\" to computed value\n\t\tif ( val === \"normal\" && name in cssNormalTransform ) {\n\t\t\tval = cssNormalTransform[ name ];\n\t\t}\n\n\t\t// Make numeric if forced or a qualifier was provided and val looks numeric\n\t\tif ( extra === \"\" || extra ) {\n\t\t\tnum = parseFloat( val );\n\t\t\treturn extra === true || isFinite( num ) ? num || 0 : val;\n\t\t}\n\t\treturn val;\n\t}\n} );\n\njQuery.each( [ \"height\", \"width\" ], function( i, name ) {\n\tjQuery.cssHooks[ name ] = {\n\t\tget: function( elem, computed, extra ) {\n\t\t\tif ( computed ) {\n\n\t\t\t\t// Certain elements can have dimension info if we invisibly show them\n\t\t\t\t// but it must have a current display style that would benefit\n\t\t\t\treturn rdisplayswap.test( jQuery.css( elem, \"display\" ) ) &&\n\t\t\t\t\telem.offsetWidth === 0 ?\n\t\t\t\t\t\tswap( elem, cssShow, function() {\n\t\t\t\t\t\t\treturn getWidthOrHeight( elem, name, extra );\n\t\t\t\t\t\t} ) :\n\t\t\t\t\t\tgetWidthOrHeight( elem, name, extra );\n\t\t\t}\n\t\t},\n\n\t\tset: function( elem, value, extra ) {\n\t\t\tvar matches,\n\t\t\t\tstyles = extra && getStyles( elem ),\n\t\t\t\tsubtract = extra && augmentWidthOrHeight(\n\t\t\t\t\telem,\n\t\t\t\t\tname,\n\t\t\t\t\textra,\n\t\t\t\t\tjQuery.css( elem, \"boxSizing\", false, styles ) === \"border-box\",\n\t\t\t\t\tstyles\n\t\t\t\t);\n\n\t\t\t// Convert to pixels if value adjustment is needed\n\t\t\tif ( subtract && ( matches = rcssNum.exec( value ) ) &&\n\t\t\t\t( matches[ 3 ] || \"px\" ) !== \"px\" ) {\n\n\t\t\t\telem.style[ name ] = value;\n\t\t\t\tvalue = jQuery.css( elem, name );\n\t\t\t}\n\n\t\t\treturn setPositiveNumber( elem, value, subtract );\n\t\t}\n\t};\n} );\n\njQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft,\n\tfunction( elem, computed ) {\n\t\tif ( computed ) {\n\t\t\treturn ( parseFloat( curCSS( elem, \"marginLeft\" ) ) ||\n\t\t\t\telem.getBoundingClientRect().left -\n\t\t\t\t\tswap( elem, { marginLeft: 0 }, function() {\n\t\t\t\t\t\treturn elem.getBoundingClientRect().left;\n\t\t\t\t\t} )\n\t\t\t\t) + \"px\";\n\t\t}\n\t}\n);\n\n// Support: Android 2.3\njQuery.cssHooks.marginRight = addGetHookIf( support.reliableMarginRight,\n\tfunction( elem, computed ) {\n\t\tif ( computed ) {\n\t\t\treturn swap( elem, { \"display\": \"inline-block\" },\n\t\t\t\tcurCSS, [ elem, \"marginRight\" ] );\n\t\t}\n\t}\n);\n\n// These hooks are used by animate to expand properties\njQuery.each( {\n\tmargin: \"\",\n\tpadding: \"\",\n\tborder: \"Width\"\n}, function( prefix, suffix ) {\n\tjQuery.cssHooks[ prefix + suffix ] = {\n\t\texpand: function( value ) {\n\t\t\tvar i = 0,\n\t\t\t\texpanded = {},\n\n\t\t\t\t// Assumes a single number if not a string\n\t\t\t\tparts = typeof value === \"string\" ? value.split( \" \" ) : [ value ];\n\n\t\t\tfor ( ; i < 4; i++ ) {\n\t\t\t\texpanded[ prefix + cssExpand[ i ] + suffix ] =\n\t\t\t\t\tparts[ i ] || parts[ i - 2 ] || parts[ 0 ];\n\t\t\t}\n\n\t\t\treturn expanded;\n\t\t}\n\t};\n\n\tif ( !rmargin.test( prefix ) ) {\n\t\tjQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;\n\t}\n} );\n\njQuery.fn.extend( {\n\tcss: function( name, value ) {\n\t\treturn access( this, function( elem, name, value ) {\n\t\t\tvar styles, len,\n\t\t\t\tmap = {},\n\t\t\t\ti = 0;\n\n\t\t\tif ( jQuery.isArray( name ) ) {\n\t\t\t\tstyles = getStyles( elem );\n\t\t\t\tlen = name.length;\n\n\t\t\t\tfor ( ; i < len; i++ ) {\n\t\t\t\t\tmap[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );\n\t\t\t\t}\n\n\t\t\t\treturn map;\n\t\t\t}\n\n\t\t\treturn value !== undefined ?\n\t\t\t\tjQuery.style( elem, name, value ) :\n\t\t\t\tjQuery.css( elem, name );\n\t\t}, name, value, arguments.length > 1 );\n\t},\n\tshow: function() {\n\t\treturn showHide( this, true );\n\t},\n\thide: function() {\n\t\treturn showHide( this );\n\t},\n\ttoggle: function( state ) {\n\t\tif ( typeof state === \"boolean\" ) {\n\t\t\treturn state ? this.show() : this.hide();\n\t\t}\n\n\t\treturn this.each( function() {\n\t\t\tif ( isHidden( this ) ) {\n\t\t\t\tjQuery( this ).show();\n\t\t\t} else {\n\t\t\t\tjQuery( this ).hide();\n\t\t\t}\n\t\t} );\n\t}\n} );\n\n\nfunction Tween( elem, options, prop, end, easing ) {\n\treturn new Tween.prototype.init( elem, options, prop, end, easing );\n}\njQuery.Tween = Tween;\n\nTween.prototype = {\n\tconstructor: Tween,\n\tinit: function( elem, options, prop, end, easing, unit ) {\n\t\tthis.elem = elem;\n\t\tthis.prop = prop;\n\t\tthis.easing = easing || jQuery.easing._default;\n\t\tthis.options = options;\n\t\tthis.start = this.now = this.cur();\n\t\tthis.end = end;\n\t\tthis.unit = unit || ( jQuery.cssNumber[ prop ] ? \"\" : \"px\" );\n\t},\n\tcur: function() {\n\t\tvar hooks = Tween.propHooks[ this.prop ];\n\n\t\treturn hooks && hooks.get ?\n\t\t\thooks.get( this ) :\n\t\t\tTween.propHooks._default.get( this );\n\t},\n\trun: function( percent ) {\n\t\tvar eased,\n\t\t\thooks = Tween.propHooks[ this.prop ];\n\n\t\tif ( this.options.duration ) {\n\t\t\tthis.pos = eased = jQuery.easing[ this.easing ](\n\t\t\t\tpercent, this.options.duration * percent, 0, 1, this.options.duration\n\t\t\t);\n\t\t} else {\n\t\t\tthis.pos = eased = percent;\n\t\t}\n\t\tthis.now = ( this.end - this.start ) * eased + this.start;\n\n\t\tif ( this.options.step ) {\n\t\t\tthis.options.step.call( this.elem, this.now, this );\n\t\t}\n\n\t\tif ( hooks && hooks.set ) {\n\t\t\thooks.set( this );\n\t\t} else {\n\t\t\tTween.propHooks._default.set( this );\n\t\t}\n\t\treturn this;\n\t}\n};\n\nTween.prototype.init.prototype = Tween.prototype;\n\nTween.propHooks = {\n\t_default: {\n\t\tget: function( tween ) {\n\t\t\tvar result;\n\n\t\t\t// Use a property on the element directly when it is not a DOM element,\n\t\t\t// or when there is no matching style property that exists.\n\t\t\tif ( tween.elem.nodeType !== 1 ||\n\t\t\t\ttween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) {\n\t\t\t\treturn tween.elem[ tween.prop ];\n\t\t\t}\n\n\t\t\t// Passing an empty string as a 3rd parameter to .css will automatically\n\t\t\t// attempt a parseFloat and fallback to a string if the parse fails.\n\t\t\t// Simple values such as \"10px\" are parsed to Float;\n\t\t\t// complex values such as \"rotate(1rad)\" are returned as-is.\n\t\t\tresult = jQuery.css( tween.elem, tween.prop, \"\" );\n\n\t\t\t// Empty strings, null, undefined and \"auto\" are converted to 0.\n\t\t\treturn !result || result === \"auto\" ? 0 : result;\n\t\t},\n\t\tset: function( tween ) {\n\n\t\t\t// Use step hook for back compat.\n\t\t\t// Use cssHook if its there.\n\t\t\t// Use .style if available and use plain properties where available.\n\t\t\tif ( jQuery.fx.step[ tween.prop ] ) {\n\t\t\t\tjQuery.fx.step[ tween.prop ]( tween );\n\t\t\t} else if ( tween.elem.nodeType === 1 &&\n\t\t\t\t( tween.elem.style[ jQuery.cssProps[ tween.prop ] ] != null ||\n\t\t\t\t\tjQuery.cssHooks[ tween.prop ] ) ) {\n\t\t\t\tjQuery.style( tween.elem, tween.prop, tween.now + tween.unit );\n\t\t\t} else {\n\t\t\t\ttween.elem[ tween.prop ] = tween.now;\n\t\t\t}\n\t\t}\n\t}\n};\n\n// Support: IE9\n// Panic based approach to setting things on disconnected nodes\nTween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {\n\tset: function( tween ) {\n\t\tif ( tween.elem.nodeType && tween.elem.parentNode ) {\n\t\t\ttween.elem[ tween.prop ] = tween.now;\n\t\t}\n\t}\n};\n\njQuery.easing = {\n\tlinear: function( p ) {\n\t\treturn p;\n\t},\n\tswing: function( p ) {\n\t\treturn 0.5 - Math.cos( p * Math.PI ) / 2;\n\t},\n\t_default: \"swing\"\n};\n\njQuery.fx = Tween.prototype.init;\n\n// Back Compat <1.8 extension point\njQuery.fx.step = {};\n\n\n\n\nvar\n\tfxNow, timerId,\n\trfxtypes = /^(?:toggle|show|hide)$/,\n\trrun = /queueHooks$/;\n\n// Animations created synchronously will run synchronously\nfunction createFxNow() {\n\twindow.setTimeout( function() {\n\t\tfxNow = undefined;\n\t} );\n\treturn ( fxNow = jQuery.now() );\n}\n\n// Generate parameters to create a standard animation\nfunction genFx( type, includeWidth ) {\n\tvar which,\n\t\ti = 0,\n\t\tattrs = { height: type };\n\n\t// If we include width, step value is 1 to do all cssExpand values,\n\t// otherwise step value is 2 to skip over Left and Right\n\tincludeWidth = includeWidth ? 1 : 0;\n\tfor ( ; i < 4 ; i += 2 - includeWidth ) {\n\t\twhich = cssExpand[ i ];\n\t\tattrs[ \"margin\" + which ] = attrs[ \"padding\" + which ] = type;\n\t}\n\n\tif ( includeWidth ) {\n\t\tattrs.opacity = attrs.width = type;\n\t}\n\n\treturn attrs;\n}\n\nfunction createTween( value, prop, animation ) {\n\tvar tween,\n\t\tcollection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ \"*\" ] ),\n\t\tindex = 0,\n\t\tlength = collection.length;\n\tfor ( ; index < length; index++ ) {\n\t\tif ( ( tween = collection[ index ].call( animation, prop, value ) ) ) {\n\n\t\t\t// We're done with this property\n\t\t\treturn tween;\n\t\t}\n\t}\n}\n\nfunction defaultPrefilter( elem, props, opts ) {\n\t/* jshint validthis: true */\n\tvar prop, value, toggle, tween, hooks, oldfire, display, checkDisplay,\n\t\tanim = this,\n\t\torig = {},\n\t\tstyle = elem.style,\n\t\thidden = elem.nodeType && isHidden( elem ),\n\t\tdataShow = dataPriv.get( elem, \"fxshow\" );\n\n\t// Handle queue: false promises\n\tif ( !opts.queue ) {\n\t\thooks = jQuery._queueHooks( elem, \"fx\" );\n\t\tif ( hooks.unqueued == null ) {\n\t\t\thooks.unqueued = 0;\n\t\t\toldfire = hooks.empty.fire;\n\t\t\thooks.empty.fire = function() {\n\t\t\t\tif ( !hooks.unqueued ) {\n\t\t\t\t\toldfire();\n\t\t\t\t}\n\t\t\t};\n\t\t}\n\t\thooks.unqueued++;\n\n\t\tanim.always( function() {\n\n\t\t\t// Ensure the complete handler is called before this completes\n\t\t\tanim.always( function() {\n\t\t\t\thooks.unqueued--;\n\t\t\t\tif ( !jQuery.queue( elem, \"fx\" ).length ) {\n\t\t\t\t\thooks.empty.fire();\n\t\t\t\t}\n\t\t\t} );\n\t\t} );\n\t}\n\n\t// Height/width overflow pass\n\tif ( elem.nodeType === 1 && ( \"height\" in props || \"width\" in props ) ) {\n\n\t\t// Make sure that nothing sneaks out\n\t\t// Record all 3 overflow attributes because IE9-10 do not\n\t\t// change the overflow attribute when overflowX and\n\t\t// overflowY are set to the same value\n\t\topts.overflow = [ style.overflow, style.overflowX, style.overflowY ];\n\n\t\t// Set display property to inline-block for height/width\n\t\t// animations on inline elements that are having width/height animated\n\t\tdisplay = jQuery.css( elem, \"display\" );\n\n\t\t// Test default display if display is currently \"none\"\n\t\tcheckDisplay = display === \"none\" ?\n\t\t\tdataPriv.get( elem, \"olddisplay\" ) || defaultDisplay( elem.nodeName ) : display;\n\n\t\tif ( checkDisplay === \"inline\" && jQuery.css( elem, \"float\" ) === \"none\" ) {\n\t\t\tstyle.display = \"inline-block\";\n\t\t}\n\t}\n\n\tif ( opts.overflow ) {\n\t\tstyle.overflow = \"hidden\";\n\t\tanim.always( function() {\n\t\t\tstyle.overflow = opts.overflow[ 0 ];\n\t\t\tstyle.overflowX = opts.overflow[ 1 ];\n\t\t\tstyle.overflowY = opts.overflow[ 2 ];\n\t\t} );\n\t}\n\n\t// show/hide pass\n\tfor ( prop in props ) {\n\t\tvalue = props[ prop ];\n\t\tif ( rfxtypes.exec( value ) ) {\n\t\t\tdelete props[ prop ];\n\t\t\ttoggle = toggle || value === \"toggle\";\n\t\t\tif ( value === ( hidden ? \"hide\" : \"show\" ) ) {\n\n\t\t\t\t// If there is dataShow left over from a stopped hide or show\n\t\t\t\t// and we are going to proceed with show, we should pretend to be hidden\n\t\t\t\tif ( value === \"show\" && dataShow && dataShow[ prop ] !== undefined ) {\n\t\t\t\t\thidden = true;\n\t\t\t\t} else {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t}\n\t\t\torig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop );\n\n\t\t// Any non-fx value stops us from restoring the original display value\n\t\t} else {\n\t\t\tdisplay = undefined;\n\t\t}\n\t}\n\n\tif ( !jQuery.isEmptyObject( orig ) ) {\n\t\tif ( dataShow ) {\n\t\t\tif ( \"hidden\" in dataShow ) {\n\t\t\t\thidden = dataShow.hidden;\n\t\t\t}\n\t\t} else {\n\t\t\tdataShow = dataPriv.access( elem, \"fxshow\", {} );\n\t\t}\n\n\t\t// Store state if its toggle - enables .stop().toggle() to \"reverse\"\n\t\tif ( toggle ) {\n\t\t\tdataShow.hidden = !hidden;\n\t\t}\n\t\tif ( hidden ) {\n\t\t\tjQuery( elem ).show();\n\t\t} else {\n\t\t\tanim.done( function() {\n\t\t\t\tjQuery( elem ).hide();\n\t\t\t} );\n\t\t}\n\t\tanim.done( function() {\n\t\t\tvar prop;\n\n\t\t\tdataPriv.remove( elem, \"fxshow\" );\n\t\t\tfor ( prop in orig ) {\n\t\t\t\tjQuery.style( elem, prop, orig[ prop ] );\n\t\t\t}\n\t\t} );\n\t\tfor ( prop in orig ) {\n\t\t\ttween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim );\n\n\t\t\tif ( !( prop in dataShow ) ) {\n\t\t\t\tdataShow[ prop ] = tween.start;\n\t\t\t\tif ( hidden ) {\n\t\t\t\t\ttween.end = tween.start;\n\t\t\t\t\ttween.start = prop === \"width\" || prop === \"height\" ? 1 : 0;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t// If this is a noop like .hide().hide(), restore an overwritten display value\n\t} else if ( ( display === \"none\" ? defaultDisplay( elem.nodeName ) : display ) === \"inline\" ) {\n\t\tstyle.display = display;\n\t}\n}\n\nfunction propFilter( props, specialEasing ) {\n\tvar index, name, easing, value, hooks;\n\n\t// camelCase, specialEasing and expand cssHook pass\n\tfor ( index in props ) {\n\t\tname = jQuery.camelCase( index );\n\t\teasing = specialEasing[ name ];\n\t\tvalue = props[ index ];\n\t\tif ( jQuery.isArray( value ) ) {\n\t\t\teasing = value[ 1 ];\n\t\t\tvalue = props[ index ] = value[ 0 ];\n\t\t}\n\n\t\tif ( index !== name ) {\n\t\t\tprops[ name ] = value;\n\t\t\tdelete props[ index ];\n\t\t}\n\n\t\thooks = jQuery.cssHooks[ name ];\n\t\tif ( hooks && \"expand\" in hooks ) {\n\t\t\tvalue = hooks.expand( value );\n\t\t\tdelete props[ name ];\n\n\t\t\t// Not quite $.extend, this won't overwrite existing keys.\n\t\t\t// Reusing 'index' because we have the correct \"name\"\n\t\t\tfor ( index in value ) {\n\t\t\t\tif ( !( index in props ) ) {\n\t\t\t\t\tprops[ index ] = value[ index ];\n\t\t\t\t\tspecialEasing[ index ] = easing;\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tspecialEasing[ name ] = easing;\n\t\t}\n\t}\n}\n\nfunction Animation( elem, properties, options ) {\n\tvar result,\n\t\tstopped,\n\t\tindex = 0,\n\t\tlength = Animation.prefilters.length,\n\t\tdeferred = jQuery.Deferred().always( function() {\n\n\t\t\t// Don't match elem in the :animated selector\n\t\t\tdelete tick.elem;\n\t\t} ),\n\t\ttick = function() {\n\t\t\tif ( stopped ) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t\tvar currentTime = fxNow || createFxNow(),\n\t\t\t\tremaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),\n\n\t\t\t\t// Support: Android 2.3\n\t\t\t\t// Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497)\n\t\t\t\ttemp = remaining / animation.duration || 0,\n\t\t\t\tpercent = 1 - temp,\n\t\t\t\tindex = 0,\n\t\t\t\tlength = animation.tweens.length;\n\n\t\t\tfor ( ; index < length ; index++ ) {\n\t\t\t\tanimation.tweens[ index ].run( percent );\n\t\t\t}\n\n\t\t\tdeferred.notifyWith( elem, [ animation, percent, remaining ] );\n\n\t\t\tif ( percent < 1 && length ) {\n\t\t\t\treturn remaining;\n\t\t\t} else {\n\t\t\t\tdeferred.resolveWith( elem, [ animation ] );\n\t\t\t\treturn false;\n\t\t\t}\n\t\t},\n\t\tanimation = deferred.promise( {\n\t\t\telem: elem,\n\t\t\tprops: jQuery.extend( {}, properties ),\n\t\t\topts: jQuery.extend( true, {\n\t\t\t\tspecialEasing: {},\n\t\t\t\teasing: jQuery.easing._default\n\t\t\t}, options ),\n\t\t\toriginalProperties: properties,\n\t\t\toriginalOptions: options,\n\t\t\tstartTime: fxNow || createFxNow(),\n\t\t\tduration: options.duration,\n\t\t\ttweens: [],\n\t\t\tcreateTween: function( prop, end ) {\n\t\t\t\tvar tween = jQuery.Tween( elem, animation.opts, prop, end,\n\t\t\t\t\t\tanimation.opts.specialEasing[ prop ] || animation.opts.easing );\n\t\t\t\tanimation.tweens.push( tween );\n\t\t\t\treturn tween;\n\t\t\t},\n\t\t\tstop: function( gotoEnd ) {\n\t\t\t\tvar index = 0,\n\n\t\t\t\t\t// If we are going to the end, we want to run all the tweens\n\t\t\t\t\t// otherwise we skip this part\n\t\t\t\t\tlength = gotoEnd ? animation.tweens.length : 0;\n\t\t\t\tif ( stopped ) {\n\t\t\t\t\treturn this;\n\t\t\t\t}\n\t\t\t\tstopped = true;\n\t\t\t\tfor ( ; index < length ; index++ ) {\n\t\t\t\t\tanimation.tweens[ index ].run( 1 );\n\t\t\t\t}\n\n\t\t\t\t// Resolve when we played the last frame; otherwise, reject\n\t\t\t\tif ( gotoEnd ) {\n\t\t\t\t\tdeferred.notifyWith( elem, [ animation, 1, 0 ] );\n\t\t\t\t\tdeferred.resolveWith( elem, [ animation, gotoEnd ] );\n\t\t\t\t} else {\n\t\t\t\t\tdeferred.rejectWith( elem, [ animation, gotoEnd ] );\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t}\n\t\t} ),\n\t\tprops = animation.props;\n\n\tpropFilter( props, animation.opts.specialEasing );\n\n\tfor ( ; index < length ; index++ ) {\n\t\tresult = Animation.prefilters[ index ].call( animation, elem, props, animation.opts );\n\t\tif ( result ) {\n\t\t\tif ( jQuery.isFunction( result.stop ) ) {\n\t\t\t\tjQuery._queueHooks( animation.elem, animation.opts.queue ).stop =\n\t\t\t\t\tjQuery.proxy( result.stop, result );\n\t\t\t}\n\t\t\treturn result;\n\t\t}\n\t}\n\n\tjQuery.map( props, createTween, animation );\n\n\tif ( jQuery.isFunction( animation.opts.start ) ) {\n\t\tanimation.opts.start.call( elem, animation );\n\t}\n\n\tjQuery.fx.timer(\n\t\tjQuery.extend( tick, {\n\t\t\telem: elem,\n\t\t\tanim: animation,\n\t\t\tqueue: animation.opts.queue\n\t\t} )\n\t);\n\n\t// attach callbacks from options\n\treturn animation.progress( animation.opts.progress )\n\t\t.done( animation.opts.done, animation.opts.complete )\n\t\t.fail( animation.opts.fail )\n\t\t.always( animation.opts.always );\n}\n\njQuery.Animation = jQuery.extend( Animation, {\n\ttweeners: {\n\t\t\"*\": [ function( prop, value ) {\n\t\t\tvar tween = this.createTween( prop, value );\n\t\t\tadjustCSS( tween.elem, prop, rcssNum.exec( value ), tween );\n\t\t\treturn tween;\n\t\t} ]\n\t},\n\n\ttweener: function( props, callback ) {\n\t\tif ( jQuery.isFunction( props ) ) {\n\t\t\tcallback = props;\n\t\t\tprops = [ \"*\" ];\n\t\t} else {\n\t\t\tprops = props.match( rnotwhite );\n\t\t}\n\n\t\tvar prop,\n\t\t\tindex = 0,\n\t\t\tlength = props.length;\n\n\t\tfor ( ; index < length ; index++ ) {\n\t\t\tprop = props[ index ];\n\t\t\tAnimation.tweeners[ prop ] = Animation.tweeners[ prop ] || [];\n\t\t\tAnimation.tweeners[ prop ].unshift( callback );\n\t\t}\n\t},\n\n\tprefilters: [ defaultPrefilter ],\n\n\tprefilter: function( callback, prepend ) {\n\t\tif ( prepend ) {\n\t\t\tAnimation.prefilters.unshift( callback );\n\t\t} else {\n\t\t\tAnimation.prefilters.push( callback );\n\t\t}\n\t}\n} );\n\njQuery.speed = function( speed, easing, fn ) {\n\tvar opt = speed && typeof speed === \"object\" ? jQuery.extend( {}, speed ) : {\n\t\tcomplete: fn || !fn && easing ||\n\t\t\tjQuery.isFunction( speed ) && speed,\n\t\tduration: speed,\n\t\teasing: fn && easing || easing && !jQuery.isFunction( easing ) && easing\n\t};\n\n\topt.duration = jQuery.fx.off ? 0 : typeof opt.duration === \"number\" ?\n\t\topt.duration : opt.duration in jQuery.fx.speeds ?\n\t\t\tjQuery.fx.speeds[ opt.duration ] : jQuery.fx.speeds._default;\n\n\t// Normalize opt.queue - true/undefined/null -> \"fx\"\n\tif ( opt.queue == null || opt.queue === true ) {\n\t\topt.queue = \"fx\";\n\t}\n\n\t// Queueing\n\topt.old = opt.complete;\n\n\topt.complete = function() {\n\t\tif ( jQuery.isFunction( opt.old ) ) {\n\t\t\topt.old.call( this );\n\t\t}\n\n\t\tif ( opt.queue ) {\n\t\t\tjQuery.dequeue( this, opt.queue );\n\t\t}\n\t};\n\n\treturn opt;\n};\n\njQuery.fn.extend( {\n\tfadeTo: function( speed, to, easing, callback ) {\n\n\t\t// Show any hidden elements after setting opacity to 0\n\t\treturn this.filter( isHidden ).css( \"opacity\", 0 ).show()\n\n\t\t\t// Animate to the value specified\n\t\t\t.end().animate( { opacity: to }, speed, easing, callback );\n\t},\n\tanimate: function( prop, speed, easing, callback ) {\n\t\tvar empty = jQuery.isEmptyObject( prop ),\n\t\t\toptall = jQuery.speed( speed, easing, callback ),\n\t\t\tdoAnimation = function() {\n\n\t\t\t\t// Operate on a copy of prop so per-property easing won't be lost\n\t\t\t\tvar anim = Animation( this, jQuery.extend( {}, prop ), optall );\n\n\t\t\t\t// Empty animations, or finishing resolves immediately\n\t\t\t\tif ( empty || dataPriv.get( this, \"finish\" ) ) {\n\t\t\t\t\tanim.stop( true );\n\t\t\t\t}\n\t\t\t};\n\t\t\tdoAnimation.finish = doAnimation;\n\n\t\treturn empty || optall.queue === false ?\n\t\t\tthis.each( doAnimation ) :\n\t\t\tthis.queue( optall.queue, doAnimation );\n\t},\n\tstop: function( type, clearQueue, gotoEnd ) {\n\t\tvar stopQueue = function( hooks ) {\n\t\t\tvar stop = hooks.stop;\n\t\t\tdelete hooks.stop;\n\t\t\tstop( gotoEnd );\n\t\t};\n\n\t\tif ( typeof type !== \"string\" ) {\n\t\t\tgotoEnd = clearQueue;\n\t\t\tclearQueue = type;\n\t\t\ttype = undefined;\n\t\t}\n\t\tif ( clearQueue && type !== false ) {\n\t\t\tthis.queue( type || \"fx\", [] );\n\t\t}\n\n\t\treturn this.each( function() {\n\t\t\tvar dequeue = true,\n\t\t\t\tindex = type != null && type + \"queueHooks\",\n\t\t\t\ttimers = jQuery.timers,\n\t\t\t\tdata = dataPriv.get( this );\n\n\t\t\tif ( index ) {\n\t\t\t\tif ( data[ index ] && data[ index ].stop ) {\n\t\t\t\t\tstopQueue( data[ index ] );\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tfor ( index in data ) {\n\t\t\t\t\tif ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {\n\t\t\t\t\t\tstopQueue( data[ index ] );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tfor ( index = timers.length; index--; ) {\n\t\t\t\tif ( timers[ index ].elem === this &&\n\t\t\t\t\t( type == null || timers[ index ].queue === type ) ) {\n\n\t\t\t\t\ttimers[ index ].anim.stop( gotoEnd );\n\t\t\t\t\tdequeue = false;\n\t\t\t\t\ttimers.splice( index, 1 );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Start the next in the queue if the last step wasn't forced.\n\t\t\t// Timers currently will call their complete callbacks, which\n\t\t\t// will dequeue but only if they were gotoEnd.\n\t\t\tif ( dequeue || !gotoEnd ) {\n\t\t\t\tjQuery.dequeue( this, type );\n\t\t\t}\n\t\t} );\n\t},\n\tfinish: function( type ) {\n\t\tif ( type !== false ) {\n\t\t\ttype = type || \"fx\";\n\t\t}\n\t\treturn this.each( function() {\n\t\t\tvar index,\n\t\t\t\tdata = dataPriv.get( this ),\n\t\t\t\tqueue = data[ type + \"queue\" ],\n\t\t\t\thooks = data[ type + \"queueHooks\" ],\n\t\t\t\ttimers = jQuery.timers,\n\t\t\t\tlength = queue ? queue.length : 0;\n\n\t\t\t// Enable finishing flag on private data\n\t\t\tdata.finish = true;\n\n\t\t\t// Empty the queue first\n\t\t\tjQuery.queue( this, type, [] );\n\n\t\t\tif ( hooks && hooks.stop ) {\n\t\t\t\thooks.stop.call( this, true );\n\t\t\t}\n\n\t\t\t// Look for any active animations, and finish them\n\t\t\tfor ( index = timers.length; index--; ) {\n\t\t\t\tif ( timers[ index ].elem === this && timers[ index ].queue === type ) {\n\t\t\t\t\ttimers[ index ].anim.stop( true );\n\t\t\t\t\ttimers.splice( index, 1 );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Look for any animations in the old queue and finish them\n\t\t\tfor ( index = 0; index < length; index++ ) {\n\t\t\t\tif ( queue[ index ] && queue[ index ].finish ) {\n\t\t\t\t\tqueue[ index ].finish.call( this );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Turn off finishing flag\n\t\t\tdelete data.finish;\n\t\t} );\n\t}\n} );\n\njQuery.each( [ \"toggle\", \"show\", \"hide\" ], function( i, name ) {\n\tvar cssFn = jQuery.fn[ name ];\n\tjQuery.fn[ name ] = function( speed, easing, callback ) {\n\t\treturn speed == null || typeof speed === \"boolean\" ?\n\t\t\tcssFn.apply( this, arguments ) :\n\t\t\tthis.animate( genFx( name, true ), speed, easing, callback );\n\t};\n} );\n\n// Generate shortcuts for custom animations\njQuery.each( {\n\tslideDown: genFx( \"show\" ),\n\tslideUp: genFx( \"hide\" ),\n\tslideToggle: genFx( \"toggle\" ),\n\tfadeIn: { opacity: \"show\" },\n\tfadeOut: { opacity: \"hide\" },\n\tfadeToggle: { opacity: \"toggle\" }\n}, function( name, props ) {\n\tjQuery.fn[ name ] = function( speed, easing, callback ) {\n\t\treturn this.animate( props, speed, easing, callback );\n\t};\n} );\n\njQuery.timers = [];\njQuery.fx.tick = function() {\n\tvar timer,\n\t\ti = 0,\n\t\ttimers = jQuery.timers;\n\n\tfxNow = jQuery.now();\n\n\tfor ( ; i < timers.length; i++ ) {\n\t\ttimer = timers[ i ];\n\n\t\t// Checks the timer has not already been removed\n\t\tif ( !timer() && timers[ i ] === timer ) {\n\t\t\ttimers.splice( i--, 1 );\n\t\t}\n\t}\n\n\tif ( !timers.length ) {\n\t\tjQuery.fx.stop();\n\t}\n\tfxNow = undefined;\n};\n\njQuery.fx.timer = function( timer ) {\n\tjQuery.timers.push( timer );\n\tif ( timer() ) {\n\t\tjQuery.fx.start();\n\t} else {\n\t\tjQuery.timers.pop();\n\t}\n};\n\njQuery.fx.interval = 13;\njQuery.fx.start = function() {\n\tif ( !timerId ) {\n\t\ttimerId = window.setInterval( jQuery.fx.tick, jQuery.fx.interval );\n\t}\n};\n\njQuery.fx.stop = function() {\n\twindow.clearInterval( timerId );\n\n\ttimerId = null;\n};\n\njQuery.fx.speeds = {\n\tslow: 600,\n\tfast: 200,\n\n\t// Default speed\n\t_default: 400\n};\n\n\n// Based off of the plugin by Clint Helfers, with permission.\n// http://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/\njQuery.fn.delay = function( time, type ) {\n\ttime = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;\n\ttype = type || \"fx\";\n\n\treturn this.queue( type, function( next, hooks ) {\n\t\tvar timeout = window.setTimeout( next, time );\n\t\thooks.stop = function() {\n\t\t\twindow.clearTimeout( timeout );\n\t\t};\n\t} );\n};\n\n\n( function() {\n\tvar input = document.createElement( \"input\" ),\n\t\tselect = document.createElement( \"select\" ),\n\t\topt = select.appendChild( document.createElement( \"option\" ) );\n\n\tinput.type = \"checkbox\";\n\n\t// Support: iOS<=5.1, Android<=4.2+\n\t// Default value for a checkbox should be \"on\"\n\tsupport.checkOn = input.value !== \"\";\n\n\t// Support: IE<=11+\n\t// Must access selectedIndex to make default options select\n\tsupport.optSelected = opt.selected;\n\n\t// Support: Android<=2.3\n\t// Options inside disabled selects are incorrectly marked as disabled\n\tselect.disabled = true;\n\tsupport.optDisabled = !opt.disabled;\n\n\t// Support: IE<=11+\n\t// An input loses its value after becoming a radio\n\tinput = document.createElement( \"input\" );\n\tinput.value = \"t\";\n\tinput.type = \"radio\";\n\tsupport.radioValue = input.value === \"t\";\n} )();\n\n\nvar boolHook,\n\tattrHandle = jQuery.expr.attrHandle;\n\njQuery.fn.extend( {\n\tattr: function( name, value ) {\n\t\treturn access( this, jQuery.attr, name, value, arguments.length > 1 );\n\t},\n\n\tremoveAttr: function( name ) {\n\t\treturn this.each( function() {\n\t\t\tjQuery.removeAttr( this, name );\n\t\t} );\n\t}\n} );\n\njQuery.extend( {\n\tattr: function( elem, name, value ) {\n\t\tvar ret, hooks,\n\t\t\tnType = elem.nodeType;\n\n\t\t// Don't get/set attributes on text, comment and attribute nodes\n\t\tif ( nType === 3 || nType === 8 || nType === 2 ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Fallback to prop when attributes are not supported\n\t\tif ( typeof elem.getAttribute === \"undefined\" ) {\n\t\t\treturn jQuery.prop( elem, name, value );\n\t\t}\n\n\t\t// All attributes are lowercase\n\t\t// Grab necessary hook if one is defined\n\t\tif ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {\n\t\t\tname = name.toLowerCase();\n\t\t\thooks = jQuery.attrHooks[ name ] ||\n\t\t\t\t( jQuery.expr.match.bool.test( name ) ? boolHook : undefined );\n\t\t}\n\n\t\tif ( value !== undefined ) {\n\t\t\tif ( value === null ) {\n\t\t\t\tjQuery.removeAttr( elem, name );\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tif ( hooks && \"set\" in hooks &&\n\t\t\t\t( ret = hooks.set( elem, value, name ) ) !== undefined ) {\n\t\t\t\treturn ret;\n\t\t\t}\n\n\t\t\telem.setAttribute( name, value + \"\" );\n\t\t\treturn value;\n\t\t}\n\n\t\tif ( hooks && \"get\" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {\n\t\t\treturn ret;\n\t\t}\n\n\t\tret = jQuery.find.attr( elem, name );\n\n\t\t// Non-existent attributes return null, we normalize to undefined\n\t\treturn ret == null ? undefined : ret;\n\t},\n\n\tattrHooks: {\n\t\ttype: {\n\t\t\tset: function( elem, value ) {\n\t\t\t\tif ( !support.radioValue && value === \"radio\" &&\n\t\t\t\t\tjQuery.nodeName( elem, \"input\" ) ) {\n\t\t\t\t\tvar val = elem.value;\n\t\t\t\t\telem.setAttribute( \"type\", value );\n\t\t\t\t\tif ( val ) {\n\t\t\t\t\t\telem.value = val;\n\t\t\t\t\t}\n\t\t\t\t\treturn value;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t},\n\n\tremoveAttr: function( elem, value ) {\n\t\tvar name, propName,\n\t\t\ti = 0,\n\t\t\tattrNames = value && value.match( rnotwhite );\n\n\t\tif ( attrNames && elem.nodeType === 1 ) {\n\t\t\twhile ( ( name = attrNames[ i++ ] ) ) {\n\t\t\t\tpropName = jQuery.propFix[ name ] || name;\n\n\t\t\t\t// Boolean attributes get special treatment (#10870)\n\t\t\t\tif ( jQuery.expr.match.bool.test( name ) ) {\n\n\t\t\t\t\t// Set corresponding property to false\n\t\t\t\t\telem[ propName ] = false;\n\t\t\t\t}\n\n\t\t\t\telem.removeAttribute( name );\n\t\t\t}\n\t\t}\n\t}\n} );\n\n// Hooks for boolean attributes\nboolHook = {\n\tset: function( elem, value, name ) {\n\t\tif ( value === false ) {\n\n\t\t\t// Remove boolean attributes when set to false\n\t\t\tjQuery.removeAttr( elem, name );\n\t\t} else {\n\t\t\telem.setAttribute( name, name );\n\t\t}\n\t\treturn name;\n\t}\n};\njQuery.each( jQuery.expr.match.bool.source.match( /\\w+/g ), function( i, name ) {\n\tvar getter = attrHandle[ name ] || jQuery.find.attr;\n\n\tattrHandle[ name ] = function( elem, name, isXML ) {\n\t\tvar ret, handle;\n\t\tif ( !isXML ) {\n\n\t\t\t// Avoid an infinite loop by temporarily removing this function from the getter\n\t\t\thandle = attrHandle[ name ];\n\t\t\tattrHandle[ name ] = ret;\n\t\t\tret = getter( elem, name, isXML ) != null ?\n\t\t\t\tname.toLowerCase() :\n\t\t\t\tnull;\n\t\t\tattrHandle[ name ] = handle;\n\t\t}\n\t\treturn ret;\n\t};\n} );\n\n\n\n\nvar rfocusable = /^(?:input|select|textarea|button)$/i,\n\trclickable = /^(?:a|area)$/i;\n\njQuery.fn.extend( {\n\tprop: function( name, value ) {\n\t\treturn access( this, jQuery.prop, name, value, arguments.length > 1 );\n\t},\n\n\tremoveProp: function( name ) {\n\t\treturn this.each( function() {\n\t\t\tdelete this[ jQuery.propFix[ name ] || name ];\n\t\t} );\n\t}\n} );\n\njQuery.extend( {\n\tprop: function( elem, name, value ) {\n\t\tvar ret, hooks,\n\t\t\tnType = elem.nodeType;\n\n\t\t// Don't get/set properties on text, comment and attribute nodes\n\t\tif ( nType === 3 || nType === 8 || nType === 2 ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {\n\n\t\t\t// Fix name and attach hooks\n\t\t\tname = jQuery.propFix[ name ] || name;\n\t\t\thooks = jQuery.propHooks[ name ];\n\t\t}\n\n\t\tif ( value !== undefined ) {\n\t\t\tif ( hooks && \"set\" in hooks &&\n\t\t\t\t( ret = hooks.set( elem, value, name ) ) !== undefined ) {\n\t\t\t\treturn ret;\n\t\t\t}\n\n\t\t\treturn ( elem[ name ] = value );\n\t\t}\n\n\t\tif ( hooks && \"get\" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {\n\t\t\treturn ret;\n\t\t}\n\n\t\treturn elem[ name ];\n\t},\n\n\tpropHooks: {\n\t\ttabIndex: {\n\t\t\tget: function( elem ) {\n\n\t\t\t\t// elem.tabIndex doesn't always return the\n\t\t\t\t// correct value when it hasn't been explicitly set\n\t\t\t\t// http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/\n\t\t\t\t// Use proper attribute retrieval(#12072)\n\t\t\t\tvar tabindex = jQuery.find.attr( elem, \"tabindex\" );\n\n\t\t\t\treturn tabindex ?\n\t\t\t\t\tparseInt( tabindex, 10 ) :\n\t\t\t\t\trfocusable.test( elem.nodeName ) ||\n\t\t\t\t\t\trclickable.test( elem.nodeName ) && elem.href ?\n\t\t\t\t\t\t\t0 :\n\t\t\t\t\t\t\t-1;\n\t\t\t}\n\t\t}\n\t},\n\n\tpropFix: {\n\t\t\"for\": \"htmlFor\",\n\t\t\"class\": \"className\"\n\t}\n} );\n\n// Support: IE <=11 only\n// Accessing the selectedIndex property\n// forces the browser to respect setting selected\n// on the option\n// The getter ensures a default option is selected\n// when in an optgroup\nif ( !support.optSelected ) {\n\tjQuery.propHooks.selected = {\n\t\tget: function( elem ) {\n\t\t\tvar parent = elem.parentNode;\n\t\t\tif ( parent && parent.parentNode ) {\n\t\t\t\tparent.parentNode.selectedIndex;\n\t\t\t}\n\t\t\treturn null;\n\t\t},\n\t\tset: function( elem ) {\n\t\t\tvar parent = elem.parentNode;\n\t\t\tif ( parent ) {\n\t\t\t\tparent.selectedIndex;\n\n\t\t\t\tif ( parent.parentNode ) {\n\t\t\t\t\tparent.parentNode.selectedIndex;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n}\n\njQuery.each( [\n\t\"tabIndex\",\n\t\"readOnly\",\n\t\"maxLength\",\n\t\"cellSpacing\",\n\t\"cellPadding\",\n\t\"rowSpan\",\n\t\"colSpan\",\n\t\"useMap\",\n\t\"frameBorder\",\n\t\"contentEditable\"\n], function() {\n\tjQuery.propFix[ this.toLowerCase() ] = this;\n} );\n\n\n\n\nvar rclass = /[\\t\\r\\n\\f]/g;\n\nfunction getClass( elem ) {\n\treturn elem.getAttribute && elem.getAttribute( \"class\" ) || \"\";\n}\n\njQuery.fn.extend( {\n\taddClass: function( value ) {\n\t\tvar classes, elem, cur, curValue, clazz, j, finalValue,\n\t\t\ti = 0;\n\n\t\tif ( jQuery.isFunction( value ) ) {\n\t\t\treturn this.each( function( j ) {\n\t\t\t\tjQuery( this ).addClass( value.call( this, j, getClass( this ) ) );\n\t\t\t} );\n\t\t}\n\n\t\tif ( typeof value === \"string\" && value ) {\n\t\t\tclasses = value.match( rnotwhite ) || [];\n\n\t\t\twhile ( ( elem = this[ i++ ] ) ) {\n\t\t\t\tcurValue = getClass( elem );\n\t\t\t\tcur = elem.nodeType === 1 &&\n\t\t\t\t\t( \" \" + curValue + \" \" ).replace( rclass, \" \" );\n\n\t\t\t\tif ( cur ) {\n\t\t\t\t\tj = 0;\n\t\t\t\t\twhile ( ( clazz = classes[ j++ ] ) ) {\n\t\t\t\t\t\tif ( cur.indexOf( \" \" + clazz + \" \" ) < 0 ) {\n\t\t\t\t\t\t\tcur += clazz + \" \";\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Only assign if different to avoid unneeded rendering.\n\t\t\t\t\tfinalValue = jQuery.trim( cur );\n\t\t\t\t\tif ( curValue !== finalValue ) {\n\t\t\t\t\t\telem.setAttribute( \"class\", finalValue );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn this;\n\t},\n\n\tremoveClass: function( value ) {\n\t\tvar classes, elem, cur, curValue, clazz, j, finalValue,\n\t\t\ti = 0;\n\n\t\tif ( jQuery.isFunction( value ) ) {\n\t\t\treturn this.each( function( j ) {\n\t\t\t\tjQuery( this ).removeClass( value.call( this, j, getClass( this ) ) );\n\t\t\t} );\n\t\t}\n\n\t\tif ( !arguments.length ) {\n\t\t\treturn this.attr( \"class\", \"\" );\n\t\t}\n\n\t\tif ( typeof value === \"string\" && value ) {\n\t\t\tclasses = value.match( rnotwhite ) || [];\n\n\t\t\twhile ( ( elem = this[ i++ ] ) ) {\n\t\t\t\tcurValue = getClass( elem );\n\n\t\t\t\t// This expression is here for better compressibility (see addClass)\n\t\t\t\tcur = elem.nodeType === 1 &&\n\t\t\t\t\t( \" \" + curValue + \" \" ).replace( rclass, \" \" );\n\n\t\t\t\tif ( cur ) {\n\t\t\t\t\tj = 0;\n\t\t\t\t\twhile ( ( clazz = classes[ j++ ] ) ) {\n\n\t\t\t\t\t\t// Remove *all* instances\n\t\t\t\t\t\twhile ( cur.indexOf( \" \" + clazz + \" \" ) > -1 ) {\n\t\t\t\t\t\t\tcur = cur.replace( \" \" + clazz + \" \", \" \" );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Only assign if different to avoid unneeded rendering.\n\t\t\t\t\tfinalValue = jQuery.trim( cur );\n\t\t\t\t\tif ( curValue !== finalValue ) {\n\t\t\t\t\t\telem.setAttribute( \"class\", finalValue );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn this;\n\t},\n\n\ttoggleClass: function( value, stateVal ) {\n\t\tvar type = typeof value;\n\n\t\tif ( typeof stateVal === \"boolean\" && type === \"string\" ) {\n\t\t\treturn stateVal ? this.addClass( value ) : this.removeClass( value );\n\t\t}\n\n\t\tif ( jQuery.isFunction( value ) ) {\n\t\t\treturn this.each( function( i ) {\n\t\t\t\tjQuery( this ).toggleClass(\n\t\t\t\t\tvalue.call( this, i, getClass( this ), stateVal ),\n\t\t\t\t\tstateVal\n\t\t\t\t);\n\t\t\t} );\n\t\t}\n\n\t\treturn this.each( function() {\n\t\t\tvar className, i, self, classNames;\n\n\t\t\tif ( type === \"string\" ) {\n\n\t\t\t\t// Toggle individual class names\n\t\t\t\ti = 0;\n\t\t\t\tself = jQuery( this );\n\t\t\t\tclassNames = value.match( rnotwhite ) || [];\n\n\t\t\t\twhile ( ( className = classNames[ i++ ] ) ) {\n\n\t\t\t\t\t// Check each className given, space separated list\n\t\t\t\t\tif ( self.hasClass( className ) ) {\n\t\t\t\t\t\tself.removeClass( className );\n\t\t\t\t\t} else {\n\t\t\t\t\t\tself.addClass( className );\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t// Toggle whole class name\n\t\t\t} else if ( value === undefined || type === \"boolean\" ) {\n\t\t\t\tclassName = getClass( this );\n\t\t\t\tif ( className ) {\n\n\t\t\t\t\t// Store className if set\n\t\t\t\t\tdataPriv.set( this, \"__className__\", className );\n\t\t\t\t}\n\n\t\t\t\t// If the element has a class name or if we're passed `false`,\n\t\t\t\t// then remove the whole classname (if there was one, the above saved it).\n\t\t\t\t// Otherwise bring back whatever was previously saved (if anything),\n\t\t\t\t// falling back to the empty string if nothing was stored.\n\t\t\t\tif ( this.setAttribute ) {\n\t\t\t\t\tthis.setAttribute( \"class\",\n\t\t\t\t\t\tclassName || value === false ?\n\t\t\t\t\t\t\"\" :\n\t\t\t\t\t\tdataPriv.get( this, \"__className__\" ) || \"\"\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t}\n\t\t} );\n\t},\n\n\thasClass: function( selector ) {\n\t\tvar className, elem,\n\t\t\ti = 0;\n\n\t\tclassName = \" \" + selector + \" \";\n\t\twhile ( ( elem = this[ i++ ] ) ) {\n\t\t\tif ( elem.nodeType === 1 &&\n\t\t\t\t( \" \" + getClass( elem ) + \" \" ).replace( rclass, \" \" )\n\t\t\t\t\t.indexOf( className ) > -1\n\t\t\t) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\n\t\treturn false;\n\t}\n} );\n\n\n\n\nvar rreturn = /\\r/g,\n\trspaces = /[\\x20\\t\\r\\n\\f]+/g;\n\njQuery.fn.extend( {\n\tval: function( value ) {\n\t\tvar hooks, ret, isFunction,\n\t\t\telem = this[ 0 ];\n\n\t\tif ( !arguments.length ) {\n\t\t\tif ( elem ) {\n\t\t\t\thooks = jQuery.valHooks[ elem.type ] ||\n\t\t\t\t\tjQuery.valHooks[ elem.nodeName.toLowerCase() ];\n\n\t\t\t\tif ( hooks &&\n\t\t\t\t\t\"get\" in hooks &&\n\t\t\t\t\t( ret = hooks.get( elem, \"value\" ) ) !== undefined\n\t\t\t\t) {\n\t\t\t\t\treturn ret;\n\t\t\t\t}\n\n\t\t\t\tret = elem.value;\n\n\t\t\t\treturn typeof ret === \"string\" ?\n\n\t\t\t\t\t// Handle most common string cases\n\t\t\t\t\tret.replace( rreturn, \"\" ) :\n\n\t\t\t\t\t// Handle cases where value is null/undef or number\n\t\t\t\t\tret == null ? \"\" : ret;\n\t\t\t}\n\n\t\t\treturn;\n\t\t}\n\n\t\tisFunction = jQuery.isFunction( value );\n\n\t\treturn this.each( function( i ) {\n\t\t\tvar val;\n\n\t\t\tif ( this.nodeType !== 1 ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tif ( isFunction ) {\n\t\t\t\tval = value.call( this, i, jQuery( this ).val() );\n\t\t\t} else {\n\t\t\t\tval = value;\n\t\t\t}\n\n\t\t\t// Treat null/undefined as \"\"; convert numbers to string\n\t\t\tif ( val == null ) {\n\t\t\t\tval = \"\";\n\n\t\t\t} else if ( typeof val === \"number\" ) {\n\t\t\t\tval += \"\";\n\n\t\t\t} else if ( jQuery.isArray( val ) ) {\n\t\t\t\tval = jQuery.map( val, function( value ) {\n\t\t\t\t\treturn value == null ? \"\" : value + \"\";\n\t\t\t\t} );\n\t\t\t}\n\n\t\t\thooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];\n\n\t\t\t// If set returns undefined, fall back to normal setting\n\t\t\tif ( !hooks || !( \"set\" in hooks ) || hooks.set( this, val, \"value\" ) === undefined ) {\n\t\t\t\tthis.value = val;\n\t\t\t}\n\t\t} );\n\t}\n} );\n\njQuery.extend( {\n\tvalHooks: {\n\t\toption: {\n\t\t\tget: function( elem ) {\n\n\t\t\t\tvar val = jQuery.find.attr( elem, \"value\" );\n\t\t\t\treturn val != null ?\n\t\t\t\t\tval :\n\n\t\t\t\t\t// Support: IE10-11+\n\t\t\t\t\t// option.text throws exceptions (#14686, #14858)\n\t\t\t\t\t// Strip and collapse whitespace\n\t\t\t\t\t// https://html.spec.whatwg.org/#strip-and-collapse-whitespace\n\t\t\t\t\tjQuery.trim( jQuery.text( elem ) ).replace( rspaces, \" \" );\n\t\t\t}\n\t\t},\n\t\tselect: {\n\t\t\tget: function( elem ) {\n\t\t\t\tvar value, option,\n\t\t\t\t\toptions = elem.options,\n\t\t\t\t\tindex = elem.selectedIndex,\n\t\t\t\t\tone = elem.type === \"select-one\" || index < 0,\n\t\t\t\t\tvalues = one ? null : [],\n\t\t\t\t\tmax = one ? index + 1 : options.length,\n\t\t\t\t\ti = index < 0 ?\n\t\t\t\t\t\tmax :\n\t\t\t\t\t\tone ? index : 0;\n\n\t\t\t\t// Loop through all the selected options\n\t\t\t\tfor ( ; i < max; i++ ) {\n\t\t\t\t\toption = options[ i ];\n\n\t\t\t\t\t// IE8-9 doesn't update selected after form reset (#2551)\n\t\t\t\t\tif ( ( option.selected || i === index ) &&\n\n\t\t\t\t\t\t\t// Don't return options that are disabled or in a disabled optgroup\n\t\t\t\t\t\t\t( support.optDisabled ?\n\t\t\t\t\t\t\t\t!option.disabled : option.getAttribute( \"disabled\" ) === null ) &&\n\t\t\t\t\t\t\t( !option.parentNode.disabled ||\n\t\t\t\t\t\t\t\t!jQuery.nodeName( option.parentNode, \"optgroup\" ) ) ) {\n\n\t\t\t\t\t\t// Get the specific value for the option\n\t\t\t\t\t\tvalue = jQuery( option ).val();\n\n\t\t\t\t\t\t// We don't need an array for one selects\n\t\t\t\t\t\tif ( one ) {\n\t\t\t\t\t\t\treturn value;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Multi-Selects return an array\n\t\t\t\t\t\tvalues.push( value );\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\treturn values;\n\t\t\t},\n\n\t\t\tset: function( elem, value ) {\n\t\t\t\tvar optionSet, option,\n\t\t\t\t\toptions = elem.options,\n\t\t\t\t\tvalues = jQuery.makeArray( value ),\n\t\t\t\t\ti = options.length;\n\n\t\t\t\twhile ( i-- ) {\n\t\t\t\t\toption = options[ i ];\n\t\t\t\t\tif ( option.selected =\n\t\t\t\t\t\tjQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1\n\t\t\t\t\t) {\n\t\t\t\t\t\toptionSet = true;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Force browsers to behave consistently when non-matching value is set\n\t\t\t\tif ( !optionSet ) {\n\t\t\t\t\telem.selectedIndex = -1;\n\t\t\t\t}\n\t\t\t\treturn values;\n\t\t\t}\n\t\t}\n\t}\n} );\n\n// Radios and checkboxes getter/setter\njQuery.each( [ \"radio\", \"checkbox\" ], function() {\n\tjQuery.valHooks[ this ] = {\n\t\tset: function( elem, value ) {\n\t\t\tif ( jQuery.isArray( value ) ) {\n\t\t\t\treturn ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 );\n\t\t\t}\n\t\t}\n\t};\n\tif ( !support.checkOn ) {\n\t\tjQuery.valHooks[ this ].get = function( elem ) {\n\t\t\treturn elem.getAttribute( \"value\" ) === null ? \"on\" : elem.value;\n\t\t};\n\t}\n} );\n\n\n\n\n// Return jQuery for attributes-only inclusion\n\n\nvar rfocusMorph = /^(?:focusinfocus|focusoutblur)$/;\n\njQuery.extend( jQuery.event, {\n\n\ttrigger: function( event, data, elem, onlyHandlers ) {\n\n\t\tvar i, cur, tmp, bubbleType, ontype, handle, special,\n\t\t\teventPath = [ elem || document ],\n\t\t\ttype = hasOwn.call( event, \"type\" ) ? event.type : event,\n\t\t\tnamespaces = hasOwn.call( event, \"namespace\" ) ? event.namespace.split( \".\" ) : [];\n\n\t\tcur = tmp = elem = elem || document;\n\n\t\t// Don't do events on text and comment nodes\n\t\tif ( elem.nodeType === 3 || elem.nodeType === 8 ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// focus/blur morphs to focusin/out; ensure we're not firing them right now\n\t\tif ( rfocusMorph.test( type + jQuery.event.triggered ) ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( type.indexOf( \".\" ) > -1 ) {\n\n\t\t\t// Namespaced trigger; create a regexp to match event type in handle()\n\t\t\tnamespaces = type.split( \".\" );\n\t\t\ttype = namespaces.shift();\n\t\t\tnamespaces.sort();\n\t\t}\n\t\tontype = type.indexOf( \":\" ) < 0 && \"on\" + type;\n\n\t\t// Caller can pass in a jQuery.Event object, Object, or just an event type string\n\t\tevent = event[ jQuery.expando ] ?\n\t\t\tevent :\n\t\t\tnew jQuery.Event( type, typeof event === \"object\" && event );\n\n\t\t// Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)\n\t\tevent.isTrigger = onlyHandlers ? 2 : 3;\n\t\tevent.namespace = namespaces.join( \".\" );\n\t\tevent.rnamespace = event.namespace ?\n\t\t\tnew RegExp( \"(^|\\\\.)\" + namespaces.join( \"\\\\.(?:.*\\\\.|)\" ) + \"(\\\\.|$)\" ) :\n\t\t\tnull;\n\n\t\t// Clean up the event in case it is being reused\n\t\tevent.result = undefined;\n\t\tif ( !event.target ) {\n\t\t\tevent.target = elem;\n\t\t}\n\n\t\t// Clone any incoming data and prepend the event, creating the handler arg list\n\t\tdata = data == null ?\n\t\t\t[ event ] :\n\t\t\tjQuery.makeArray( data, [ event ] );\n\n\t\t// Allow special events to draw outside the lines\n\t\tspecial = jQuery.event.special[ type ] || {};\n\t\tif ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Determine event propagation path in advance, per W3C events spec (#9951)\n\t\t// Bubble up to document, then to window; watch for a global ownerDocument var (#9724)\n\t\tif ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) {\n\n\t\t\tbubbleType = special.delegateType || type;\n\t\t\tif ( !rfocusMorph.test( bubbleType + type ) ) {\n\t\t\t\tcur = cur.parentNode;\n\t\t\t}\n\t\t\tfor ( ; cur; cur = cur.parentNode ) {\n\t\t\t\teventPath.push( cur );\n\t\t\t\ttmp = cur;\n\t\t\t}\n\n\t\t\t// Only add window if we got to document (e.g., not plain obj or detached DOM)\n\t\t\tif ( tmp === ( elem.ownerDocument || document ) ) {\n\t\t\t\teventPath.push( tmp.defaultView || tmp.parentWindow || window );\n\t\t\t}\n\t\t}\n\n\t\t// Fire handlers on the event path\n\t\ti = 0;\n\t\twhile ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) {\n\n\t\t\tevent.type = i > 1 ?\n\t\t\t\tbubbleType :\n\t\t\t\tspecial.bindType || type;\n\n\t\t\t// jQuery handler\n\t\t\thandle = ( dataPriv.get( cur, \"events\" ) || {} )[ event.type ] &&\n\t\t\t\tdataPriv.get( cur, \"handle\" );\n\t\t\tif ( handle ) {\n\t\t\t\thandle.apply( cur, data );\n\t\t\t}\n\n\t\t\t// Native handler\n\t\t\thandle = ontype && cur[ ontype ];\n\t\t\tif ( handle && handle.apply && acceptData( cur ) ) {\n\t\t\t\tevent.result = handle.apply( cur, data );\n\t\t\t\tif ( event.result === false ) {\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tevent.type = type;\n\n\t\t// If nobody prevented the default action, do it now\n\t\tif ( !onlyHandlers && !event.isDefaultPrevented() ) {\n\n\t\t\tif ( ( !special._default ||\n\t\t\t\tspecial._default.apply( eventPath.pop(), data ) === false ) &&\n\t\t\t\tacceptData( elem ) ) {\n\n\t\t\t\t// Call a native DOM method on the target with the same name name as the event.\n\t\t\t\t// Don't do default actions on window, that's where global variables be (#6170)\n\t\t\t\tif ( ontype && jQuery.isFunction( elem[ type ] ) && !jQuery.isWindow( elem ) ) {\n\n\t\t\t\t\t// Don't re-trigger an onFOO event when we call its FOO() method\n\t\t\t\t\ttmp = elem[ ontype ];\n\n\t\t\t\t\tif ( tmp ) {\n\t\t\t\t\t\telem[ ontype ] = null;\n\t\t\t\t\t}\n\n\t\t\t\t\t// Prevent re-triggering of the same event, since we already bubbled it above\n\t\t\t\t\tjQuery.event.triggered = type;\n\t\t\t\t\telem[ type ]();\n\t\t\t\t\tjQuery.event.triggered = undefined;\n\n\t\t\t\t\tif ( tmp ) {\n\t\t\t\t\t\telem[ ontype ] = tmp;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn event.result;\n\t},\n\n\t// Piggyback on a donor event to simulate a different one\n\t// Used only for `focus(in | out)` events\n\tsimulate: function( type, elem, event ) {\n\t\tvar e = jQuery.extend(\n\t\t\tnew jQuery.Event(),\n\t\t\tevent,\n\t\t\t{\n\t\t\t\ttype: type,\n\t\t\t\tisSimulated: true\n\t\t\t}\n\t\t);\n\n\t\tjQuery.event.trigger( e, null, elem );\n\t}\n\n} );\n\njQuery.fn.extend( {\n\n\ttrigger: function( type, data ) {\n\t\treturn this.each( function() {\n\t\t\tjQuery.event.trigger( type, data, this );\n\t\t} );\n\t},\n\ttriggerHandler: function( type, data ) {\n\t\tvar elem = this[ 0 ];\n\t\tif ( elem ) {\n\t\t\treturn jQuery.event.trigger( type, data, elem, true );\n\t\t}\n\t}\n} );\n\n\njQuery.each( ( \"blur focus focusin focusout load resize scroll unload click dblclick \" +\n\t\"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave \" +\n\t\"change select submit keydown keypress keyup error contextmenu\" ).split( \" \" ),\n\tfunction( i, name ) {\n\n\t// Handle event binding\n\tjQuery.fn[ name ] = function( data, fn ) {\n\t\treturn arguments.length > 0 ?\n\t\t\tthis.on( name, null, data, fn ) :\n\t\t\tthis.trigger( name );\n\t};\n} );\n\njQuery.fn.extend( {\n\thover: function( fnOver, fnOut ) {\n\t\treturn this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );\n\t}\n} );\n\n\n\n\nsupport.focusin = \"onfocusin\" in window;\n\n\n// Support: Firefox\n// Firefox doesn't have focus(in | out) events\n// Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787\n//\n// Support: Chrome, Safari\n// focus(in | out) events fire after focus & blur events,\n// which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order\n// Related ticket - https://code.google.com/p/chromium/issues/detail?id=449857\nif ( !support.focusin ) {\n\tjQuery.each( { focus: \"focusin\", blur: \"focusout\" }, function( orig, fix ) {\n\n\t\t// Attach a single capturing handler on the document while someone wants focusin/focusout\n\t\tvar handler = function( event ) {\n\t\t\tjQuery.event.simulate( fix, event.target, jQuery.event.fix( event ) );\n\t\t};\n\n\t\tjQuery.event.special[ fix ] = {\n\t\t\tsetup: function() {\n\t\t\t\tvar doc = this.ownerDocument || this,\n\t\t\t\t\tattaches = dataPriv.access( doc, fix );\n\n\t\t\t\tif ( !attaches ) {\n\t\t\t\t\tdoc.addEventListener( orig, handler, true );\n\t\t\t\t}\n\t\t\t\tdataPriv.access( doc, fix, ( attaches || 0 ) + 1 );\n\t\t\t},\n\t\t\tteardown: function() {\n\t\t\t\tvar doc = this.ownerDocument || this,\n\t\t\t\t\tattaches = dataPriv.access( doc, fix ) - 1;\n\n\t\t\t\tif ( !attaches ) {\n\t\t\t\t\tdoc.removeEventListener( orig, handler, true );\n\t\t\t\t\tdataPriv.remove( doc, fix );\n\n\t\t\t\t} else {\n\t\t\t\t\tdataPriv.access( doc, fix, attaches );\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\t} );\n}\nvar location = window.location;\n\nvar nonce = jQuery.now();\n\nvar rquery = ( /\\?/ );\n\n\n\n// Support: Android 2.3\n// Workaround failure to string-cast null input\njQuery.parseJSON = function( data ) {\n\treturn JSON.parse( data + \"\" );\n};\n\n\n// Cross-browser xml parsing\njQuery.parseXML = function( data ) {\n\tvar xml;\n\tif ( !data || typeof data !== \"string\" ) {\n\t\treturn null;\n\t}\n\n\t// Support: IE9\n\ttry {\n\t\txml = ( new window.DOMParser() ).parseFromString( data, \"text/xml\" );\n\t} catch ( e ) {\n\t\txml = undefined;\n\t}\n\n\tif ( !xml || xml.getElementsByTagName( \"parsererror\" ).length ) {\n\t\tjQuery.error( \"Invalid XML: \" + data );\n\t}\n\treturn xml;\n};\n\n\nvar\n\trhash = /#.*$/,\n\trts = /([?&])_=[^&]*/,\n\trheaders = /^(.*?):[ \\t]*([^\\r\\n]*)$/mg,\n\n\t// #7653, #8125, #8152: local protocol detection\n\trlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,\n\trnoContent = /^(?:GET|HEAD)$/,\n\trprotocol = /^\\/\\//,\n\n\t/* Prefilters\n\t * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)\n\t * 2) These are called:\n\t *    - BEFORE asking for a transport\n\t *    - AFTER param serialization (s.data is a string if s.processData is true)\n\t * 3) key is the dataType\n\t * 4) the catchall symbol \"*\" can be used\n\t * 5) execution will start with transport dataType and THEN continue down to \"*\" if needed\n\t */\n\tprefilters = {},\n\n\t/* Transports bindings\n\t * 1) key is the dataType\n\t * 2) the catchall symbol \"*\" can be used\n\t * 3) selection will start with transport dataType and THEN go to \"*\" if needed\n\t */\n\ttransports = {},\n\n\t// Avoid comment-prolog char sequence (#10098); must appease lint and evade compression\n\tallTypes = \"*/\".concat( \"*\" ),\n\n\t// Anchor tag for parsing the document origin\n\toriginAnchor = document.createElement( \"a\" );\n\toriginAnchor.href = location.href;\n\n// Base \"constructor\" for jQuery.ajaxPrefilter and jQuery.ajaxTransport\nfunction addToPrefiltersOrTransports( structure ) {\n\n\t// dataTypeExpression is optional and defaults to \"*\"\n\treturn function( dataTypeExpression, func ) {\n\n\t\tif ( typeof dataTypeExpression !== \"string\" ) {\n\t\t\tfunc = dataTypeExpression;\n\t\t\tdataTypeExpression = \"*\";\n\t\t}\n\n\t\tvar dataType,\n\t\t\ti = 0,\n\t\t\tdataTypes = dataTypeExpression.toLowerCase().match( rnotwhite ) || [];\n\n\t\tif ( jQuery.isFunction( func ) ) {\n\n\t\t\t// For each dataType in the dataTypeExpression\n\t\t\twhile ( ( dataType = dataTypes[ i++ ] ) ) {\n\n\t\t\t\t// Prepend if requested\n\t\t\t\tif ( dataType[ 0 ] === \"+\" ) {\n\t\t\t\t\tdataType = dataType.slice( 1 ) || \"*\";\n\t\t\t\t\t( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func );\n\n\t\t\t\t// Otherwise append\n\t\t\t\t} else {\n\t\t\t\t\t( structure[ dataType ] = structure[ dataType ] || [] ).push( func );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n}\n\n// Base inspection function for prefilters and transports\nfunction inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {\n\n\tvar inspected = {},\n\t\tseekingTransport = ( structure === transports );\n\n\tfunction inspect( dataType ) {\n\t\tvar selected;\n\t\tinspected[ dataType ] = true;\n\t\tjQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {\n\t\t\tvar dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );\n\t\t\tif ( typeof dataTypeOrTransport === \"string\" &&\n\t\t\t\t!seekingTransport && !inspected[ dataTypeOrTransport ] ) {\n\n\t\t\t\toptions.dataTypes.unshift( dataTypeOrTransport );\n\t\t\t\tinspect( dataTypeOrTransport );\n\t\t\t\treturn false;\n\t\t\t} else if ( seekingTransport ) {\n\t\t\t\treturn !( selected = dataTypeOrTransport );\n\t\t\t}\n\t\t} );\n\t\treturn selected;\n\t}\n\n\treturn inspect( options.dataTypes[ 0 ] ) || !inspected[ \"*\" ] && inspect( \"*\" );\n}\n\n// A special extend for ajax options\n// that takes \"flat\" options (not to be deep extended)\n// Fixes #9887\nfunction ajaxExtend( target, src ) {\n\tvar key, deep,\n\t\tflatOptions = jQuery.ajaxSettings.flatOptions || {};\n\n\tfor ( key in src ) {\n\t\tif ( src[ key ] !== undefined ) {\n\t\t\t( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];\n\t\t}\n\t}\n\tif ( deep ) {\n\t\tjQuery.extend( true, target, deep );\n\t}\n\n\treturn target;\n}\n\n/* Handles responses to an ajax request:\n * - finds the right dataType (mediates between content-type and expected dataType)\n * - returns the corresponding response\n */\nfunction ajaxHandleResponses( s, jqXHR, responses ) {\n\n\tvar ct, type, finalDataType, firstDataType,\n\t\tcontents = s.contents,\n\t\tdataTypes = s.dataTypes;\n\n\t// Remove auto dataType and get content-type in the process\n\twhile ( dataTypes[ 0 ] === \"*\" ) {\n\t\tdataTypes.shift();\n\t\tif ( ct === undefined ) {\n\t\t\tct = s.mimeType || jqXHR.getResponseHeader( \"Content-Type\" );\n\t\t}\n\t}\n\n\t// Check if we're dealing with a known content-type\n\tif ( ct ) {\n\t\tfor ( type in contents ) {\n\t\t\tif ( contents[ type ] && contents[ type ].test( ct ) ) {\n\t\t\t\tdataTypes.unshift( type );\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n\n\t// Check to see if we have a response for the expected dataType\n\tif ( dataTypes[ 0 ] in responses ) {\n\t\tfinalDataType = dataTypes[ 0 ];\n\t} else {\n\n\t\t// Try convertible dataTypes\n\t\tfor ( type in responses ) {\n\t\t\tif ( !dataTypes[ 0 ] || s.converters[ type + \" \" + dataTypes[ 0 ] ] ) {\n\t\t\t\tfinalDataType = type;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tif ( !firstDataType ) {\n\t\t\t\tfirstDataType = type;\n\t\t\t}\n\t\t}\n\n\t\t// Or just use first one\n\t\tfinalDataType = finalDataType || firstDataType;\n\t}\n\n\t// If we found a dataType\n\t// We add the dataType to the list if needed\n\t// and return the corresponding response\n\tif ( finalDataType ) {\n\t\tif ( finalDataType !== dataTypes[ 0 ] ) {\n\t\t\tdataTypes.unshift( finalDataType );\n\t\t}\n\t\treturn responses[ finalDataType ];\n\t}\n}\n\n/* Chain conversions given the request and the original response\n * Also sets the responseXXX fields on the jqXHR instance\n */\nfunction ajaxConvert( s, response, jqXHR, isSuccess ) {\n\tvar conv2, current, conv, tmp, prev,\n\t\tconverters = {},\n\n\t\t// Work with a copy of dataTypes in case we need to modify it for conversion\n\t\tdataTypes = s.dataTypes.slice();\n\n\t// Create converters map with lowercased keys\n\tif ( dataTypes[ 1 ] ) {\n\t\tfor ( conv in s.converters ) {\n\t\t\tconverters[ conv.toLowerCase() ] = s.converters[ conv ];\n\t\t}\n\t}\n\n\tcurrent = dataTypes.shift();\n\n\t// Convert to each sequential dataType\n\twhile ( current ) {\n\n\t\tif ( s.responseFields[ current ] ) {\n\t\t\tjqXHR[ s.responseFields[ current ] ] = response;\n\t\t}\n\n\t\t// Apply the dataFilter if provided\n\t\tif ( !prev && isSuccess && s.dataFilter ) {\n\t\t\tresponse = s.dataFilter( response, s.dataType );\n\t\t}\n\n\t\tprev = current;\n\t\tcurrent = dataTypes.shift();\n\n\t\tif ( current ) {\n\n\t\t// There's only work to do if current dataType is non-auto\n\t\t\tif ( current === \"*\" ) {\n\n\t\t\t\tcurrent = prev;\n\n\t\t\t// Convert response if prev dataType is non-auto and differs from current\n\t\t\t} else if ( prev !== \"*\" && prev !== current ) {\n\n\t\t\t\t// Seek a direct converter\n\t\t\t\tconv = converters[ prev + \" \" + current ] || converters[ \"* \" + current ];\n\n\t\t\t\t// If none found, seek a pair\n\t\t\t\tif ( !conv ) {\n\t\t\t\t\tfor ( conv2 in converters ) {\n\n\t\t\t\t\t\t// If conv2 outputs current\n\t\t\t\t\t\ttmp = conv2.split( \" \" );\n\t\t\t\t\t\tif ( tmp[ 1 ] === current ) {\n\n\t\t\t\t\t\t\t// If prev can be converted to accepted input\n\t\t\t\t\t\t\tconv = converters[ prev + \" \" + tmp[ 0 ] ] ||\n\t\t\t\t\t\t\t\tconverters[ \"* \" + tmp[ 0 ] ];\n\t\t\t\t\t\t\tif ( conv ) {\n\n\t\t\t\t\t\t\t\t// Condense equivalence converters\n\t\t\t\t\t\t\t\tif ( conv === true ) {\n\t\t\t\t\t\t\t\t\tconv = converters[ conv2 ];\n\n\t\t\t\t\t\t\t\t// Otherwise, insert the intermediate dataType\n\t\t\t\t\t\t\t\t} else if ( converters[ conv2 ] !== true ) {\n\t\t\t\t\t\t\t\t\tcurrent = tmp[ 0 ];\n\t\t\t\t\t\t\t\t\tdataTypes.unshift( tmp[ 1 ] );\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Apply converter (if not an equivalence)\n\t\t\t\tif ( conv !== true ) {\n\n\t\t\t\t\t// Unless errors are allowed to bubble, catch and return them\n\t\t\t\t\tif ( conv && s.throws ) {\n\t\t\t\t\t\tresponse = conv( response );\n\t\t\t\t\t} else {\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\tresponse = conv( response );\n\t\t\t\t\t\t} catch ( e ) {\n\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\tstate: \"parsererror\",\n\t\t\t\t\t\t\t\terror: conv ? e : \"No conversion from \" + prev + \" to \" + current\n\t\t\t\t\t\t\t};\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn { state: \"success\", data: response };\n}\n\njQuery.extend( {\n\n\t// Counter for holding the number of active queries\n\tactive: 0,\n\n\t// Last-Modified header cache for next request\n\tlastModified: {},\n\tetag: {},\n\n\tajaxSettings: {\n\t\turl: location.href,\n\t\ttype: \"GET\",\n\t\tisLocal: rlocalProtocol.test( location.protocol ),\n\t\tglobal: true,\n\t\tprocessData: true,\n\t\tasync: true,\n\t\tcontentType: \"application/x-www-form-urlencoded; charset=UTF-8\",\n\t\t/*\n\t\ttimeout: 0,\n\t\tdata: null,\n\t\tdataType: null,\n\t\tusername: null,\n\t\tpassword: null,\n\t\tcache: null,\n\t\tthrows: false,\n\t\ttraditional: false,\n\t\theaders: {},\n\t\t*/\n\n\t\taccepts: {\n\t\t\t\"*\": allTypes,\n\t\t\ttext: \"text/plain\",\n\t\t\thtml: \"text/html\",\n\t\t\txml: \"application/xml, text/xml\",\n\t\t\tjson: \"application/json, text/javascript\"\n\t\t},\n\n\t\tcontents: {\n\t\t\txml: /\\bxml\\b/,\n\t\t\thtml: /\\bhtml/,\n\t\t\tjson: /\\bjson\\b/\n\t\t},\n\n\t\tresponseFields: {\n\t\t\txml: \"responseXML\",\n\t\t\ttext: \"responseText\",\n\t\t\tjson: \"responseJSON\"\n\t\t},\n\n\t\t// Data converters\n\t\t// Keys separate source (or catchall \"*\") and destination types with a single space\n\t\tconverters: {\n\n\t\t\t// Convert anything to text\n\t\t\t\"* text\": String,\n\n\t\t\t// Text to html (true = no transformation)\n\t\t\t\"text html\": true,\n\n\t\t\t// Evaluate text as a json expression\n\t\t\t\"text json\": jQuery.parseJSON,\n\n\t\t\t// Parse text as xml\n\t\t\t\"text xml\": jQuery.parseXML\n\t\t},\n\n\t\t// For options that shouldn't be deep extended:\n\t\t// you can add your own custom options here if\n\t\t// and when you create one that shouldn't be\n\t\t// deep extended (see ajaxExtend)\n\t\tflatOptions: {\n\t\t\turl: true,\n\t\t\tcontext: true\n\t\t}\n\t},\n\n\t// Creates a full fledged settings object into target\n\t// with both ajaxSettings and settings fields.\n\t// If target is omitted, writes into ajaxSettings.\n\tajaxSetup: function( target, settings ) {\n\t\treturn settings ?\n\n\t\t\t// Building a settings object\n\t\t\tajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :\n\n\t\t\t// Extending ajaxSettings\n\t\t\tajaxExtend( jQuery.ajaxSettings, target );\n\t},\n\n\tajaxPrefilter: addToPrefiltersOrTransports( prefilters ),\n\tajaxTransport: addToPrefiltersOrTransports( transports ),\n\n\t// Main method\n\tajax: function( url, options ) {\n\n\t\t// If url is an object, simulate pre-1.5 signature\n\t\tif ( typeof url === \"object\" ) {\n\t\t\toptions = url;\n\t\t\turl = undefined;\n\t\t}\n\n\t\t// Force options to be an object\n\t\toptions = options || {};\n\n\t\tvar transport,\n\n\t\t\t// URL without anti-cache param\n\t\t\tcacheURL,\n\n\t\t\t// Response headers\n\t\t\tresponseHeadersString,\n\t\t\tresponseHeaders,\n\n\t\t\t// timeout handle\n\t\t\ttimeoutTimer,\n\n\t\t\t// Url cleanup var\n\t\t\turlAnchor,\n\n\t\t\t// To know if global events are to be dispatched\n\t\t\tfireGlobals,\n\n\t\t\t// Loop variable\n\t\t\ti,\n\n\t\t\t// Create the final options object\n\t\t\ts = jQuery.ajaxSetup( {}, options ),\n\n\t\t\t// Callbacks context\n\t\t\tcallbackContext = s.context || s,\n\n\t\t\t// Context for global events is callbackContext if it is a DOM node or jQuery collection\n\t\t\tglobalEventContext = s.context &&\n\t\t\t\t( callbackContext.nodeType || callbackContext.jquery ) ?\n\t\t\t\t\tjQuery( callbackContext ) :\n\t\t\t\t\tjQuery.event,\n\n\t\t\t// Deferreds\n\t\t\tdeferred = jQuery.Deferred(),\n\t\t\tcompleteDeferred = jQuery.Callbacks( \"once memory\" ),\n\n\t\t\t// Status-dependent callbacks\n\t\t\tstatusCode = s.statusCode || {},\n\n\t\t\t// Headers (they are sent all at once)\n\t\t\trequestHeaders = {},\n\t\t\trequestHeadersNames = {},\n\n\t\t\t// The jqXHR state\n\t\t\tstate = 0,\n\n\t\t\t// Default abort message\n\t\t\tstrAbort = \"canceled\",\n\n\t\t\t// Fake xhr\n\t\t\tjqXHR = {\n\t\t\t\treadyState: 0,\n\n\t\t\t\t// Builds headers hashtable if needed\n\t\t\t\tgetResponseHeader: function( key ) {\n\t\t\t\t\tvar match;\n\t\t\t\t\tif ( state === 2 ) {\n\t\t\t\t\t\tif ( !responseHeaders ) {\n\t\t\t\t\t\t\tresponseHeaders = {};\n\t\t\t\t\t\t\twhile ( ( match = rheaders.exec( responseHeadersString ) ) ) {\n\t\t\t\t\t\t\t\tresponseHeaders[ match[ 1 ].toLowerCase() ] = match[ 2 ];\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\tmatch = responseHeaders[ key.toLowerCase() ];\n\t\t\t\t\t}\n\t\t\t\t\treturn match == null ? null : match;\n\t\t\t\t},\n\n\t\t\t\t// Raw string\n\t\t\t\tgetAllResponseHeaders: function() {\n\t\t\t\t\treturn state === 2 ? responseHeadersString : null;\n\t\t\t\t},\n\n\t\t\t\t// Caches the header\n\t\t\t\tsetRequestHeader: function( name, value ) {\n\t\t\t\t\tvar lname = name.toLowerCase();\n\t\t\t\t\tif ( !state ) {\n\t\t\t\t\t\tname = requestHeadersNames[ lname ] = requestHeadersNames[ lname ] || name;\n\t\t\t\t\t\trequestHeaders[ name ] = value;\n\t\t\t\t\t}\n\t\t\t\t\treturn this;\n\t\t\t\t},\n\n\t\t\t\t// Overrides response content-type header\n\t\t\t\toverrideMimeType: function( type ) {\n\t\t\t\t\tif ( !state ) {\n\t\t\t\t\t\ts.mimeType = type;\n\t\t\t\t\t}\n\t\t\t\t\treturn this;\n\t\t\t\t},\n\n\t\t\t\t// Status-dependent callbacks\n\t\t\t\tstatusCode: function( map ) {\n\t\t\t\t\tvar code;\n\t\t\t\t\tif ( map ) {\n\t\t\t\t\t\tif ( state < 2 ) {\n\t\t\t\t\t\t\tfor ( code in map ) {\n\n\t\t\t\t\t\t\t\t// Lazy-add the new callback in a way that preserves old ones\n\t\t\t\t\t\t\t\tstatusCode[ code ] = [ statusCode[ code ], map[ code ] ];\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t// Execute the appropriate callbacks\n\t\t\t\t\t\t\tjqXHR.always( map[ jqXHR.status ] );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\treturn this;\n\t\t\t\t},\n\n\t\t\t\t// Cancel the request\n\t\t\t\tabort: function( statusText ) {\n\t\t\t\t\tvar finalText = statusText || strAbort;\n\t\t\t\t\tif ( transport ) {\n\t\t\t\t\t\ttransport.abort( finalText );\n\t\t\t\t\t}\n\t\t\t\t\tdone( 0, finalText );\n\t\t\t\t\treturn this;\n\t\t\t\t}\n\t\t\t};\n\n\t\t// Attach deferreds\n\t\tdeferred.promise( jqXHR ).complete = completeDeferred.add;\n\t\tjqXHR.success = jqXHR.done;\n\t\tjqXHR.error = jqXHR.fail;\n\n\t\t// Remove hash character (#7531: and string promotion)\n\t\t// Add protocol if not provided (prefilters might expect it)\n\t\t// Handle falsy url in the settings object (#10093: consistency with old signature)\n\t\t// We also use the url parameter if available\n\t\ts.url = ( ( url || s.url || location.href ) + \"\" ).replace( rhash, \"\" )\n\t\t\t.replace( rprotocol, location.protocol + \"//\" );\n\n\t\t// Alias method option to type as per ticket #12004\n\t\ts.type = options.method || options.type || s.method || s.type;\n\n\t\t// Extract dataTypes list\n\t\ts.dataTypes = jQuery.trim( s.dataType || \"*\" ).toLowerCase().match( rnotwhite ) || [ \"\" ];\n\n\t\t// A cross-domain request is in order when the origin doesn't match the current origin.\n\t\tif ( s.crossDomain == null ) {\n\t\t\turlAnchor = document.createElement( \"a\" );\n\n\t\t\t// Support: IE8-11+\n\t\t\t// IE throws exception if url is malformed, e.g. http://example.com:80x/\n\t\t\ttry {\n\t\t\t\turlAnchor.href = s.url;\n\n\t\t\t\t// Support: IE8-11+\n\t\t\t\t// Anchor's host property isn't correctly set when s.url is relative\n\t\t\t\turlAnchor.href = urlAnchor.href;\n\t\t\t\ts.crossDomain = originAnchor.protocol + \"//\" + originAnchor.host !==\n\t\t\t\t\turlAnchor.protocol + \"//\" + urlAnchor.host;\n\t\t\t} catch ( e ) {\n\n\t\t\t\t// If there is an error parsing the URL, assume it is crossDomain,\n\t\t\t\t// it can be rejected by the transport if it is invalid\n\t\t\t\ts.crossDomain = true;\n\t\t\t}\n\t\t}\n\n\t\t// Convert data if not already a string\n\t\tif ( s.data && s.processData && typeof s.data !== \"string\" ) {\n\t\t\ts.data = jQuery.param( s.data, s.traditional );\n\t\t}\n\n\t\t// Apply prefilters\n\t\tinspectPrefiltersOrTransports( prefilters, s, options, jqXHR );\n\n\t\t// If request was aborted inside a prefilter, stop there\n\t\tif ( state === 2 ) {\n\t\t\treturn jqXHR;\n\t\t}\n\n\t\t// We can fire global events as of now if asked to\n\t\t// Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118)\n\t\tfireGlobals = jQuery.event && s.global;\n\n\t\t// Watch for a new set of requests\n\t\tif ( fireGlobals && jQuery.active++ === 0 ) {\n\t\t\tjQuery.event.trigger( \"ajaxStart\" );\n\t\t}\n\n\t\t// Uppercase the type\n\t\ts.type = s.type.toUpperCase();\n\n\t\t// Determine if request has content\n\t\ts.hasContent = !rnoContent.test( s.type );\n\n\t\t// Save the URL in case we're toying with the If-Modified-Since\n\t\t// and/or If-None-Match header later on\n\t\tcacheURL = s.url;\n\n\t\t// More options handling for requests with no content\n\t\tif ( !s.hasContent ) {\n\n\t\t\t// If data is available, append data to url\n\t\t\tif ( s.data ) {\n\t\t\t\tcacheURL = ( s.url += ( rquery.test( cacheURL ) ? \"&\" : \"?\" ) + s.data );\n\n\t\t\t\t// #9682: remove data so that it's not used in an eventual retry\n\t\t\t\tdelete s.data;\n\t\t\t}\n\n\t\t\t// Add anti-cache in url if needed\n\t\t\tif ( s.cache === false ) {\n\t\t\t\ts.url = rts.test( cacheURL ) ?\n\n\t\t\t\t\t// If there is already a '_' parameter, set its value\n\t\t\t\t\tcacheURL.replace( rts, \"$1_=\" + nonce++ ) :\n\n\t\t\t\t\t// Otherwise add one to the end\n\t\t\t\t\tcacheURL + ( rquery.test( cacheURL ) ? \"&\" : \"?\" ) + \"_=\" + nonce++;\n\t\t\t}\n\t\t}\n\n\t\t// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.\n\t\tif ( s.ifModified ) {\n\t\t\tif ( jQuery.lastModified[ cacheURL ] ) {\n\t\t\t\tjqXHR.setRequestHeader( \"If-Modified-Since\", jQuery.lastModified[ cacheURL ] );\n\t\t\t}\n\t\t\tif ( jQuery.etag[ cacheURL ] ) {\n\t\t\t\tjqXHR.setRequestHeader( \"If-None-Match\", jQuery.etag[ cacheURL ] );\n\t\t\t}\n\t\t}\n\n\t\t// Set the correct header, if data is being sent\n\t\tif ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {\n\t\t\tjqXHR.setRequestHeader( \"Content-Type\", s.contentType );\n\t\t}\n\n\t\t// Set the Accepts header for the server, depending on the dataType\n\t\tjqXHR.setRequestHeader(\n\t\t\t\"Accept\",\n\t\t\ts.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ?\n\t\t\t\ts.accepts[ s.dataTypes[ 0 ] ] +\n\t\t\t\t\t( s.dataTypes[ 0 ] !== \"*\" ? \", \" + allTypes + \"; q=0.01\" : \"\" ) :\n\t\t\t\ts.accepts[ \"*\" ]\n\t\t);\n\n\t\t// Check for headers option\n\t\tfor ( i in s.headers ) {\n\t\t\tjqXHR.setRequestHeader( i, s.headers[ i ] );\n\t\t}\n\n\t\t// Allow custom headers/mimetypes and early abort\n\t\tif ( s.beforeSend &&\n\t\t\t( s.beforeSend.call( callbackContext, jqXHR, s ) === false || state === 2 ) ) {\n\n\t\t\t// Abort if not done already and return\n\t\t\treturn jqXHR.abort();\n\t\t}\n\n\t\t// Aborting is no longer a cancellation\n\t\tstrAbort = \"abort\";\n\n\t\t// Install callbacks on deferreds\n\t\tfor ( i in { success: 1, error: 1, complete: 1 } ) {\n\t\t\tjqXHR[ i ]( s[ i ] );\n\t\t}\n\n\t\t// Get transport\n\t\ttransport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );\n\n\t\t// If no transport, we auto-abort\n\t\tif ( !transport ) {\n\t\t\tdone( -1, \"No Transport\" );\n\t\t} else {\n\t\t\tjqXHR.readyState = 1;\n\n\t\t\t// Send global event\n\t\t\tif ( fireGlobals ) {\n\t\t\t\tglobalEventContext.trigger( \"ajaxSend\", [ jqXHR, s ] );\n\t\t\t}\n\n\t\t\t// If request was aborted inside ajaxSend, stop there\n\t\t\tif ( state === 2 ) {\n\t\t\t\treturn jqXHR;\n\t\t\t}\n\n\t\t\t// Timeout\n\t\t\tif ( s.async && s.timeout > 0 ) {\n\t\t\t\ttimeoutTimer = window.setTimeout( function() {\n\t\t\t\t\tjqXHR.abort( \"timeout\" );\n\t\t\t\t}, s.timeout );\n\t\t\t}\n\n\t\t\ttry {\n\t\t\t\tstate = 1;\n\t\t\t\ttransport.send( requestHeaders, done );\n\t\t\t} catch ( e ) {\n\n\t\t\t\t// Propagate exception as error if not done\n\t\t\t\tif ( state < 2 ) {\n\t\t\t\t\tdone( -1, e );\n\n\t\t\t\t// Simply rethrow otherwise\n\t\t\t\t} else {\n\t\t\t\t\tthrow e;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Callback for when everything is done\n\t\tfunction done( status, nativeStatusText, responses, headers ) {\n\t\t\tvar isSuccess, success, error, response, modified,\n\t\t\t\tstatusText = nativeStatusText;\n\n\t\t\t// Called once\n\t\t\tif ( state === 2 ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// State is \"done\" now\n\t\t\tstate = 2;\n\n\t\t\t// Clear timeout if it exists\n\t\t\tif ( timeoutTimer ) {\n\t\t\t\twindow.clearTimeout( timeoutTimer );\n\t\t\t}\n\n\t\t\t// Dereference transport for early garbage collection\n\t\t\t// (no matter how long the jqXHR object will be used)\n\t\t\ttransport = undefined;\n\n\t\t\t// Cache response headers\n\t\t\tresponseHeadersString = headers || \"\";\n\n\t\t\t// Set readyState\n\t\t\tjqXHR.readyState = status > 0 ? 4 : 0;\n\n\t\t\t// Determine if successful\n\t\t\tisSuccess = status >= 200 && status < 300 || status === 304;\n\n\t\t\t// Get response data\n\t\t\tif ( responses ) {\n\t\t\t\tresponse = ajaxHandleResponses( s, jqXHR, responses );\n\t\t\t}\n\n\t\t\t// Convert no matter what (that way responseXXX fields are always set)\n\t\t\tresponse = ajaxConvert( s, response, jqXHR, isSuccess );\n\n\t\t\t// If successful, handle type chaining\n\t\t\tif ( isSuccess ) {\n\n\t\t\t\t// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.\n\t\t\t\tif ( s.ifModified ) {\n\t\t\t\t\tmodified = jqXHR.getResponseHeader( \"Last-Modified\" );\n\t\t\t\t\tif ( modified ) {\n\t\t\t\t\t\tjQuery.lastModified[ cacheURL ] = modified;\n\t\t\t\t\t}\n\t\t\t\t\tmodified = jqXHR.getResponseHeader( \"etag\" );\n\t\t\t\t\tif ( modified ) {\n\t\t\t\t\t\tjQuery.etag[ cacheURL ] = modified;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// if no content\n\t\t\t\tif ( status === 204 || s.type === \"HEAD\" ) {\n\t\t\t\t\tstatusText = \"nocontent\";\n\n\t\t\t\t// if not modified\n\t\t\t\t} else if ( status === 304 ) {\n\t\t\t\t\tstatusText = \"notmodified\";\n\n\t\t\t\t// If we have data, let's convert it\n\t\t\t\t} else {\n\t\t\t\t\tstatusText = response.state;\n\t\t\t\t\tsuccess = response.data;\n\t\t\t\t\terror = response.error;\n\t\t\t\t\tisSuccess = !error;\n\t\t\t\t}\n\t\t\t} else {\n\n\t\t\t\t// Extract error from statusText and normalize for non-aborts\n\t\t\t\terror = statusText;\n\t\t\t\tif ( status || !statusText ) {\n\t\t\t\t\tstatusText = \"error\";\n\t\t\t\t\tif ( status < 0 ) {\n\t\t\t\t\t\tstatus = 0;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Set data for the fake xhr object\n\t\t\tjqXHR.status = status;\n\t\t\tjqXHR.statusText = ( nativeStatusText || statusText ) + \"\";\n\n\t\t\t// Success/Error\n\t\t\tif ( isSuccess ) {\n\t\t\t\tdeferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );\n\t\t\t} else {\n\t\t\t\tdeferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );\n\t\t\t}\n\n\t\t\t// Status-dependent callbacks\n\t\t\tjqXHR.statusCode( statusCode );\n\t\t\tstatusCode = undefined;\n\n\t\t\tif ( fireGlobals ) {\n\t\t\t\tglobalEventContext.trigger( isSuccess ? \"ajaxSuccess\" : \"ajaxError\",\n\t\t\t\t\t[ jqXHR, s, isSuccess ? success : error ] );\n\t\t\t}\n\n\t\t\t// Complete\n\t\t\tcompleteDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );\n\n\t\t\tif ( fireGlobals ) {\n\t\t\t\tglobalEventContext.trigger( \"ajaxComplete\", [ jqXHR, s ] );\n\n\t\t\t\t// Handle the global AJAX counter\n\t\t\t\tif ( !( --jQuery.active ) ) {\n\t\t\t\t\tjQuery.event.trigger( \"ajaxStop\" );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn jqXHR;\n\t},\n\n\tgetJSON: function( url, data, callback ) {\n\t\treturn jQuery.get( url, data, callback, \"json\" );\n\t},\n\n\tgetScript: function( url, callback ) {\n\t\treturn jQuery.get( url, undefined, callback, \"script\" );\n\t}\n} );\n\njQuery.each( [ \"get\", \"post\" ], function( i, method ) {\n\tjQuery[ method ] = function( url, data, callback, type ) {\n\n\t\t// Shift arguments if data argument was omitted\n\t\tif ( jQuery.isFunction( data ) ) {\n\t\t\ttype = type || callback;\n\t\t\tcallback = data;\n\t\t\tdata = undefined;\n\t\t}\n\n\t\t// The url can be an options object (which then must have .url)\n\t\treturn jQuery.ajax( jQuery.extend( {\n\t\t\turl: url,\n\t\t\ttype: method,\n\t\t\tdataType: type,\n\t\t\tdata: data,\n\t\t\tsuccess: callback\n\t\t}, jQuery.isPlainObject( url ) && url ) );\n\t};\n} );\n\n\njQuery._evalUrl = function( url ) {\n\treturn jQuery.ajax( {\n\t\turl: url,\n\n\t\t// Make this explicit, since user can override this through ajaxSetup (#11264)\n\t\ttype: \"GET\",\n\t\tdataType: \"script\",\n\t\tasync: false,\n\t\tglobal: false,\n\t\t\"throws\": true\n\t} );\n};\n\n\njQuery.fn.extend( {\n\twrapAll: function( html ) {\n\t\tvar wrap;\n\n\t\tif ( jQuery.isFunction( html ) ) {\n\t\t\treturn this.each( function( i ) {\n\t\t\t\tjQuery( this ).wrapAll( html.call( this, i ) );\n\t\t\t} );\n\t\t}\n\n\t\tif ( this[ 0 ] ) {\n\n\t\t\t// The elements to wrap the target around\n\t\t\twrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true );\n\n\t\t\tif ( this[ 0 ].parentNode ) {\n\t\t\t\twrap.insertBefore( this[ 0 ] );\n\t\t\t}\n\n\t\t\twrap.map( function() {\n\t\t\t\tvar elem = this;\n\n\t\t\t\twhile ( elem.firstElementChild ) {\n\t\t\t\t\telem = elem.firstElementChild;\n\t\t\t\t}\n\n\t\t\t\treturn elem;\n\t\t\t} ).append( this );\n\t\t}\n\n\t\treturn this;\n\t},\n\n\twrapInner: function( html ) {\n\t\tif ( jQuery.isFunction( html ) ) {\n\t\t\treturn this.each( function( i ) {\n\t\t\t\tjQuery( this ).wrapInner( html.call( this, i ) );\n\t\t\t} );\n\t\t}\n\n\t\treturn this.each( function() {\n\t\t\tvar self = jQuery( this ),\n\t\t\t\tcontents = self.contents();\n\n\t\t\tif ( contents.length ) {\n\t\t\t\tcontents.wrapAll( html );\n\n\t\t\t} else {\n\t\t\t\tself.append( html );\n\t\t\t}\n\t\t} );\n\t},\n\n\twrap: function( html ) {\n\t\tvar isFunction = jQuery.isFunction( html );\n\n\t\treturn this.each( function( i ) {\n\t\t\tjQuery( this ).wrapAll( isFunction ? html.call( this, i ) : html );\n\t\t} );\n\t},\n\n\tunwrap: function() {\n\t\treturn this.parent().each( function() {\n\t\t\tif ( !jQuery.nodeName( this, \"body\" ) ) {\n\t\t\t\tjQuery( this ).replaceWith( this.childNodes );\n\t\t\t}\n\t\t} ).end();\n\t}\n} );\n\n\njQuery.expr.filters.hidden = function( elem ) {\n\treturn !jQuery.expr.filters.visible( elem );\n};\njQuery.expr.filters.visible = function( elem ) {\n\n\t// Support: Opera <= 12.12\n\t// Opera reports offsetWidths and offsetHeights less than zero on some elements\n\t// Use OR instead of AND as the element is not visible if either is true\n\t// See tickets #10406 and #13132\n\treturn elem.offsetWidth > 0 || elem.offsetHeight > 0 || elem.getClientRects().length > 0;\n};\n\n\n\n\nvar r20 = /%20/g,\n\trbracket = /\\[\\]$/,\n\trCRLF = /\\r?\\n/g,\n\trsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,\n\trsubmittable = /^(?:input|select|textarea|keygen)/i;\n\nfunction buildParams( prefix, obj, traditional, add ) {\n\tvar name;\n\n\tif ( jQuery.isArray( obj ) ) {\n\n\t\t// Serialize array item.\n\t\tjQuery.each( obj, function( i, v ) {\n\t\t\tif ( traditional || rbracket.test( prefix ) ) {\n\n\t\t\t\t// Treat each array item as a scalar.\n\t\t\t\tadd( prefix, v );\n\n\t\t\t} else {\n\n\t\t\t\t// Item is non-scalar (array or object), encode its numeric index.\n\t\t\t\tbuildParams(\n\t\t\t\t\tprefix + \"[\" + ( typeof v === \"object\" && v != null ? i : \"\" ) + \"]\",\n\t\t\t\t\tv,\n\t\t\t\t\ttraditional,\n\t\t\t\t\tadd\n\t\t\t\t);\n\t\t\t}\n\t\t} );\n\n\t} else if ( !traditional && jQuery.type( obj ) === \"object\" ) {\n\n\t\t// Serialize object item.\n\t\tfor ( name in obj ) {\n\t\t\tbuildParams( prefix + \"[\" + name + \"]\", obj[ name ], traditional, add );\n\t\t}\n\n\t} else {\n\n\t\t// Serialize scalar item.\n\t\tadd( prefix, obj );\n\t}\n}\n\n// Serialize an array of form elements or a set of\n// key/values into a query string\njQuery.param = function( a, traditional ) {\n\tvar prefix,\n\t\ts = [],\n\t\tadd = function( key, value ) {\n\n\t\t\t// If value is a function, invoke it and return its value\n\t\t\tvalue = jQuery.isFunction( value ) ? value() : ( value == null ? \"\" : value );\n\t\t\ts[ s.length ] = encodeURIComponent( key ) + \"=\" + encodeURIComponent( value );\n\t\t};\n\n\t// Set traditional to true for jQuery <= 1.3.2 behavior.\n\tif ( traditional === undefined ) {\n\t\ttraditional = jQuery.ajaxSettings && jQuery.ajaxSettings.traditional;\n\t}\n\n\t// If an array was passed in, assume that it is an array of form elements.\n\tif ( jQuery.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {\n\n\t\t// Serialize the form elements\n\t\tjQuery.each( a, function() {\n\t\t\tadd( this.name, this.value );\n\t\t} );\n\n\t} else {\n\n\t\t// If traditional, encode the \"old\" way (the way 1.3.2 or older\n\t\t// did it), otherwise encode params recursively.\n\t\tfor ( prefix in a ) {\n\t\t\tbuildParams( prefix, a[ prefix ], traditional, add );\n\t\t}\n\t}\n\n\t// Return the resulting serialization\n\treturn s.join( \"&\" ).replace( r20, \"+\" );\n};\n\njQuery.fn.extend( {\n\tserialize: function() {\n\t\treturn jQuery.param( this.serializeArray() );\n\t},\n\tserializeArray: function() {\n\t\treturn this.map( function() {\n\n\t\t\t// Can add propHook for \"elements\" to filter or add form elements\n\t\t\tvar elements = jQuery.prop( this, \"elements\" );\n\t\t\treturn elements ? jQuery.makeArray( elements ) : this;\n\t\t} )\n\t\t.filter( function() {\n\t\t\tvar type = this.type;\n\n\t\t\t// Use .is( \":disabled\" ) so that fieldset[disabled] works\n\t\t\treturn this.name && !jQuery( this ).is( \":disabled\" ) &&\n\t\t\t\trsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) &&\n\t\t\t\t( this.checked || !rcheckableType.test( type ) );\n\t\t} )\n\t\t.map( function( i, elem ) {\n\t\t\tvar val = jQuery( this ).val();\n\n\t\t\treturn val == null ?\n\t\t\t\tnull :\n\t\t\t\tjQuery.isArray( val ) ?\n\t\t\t\t\tjQuery.map( val, function( val ) {\n\t\t\t\t\t\treturn { name: elem.name, value: val.replace( rCRLF, \"\\r\\n\" ) };\n\t\t\t\t\t} ) :\n\t\t\t\t\t{ name: elem.name, value: val.replace( rCRLF, \"\\r\\n\" ) };\n\t\t} ).get();\n\t}\n} );\n\n\njQuery.ajaxSettings.xhr = function() {\n\ttry {\n\t\treturn new window.XMLHttpRequest();\n\t} catch ( e ) {}\n};\n\nvar xhrSuccessStatus = {\n\n\t\t// File protocol always yields status code 0, assume 200\n\t\t0: 200,\n\n\t\t// Support: IE9\n\t\t// #1450: sometimes IE returns 1223 when it should be 204\n\t\t1223: 204\n\t},\n\txhrSupported = jQuery.ajaxSettings.xhr();\n\nsupport.cors = !!xhrSupported && ( \"withCredentials\" in xhrSupported );\nsupport.ajax = xhrSupported = !!xhrSupported;\n\njQuery.ajaxTransport( function( options ) {\n\tvar callback, errorCallback;\n\n\t// Cross domain only allowed if supported through XMLHttpRequest\n\tif ( support.cors || xhrSupported && !options.crossDomain ) {\n\t\treturn {\n\t\t\tsend: function( headers, complete ) {\n\t\t\t\tvar i,\n\t\t\t\t\txhr = options.xhr();\n\n\t\t\t\txhr.open(\n\t\t\t\t\toptions.type,\n\t\t\t\t\toptions.url,\n\t\t\t\t\toptions.async,\n\t\t\t\t\toptions.username,\n\t\t\t\t\toptions.password\n\t\t\t\t);\n\n\t\t\t\t// Apply custom fields if provided\n\t\t\t\tif ( options.xhrFields ) {\n\t\t\t\t\tfor ( i in options.xhrFields ) {\n\t\t\t\t\t\txhr[ i ] = options.xhrFields[ i ];\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Override mime type if needed\n\t\t\t\tif ( options.mimeType && xhr.overrideMimeType ) {\n\t\t\t\t\txhr.overrideMimeType( options.mimeType );\n\t\t\t\t}\n\n\t\t\t\t// X-Requested-With header\n\t\t\t\t// For cross-domain requests, seeing as conditions for a preflight are\n\t\t\t\t// akin to a jigsaw puzzle, we simply never set it to be sure.\n\t\t\t\t// (it can always be set on a per-request basis or even using ajaxSetup)\n\t\t\t\t// For same-domain requests, won't change header if already provided.\n\t\t\t\tif ( !options.crossDomain && !headers[ \"X-Requested-With\" ] ) {\n\t\t\t\t\theaders[ \"X-Requested-With\" ] = \"XMLHttpRequest\";\n\t\t\t\t}\n\n\t\t\t\t// Set headers\n\t\t\t\tfor ( i in headers ) {\n\t\t\t\t\txhr.setRequestHeader( i, headers[ i ] );\n\t\t\t\t}\n\n\t\t\t\t// Callback\n\t\t\t\tcallback = function( type ) {\n\t\t\t\t\treturn function() {\n\t\t\t\t\t\tif ( callback ) {\n\t\t\t\t\t\t\tcallback = errorCallback = xhr.onload =\n\t\t\t\t\t\t\t\txhr.onerror = xhr.onabort = xhr.onreadystatechange = null;\n\n\t\t\t\t\t\t\tif ( type === \"abort\" ) {\n\t\t\t\t\t\t\t\txhr.abort();\n\t\t\t\t\t\t\t} else if ( type === \"error\" ) {\n\n\t\t\t\t\t\t\t\t// Support: IE9\n\t\t\t\t\t\t\t\t// On a manual native abort, IE9 throws\n\t\t\t\t\t\t\t\t// errors on any property access that is not readyState\n\t\t\t\t\t\t\t\tif ( typeof xhr.status !== \"number\" ) {\n\t\t\t\t\t\t\t\t\tcomplete( 0, \"error\" );\n\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\tcomplete(\n\n\t\t\t\t\t\t\t\t\t\t// File: protocol always yields status 0; see #8605, #14207\n\t\t\t\t\t\t\t\t\t\txhr.status,\n\t\t\t\t\t\t\t\t\t\txhr.statusText\n\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tcomplete(\n\t\t\t\t\t\t\t\t\txhrSuccessStatus[ xhr.status ] || xhr.status,\n\t\t\t\t\t\t\t\t\txhr.statusText,\n\n\t\t\t\t\t\t\t\t\t// Support: IE9 only\n\t\t\t\t\t\t\t\t\t// IE9 has no XHR2 but throws on binary (trac-11426)\n\t\t\t\t\t\t\t\t\t// For XHR2 non-text, let the caller handle it (gh-2498)\n\t\t\t\t\t\t\t\t\t( xhr.responseType || \"text\" ) !== \"text\"  ||\n\t\t\t\t\t\t\t\t\ttypeof xhr.responseText !== \"string\" ?\n\t\t\t\t\t\t\t\t\t\t{ binary: xhr.response } :\n\t\t\t\t\t\t\t\t\t\t{ text: xhr.responseText },\n\t\t\t\t\t\t\t\t\txhr.getAllResponseHeaders()\n\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\t\t\t\t};\n\n\t\t\t\t// Listen to events\n\t\t\t\txhr.onload = callback();\n\t\t\t\terrorCallback = xhr.onerror = callback( \"error\" );\n\n\t\t\t\t// Support: IE9\n\t\t\t\t// Use onreadystatechange to replace onabort\n\t\t\t\t// to handle uncaught aborts\n\t\t\t\tif ( xhr.onabort !== undefined ) {\n\t\t\t\t\txhr.onabort = errorCallback;\n\t\t\t\t} else {\n\t\t\t\t\txhr.onreadystatechange = function() {\n\n\t\t\t\t\t\t// Check readyState before timeout as it changes\n\t\t\t\t\t\tif ( xhr.readyState === 4 ) {\n\n\t\t\t\t\t\t\t// Allow onerror to be called first,\n\t\t\t\t\t\t\t// but that will not handle a native abort\n\t\t\t\t\t\t\t// Also, save errorCallback to a variable\n\t\t\t\t\t\t\t// as xhr.onerror cannot be accessed\n\t\t\t\t\t\t\twindow.setTimeout( function() {\n\t\t\t\t\t\t\t\tif ( callback ) {\n\t\t\t\t\t\t\t\t\terrorCallback();\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} );\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\t\t\t\t}\n\n\t\t\t\t// Create the abort callback\n\t\t\t\tcallback = callback( \"abort\" );\n\n\t\t\t\ttry {\n\n\t\t\t\t\t// Do send the request (this may raise an exception)\n\t\t\t\t\txhr.send( options.hasContent && options.data || null );\n\t\t\t\t} catch ( e ) {\n\n\t\t\t\t\t// #14683: Only rethrow if this hasn't been notified as an error yet\n\t\t\t\t\tif ( callback ) {\n\t\t\t\t\t\tthrow e;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t},\n\n\t\t\tabort: function() {\n\t\t\t\tif ( callback ) {\n\t\t\t\t\tcallback();\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\t}\n} );\n\n\n\n\n// Install script dataType\njQuery.ajaxSetup( {\n\taccepts: {\n\t\tscript: \"text/javascript, application/javascript, \" +\n\t\t\t\"application/ecmascript, application/x-ecmascript\"\n\t},\n\tcontents: {\n\t\tscript: /\\b(?:java|ecma)script\\b/\n\t},\n\tconverters: {\n\t\t\"text script\": function( text ) {\n\t\t\tjQuery.globalEval( text );\n\t\t\treturn text;\n\t\t}\n\t}\n} );\n\n// Handle cache's special case and crossDomain\njQuery.ajaxPrefilter( \"script\", function( s ) {\n\tif ( s.cache === undefined ) {\n\t\ts.cache = false;\n\t}\n\tif ( s.crossDomain ) {\n\t\ts.type = \"GET\";\n\t}\n} );\n\n// Bind script tag hack transport\njQuery.ajaxTransport( \"script\", function( s ) {\n\n\t// This transport only deals with cross domain requests\n\tif ( s.crossDomain ) {\n\t\tvar script, callback;\n\t\treturn {\n\t\t\tsend: function( _, complete ) {\n\t\t\t\tscript = jQuery( \"<script>\" ).prop( {\n\t\t\t\t\tcharset: s.scriptCharset,\n\t\t\t\t\tsrc: s.url\n\t\t\t\t} ).on(\n\t\t\t\t\t\"load error\",\n\t\t\t\t\tcallback = function( evt ) {\n\t\t\t\t\t\tscript.remove();\n\t\t\t\t\t\tcallback = null;\n\t\t\t\t\t\tif ( evt ) {\n\t\t\t\t\t\t\tcomplete( evt.type === \"error\" ? 404 : 200, evt.type );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t);\n\n\t\t\t\t// Use native DOM manipulation to avoid our domManip AJAX trickery\n\t\t\t\tdocument.head.appendChild( script[ 0 ] );\n\t\t\t},\n\t\t\tabort: function() {\n\t\t\t\tif ( callback ) {\n\t\t\t\t\tcallback();\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\t}\n} );\n\n\n\n\nvar oldCallbacks = [],\n\trjsonp = /(=)\\?(?=&|$)|\\?\\?/;\n\n// Default jsonp settings\njQuery.ajaxSetup( {\n\tjsonp: \"callback\",\n\tjsonpCallback: function() {\n\t\tvar callback = oldCallbacks.pop() || ( jQuery.expando + \"_\" + ( nonce++ ) );\n\t\tthis[ callback ] = true;\n\t\treturn callback;\n\t}\n} );\n\n// Detect, normalize options and install callbacks for jsonp requests\njQuery.ajaxPrefilter( \"json jsonp\", function( s, originalSettings, jqXHR ) {\n\n\tvar callbackName, overwritten, responseContainer,\n\t\tjsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ?\n\t\t\t\"url\" :\n\t\t\ttypeof s.data === \"string\" &&\n\t\t\t\t( s.contentType || \"\" )\n\t\t\t\t\t.indexOf( \"application/x-www-form-urlencoded\" ) === 0 &&\n\t\t\t\trjsonp.test( s.data ) && \"data\"\n\t\t);\n\n\t// Handle iff the expected data type is \"jsonp\" or we have a parameter to set\n\tif ( jsonProp || s.dataTypes[ 0 ] === \"jsonp\" ) {\n\n\t\t// Get callback name, remembering preexisting value associated with it\n\t\tcallbackName = s.jsonpCallback = jQuery.isFunction( s.jsonpCallback ) ?\n\t\t\ts.jsonpCallback() :\n\t\t\ts.jsonpCallback;\n\n\t\t// Insert callback into url or form data\n\t\tif ( jsonProp ) {\n\t\t\ts[ jsonProp ] = s[ jsonProp ].replace( rjsonp, \"$1\" + callbackName );\n\t\t} else if ( s.jsonp !== false ) {\n\t\t\ts.url += ( rquery.test( s.url ) ? \"&\" : \"?\" ) + s.jsonp + \"=\" + callbackName;\n\t\t}\n\n\t\t// Use data converter to retrieve json after script execution\n\t\ts.converters[ \"script json\" ] = function() {\n\t\t\tif ( !responseContainer ) {\n\t\t\t\tjQuery.error( callbackName + \" was not called\" );\n\t\t\t}\n\t\t\treturn responseContainer[ 0 ];\n\t\t};\n\n\t\t// Force json dataType\n\t\ts.dataTypes[ 0 ] = \"json\";\n\n\t\t// Install callback\n\t\toverwritten = window[ callbackName ];\n\t\twindow[ callbackName ] = function() {\n\t\t\tresponseContainer = arguments;\n\t\t};\n\n\t\t// Clean-up function (fires after converters)\n\t\tjqXHR.always( function() {\n\n\t\t\t// If previous value didn't exist - remove it\n\t\t\tif ( overwritten === undefined ) {\n\t\t\t\tjQuery( window ).removeProp( callbackName );\n\n\t\t\t// Otherwise restore preexisting value\n\t\t\t} else {\n\t\t\t\twindow[ callbackName ] = overwritten;\n\t\t\t}\n\n\t\t\t// Save back as free\n\t\t\tif ( s[ callbackName ] ) {\n\n\t\t\t\t// Make sure that re-using the options doesn't screw things around\n\t\t\t\ts.jsonpCallback = originalSettings.jsonpCallback;\n\n\t\t\t\t// Save the callback name for future use\n\t\t\t\toldCallbacks.push( callbackName );\n\t\t\t}\n\n\t\t\t// Call if it was a function and we have a response\n\t\t\tif ( responseContainer && jQuery.isFunction( overwritten ) ) {\n\t\t\t\toverwritten( responseContainer[ 0 ] );\n\t\t\t}\n\n\t\t\tresponseContainer = overwritten = undefined;\n\t\t} );\n\n\t\t// Delegate to script\n\t\treturn \"script\";\n\t}\n} );\n\n\n\n\n// Argument \"data\" should be string of html\n// context (optional): If specified, the fragment will be created in this context,\n// defaults to document\n// keepScripts (optional): If true, will include scripts passed in the html string\njQuery.parseHTML = function( data, context, keepScripts ) {\n\tif ( !data || typeof data !== \"string\" ) {\n\t\treturn null;\n\t}\n\tif ( typeof context === \"boolean\" ) {\n\t\tkeepScripts = context;\n\t\tcontext = false;\n\t}\n\tcontext = context || document;\n\n\tvar parsed = rsingleTag.exec( data ),\n\t\tscripts = !keepScripts && [];\n\n\t// Single tag\n\tif ( parsed ) {\n\t\treturn [ context.createElement( parsed[ 1 ] ) ];\n\t}\n\n\tparsed = buildFragment( [ data ], context, scripts );\n\n\tif ( scripts && scripts.length ) {\n\t\tjQuery( scripts ).remove();\n\t}\n\n\treturn jQuery.merge( [], parsed.childNodes );\n};\n\n\n// Keep a copy of the old load method\nvar _load = jQuery.fn.load;\n\n/**\n * Load a url into a page\n */\njQuery.fn.load = function( url, params, callback ) {\n\tif ( typeof url !== \"string\" && _load ) {\n\t\treturn _load.apply( this, arguments );\n\t}\n\n\tvar selector, type, response,\n\t\tself = this,\n\t\toff = url.indexOf( \" \" );\n\n\tif ( off > -1 ) {\n\t\tselector = jQuery.trim( url.slice( off ) );\n\t\turl = url.slice( 0, off );\n\t}\n\n\t// If it's a function\n\tif ( jQuery.isFunction( params ) ) {\n\n\t\t// We assume that it's the callback\n\t\tcallback = params;\n\t\tparams = undefined;\n\n\t// Otherwise, build a param string\n\t} else if ( params && typeof params === \"object\" ) {\n\t\ttype = \"POST\";\n\t}\n\n\t// If we have elements to modify, make the request\n\tif ( self.length > 0 ) {\n\t\tjQuery.ajax( {\n\t\t\turl: url,\n\n\t\t\t// If \"type\" variable is undefined, then \"GET\" method will be used.\n\t\t\t// Make value of this field explicit since\n\t\t\t// user can override it through ajaxSetup method\n\t\t\ttype: type || \"GET\",\n\t\t\tdataType: \"html\",\n\t\t\tdata: params\n\t\t} ).done( function( responseText ) {\n\n\t\t\t// Save response for use in complete callback\n\t\t\tresponse = arguments;\n\n\t\t\tself.html( selector ?\n\n\t\t\t\t// If a selector was specified, locate the right elements in a dummy div\n\t\t\t\t// Exclude scripts to avoid IE 'Permission Denied' errors\n\t\t\t\tjQuery( \"<div>\" ).append( jQuery.parseHTML( responseText ) ).find( selector ) :\n\n\t\t\t\t// Otherwise use the full result\n\t\t\t\tresponseText );\n\n\t\t// If the request succeeds, this function gets \"data\", \"status\", \"jqXHR\"\n\t\t// but they are ignored because response was set above.\n\t\t// If it fails, this function gets \"jqXHR\", \"status\", \"error\"\n\t\t} ).always( callback && function( jqXHR, status ) {\n\t\t\tself.each( function() {\n\t\t\t\tcallback.apply( this, response || [ jqXHR.responseText, status, jqXHR ] );\n\t\t\t} );\n\t\t} );\n\t}\n\n\treturn this;\n};\n\n\n\n\n// Attach a bunch of functions for handling common AJAX events\njQuery.each( [\n\t\"ajaxStart\",\n\t\"ajaxStop\",\n\t\"ajaxComplete\",\n\t\"ajaxError\",\n\t\"ajaxSuccess\",\n\t\"ajaxSend\"\n], function( i, type ) {\n\tjQuery.fn[ type ] = function( fn ) {\n\t\treturn this.on( type, fn );\n\t};\n} );\n\n\n\n\njQuery.expr.filters.animated = function( elem ) {\n\treturn jQuery.grep( jQuery.timers, function( fn ) {\n\t\treturn elem === fn.elem;\n\t} ).length;\n};\n\n\n\n\n/**\n * Gets a window from an element\n */\nfunction getWindow( elem ) {\n\treturn jQuery.isWindow( elem ) ? elem : elem.nodeType === 9 && elem.defaultView;\n}\n\njQuery.offset = {\n\tsetOffset: function( elem, options, i ) {\n\t\tvar curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition,\n\t\t\tposition = jQuery.css( elem, \"position\" ),\n\t\t\tcurElem = jQuery( elem ),\n\t\t\tprops = {};\n\n\t\t// Set position first, in-case top/left are set even on static elem\n\t\tif ( position === \"static\" ) {\n\t\t\telem.style.position = \"relative\";\n\t\t}\n\n\t\tcurOffset = curElem.offset();\n\t\tcurCSSTop = jQuery.css( elem, \"top\" );\n\t\tcurCSSLeft = jQuery.css( elem, \"left\" );\n\t\tcalculatePosition = ( position === \"absolute\" || position === \"fixed\" ) &&\n\t\t\t( curCSSTop + curCSSLeft ).indexOf( \"auto\" ) > -1;\n\n\t\t// Need to be able to calculate position if either\n\t\t// top or left is auto and position is either absolute or fixed\n\t\tif ( calculatePosition ) {\n\t\t\tcurPosition = curElem.position();\n\t\t\tcurTop = curPosition.top;\n\t\t\tcurLeft = curPosition.left;\n\n\t\t} else {\n\t\t\tcurTop = parseFloat( curCSSTop ) || 0;\n\t\t\tcurLeft = parseFloat( curCSSLeft ) || 0;\n\t\t}\n\n\t\tif ( jQuery.isFunction( options ) ) {\n\n\t\t\t// Use jQuery.extend here to allow modification of coordinates argument (gh-1848)\n\t\t\toptions = options.call( elem, i, jQuery.extend( {}, curOffset ) );\n\t\t}\n\n\t\tif ( options.top != null ) {\n\t\t\tprops.top = ( options.top - curOffset.top ) + curTop;\n\t\t}\n\t\tif ( options.left != null ) {\n\t\t\tprops.left = ( options.left - curOffset.left ) + curLeft;\n\t\t}\n\n\t\tif ( \"using\" in options ) {\n\t\t\toptions.using.call( elem, props );\n\n\t\t} else {\n\t\t\tcurElem.css( props );\n\t\t}\n\t}\n};\n\njQuery.fn.extend( {\n\toffset: function( options ) {\n\t\tif ( arguments.length ) {\n\t\t\treturn options === undefined ?\n\t\t\t\tthis :\n\t\t\t\tthis.each( function( i ) {\n\t\t\t\t\tjQuery.offset.setOffset( this, options, i );\n\t\t\t\t} );\n\t\t}\n\n\t\tvar docElem, win,\n\t\t\telem = this[ 0 ],\n\t\t\tbox = { top: 0, left: 0 },\n\t\t\tdoc = elem && elem.ownerDocument;\n\n\t\tif ( !doc ) {\n\t\t\treturn;\n\t\t}\n\n\t\tdocElem = doc.documentElement;\n\n\t\t// Make sure it's not a disconnected DOM node\n\t\tif ( !jQuery.contains( docElem, elem ) ) {\n\t\t\treturn box;\n\t\t}\n\n\t\tbox = elem.getBoundingClientRect();\n\t\twin = getWindow( doc );\n\t\treturn {\n\t\t\ttop: box.top + win.pageYOffset - docElem.clientTop,\n\t\t\tleft: box.left + win.pageXOffset - docElem.clientLeft\n\t\t};\n\t},\n\n\tposition: function() {\n\t\tif ( !this[ 0 ] ) {\n\t\t\treturn;\n\t\t}\n\n\t\tvar offsetParent, offset,\n\t\t\telem = this[ 0 ],\n\t\t\tparentOffset = { top: 0, left: 0 };\n\n\t\t// Fixed elements are offset from window (parentOffset = {top:0, left: 0},\n\t\t// because it is its only offset parent\n\t\tif ( jQuery.css( elem, \"position\" ) === \"fixed\" ) {\n\n\t\t\t// Assume getBoundingClientRect is there when computed position is fixed\n\t\t\toffset = elem.getBoundingClientRect();\n\n\t\t} else {\n\n\t\t\t// Get *real* offsetParent\n\t\t\toffsetParent = this.offsetParent();\n\n\t\t\t// Get correct offsets\n\t\t\toffset = this.offset();\n\t\t\tif ( !jQuery.nodeName( offsetParent[ 0 ], \"html\" ) ) {\n\t\t\t\tparentOffset = offsetParent.offset();\n\t\t\t}\n\n\t\t\t// Add offsetParent borders\n\t\t\tparentOffset.top += jQuery.css( offsetParent[ 0 ], \"borderTopWidth\", true );\n\t\t\tparentOffset.left += jQuery.css( offsetParent[ 0 ], \"borderLeftWidth\", true );\n\t\t}\n\n\t\t// Subtract parent offsets and element margins\n\t\treturn {\n\t\t\ttop: offset.top - parentOffset.top - jQuery.css( elem, \"marginTop\", true ),\n\t\t\tleft: offset.left - parentOffset.left - jQuery.css( elem, \"marginLeft\", true )\n\t\t};\n\t},\n\n\t// This method will return documentElement in the following cases:\n\t// 1) For the element inside the iframe without offsetParent, this method will return\n\t//    documentElement of the parent window\n\t// 2) For the hidden or detached element\n\t// 3) For body or html element, i.e. in case of the html node - it will return itself\n\t//\n\t// but those exceptions were never presented as a real life use-cases\n\t// and might be considered as more preferable results.\n\t//\n\t// This logic, however, is not guaranteed and can change at any point in the future\n\toffsetParent: function() {\n\t\treturn this.map( function() {\n\t\t\tvar offsetParent = this.offsetParent;\n\n\t\t\twhile ( offsetParent && jQuery.css( offsetParent, \"position\" ) === \"static\" ) {\n\t\t\t\toffsetParent = offsetParent.offsetParent;\n\t\t\t}\n\n\t\t\treturn offsetParent || documentElement;\n\t\t} );\n\t}\n} );\n\n// Create scrollLeft and scrollTop methods\njQuery.each( { scrollLeft: \"pageXOffset\", scrollTop: \"pageYOffset\" }, function( method, prop ) {\n\tvar top = \"pageYOffset\" === prop;\n\n\tjQuery.fn[ method ] = function( val ) {\n\t\treturn access( this, function( elem, method, val ) {\n\t\t\tvar win = getWindow( elem );\n\n\t\t\tif ( val === undefined ) {\n\t\t\t\treturn win ? win[ prop ] : elem[ method ];\n\t\t\t}\n\n\t\t\tif ( win ) {\n\t\t\t\twin.scrollTo(\n\t\t\t\t\t!top ? val : win.pageXOffset,\n\t\t\t\t\ttop ? val : win.pageYOffset\n\t\t\t\t);\n\n\t\t\t} else {\n\t\t\t\telem[ method ] = val;\n\t\t\t}\n\t\t}, method, val, arguments.length );\n\t};\n} );\n\n// Support: Safari<7-8+, Chrome<37-44+\n// Add the top/left cssHooks using jQuery.fn.position\n// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084\n// Blink bug: https://code.google.com/p/chromium/issues/detail?id=229280\n// getComputedStyle returns percent when specified for top/left/bottom/right;\n// rather than make the css module depend on the offset module, just check for it here\njQuery.each( [ \"top\", \"left\" ], function( i, prop ) {\n\tjQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition,\n\t\tfunction( elem, computed ) {\n\t\t\tif ( computed ) {\n\t\t\t\tcomputed = curCSS( elem, prop );\n\n\t\t\t\t// If curCSS returns percentage, fallback to offset\n\t\t\t\treturn rnumnonpx.test( computed ) ?\n\t\t\t\t\tjQuery( elem ).position()[ prop ] + \"px\" :\n\t\t\t\t\tcomputed;\n\t\t\t}\n\t\t}\n\t);\n} );\n\n\n// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods\njQuery.each( { Height: \"height\", Width: \"width\" }, function( name, type ) {\n\tjQuery.each( { padding: \"inner\" + name, content: type, \"\": \"outer\" + name },\n\t\tfunction( defaultExtra, funcName ) {\n\n\t\t// Margin is only for outerHeight, outerWidth\n\t\tjQuery.fn[ funcName ] = function( margin, value ) {\n\t\t\tvar chainable = arguments.length && ( defaultExtra || typeof margin !== \"boolean\" ),\n\t\t\t\textra = defaultExtra || ( margin === true || value === true ? \"margin\" : \"border\" );\n\n\t\t\treturn access( this, function( elem, type, value ) {\n\t\t\t\tvar doc;\n\n\t\t\t\tif ( jQuery.isWindow( elem ) ) {\n\n\t\t\t\t\t// As of 5/8/2012 this will yield incorrect results for Mobile Safari, but there\n\t\t\t\t\t// isn't a whole lot we can do. See pull request at this URL for discussion:\n\t\t\t\t\t// https://github.com/jquery/jquery/pull/764\n\t\t\t\t\treturn elem.document.documentElement[ \"client\" + name ];\n\t\t\t\t}\n\n\t\t\t\t// Get document width or height\n\t\t\t\tif ( elem.nodeType === 9 ) {\n\t\t\t\t\tdoc = elem.documentElement;\n\n\t\t\t\t\t// Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],\n\t\t\t\t\t// whichever is greatest\n\t\t\t\t\treturn Math.max(\n\t\t\t\t\t\telem.body[ \"scroll\" + name ], doc[ \"scroll\" + name ],\n\t\t\t\t\t\telem.body[ \"offset\" + name ], doc[ \"offset\" + name ],\n\t\t\t\t\t\tdoc[ \"client\" + name ]\n\t\t\t\t\t);\n\t\t\t\t}\n\n\t\t\t\treturn value === undefined ?\n\n\t\t\t\t\t// Get width or height on the element, requesting but not forcing parseFloat\n\t\t\t\t\tjQuery.css( elem, type, extra ) :\n\n\t\t\t\t\t// Set width or height on the element\n\t\t\t\t\tjQuery.style( elem, type, value, extra );\n\t\t\t}, type, chainable ? margin : undefined, chainable, null );\n\t\t};\n\t} );\n} );\n\n\njQuery.fn.extend( {\n\n\tbind: function( types, data, fn ) {\n\t\treturn this.on( types, null, data, fn );\n\t},\n\tunbind: function( types, fn ) {\n\t\treturn this.off( types, null, fn );\n\t},\n\n\tdelegate: function( selector, types, data, fn ) {\n\t\treturn this.on( types, selector, data, fn );\n\t},\n\tundelegate: function( selector, types, fn ) {\n\n\t\t// ( namespace ) or ( selector, types [, fn] )\n\t\treturn arguments.length === 1 ?\n\t\t\tthis.off( selector, \"**\" ) :\n\t\t\tthis.off( types, selector || \"**\", fn );\n\t},\n\tsize: function() {\n\t\treturn this.length;\n\t}\n} );\n\njQuery.fn.andSelf = jQuery.fn.addBack;\n\n\n\n\n// Register as a named AMD module, since jQuery can be concatenated with other\n// files that may use define, but not via a proper concatenation script that\n// understands anonymous AMD modules. A named AMD is safest and most robust\n// way to register. Lowercase jquery is used because AMD module names are\n// derived from file names, and jQuery is normally delivered in a lowercase\n// file name. Do this after creating the global so that if an AMD module wants\n// to call noConflict to hide this version of jQuery, it will work.\n\n// Note that for maximum portability, libraries that are not jQuery should\n// declare themselves as anonymous modules, and avoid setting a global if an\n// AMD loader is present. jQuery is a special case. For more information, see\n// https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon\n\nif ( typeof define === \"function\" && define.amd ) {\n\tdefine( \"jquery\", [], function() {\n\t\treturn jQuery;\n\t} );\n}\n\n\n\nvar\n\n\t// Map over jQuery in case of overwrite\n\t_jQuery = window.jQuery,\n\n\t// Map over the $ in case of overwrite\n\t_$ = window.$;\n\njQuery.noConflict = function( deep ) {\n\tif ( window.$ === jQuery ) {\n\t\twindow.$ = _$;\n\t}\n\n\tif ( deep && window.jQuery === jQuery ) {\n\t\twindow.jQuery = _jQuery;\n\t}\n\n\treturn jQuery;\n};\n\n// Expose jQuery and $ identifiers, even in AMD\n// (#7102#comment:10, https://github.com/jquery/jquery/pull/557)\n// and CommonJS for browser emulators (#13566)\nif ( !noGlobal ) {\n\twindow.jQuery = window.$ = jQuery;\n}\n\nreturn jQuery;\n}));\n","/*!\n\tZoom 1.7.21\n\tlicense: MIT\n\thttp://www.jacklmoore.com/zoom\n*/\n(function ($) {\n\tvar defaults = {\n\t\turl: false,\n\t\tcallback: false,\n\t\ttarget: false,\n\t\tduration: 120,\n\t\ton: 'mouseover', // other options: grab, click, toggle\n\t\ttouch: true, // enables a touch fallback\n\t\tonZoomIn: false,\n\t\tonZoomOut: false,\n\t\tmagnify: 1\n\t};\n\n\t// Core Zoom Logic, independent of event listeners.\n\t$.zoom = function(target, source, img, magnify) {\n\t\tvar targetHeight,\n\t\t\ttargetWidth,\n\t\t\tsourceHeight,\n\t\t\tsourceWidth,\n\t\t\txRatio,\n\t\t\tyRatio,\n\t\t\toffset,\n\t\t\t$target = $(target),\n\t\t\tposition = $target.css('position'),\n\t\t\t$source = $(source);\n\n\t\t// The parent element needs positioning so that the zoomed element can be correctly positioned within.\n\t\ttarget.style.position = /(absolute|fixed)/.test(position) ? position : 'relative';\n\t\ttarget.style.overflow = 'hidden';\n\t\timg.style.width = img.style.height = '';\n\n\t\t$(img)\n\t\t\t.addClass('zoomImg')\n\t\t\t.css({\n\t\t\t\tposition: 'absolute',\n\t\t\t\ttop: 0,\n\t\t\t\tleft: 0,\n\t\t\t\topacity: 0,\n\t\t\t\twidth: img.width * magnify,\n\t\t\t\theight: img.height * magnify,\n\t\t\t\tborder: 'none',\n\t\t\t\tmaxWidth: 'none',\n\t\t\t\tmaxHeight: 'none'\n\t\t\t})\n\t\t\t.appendTo(target);\n\n\t\treturn {\n\t\t\tinit: function() {\n\t\t\t\ttargetWidth = $target.outerWidth();\n\t\t\t\ttargetHeight = $target.outerHeight();\n\n\t\t\t\tif (source === target) {\n\t\t\t\t\tsourceWidth = targetWidth;\n\t\t\t\t\tsourceHeight = targetHeight;\n\t\t\t\t} else {\n\t\t\t\t\tsourceWidth = $source.outerWidth();\n\t\t\t\t\tsourceHeight = $source.outerHeight();\n\t\t\t\t}\n\n\t\t\t\txRatio = (img.width - targetWidth) / sourceWidth;\n\t\t\t\tyRatio = (img.height - targetHeight) / sourceHeight;\n\n\t\t\t\toffset = $source.offset();\n\t\t\t},\n\t\t\tmove: function (e) {\n\t\t\t\tvar left = (e.pageX - offset.left),\n\t\t\t\t\ttop = (e.pageY - offset.top);\n\n\t\t\t\ttop = Math.max(Math.min(top, sourceHeight), 0);\n\t\t\t\tleft = Math.max(Math.min(left, sourceWidth), 0);\n\n\t\t\t\timg.style.left = (left * -xRatio) + 'px';\n\t\t\t\timg.style.top = (top * -yRatio) + 'px';\n\t\t\t}\n\t\t};\n\t};\n\n\t$.fn.zoom = function (options) {\n\t\treturn this.each(function () {\n\t\t\tvar\n\t\t\tsettings = $.extend({}, defaults, options || {}),\n\t\t\t//target will display the zoomed image\n\t\t\ttarget = settings.target && $(settings.target)[0] || this,\n\t\t\t//source will provide zoom location info (thumbnail)\n\t\t\tsource = this,\n\t\t\t$source = $(source),\n\t\t\timg = document.createElement('img'),\n\t\t\t$img = $(img),\n\t\t\tmousemove = 'mousemove.zoom',\n\t\t\tclicked = false,\n\t\t\ttouched = false;\n\n\t\t\t// If a url wasn't specified, look for an image element.\n\t\t\tif (!settings.url) {\n\t\t\t\tvar srcElement = source.querySelector('img');\n\t\t\t\tif (srcElement) {\n\t\t\t\t\tsettings.url = srcElement.getAttribute('data-src') || srcElement.currentSrc || srcElement.src;\n\t\t\t\t}\n\t\t\t\tif (!settings.url) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t$source.one('zoom.destroy', function(position, overflow){\n\t\t\t\t$source.off(\".zoom\");\n\t\t\t\ttarget.style.position = position;\n\t\t\t\ttarget.style.overflow = overflow;\n\t\t\t\timg.onload = null;\n\t\t\t\t$img.remove();\n\t\t\t}.bind(this, target.style.position, target.style.overflow));\n\n\t\t\timg.onload = function () {\n\t\t\t\tvar zoom = $.zoom(target, source, img, settings.magnify);\n\n\t\t\t\tfunction start(e) {\n\t\t\t\t\tzoom.init();\n\t\t\t\t\tzoom.move(e);\n\n\t\t\t\t\t// Skip the fade-in for IE8 and lower since it chokes on fading-in\n\t\t\t\t\t// and changing position based on mousemovement at the same time.\n\t\t\t\t\t$img.stop()\n\t\t\t\t\t.fadeTo($.support.opacity ? settings.duration : 0, 1, $.isFunction(settings.onZoomIn) ? settings.onZoomIn.call(img) : false);\n\t\t\t\t}\n\n\t\t\t\tfunction stop() {\n\t\t\t\t\t$img.stop()\n\t\t\t\t\t.fadeTo(settings.duration, 0, $.isFunction(settings.onZoomOut) ? settings.onZoomOut.call(img) : false);\n\t\t\t\t}\n\n\t\t\t\t// Mouse events\n\t\t\t\tif (settings.on === 'grab') {\n\t\t\t\t\t$source\n\t\t\t\t\t\t.on('mousedown.zoom',\n\t\t\t\t\t\t\tfunction (e) {\n\t\t\t\t\t\t\t\tif (e.which === 1) {\n\t\t\t\t\t\t\t\t\t$(document).one('mouseup.zoom',\n\t\t\t\t\t\t\t\t\t\tfunction () {\n\t\t\t\t\t\t\t\t\t\t\tstop();\n\n\t\t\t\t\t\t\t\t\t\t\t$(document).off(mousemove, zoom.move);\n\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t);\n\n\t\t\t\t\t\t\t\t\tstart(e);\n\n\t\t\t\t\t\t\t\t\t$(document).on(mousemove, zoom.move);\n\n\t\t\t\t\t\t\t\t\te.preventDefault();\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t);\n\t\t\t\t} else if (settings.on === 'click') {\n\t\t\t\t\t$source.on('click.zoom',\n\t\t\t\t\t\tfunction (e) {\n\t\t\t\t\t\t\tif (clicked) {\n\t\t\t\t\t\t\t\t// bubble the event up to the document to trigger the unbind.\n\t\t\t\t\t\t\t\treturn;\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tclicked = true;\n\t\t\t\t\t\t\t\tstart(e);\n\t\t\t\t\t\t\t\t$(document).on(mousemove, zoom.move);\n\t\t\t\t\t\t\t\t$(document).one('click.zoom',\n\t\t\t\t\t\t\t\t\tfunction () {\n\t\t\t\t\t\t\t\t\t\tstop();\n\t\t\t\t\t\t\t\t\t\tclicked = false;\n\t\t\t\t\t\t\t\t\t\t$(document).off(mousemove, zoom.move);\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\treturn false;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t);\n\t\t\t\t} else if (settings.on === 'toggle') {\n\t\t\t\t\t$source.on('click.zoom',\n\t\t\t\t\t\tfunction (e) {\n\t\t\t\t\t\t\tif (clicked) {\n\t\t\t\t\t\t\t\tstop();\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tstart(e);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tclicked = !clicked;\n\t\t\t\t\t\t}\n\t\t\t\t\t);\n\t\t\t\t} else if (settings.on === 'mouseover') {\n\t\t\t\t\tzoom.init(); // Preemptively call init because IE7 will fire the mousemove handler before the hover handler.\n\n\t\t\t\t\t$source\n\t\t\t\t\t\t.on('mouseenter.zoom', start)\n\t\t\t\t\t\t.on('mouseleave.zoom', stop)\n\t\t\t\t\t\t.on(mousemove, zoom.move);\n\t\t\t\t}\n\n\t\t\t\t// Touch fallback\n\t\t\t\tif (settings.touch) {\n\t\t\t\t\t$source\n\t\t\t\t\t\t.on('touchstart.zoom', function (e) {\n\t\t\t\t\t\t\te.preventDefault();\n\t\t\t\t\t\t\tif (touched) {\n\t\t\t\t\t\t\t\ttouched = false;\n\t\t\t\t\t\t\t\tstop();\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\ttouched = true;\n\t\t\t\t\t\t\t\tstart( e.originalEvent.touches[0] || e.originalEvent.changedTouches[0] );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t})\n\t\t\t\t\t\t.on('touchmove.zoom', function (e) {\n\t\t\t\t\t\t\te.preventDefault();\n\t\t\t\t\t\t\tzoom.move( e.originalEvent.touches[0] || e.originalEvent.changedTouches[0] );\n\t\t\t\t\t\t})\n\t\t\t\t\t\t.on('touchend.zoom', function (e) {\n\t\t\t\t\t\t\te.preventDefault();\n\t\t\t\t\t\t\tif (touched) {\n\t\t\t\t\t\t\t\ttouched = false;\n\t\t\t\t\t\t\t\tstop();\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\tif ($.isFunction(settings.callback)) {\n\t\t\t\t\tsettings.callback.call(img);\n\t\t\t\t}\n\t\t\t};\n\n\t\t\timg.setAttribute('role', 'presentation');\n\t\t\timg.alt = '';\n\t\t\timg.src = settings.url;\n\t\t});\n\t};\n\n\t$.fn.zoom.defaults = defaults;\n}(window.jQuery));\n","/*! Hammer.JS - v2.0.7 - 2016-04-22\n * http://hammerjs.github.io/\n *\n * Copyright (c) 2016 Jorik Tangelder;\n * Licensed under the MIT license */\n(function(window, document, exportName, undefined) {\n  'use strict';\n\nvar VENDOR_PREFIXES = ['', 'webkit', 'Moz', 'MS', 'ms', 'o'];\nvar TEST_ELEMENT = document.createElement('div');\n\nvar TYPE_FUNCTION = 'function';\n\nvar round = Math.round;\nvar abs = Math.abs;\nvar now = Date.now;\n\n/**\n * set a timeout with a given scope\n * @param {Function} fn\n * @param {Number} timeout\n * @param {Object} context\n * @returns {number}\n */\nfunction setTimeoutContext(fn, timeout, context) {\n    return setTimeout(bindFn(fn, context), timeout);\n}\n\n/**\n * if the argument is an array, we want to execute the fn on each entry\n * if it aint an array we don't want to do a thing.\n * this is used by all the methods that accept a single and array argument.\n * @param {*|Array} arg\n * @param {String} fn\n * @param {Object} [context]\n * @returns {Boolean}\n */\nfunction invokeArrayArg(arg, fn, context) {\n    if (Array.isArray(arg)) {\n        each(arg, context[fn], context);\n        return true;\n    }\n    return false;\n}\n\n/**\n * walk objects and arrays\n * @param {Object} obj\n * @param {Function} iterator\n * @param {Object} context\n */\nfunction each(obj, iterator, context) {\n    var i;\n\n    if (!obj) {\n        return;\n    }\n\n    if (obj.forEach) {\n        obj.forEach(iterator, context);\n    } else if (obj.length !== undefined) {\n        i = 0;\n        while (i < obj.length) {\n            iterator.call(context, obj[i], i, obj);\n            i++;\n        }\n    } else {\n        for (i in obj) {\n            obj.hasOwnProperty(i) && iterator.call(context, obj[i], i, obj);\n        }\n    }\n}\n\n/**\n * wrap a method with a deprecation warning and stack trace\n * @param {Function} method\n * @param {String} name\n * @param {String} message\n * @returns {Function} A new function wrapping the supplied method.\n */\nfunction deprecate(method, name, message) {\n    var deprecationMessage = 'DEPRECATED METHOD: ' + name + '\\n' + message + ' AT \\n';\n    return function() {\n        var e = new Error('get-stack-trace');\n        var stack = e && e.stack ? e.stack.replace(/^[^\\(]+?[\\n$]/gm, '')\n            .replace(/^\\s+at\\s+/gm, '')\n            .replace(/^Object.<anonymous>\\s*\\(/gm, '{anonymous}()@') : 'Unknown Stack Trace';\n\n        var log = window.console && (window.console.warn || window.console.log);\n        if (log) {\n            log.call(window.console, deprecationMessage, stack);\n        }\n        return method.apply(this, arguments);\n    };\n}\n\n/**\n * extend object.\n * means that properties in dest will be overwritten by the ones in src.\n * @param {Object} target\n * @param {...Object} objects_to_assign\n * @returns {Object} target\n */\nvar assign;\nif (typeof Object.assign !== 'function') {\n    assign = function assign(target) {\n        if (target === undefined || target === null) {\n            throw new TypeError('Cannot convert undefined or null to object');\n        }\n\n        var output = Object(target);\n        for (var index = 1; index < arguments.length; index++) {\n            var source = arguments[index];\n            if (source !== undefined && source !== null) {\n                for (var nextKey in source) {\n                    if (source.hasOwnProperty(nextKey)) {\n                        output[nextKey] = source[nextKey];\n                    }\n                }\n            }\n        }\n        return output;\n    };\n} else {\n    assign = Object.assign;\n}\n\n/**\n * extend object.\n * means that properties in dest will be overwritten by the ones in src.\n * @param {Object} dest\n * @param {Object} src\n * @param {Boolean} [merge=false]\n * @returns {Object} dest\n */\nvar extend = deprecate(function extend(dest, src, merge) {\n    var keys = Object.keys(src);\n    var i = 0;\n    while (i < keys.length) {\n        if (!merge || (merge && dest[keys[i]] === undefined)) {\n            dest[keys[i]] = src[keys[i]];\n        }\n        i++;\n    }\n    return dest;\n}, 'extend', 'Use `assign`.');\n\n/**\n * merge the values from src in the dest.\n * means that properties that exist in dest will not be overwritten by src\n * @param {Object} dest\n * @param {Object} src\n * @returns {Object} dest\n */\nvar merge = deprecate(function merge(dest, src) {\n    return extend(dest, src, true);\n}, 'merge', 'Use `assign`.');\n\n/**\n * simple class inheritance\n * @param {Function} child\n * @param {Function} base\n * @param {Object} [properties]\n */\nfunction inherit(child, base, properties) {\n    var baseP = base.prototype,\n        childP;\n\n    childP = child.prototype = Object.create(baseP);\n    childP.constructor = child;\n    childP._super = baseP;\n\n    if (properties) {\n        assign(childP, properties);\n    }\n}\n\n/**\n * simple function bind\n * @param {Function} fn\n * @param {Object} context\n * @returns {Function}\n */\nfunction bindFn(fn, context) {\n    return function boundFn() {\n        return fn.apply(context, arguments);\n    };\n}\n\n/**\n * let a boolean value also be a function that must return a boolean\n * this first item in args will be used as the context\n * @param {Boolean|Function} val\n * @param {Array} [args]\n * @returns {Boolean}\n */\nfunction boolOrFn(val, args) {\n    if (typeof val == TYPE_FUNCTION) {\n        return val.apply(args ? args[0] || undefined : undefined, args);\n    }\n    return val;\n}\n\n/**\n * use the val2 when val1 is undefined\n * @param {*} val1\n * @param {*} val2\n * @returns {*}\n */\nfunction ifUndefined(val1, val2) {\n    return (val1 === undefined) ? val2 : val1;\n}\n\n/**\n * addEventListener with multiple events at once\n * @param {EventTarget} target\n * @param {String} types\n * @param {Function} handler\n */\nfunction addEventListeners(target, types, handler) {\n    each(splitStr(types), function(type) {\n        target.addEventListener(type, handler, false);\n    });\n}\n\n/**\n * removeEventListener with multiple events at once\n * @param {EventTarget} target\n * @param {String} types\n * @param {Function} handler\n */\nfunction removeEventListeners(target, types, handler) {\n    each(splitStr(types), function(type) {\n        target.removeEventListener(type, handler, false);\n    });\n}\n\n/**\n * find if a node is in the given parent\n * @method hasParent\n * @param {HTMLElement} node\n * @param {HTMLElement} parent\n * @return {Boolean} found\n */\nfunction hasParent(node, parent) {\n    while (node) {\n        if (node == parent) {\n            return true;\n        }\n        node = node.parentNode;\n    }\n    return false;\n}\n\n/**\n * small indexOf wrapper\n * @param {String} str\n * @param {String} find\n * @returns {Boolean} found\n */\nfunction inStr(str, find) {\n    return str.indexOf(find) > -1;\n}\n\n/**\n * split string on whitespace\n * @param {String} str\n * @returns {Array} words\n */\nfunction splitStr(str) {\n    return str.trim().split(/\\s+/g);\n}\n\n/**\n * find if a array contains the object using indexOf or a simple polyFill\n * @param {Array} src\n * @param {String} find\n * @param {String} [findByKey]\n * @return {Boolean|Number} false when not found, or the index\n */\nfunction inArray(src, find, findByKey) {\n    if (src.indexOf && !findByKey) {\n        return src.indexOf(find);\n    } else {\n        var i = 0;\n        while (i < src.length) {\n            if ((findByKey && src[i][findByKey] == find) || (!findByKey && src[i] === find)) {\n                return i;\n            }\n            i++;\n        }\n        return -1;\n    }\n}\n\n/**\n * convert array-like objects to real arrays\n * @param {Object} obj\n * @returns {Array}\n */\nfunction toArray(obj) {\n    return Array.prototype.slice.call(obj, 0);\n}\n\n/**\n * unique array with objects based on a key (like 'id') or just by the array's value\n * @param {Array} src [{id:1},{id:2},{id:1}]\n * @param {String} [key]\n * @param {Boolean} [sort=False]\n * @returns {Array} [{id:1},{id:2}]\n */\nfunction uniqueArray(src, key, sort) {\n    var results = [];\n    var values = [];\n    var i = 0;\n\n    while (i < src.length) {\n        var val = key ? src[i][key] : src[i];\n        if (inArray(values, val) < 0) {\n            results.push(src[i]);\n        }\n        values[i] = val;\n        i++;\n    }\n\n    if (sort) {\n        if (!key) {\n            results = results.sort();\n        } else {\n            results = results.sort(function sortUniqueArray(a, b) {\n                return a[key] > b[key];\n            });\n        }\n    }\n\n    return results;\n}\n\n/**\n * get the prefixed property\n * @param {Object} obj\n * @param {String} property\n * @returns {String|Undefined} prefixed\n */\nfunction prefixed(obj, property) {\n    var prefix, prop;\n    var camelProp = property[0].toUpperCase() + property.slice(1);\n\n    var i = 0;\n    while (i < VENDOR_PREFIXES.length) {\n        prefix = VENDOR_PREFIXES[i];\n        prop = (prefix) ? prefix + camelProp : property;\n\n        if (prop in obj) {\n            return prop;\n        }\n        i++;\n    }\n    return undefined;\n}\n\n/**\n * get a unique id\n * @returns {number} uniqueId\n */\nvar _uniqueId = 1;\nfunction uniqueId() {\n    return _uniqueId++;\n}\n\n/**\n * get the window object of an element\n * @param {HTMLElement} element\n * @returns {DocumentView|Window}\n */\nfunction getWindowForElement(element) {\n    var doc = element.ownerDocument || element;\n    return (doc.defaultView || doc.parentWindow || window);\n}\n\nvar MOBILE_REGEX = /mobile|tablet|ip(ad|hone|od)|android/i;\n\nvar SUPPORT_TOUCH = ('ontouchstart' in window);\nvar SUPPORT_POINTER_EVENTS = prefixed(window, 'PointerEvent') !== undefined;\nvar SUPPORT_ONLY_TOUCH = SUPPORT_TOUCH && MOBILE_REGEX.test(navigator.userAgent);\n\nvar INPUT_TYPE_TOUCH = 'touch';\nvar INPUT_TYPE_PEN = 'pen';\nvar INPUT_TYPE_MOUSE = 'mouse';\nvar INPUT_TYPE_KINECT = 'kinect';\n\nvar COMPUTE_INTERVAL = 25;\n\nvar INPUT_START = 1;\nvar INPUT_MOVE = 2;\nvar INPUT_END = 4;\nvar INPUT_CANCEL = 8;\n\nvar DIRECTION_NONE = 1;\nvar DIRECTION_LEFT = 2;\nvar DIRECTION_RIGHT = 4;\nvar DIRECTION_UP = 8;\nvar DIRECTION_DOWN = 16;\n\nvar DIRECTION_HORIZONTAL = DIRECTION_LEFT | DIRECTION_RIGHT;\nvar DIRECTION_VERTICAL = DIRECTION_UP | DIRECTION_DOWN;\nvar DIRECTION_ALL = DIRECTION_HORIZONTAL | DIRECTION_VERTICAL;\n\nvar PROPS_XY = ['x', 'y'];\nvar PROPS_CLIENT_XY = ['clientX', 'clientY'];\n\n/**\n * create new input type manager\n * @param {Manager} manager\n * @param {Function} callback\n * @returns {Input}\n * @constructor\n */\nfunction Input(manager, callback) {\n    var self = this;\n    this.manager = manager;\n    this.callback = callback;\n    this.element = manager.element;\n    this.target = manager.options.inputTarget;\n\n    // smaller wrapper around the handler, for the scope and the enabled state of the manager,\n    // so when disabled the input events are completely bypassed.\n    this.domHandler = function(ev) {\n        if (boolOrFn(manager.options.enable, [manager])) {\n            self.handler(ev);\n        }\n    };\n\n    this.init();\n\n}\n\nInput.prototype = {\n    /**\n     * should handle the inputEvent data and trigger the callback\n     * @virtual\n     */\n    handler: function() { },\n\n    /**\n     * bind the events\n     */\n    init: function() {\n        this.evEl && addEventListeners(this.element, this.evEl, this.domHandler);\n        this.evTarget && addEventListeners(this.target, this.evTarget, this.domHandler);\n        this.evWin && addEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);\n    },\n\n    /**\n     * unbind the events\n     */\n    destroy: function() {\n        this.evEl && removeEventListeners(this.element, this.evEl, this.domHandler);\n        this.evTarget && removeEventListeners(this.target, this.evTarget, this.domHandler);\n        this.evWin && removeEventListeners(getWindowForElement(this.element), this.evWin, this.domHandler);\n    }\n};\n\n/**\n * create new input type manager\n * called by the Manager constructor\n * @param {Hammer} manager\n * @returns {Input}\n */\nfunction createInputInstance(manager) {\n    var Type;\n    var inputClass = manager.options.inputClass;\n\n    if (inputClass) {\n        Type = inputClass;\n    } else if (SUPPORT_POINTER_EVENTS) {\n        Type = PointerEventInput;\n    } else if (SUPPORT_ONLY_TOUCH) {\n        Type = TouchInput;\n    } else if (!SUPPORT_TOUCH) {\n        Type = MouseInput;\n    } else {\n        Type = TouchMouseInput;\n    }\n    return new (Type)(manager, inputHandler);\n}\n\n/**\n * handle input events\n * @param {Manager} manager\n * @param {String} eventType\n * @param {Object} input\n */\nfunction inputHandler(manager, eventType, input) {\n    var pointersLen = input.pointers.length;\n    var changedPointersLen = input.changedPointers.length;\n    var isFirst = (eventType & INPUT_START && (pointersLen - changedPointersLen === 0));\n    var isFinal = (eventType & (INPUT_END | INPUT_CANCEL) && (pointersLen - changedPointersLen === 0));\n\n    input.isFirst = !!isFirst;\n    input.isFinal = !!isFinal;\n\n    if (isFirst) {\n        manager.session = {};\n    }\n\n    // source event is the normalized value of the domEvents\n    // like 'touchstart, mouseup, pointerdown'\n    input.eventType = eventType;\n\n    // compute scale, rotation etc\n    computeInputData(manager, input);\n\n    // emit secret event\n    manager.emit('hammer.input', input);\n\n    manager.recognize(input);\n    manager.session.prevInput = input;\n}\n\n/**\n * extend the data with some usable properties like scale, rotate, velocity etc\n * @param {Object} manager\n * @param {Object} input\n */\nfunction computeInputData(manager, input) {\n    var session = manager.session;\n    var pointers = input.pointers;\n    var pointersLength = pointers.length;\n\n    // store the first input to calculate the distance and direction\n    if (!session.firstInput) {\n        session.firstInput = simpleCloneInputData(input);\n    }\n\n    // to compute scale and rotation we need to store the multiple touches\n    if (pointersLength > 1 && !session.firstMultiple) {\n        session.firstMultiple = simpleCloneInputData(input);\n    } else if (pointersLength === 1) {\n        session.firstMultiple = false;\n    }\n\n    var firstInput = session.firstInput;\n    var firstMultiple = session.firstMultiple;\n    var offsetCenter = firstMultiple ? firstMultiple.center : firstInput.center;\n\n    var center = input.center = getCenter(pointers);\n    input.timeStamp = now();\n    input.deltaTime = input.timeStamp - firstInput.timeStamp;\n\n    input.angle = getAngle(offsetCenter, center);\n    input.distance = getDistance(offsetCenter, center);\n\n    computeDeltaXY(session, input);\n    input.offsetDirection = getDirection(input.deltaX, input.deltaY);\n\n    var overallVelocity = getVelocity(input.deltaTime, input.deltaX, input.deltaY);\n    input.overallVelocityX = overallVelocity.x;\n    input.overallVelocityY = overallVelocity.y;\n    input.overallVelocity = (abs(overallVelocity.x) > abs(overallVelocity.y)) ? overallVelocity.x : overallVelocity.y;\n\n    input.scale = firstMultiple ? getScale(firstMultiple.pointers, pointers) : 1;\n    input.rotation = firstMultiple ? getRotation(firstMultiple.pointers, pointers) : 0;\n\n    input.maxPointers = !session.prevInput ? input.pointers.length : ((input.pointers.length >\n        session.prevInput.maxPointers) ? input.pointers.length : session.prevInput.maxPointers);\n\n    computeIntervalInputData(session, input);\n\n    // find the correct target\n    var target = manager.element;\n    if (hasParent(input.srcEvent.target, target)) {\n        target = input.srcEvent.target;\n    }\n    input.target = target;\n}\n\nfunction computeDeltaXY(session, input) {\n    var center = input.center;\n    var offset = session.offsetDelta || {};\n    var prevDelta = session.prevDelta || {};\n    var prevInput = session.prevInput || {};\n\n    if (input.eventType === INPUT_START || prevInput.eventType === INPUT_END) {\n        prevDelta = session.prevDelta = {\n            x: prevInput.deltaX || 0,\n            y: prevInput.deltaY || 0\n        };\n\n        offset = session.offsetDelta = {\n            x: center.x,\n            y: center.y\n        };\n    }\n\n    input.deltaX = prevDelta.x + (center.x - offset.x);\n    input.deltaY = prevDelta.y + (center.y - offset.y);\n}\n\n/**\n * velocity is calculated every x ms\n * @param {Object} session\n * @param {Object} input\n */\nfunction computeIntervalInputData(session, input) {\n    var last = session.lastInterval || input,\n        deltaTime = input.timeStamp - last.timeStamp,\n        velocity, velocityX, velocityY, direction;\n\n    if (input.eventType != INPUT_CANCEL && (deltaTime > COMPUTE_INTERVAL || last.velocity === undefined)) {\n        var deltaX = input.deltaX - last.deltaX;\n        var deltaY = input.deltaY - last.deltaY;\n\n        var v = getVelocity(deltaTime, deltaX, deltaY);\n        velocityX = v.x;\n        velocityY = v.y;\n        velocity = (abs(v.x) > abs(v.y)) ? v.x : v.y;\n        direction = getDirection(deltaX, deltaY);\n\n        session.lastInterval = input;\n    } else {\n        // use latest velocity info if it doesn't overtake a minimum period\n        velocity = last.velocity;\n        velocityX = last.velocityX;\n        velocityY = last.velocityY;\n        direction = last.direction;\n    }\n\n    input.velocity = velocity;\n    input.velocityX = velocityX;\n    input.velocityY = velocityY;\n    input.direction = direction;\n}\n\n/**\n * create a simple clone from the input used for storage of firstInput and firstMultiple\n * @param {Object} input\n * @returns {Object} clonedInputData\n */\nfunction simpleCloneInputData(input) {\n    // make a simple copy of the pointers because we will get a reference if we don't\n    // we only need clientXY for the calculations\n    var pointers = [];\n    var i = 0;\n    while (i < input.pointers.length) {\n        pointers[i] = {\n            clientX: round(input.pointers[i].clientX),\n            clientY: round(input.pointers[i].clientY)\n        };\n        i++;\n    }\n\n    return {\n        timeStamp: now(),\n        pointers: pointers,\n        center: getCenter(pointers),\n        deltaX: input.deltaX,\n        deltaY: input.deltaY\n    };\n}\n\n/**\n * get the center of all the pointers\n * @param {Array} pointers\n * @return {Object} center contains `x` and `y` properties\n */\nfunction getCenter(pointers) {\n    var pointersLength = pointers.length;\n\n    // no need to loop when only one touch\n    if (pointersLength === 1) {\n        return {\n            x: round(pointers[0].clientX),\n            y: round(pointers[0].clientY)\n        };\n    }\n\n    var x = 0, y = 0, i = 0;\n    while (i < pointersLength) {\n        x += pointers[i].clientX;\n        y += pointers[i].clientY;\n        i++;\n    }\n\n    return {\n        x: round(x / pointersLength),\n        y: round(y / pointersLength)\n    };\n}\n\n/**\n * calculate the velocity between two points. unit is in px per ms.\n * @param {Number} deltaTime\n * @param {Number} x\n * @param {Number} y\n * @return {Object} velocity `x` and `y`\n */\nfunction getVelocity(deltaTime, x, y) {\n    return {\n        x: x / deltaTime || 0,\n        y: y / deltaTime || 0\n    };\n}\n\n/**\n * get the direction between two points\n * @param {Number} x\n * @param {Number} y\n * @return {Number} direction\n */\nfunction getDirection(x, y) {\n    if (x === y) {\n        return DIRECTION_NONE;\n    }\n\n    if (abs(x) >= abs(y)) {\n        return x < 0 ? DIRECTION_LEFT : DIRECTION_RIGHT;\n    }\n    return y < 0 ? DIRECTION_UP : DIRECTION_DOWN;\n}\n\n/**\n * calculate the absolute distance between two points\n * @param {Object} p1 {x, y}\n * @param {Object} p2 {x, y}\n * @param {Array} [props] containing x and y keys\n * @return {Number} distance\n */\nfunction getDistance(p1, p2, props) {\n    if (!props) {\n        props = PROPS_XY;\n    }\n    var x = p2[props[0]] - p1[props[0]],\n        y = p2[props[1]] - p1[props[1]];\n\n    return Math.sqrt((x * x) + (y * y));\n}\n\n/**\n * calculate the angle between two coordinates\n * @param {Object} p1\n * @param {Object} p2\n * @param {Array} [props] containing x and y keys\n * @return {Number} angle\n */\nfunction getAngle(p1, p2, props) {\n    if (!props) {\n        props = PROPS_XY;\n    }\n    var x = p2[props[0]] - p1[props[0]],\n        y = p2[props[1]] - p1[props[1]];\n    return Math.atan2(y, x) * 180 / Math.PI;\n}\n\n/**\n * calculate the rotation degrees between two pointersets\n * @param {Array} start array of pointers\n * @param {Array} end array of pointers\n * @return {Number} rotation\n */\nfunction getRotation(start, end) {\n    return getAngle(end[1], end[0], PROPS_CLIENT_XY) + getAngle(start[1], start[0], PROPS_CLIENT_XY);\n}\n\n/**\n * calculate the scale factor between two pointersets\n * no scale is 1, and goes down to 0 when pinched together, and bigger when pinched out\n * @param {Array} start array of pointers\n * @param {Array} end array of pointers\n * @return {Number} scale\n */\nfunction getScale(start, end) {\n    return getDistance(end[0], end[1], PROPS_CLIENT_XY) / getDistance(start[0], start[1], PROPS_CLIENT_XY);\n}\n\nvar MOUSE_INPUT_MAP = {\n    mousedown: INPUT_START,\n    mousemove: INPUT_MOVE,\n    mouseup: INPUT_END\n};\n\nvar MOUSE_ELEMENT_EVENTS = 'mousedown';\nvar MOUSE_WINDOW_EVENTS = 'mousemove mouseup';\n\n/**\n * Mouse events input\n * @constructor\n * @extends Input\n */\nfunction MouseInput() {\n    this.evEl = MOUSE_ELEMENT_EVENTS;\n    this.evWin = MOUSE_WINDOW_EVENTS;\n\n    this.pressed = false; // mousedown state\n\n    Input.apply(this, arguments);\n}\n\ninherit(MouseInput, Input, {\n    /**\n     * handle mouse events\n     * @param {Object} ev\n     */\n    handler: function MEhandler(ev) {\n        var eventType = MOUSE_INPUT_MAP[ev.type];\n\n        // on start we want to have the left mouse button down\n        if (eventType & INPUT_START && ev.button === 0) {\n            this.pressed = true;\n        }\n\n        if (eventType & INPUT_MOVE && ev.which !== 1) {\n            eventType = INPUT_END;\n        }\n\n        // mouse must be down\n        if (!this.pressed) {\n            return;\n        }\n\n        if (eventType & INPUT_END) {\n            this.pressed = false;\n        }\n\n        this.callback(this.manager, eventType, {\n            pointers: [ev],\n            changedPointers: [ev],\n            pointerType: INPUT_TYPE_MOUSE,\n            srcEvent: ev\n        });\n    }\n});\n\nvar POINTER_INPUT_MAP = {\n    pointerdown: INPUT_START,\n    pointermove: INPUT_MOVE,\n    pointerup: INPUT_END,\n    pointercancel: INPUT_CANCEL,\n    pointerout: INPUT_CANCEL\n};\n\n// in IE10 the pointer types is defined as an enum\nvar IE10_POINTER_TYPE_ENUM = {\n    2: INPUT_TYPE_TOUCH,\n    3: INPUT_TYPE_PEN,\n    4: INPUT_TYPE_MOUSE,\n    5: INPUT_TYPE_KINECT // see https://twitter.com/jacobrossi/status/480596438489890816\n};\n\nvar POINTER_ELEMENT_EVENTS = 'pointerdown';\nvar POINTER_WINDOW_EVENTS = 'pointermove pointerup pointercancel';\n\n// IE10 has prefixed support, and case-sensitive\nif (window.MSPointerEvent && !window.PointerEvent) {\n    POINTER_ELEMENT_EVENTS = 'MSPointerDown';\n    POINTER_WINDOW_EVENTS = 'MSPointerMove MSPointerUp MSPointerCancel';\n}\n\n/**\n * Pointer events input\n * @constructor\n * @extends Input\n */\nfunction PointerEventInput() {\n    this.evEl = POINTER_ELEMENT_EVENTS;\n    this.evWin = POINTER_WINDOW_EVENTS;\n\n    Input.apply(this, arguments);\n\n    this.store = (this.manager.session.pointerEvents = []);\n}\n\ninherit(PointerEventInput, Input, {\n    /**\n     * handle mouse events\n     * @param {Object} ev\n     */\n    handler: function PEhandler(ev) {\n        var store = this.store;\n        var removePointer = false;\n\n        var eventTypeNormalized = ev.type.toLowerCase().replace('ms', '');\n        var eventType = POINTER_INPUT_MAP[eventTypeNormalized];\n        var pointerType = IE10_POINTER_TYPE_ENUM[ev.pointerType] || ev.pointerType;\n\n        var isTouch = (pointerType == INPUT_TYPE_TOUCH);\n\n        // get index of the event in the store\n        var storeIndex = inArray(store, ev.pointerId, 'pointerId');\n\n        // start and mouse must be down\n        if (eventType & INPUT_START && (ev.button === 0 || isTouch)) {\n            if (storeIndex < 0) {\n                store.push(ev);\n                storeIndex = store.length - 1;\n            }\n        } else if (eventType & (INPUT_END | INPUT_CANCEL)) {\n            removePointer = true;\n        }\n\n        // it not found, so the pointer hasn't been down (so it's probably a hover)\n        if (storeIndex < 0) {\n            return;\n        }\n\n        // update the event in the store\n        store[storeIndex] = ev;\n\n        this.callback(this.manager, eventType, {\n            pointers: store,\n            changedPointers: [ev],\n            pointerType: pointerType,\n            srcEvent: ev\n        });\n\n        if (removePointer) {\n            // remove from the store\n            store.splice(storeIndex, 1);\n        }\n    }\n});\n\nvar SINGLE_TOUCH_INPUT_MAP = {\n    touchstart: INPUT_START,\n    touchmove: INPUT_MOVE,\n    touchend: INPUT_END,\n    touchcancel: INPUT_CANCEL\n};\n\nvar SINGLE_TOUCH_TARGET_EVENTS = 'touchstart';\nvar SINGLE_TOUCH_WINDOW_EVENTS = 'touchstart touchmove touchend touchcancel';\n\n/**\n * Touch events input\n * @constructor\n * @extends Input\n */\nfunction SingleTouchInput() {\n    this.evTarget = SINGLE_TOUCH_TARGET_EVENTS;\n    this.evWin = SINGLE_TOUCH_WINDOW_EVENTS;\n    this.started = false;\n\n    Input.apply(this, arguments);\n}\n\ninherit(SingleTouchInput, Input, {\n    handler: function TEhandler(ev) {\n        var type = SINGLE_TOUCH_INPUT_MAP[ev.type];\n\n        // should we handle the touch events?\n        if (type === INPUT_START) {\n            this.started = true;\n        }\n\n        if (!this.started) {\n            return;\n        }\n\n        var touches = normalizeSingleTouches.call(this, ev, type);\n\n        // when done, reset the started state\n        if (type & (INPUT_END | INPUT_CANCEL) && touches[0].length - touches[1].length === 0) {\n            this.started = false;\n        }\n\n        this.callback(this.manager, type, {\n            pointers: touches[0],\n            changedPointers: touches[1],\n            pointerType: INPUT_TYPE_TOUCH,\n            srcEvent: ev\n        });\n    }\n});\n\n/**\n * @this {TouchInput}\n * @param {Object} ev\n * @param {Number} type flag\n * @returns {undefined|Array} [all, changed]\n */\nfunction normalizeSingleTouches(ev, type) {\n    var all = toArray(ev.touches);\n    var changed = toArray(ev.changedTouches);\n\n    if (type & (INPUT_END | INPUT_CANCEL)) {\n        all = uniqueArray(all.concat(changed), 'identifier', true);\n    }\n\n    return [all, changed];\n}\n\nvar TOUCH_INPUT_MAP = {\n    touchstart: INPUT_START,\n    touchmove: INPUT_MOVE,\n    touchend: INPUT_END,\n    touchcancel: INPUT_CANCEL\n};\n\nvar TOUCH_TARGET_EVENTS = 'touchstart touchmove touchend touchcancel';\n\n/**\n * Multi-user touch events input\n * @constructor\n * @extends Input\n */\nfunction TouchInput() {\n    this.evTarget = TOUCH_TARGET_EVENTS;\n    this.targetIds = {};\n\n    Input.apply(this, arguments);\n}\n\ninherit(TouchInput, Input, {\n    handler: function MTEhandler(ev) {\n        var type = TOUCH_INPUT_MAP[ev.type];\n        var touches = getTouches.call(this, ev, type);\n        if (!touches) {\n            return;\n        }\n\n        this.callback(this.manager, type, {\n            pointers: touches[0],\n            changedPointers: touches[1],\n            pointerType: INPUT_TYPE_TOUCH,\n            srcEvent: ev\n        });\n    }\n});\n\n/**\n * @this {TouchInput}\n * @param {Object} ev\n * @param {Number} type flag\n * @returns {undefined|Array} [all, changed]\n */\nfunction getTouches(ev, type) {\n    var allTouches = toArray(ev.touches);\n    var targetIds = this.targetIds;\n\n    // when there is only one touch, the process can be simplified\n    if (type & (INPUT_START | INPUT_MOVE) && allTouches.length === 1) {\n        targetIds[allTouches[0].identifier] = true;\n        return [allTouches, allTouches];\n    }\n\n    var i,\n        targetTouches,\n        changedTouches = toArray(ev.changedTouches),\n        changedTargetTouches = [],\n        target = this.target;\n\n    // get target touches from touches\n    targetTouches = allTouches.filter(function(touch) {\n        return hasParent(touch.target, target);\n    });\n\n    // collect touches\n    if (type === INPUT_START) {\n        i = 0;\n        while (i < targetTouches.length) {\n            targetIds[targetTouches[i].identifier] = true;\n            i++;\n        }\n    }\n\n    // filter changed touches to only contain touches that exist in the collected target ids\n    i = 0;\n    while (i < changedTouches.length) {\n        if (targetIds[changedTouches[i].identifier]) {\n            changedTargetTouches.push(changedTouches[i]);\n        }\n\n        // cleanup removed touches\n        if (type & (INPUT_END | INPUT_CANCEL)) {\n            delete targetIds[changedTouches[i].identifier];\n        }\n        i++;\n    }\n\n    if (!changedTargetTouches.length) {\n        return;\n    }\n\n    return [\n        // merge targetTouches with changedTargetTouches so it contains ALL touches, including 'end' and 'cancel'\n        uniqueArray(targetTouches.concat(changedTargetTouches), 'identifier', true),\n        changedTargetTouches\n    ];\n}\n\n/**\n * Combined touch and mouse input\n *\n * Touch has a higher priority then mouse, and while touching no mouse events are allowed.\n * This because touch devices also emit mouse events while doing a touch.\n *\n * @constructor\n * @extends Input\n */\n\nvar DEDUP_TIMEOUT = 2500;\nvar DEDUP_DISTANCE = 25;\n\nfunction TouchMouseInput() {\n    Input.apply(this, arguments);\n\n    var handler = bindFn(this.handler, this);\n    this.touch = new TouchInput(this.manager, handler);\n    this.mouse = new MouseInput(this.manager, handler);\n\n    this.primaryTouch = null;\n    this.lastTouches = [];\n}\n\ninherit(TouchMouseInput, Input, {\n    /**\n     * handle mouse and touch events\n     * @param {Hammer} manager\n     * @param {String} inputEvent\n     * @param {Object} inputData\n     */\n    handler: function TMEhandler(manager, inputEvent, inputData) {\n        var isTouch = (inputData.pointerType == INPUT_TYPE_TOUCH),\n            isMouse = (inputData.pointerType == INPUT_TYPE_MOUSE);\n\n        if (isMouse && inputData.sourceCapabilities && inputData.sourceCapabilities.firesTouchEvents) {\n            return;\n        }\n\n        // when we're in a touch event, record touches to  de-dupe synthetic mouse event\n        if (isTouch) {\n            recordTouches.call(this, inputEvent, inputData);\n        } else if (isMouse && isSyntheticEvent.call(this, inputData)) {\n            return;\n        }\n\n        this.callback(manager, inputEvent, inputData);\n    },\n\n    /**\n     * remove the event listeners\n     */\n    destroy: function destroy() {\n        this.touch.destroy();\n        this.mouse.destroy();\n    }\n});\n\nfunction recordTouches(eventType, eventData) {\n    if (eventType & INPUT_START) {\n        this.primaryTouch = eventData.changedPointers[0].identifier;\n        setLastTouch.call(this, eventData);\n    } else if (eventType & (INPUT_END | INPUT_CANCEL)) {\n        setLastTouch.call(this, eventData);\n    }\n}\n\nfunction setLastTouch(eventData) {\n    var touch = eventData.changedPointers[0];\n\n    if (touch.identifier === this.primaryTouch) {\n        var lastTouch = {x: touch.clientX, y: touch.clientY};\n        this.lastTouches.push(lastTouch);\n        var lts = this.lastTouches;\n        var removeLastTouch = function() {\n            var i = lts.indexOf(lastTouch);\n            if (i > -1) {\n                lts.splice(i, 1);\n            }\n        };\n        setTimeout(removeLastTouch, DEDUP_TIMEOUT);\n    }\n}\n\nfunction isSyntheticEvent(eventData) {\n    var x = eventData.srcEvent.clientX, y = eventData.srcEvent.clientY;\n    for (var i = 0; i < this.lastTouches.length; i++) {\n        var t = this.lastTouches[i];\n        var dx = Math.abs(x - t.x), dy = Math.abs(y - t.y);\n        if (dx <= DEDUP_DISTANCE && dy <= DEDUP_DISTANCE) {\n            return true;\n        }\n    }\n    return false;\n}\n\nvar PREFIXED_TOUCH_ACTION = prefixed(TEST_ELEMENT.style, 'touchAction');\nvar NATIVE_TOUCH_ACTION = PREFIXED_TOUCH_ACTION !== undefined;\n\n// magical touchAction value\nvar TOUCH_ACTION_COMPUTE = 'compute';\nvar TOUCH_ACTION_AUTO = 'auto';\nvar TOUCH_ACTION_MANIPULATION = 'manipulation'; // not implemented\nvar TOUCH_ACTION_NONE = 'none';\nvar TOUCH_ACTION_PAN_X = 'pan-x';\nvar TOUCH_ACTION_PAN_Y = 'pan-y';\nvar TOUCH_ACTION_MAP = getTouchActionProps();\n\n/**\n * Touch Action\n * sets the touchAction property or uses the js alternative\n * @param {Manager} manager\n * @param {String} value\n * @constructor\n */\nfunction TouchAction(manager, value) {\n    this.manager = manager;\n    this.set(value);\n}\n\nTouchAction.prototype = {\n    /**\n     * set the touchAction value on the element or enable the polyfill\n     * @param {String} value\n     */\n    set: function(value) {\n        // find out the touch-action by the event handlers\n        if (value == TOUCH_ACTION_COMPUTE) {\n            value = this.compute();\n        }\n\n        if (NATIVE_TOUCH_ACTION && this.manager.element.style && TOUCH_ACTION_MAP[value]) {\n            this.manager.element.style[PREFIXED_TOUCH_ACTION] = value;\n        }\n        this.actions = value.toLowerCase().trim();\n    },\n\n    /**\n     * just re-set the touchAction value\n     */\n    update: function() {\n        this.set(this.manager.options.touchAction);\n    },\n\n    /**\n     * compute the value for the touchAction property based on the recognizer's settings\n     * @returns {String} value\n     */\n    compute: function() {\n        var actions = [];\n        each(this.manager.recognizers, function(recognizer) {\n            if (boolOrFn(recognizer.options.enable, [recognizer])) {\n                actions = actions.concat(recognizer.getTouchAction());\n            }\n        });\n        return cleanTouchActions(actions.join(' '));\n    },\n\n    /**\n     * this method is called on each input cycle and provides the preventing of the browser behavior\n     * @param {Object} input\n     */\n    preventDefaults: function(input) {\n        var srcEvent = input.srcEvent;\n        var direction = input.offsetDirection;\n\n        // if the touch action did prevented once this session\n        if (this.manager.session.prevented) {\n            srcEvent.preventDefault();\n            return;\n        }\n\n        var actions = this.actions;\n        var hasNone = inStr(actions, TOUCH_ACTION_NONE) && !TOUCH_ACTION_MAP[TOUCH_ACTION_NONE];\n        var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_Y];\n        var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X) && !TOUCH_ACTION_MAP[TOUCH_ACTION_PAN_X];\n\n        if (hasNone) {\n            //do not prevent defaults if this is a tap gesture\n\n            var isTapPointer = input.pointers.length === 1;\n            var isTapMovement = input.distance < 2;\n            var isTapTouchTime = input.deltaTime < 250;\n\n            if (isTapPointer && isTapMovement && isTapTouchTime) {\n                return;\n            }\n        }\n\n        if (hasPanX && hasPanY) {\n            // `pan-x pan-y` means browser handles all scrolling/panning, do not prevent\n            return;\n        }\n\n        if (hasNone ||\n            (hasPanY && direction & DIRECTION_HORIZONTAL) ||\n            (hasPanX && direction & DIRECTION_VERTICAL)) {\n            return this.preventSrc(srcEvent);\n        }\n    },\n\n    /**\n     * call preventDefault to prevent the browser's default behavior (scrolling in most cases)\n     * @param {Object} srcEvent\n     */\n    preventSrc: function(srcEvent) {\n        this.manager.session.prevented = true;\n        srcEvent.preventDefault();\n    }\n};\n\n/**\n * when the touchActions are collected they are not a valid value, so we need to clean things up. *\n * @param {String} actions\n * @returns {*}\n */\nfunction cleanTouchActions(actions) {\n    // none\n    if (inStr(actions, TOUCH_ACTION_NONE)) {\n        return TOUCH_ACTION_NONE;\n    }\n\n    var hasPanX = inStr(actions, TOUCH_ACTION_PAN_X);\n    var hasPanY = inStr(actions, TOUCH_ACTION_PAN_Y);\n\n    // if both pan-x and pan-y are set (different recognizers\n    // for different directions, e.g. horizontal pan but vertical swipe?)\n    // we need none (as otherwise with pan-x pan-y combined none of these\n    // recognizers will work, since the browser would handle all panning\n    if (hasPanX && hasPanY) {\n        return TOUCH_ACTION_NONE;\n    }\n\n    // pan-x OR pan-y\n    if (hasPanX || hasPanY) {\n        return hasPanX ? TOUCH_ACTION_PAN_X : TOUCH_ACTION_PAN_Y;\n    }\n\n    // manipulation\n    if (inStr(actions, TOUCH_ACTION_MANIPULATION)) {\n        return TOUCH_ACTION_MANIPULATION;\n    }\n\n    return TOUCH_ACTION_AUTO;\n}\n\nfunction getTouchActionProps() {\n    if (!NATIVE_TOUCH_ACTION) {\n        return false;\n    }\n    var touchMap = {};\n    var cssSupports = window.CSS && window.CSS.supports;\n    ['auto', 'manipulation', 'pan-y', 'pan-x', 'pan-x pan-y', 'none'].forEach(function(val) {\n\n        // If css.supports is not supported but there is native touch-action assume it supports\n        // all values. This is the case for IE 10 and 11.\n        touchMap[val] = cssSupports ? window.CSS.supports('touch-action', val) : true;\n    });\n    return touchMap;\n}\n\n/**\n * Recognizer flow explained; *\n * All recognizers have the initial state of POSSIBLE when a input session starts.\n * The definition of a input session is from the first input until the last input, with all it's movement in it. *\n * Example session for mouse-input: mousedown -> mousemove -> mouseup\n *\n * On each recognizing cycle (see Manager.recognize) the .recognize() method is executed\n * which determines with state it should be.\n *\n * If the recognizer has the state FAILED, CANCELLED or RECOGNIZED (equals ENDED), it is reset to\n * POSSIBLE to give it another change on the next cycle.\n *\n *               Possible\n *                  |\n *            +-----+---------------+\n *            |                     |\n *      +-----+-----+               |\n *      |           |               |\n *   Failed      Cancelled          |\n *                          +-------+------+\n *                          |              |\n *                      Recognized       Began\n *                                         |\n *                                      Changed\n *                                         |\n *                                  Ended/Recognized\n */\nvar STATE_POSSIBLE = 1;\nvar STATE_BEGAN = 2;\nvar STATE_CHANGED = 4;\nvar STATE_ENDED = 8;\nvar STATE_RECOGNIZED = STATE_ENDED;\nvar STATE_CANCELLED = 16;\nvar STATE_FAILED = 32;\n\n/**\n * Recognizer\n * Every recognizer needs to extend from this class.\n * @constructor\n * @param {Object} options\n */\nfunction Recognizer(options) {\n    this.options = assign({}, this.defaults, options || {});\n\n    this.id = uniqueId();\n\n    this.manager = null;\n\n    // default is enable true\n    this.options.enable = ifUndefined(this.options.enable, true);\n\n    this.state = STATE_POSSIBLE;\n\n    this.simultaneous = {};\n    this.requireFail = [];\n}\n\nRecognizer.prototype = {\n    /**\n     * @virtual\n     * @type {Object}\n     */\n    defaults: {},\n\n    /**\n     * set options\n     * @param {Object} options\n     * @return {Recognizer}\n     */\n    set: function(options) {\n        assign(this.options, options);\n\n        // also update the touchAction, in case something changed about the directions/enabled state\n        this.manager && this.manager.touchAction.update();\n        return this;\n    },\n\n    /**\n     * recognize simultaneous with an other recognizer.\n     * @param {Recognizer} otherRecognizer\n     * @returns {Recognizer} this\n     */\n    recognizeWith: function(otherRecognizer) {\n        if (invokeArrayArg(otherRecognizer, 'recognizeWith', this)) {\n            return this;\n        }\n\n        var simultaneous = this.simultaneous;\n        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n        if (!simultaneous[otherRecognizer.id]) {\n            simultaneous[otherRecognizer.id] = otherRecognizer;\n            otherRecognizer.recognizeWith(this);\n        }\n        return this;\n    },\n\n    /**\n     * drop the simultaneous link. it doesnt remove the link on the other recognizer.\n     * @param {Recognizer} otherRecognizer\n     * @returns {Recognizer} this\n     */\n    dropRecognizeWith: function(otherRecognizer) {\n        if (invokeArrayArg(otherRecognizer, 'dropRecognizeWith', this)) {\n            return this;\n        }\n\n        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n        delete this.simultaneous[otherRecognizer.id];\n        return this;\n    },\n\n    /**\n     * recognizer can only run when an other is failing\n     * @param {Recognizer} otherRecognizer\n     * @returns {Recognizer} this\n     */\n    requireFailure: function(otherRecognizer) {\n        if (invokeArrayArg(otherRecognizer, 'requireFailure', this)) {\n            return this;\n        }\n\n        var requireFail = this.requireFail;\n        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n        if (inArray(requireFail, otherRecognizer) === -1) {\n            requireFail.push(otherRecognizer);\n            otherRecognizer.requireFailure(this);\n        }\n        return this;\n    },\n\n    /**\n     * drop the requireFailure link. it does not remove the link on the other recognizer.\n     * @param {Recognizer} otherRecognizer\n     * @returns {Recognizer} this\n     */\n    dropRequireFailure: function(otherRecognizer) {\n        if (invokeArrayArg(otherRecognizer, 'dropRequireFailure', this)) {\n            return this;\n        }\n\n        otherRecognizer = getRecognizerByNameIfManager(otherRecognizer, this);\n        var index = inArray(this.requireFail, otherRecognizer);\n        if (index > -1) {\n            this.requireFail.splice(index, 1);\n        }\n        return this;\n    },\n\n    /**\n     * has require failures boolean\n     * @returns {boolean}\n     */\n    hasRequireFailures: function() {\n        return this.requireFail.length > 0;\n    },\n\n    /**\n     * if the recognizer can recognize simultaneous with an other recognizer\n     * @param {Recognizer} otherRecognizer\n     * @returns {Boolean}\n     */\n    canRecognizeWith: function(otherRecognizer) {\n        return !!this.simultaneous[otherRecognizer.id];\n    },\n\n    /**\n     * You should use `tryEmit` instead of `emit` directly to check\n     * that all the needed recognizers has failed before emitting.\n     * @param {Object} input\n     */\n    emit: function(input) {\n        var self = this;\n        var state = this.state;\n\n        function emit(event) {\n            self.manager.emit(event, input);\n        }\n\n        // 'panstart' and 'panmove'\n        if (state < STATE_ENDED) {\n            emit(self.options.event + stateStr(state));\n        }\n\n        emit(self.options.event); // simple 'eventName' events\n\n        if (input.additionalEvent) { // additional event(panleft, panright, pinchin, pinchout...)\n            emit(input.additionalEvent);\n        }\n\n        // panend and pancancel\n        if (state >= STATE_ENDED) {\n            emit(self.options.event + stateStr(state));\n        }\n    },\n\n    /**\n     * Check that all the require failure recognizers has failed,\n     * if true, it emits a gesture event,\n     * otherwise, setup the state to FAILED.\n     * @param {Object} input\n     */\n    tryEmit: function(input) {\n        if (this.canEmit()) {\n            return this.emit(input);\n        }\n        // it's failing anyway\n        this.state = STATE_FAILED;\n    },\n\n    /**\n     * can we emit?\n     * @returns {boolean}\n     */\n    canEmit: function() {\n        var i = 0;\n        while (i < this.requireFail.length) {\n            if (!(this.requireFail[i].state & (STATE_FAILED | STATE_POSSIBLE))) {\n                return false;\n            }\n            i++;\n        }\n        return true;\n    },\n\n    /**\n     * update the recognizer\n     * @param {Object} inputData\n     */\n    recognize: function(inputData) {\n        // make a new copy of the inputData\n        // so we can change the inputData without messing up the other recognizers\n        var inputDataClone = assign({}, inputData);\n\n        // is is enabled and allow recognizing?\n        if (!boolOrFn(this.options.enable, [this, inputDataClone])) {\n            this.reset();\n            this.state = STATE_FAILED;\n            return;\n        }\n\n        // reset when we've reached the end\n        if (this.state & (STATE_RECOGNIZED | STATE_CANCELLED | STATE_FAILED)) {\n            this.state = STATE_POSSIBLE;\n        }\n\n        this.state = this.process(inputDataClone);\n\n        // the recognizer has recognized a gesture\n        // so trigger an event\n        if (this.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED | STATE_CANCELLED)) {\n            this.tryEmit(inputDataClone);\n        }\n    },\n\n    /**\n     * return the state of the recognizer\n     * the actual recognizing happens in this method\n     * @virtual\n     * @param {Object} inputData\n     * @returns {Const} STATE\n     */\n    process: function(inputData) { }, // jshint ignore:line\n\n    /**\n     * return the preferred touch-action\n     * @virtual\n     * @returns {Array}\n     */\n    getTouchAction: function() { },\n\n    /**\n     * called when the gesture isn't allowed to recognize\n     * like when another is being recognized or it is disabled\n     * @virtual\n     */\n    reset: function() { }\n};\n\n/**\n * get a usable string, used as event postfix\n * @param {Const} state\n * @returns {String} state\n */\nfunction stateStr(state) {\n    if (state & STATE_CANCELLED) {\n        return 'cancel';\n    } else if (state & STATE_ENDED) {\n        return 'end';\n    } else if (state & STATE_CHANGED) {\n        return 'move';\n    } else if (state & STATE_BEGAN) {\n        return 'start';\n    }\n    return '';\n}\n\n/**\n * direction cons to string\n * @param {Const} direction\n * @returns {String}\n */\nfunction directionStr(direction) {\n    if (direction == DIRECTION_DOWN) {\n        return 'down';\n    } else if (direction == DIRECTION_UP) {\n        return 'up';\n    } else if (direction == DIRECTION_LEFT) {\n        return 'left';\n    } else if (direction == DIRECTION_RIGHT) {\n        return 'right';\n    }\n    return '';\n}\n\n/**\n * get a recognizer by name if it is bound to a manager\n * @param {Recognizer|String} otherRecognizer\n * @param {Recognizer} recognizer\n * @returns {Recognizer}\n */\nfunction getRecognizerByNameIfManager(otherRecognizer, recognizer) {\n    var manager = recognizer.manager;\n    if (manager) {\n        return manager.get(otherRecognizer);\n    }\n    return otherRecognizer;\n}\n\n/**\n * This recognizer is just used as a base for the simple attribute recognizers.\n * @constructor\n * @extends Recognizer\n */\nfunction AttrRecognizer() {\n    Recognizer.apply(this, arguments);\n}\n\ninherit(AttrRecognizer, Recognizer, {\n    /**\n     * @namespace\n     * @memberof AttrRecognizer\n     */\n    defaults: {\n        /**\n         * @type {Number}\n         * @default 1\n         */\n        pointers: 1\n    },\n\n    /**\n     * Used to check if it the recognizer receives valid input, like input.distance > 10.\n     * @memberof AttrRecognizer\n     * @param {Object} input\n     * @returns {Boolean} recognized\n     */\n    attrTest: function(input) {\n        var optionPointers = this.options.pointers;\n        return optionPointers === 0 || input.pointers.length === optionPointers;\n    },\n\n    /**\n     * Process the input and return the state for the recognizer\n     * @memberof AttrRecognizer\n     * @param {Object} input\n     * @returns {*} State\n     */\n    process: function(input) {\n        var state = this.state;\n        var eventType = input.eventType;\n\n        var isRecognized = state & (STATE_BEGAN | STATE_CHANGED);\n        var isValid = this.attrTest(input);\n\n        // on cancel input and we've recognized before, return STATE_CANCELLED\n        if (isRecognized && (eventType & INPUT_CANCEL || !isValid)) {\n            return state | STATE_CANCELLED;\n        } else if (isRecognized || isValid) {\n            if (eventType & INPUT_END) {\n                return state | STATE_ENDED;\n            } else if (!(state & STATE_BEGAN)) {\n                return STATE_BEGAN;\n            }\n            return state | STATE_CHANGED;\n        }\n        return STATE_FAILED;\n    }\n});\n\n/**\n * Pan\n * Recognized when the pointer is down and moved in the allowed direction.\n * @constructor\n * @extends AttrRecognizer\n */\nfunction PanRecognizer() {\n    AttrRecognizer.apply(this, arguments);\n\n    this.pX = null;\n    this.pY = null;\n}\n\ninherit(PanRecognizer, AttrRecognizer, {\n    /**\n     * @namespace\n     * @memberof PanRecognizer\n     */\n    defaults: {\n        event: 'pan',\n        threshold: 10,\n        pointers: 1,\n        direction: DIRECTION_ALL\n    },\n\n    getTouchAction: function() {\n        var direction = this.options.direction;\n        var actions = [];\n        if (direction & DIRECTION_HORIZONTAL) {\n            actions.push(TOUCH_ACTION_PAN_Y);\n        }\n        if (direction & DIRECTION_VERTICAL) {\n            actions.push(TOUCH_ACTION_PAN_X);\n        }\n        return actions;\n    },\n\n    directionTest: function(input) {\n        var options = this.options;\n        var hasMoved = true;\n        var distance = input.distance;\n        var direction = input.direction;\n        var x = input.deltaX;\n        var y = input.deltaY;\n\n        // lock to axis?\n        if (!(direction & options.direction)) {\n            if (options.direction & DIRECTION_HORIZONTAL) {\n                direction = (x === 0) ? DIRECTION_NONE : (x < 0) ? DIRECTION_LEFT : DIRECTION_RIGHT;\n                hasMoved = x != this.pX;\n                distance = Math.abs(input.deltaX);\n            } else {\n                direction = (y === 0) ? DIRECTION_NONE : (y < 0) ? DIRECTION_UP : DIRECTION_DOWN;\n                hasMoved = y != this.pY;\n                distance = Math.abs(input.deltaY);\n            }\n        }\n        input.direction = direction;\n        return hasMoved && distance > options.threshold && direction & options.direction;\n    },\n\n    attrTest: function(input) {\n        return AttrRecognizer.prototype.attrTest.call(this, input) &&\n            (this.state & STATE_BEGAN || (!(this.state & STATE_BEGAN) && this.directionTest(input)));\n    },\n\n    emit: function(input) {\n\n        this.pX = input.deltaX;\n        this.pY = input.deltaY;\n\n        var direction = directionStr(input.direction);\n\n        if (direction) {\n            input.additionalEvent = this.options.event + direction;\n        }\n        this._super.emit.call(this, input);\n    }\n});\n\n/**\n * Pinch\n * Recognized when two or more pointers are moving toward (zoom-in) or away from each other (zoom-out).\n * @constructor\n * @extends AttrRecognizer\n */\nfunction PinchRecognizer() {\n    AttrRecognizer.apply(this, arguments);\n}\n\ninherit(PinchRecognizer, AttrRecognizer, {\n    /**\n     * @namespace\n     * @memberof PinchRecognizer\n     */\n    defaults: {\n        event: 'pinch',\n        threshold: 0,\n        pointers: 2\n    },\n\n    getTouchAction: function() {\n        return [TOUCH_ACTION_NONE];\n    },\n\n    attrTest: function(input) {\n        return this._super.attrTest.call(this, input) &&\n            (Math.abs(input.scale - 1) > this.options.threshold || this.state & STATE_BEGAN);\n    },\n\n    emit: function(input) {\n        if (input.scale !== 1) {\n            var inOut = input.scale < 1 ? 'in' : 'out';\n            input.additionalEvent = this.options.event + inOut;\n        }\n        this._super.emit.call(this, input);\n    }\n});\n\n/**\n * Press\n * Recognized when the pointer is down for x ms without any movement.\n * @constructor\n * @extends Recognizer\n */\nfunction PressRecognizer() {\n    Recognizer.apply(this, arguments);\n\n    this._timer = null;\n    this._input = null;\n}\n\ninherit(PressRecognizer, Recognizer, {\n    /**\n     * @namespace\n     * @memberof PressRecognizer\n     */\n    defaults: {\n        event: 'press',\n        pointers: 1,\n        time: 251, // minimal time of the pointer to be pressed\n        threshold: 9 // a minimal movement is ok, but keep it low\n    },\n\n    getTouchAction: function() {\n        return [TOUCH_ACTION_AUTO];\n    },\n\n    process: function(input) {\n        var options = this.options;\n        var validPointers = input.pointers.length === options.pointers;\n        var validMovement = input.distance < options.threshold;\n        var validTime = input.deltaTime > options.time;\n\n        this._input = input;\n\n        // we only allow little movement\n        // and we've reached an end event, so a tap is possible\n        if (!validMovement || !validPointers || (input.eventType & (INPUT_END | INPUT_CANCEL) && !validTime)) {\n            this.reset();\n        } else if (input.eventType & INPUT_START) {\n            this.reset();\n            this._timer = setTimeoutContext(function() {\n                this.state = STATE_RECOGNIZED;\n                this.tryEmit();\n            }, options.time, this);\n        } else if (input.eventType & INPUT_END) {\n            return STATE_RECOGNIZED;\n        }\n        return STATE_FAILED;\n    },\n\n    reset: function() {\n        clearTimeout(this._timer);\n    },\n\n    emit: function(input) {\n        if (this.state !== STATE_RECOGNIZED) {\n            return;\n        }\n\n        if (input && (input.eventType & INPUT_END)) {\n            this.manager.emit(this.options.event + 'up', input);\n        } else {\n            this._input.timeStamp = now();\n            this.manager.emit(this.options.event, this._input);\n        }\n    }\n});\n\n/**\n * Rotate\n * Recognized when two or more pointer are moving in a circular motion.\n * @constructor\n * @extends AttrRecognizer\n */\nfunction RotateRecognizer() {\n    AttrRecognizer.apply(this, arguments);\n}\n\ninherit(RotateRecognizer, AttrRecognizer, {\n    /**\n     * @namespace\n     * @memberof RotateRecognizer\n     */\n    defaults: {\n        event: 'rotate',\n        threshold: 0,\n        pointers: 2\n    },\n\n    getTouchAction: function() {\n        return [TOUCH_ACTION_NONE];\n    },\n\n    attrTest: function(input) {\n        return this._super.attrTest.call(this, input) &&\n            (Math.abs(input.rotation) > this.options.threshold || this.state & STATE_BEGAN);\n    }\n});\n\n/**\n * Swipe\n * Recognized when the pointer is moving fast (velocity), with enough distance in the allowed direction.\n * @constructor\n * @extends AttrRecognizer\n */\nfunction SwipeRecognizer() {\n    AttrRecognizer.apply(this, arguments);\n}\n\ninherit(SwipeRecognizer, AttrRecognizer, {\n    /**\n     * @namespace\n     * @memberof SwipeRecognizer\n     */\n    defaults: {\n        event: 'swipe',\n        threshold: 10,\n        velocity: 0.3,\n        direction: DIRECTION_HORIZONTAL | DIRECTION_VERTICAL,\n        pointers: 1\n    },\n\n    getTouchAction: function() {\n        return PanRecognizer.prototype.getTouchAction.call(this);\n    },\n\n    attrTest: function(input) {\n        var direction = this.options.direction;\n        var velocity;\n\n        if (direction & (DIRECTION_HORIZONTAL | DIRECTION_VERTICAL)) {\n            velocity = input.overallVelocity;\n        } else if (direction & DIRECTION_HORIZONTAL) {\n            velocity = input.overallVelocityX;\n        } else if (direction & DIRECTION_VERTICAL) {\n            velocity = input.overallVelocityY;\n        }\n\n        return this._super.attrTest.call(this, input) &&\n            direction & input.offsetDirection &&\n            input.distance > this.options.threshold &&\n            input.maxPointers == this.options.pointers &&\n            abs(velocity) > this.options.velocity && input.eventType & INPUT_END;\n    },\n\n    emit: function(input) {\n        var direction = directionStr(input.offsetDirection);\n        if (direction) {\n            this.manager.emit(this.options.event + direction, input);\n        }\n\n        this.manager.emit(this.options.event, input);\n    }\n});\n\n/**\n * A tap is ecognized when the pointer is doing a small tap/click. Multiple taps are recognized if they occur\n * between the given interval and position. The delay option can be used to recognize multi-taps without firing\n * a single tap.\n *\n * The eventData from the emitted event contains the property `tapCount`, which contains the amount of\n * multi-taps being recognized.\n * @constructor\n * @extends Recognizer\n */\nfunction TapRecognizer() {\n    Recognizer.apply(this, arguments);\n\n    // previous time and center,\n    // used for tap counting\n    this.pTime = false;\n    this.pCenter = false;\n\n    this._timer = null;\n    this._input = null;\n    this.count = 0;\n}\n\ninherit(TapRecognizer, Recognizer, {\n    /**\n     * @namespace\n     * @memberof PinchRecognizer\n     */\n    defaults: {\n        event: 'tap',\n        pointers: 1,\n        taps: 1,\n        interval: 300, // max time between the multi-tap taps\n        time: 250, // max time of the pointer to be down (like finger on the screen)\n        threshold: 9, // a minimal movement is ok, but keep it low\n        posThreshold: 10 // a multi-tap can be a bit off the initial position\n    },\n\n    getTouchAction: function() {\n        return [TOUCH_ACTION_MANIPULATION];\n    },\n\n    process: function(input) {\n        var options = this.options;\n\n        var validPointers = input.pointers.length === options.pointers;\n        var validMovement = input.distance < options.threshold;\n        var validTouchTime = input.deltaTime < options.time;\n\n        this.reset();\n\n        if ((input.eventType & INPUT_START) && (this.count === 0)) {\n            return this.failTimeout();\n        }\n\n        // we only allow little movement\n        // and we've reached an end event, so a tap is possible\n        if (validMovement && validTouchTime && validPointers) {\n            if (input.eventType != INPUT_END) {\n                return this.failTimeout();\n            }\n\n            var validInterval = this.pTime ? (input.timeStamp - this.pTime < options.interval) : true;\n            var validMultiTap = !this.pCenter || getDistance(this.pCenter, input.center) < options.posThreshold;\n\n            this.pTime = input.timeStamp;\n            this.pCenter = input.center;\n\n            if (!validMultiTap || !validInterval) {\n                this.count = 1;\n            } else {\n                this.count += 1;\n            }\n\n            this._input = input;\n\n            // if tap count matches we have recognized it,\n            // else it has began recognizing...\n            var tapCount = this.count % options.taps;\n            if (tapCount === 0) {\n                // no failing requirements, immediately trigger the tap event\n                // or wait as long as the multitap interval to trigger\n                if (!this.hasRequireFailures()) {\n                    return STATE_RECOGNIZED;\n                } else {\n                    this._timer = setTimeoutContext(function() {\n                        this.state = STATE_RECOGNIZED;\n                        this.tryEmit();\n                    }, options.interval, this);\n                    return STATE_BEGAN;\n                }\n            }\n        }\n        return STATE_FAILED;\n    },\n\n    failTimeout: function() {\n        this._timer = setTimeoutContext(function() {\n            this.state = STATE_FAILED;\n        }, this.options.interval, this);\n        return STATE_FAILED;\n    },\n\n    reset: function() {\n        clearTimeout(this._timer);\n    },\n\n    emit: function() {\n        if (this.state == STATE_RECOGNIZED) {\n            this._input.tapCount = this.count;\n            this.manager.emit(this.options.event, this._input);\n        }\n    }\n});\n\n/**\n * Simple way to create a manager with a default set of recognizers.\n * @param {HTMLElement} element\n * @param {Object} [options]\n * @constructor\n */\nfunction Hammer(element, options) {\n    options = options || {};\n    options.recognizers = ifUndefined(options.recognizers, Hammer.defaults.preset);\n    return new Manager(element, options);\n}\n\n/**\n * @const {string}\n */\nHammer.VERSION = '2.0.7';\n\n/**\n * default settings\n * @namespace\n */\nHammer.defaults = {\n    /**\n     * set if DOM events are being triggered.\n     * But this is slower and unused by simple implementations, so disabled by default.\n     * @type {Boolean}\n     * @default false\n     */\n    domEvents: false,\n\n    /**\n     * The value for the touchAction property/fallback.\n     * When set to `compute` it will magically set the correct value based on the added recognizers.\n     * @type {String}\n     * @default compute\n     */\n    touchAction: TOUCH_ACTION_COMPUTE,\n\n    /**\n     * @type {Boolean}\n     * @default true\n     */\n    enable: true,\n\n    /**\n     * EXPERIMENTAL FEATURE -- can be removed/changed\n     * Change the parent input target element.\n     * If Null, then it is being set the to main element.\n     * @type {Null|EventTarget}\n     * @default null\n     */\n    inputTarget: null,\n\n    /**\n     * force an input class\n     * @type {Null|Function}\n     * @default null\n     */\n    inputClass: null,\n\n    /**\n     * Default recognizer setup when calling `Hammer()`\n     * When creating a new Manager these will be skipped.\n     * @type {Array}\n     */\n    preset: [\n        // RecognizerClass, options, [recognizeWith, ...], [requireFailure, ...]\n        [RotateRecognizer, {enable: false}],\n        [PinchRecognizer, {enable: false}, ['rotate']],\n        [SwipeRecognizer, {direction: DIRECTION_HORIZONTAL}],\n        [PanRecognizer, {direction: DIRECTION_HORIZONTAL}, ['swipe']],\n        [TapRecognizer],\n        [TapRecognizer, {event: 'doubletap', taps: 2}, ['tap']],\n        [PressRecognizer]\n    ],\n\n    /**\n     * Some CSS properties can be used to improve the working of Hammer.\n     * Add them to this method and they will be set when creating a new Manager.\n     * @namespace\n     */\n    cssProps: {\n        /**\n         * Disables text selection to improve the dragging gesture. Mainly for desktop browsers.\n         * @type {String}\n         * @default 'none'\n         */\n        userSelect: 'none',\n\n        /**\n         * Disable the Windows Phone grippers when pressing an element.\n         * @type {String}\n         * @default 'none'\n         */\n        touchSelect: 'none',\n\n        /**\n         * Disables the default callout shown when you touch and hold a touch target.\n         * On iOS, when you touch and hold a touch target such as a link, Safari displays\n         * a callout containing information about the link. This property allows you to disable that callout.\n         * @type {String}\n         * @default 'none'\n         */\n        touchCallout: 'none',\n\n        /**\n         * Specifies whether zooming is enabled. Used by IE10>\n         * @type {String}\n         * @default 'none'\n         */\n        contentZooming: 'none',\n\n        /**\n         * Specifies that an entire element should be draggable instead of its contents. Mainly for desktop browsers.\n         * @type {String}\n         * @default 'none'\n         */\n        userDrag: 'none',\n\n        /**\n         * Overrides the highlight color shown when the user taps a link or a JavaScript\n         * clickable element in iOS. This property obeys the alpha value, if specified.\n         * @type {String}\n         * @default 'rgba(0,0,0,0)'\n         */\n        tapHighlightColor: 'rgba(0,0,0,0)'\n    }\n};\n\nvar STOP = 1;\nvar FORCED_STOP = 2;\n\n/**\n * Manager\n * @param {HTMLElement} element\n * @param {Object} [options]\n * @constructor\n */\nfunction Manager(element, options) {\n    this.options = assign({}, Hammer.defaults, options || {});\n\n    this.options.inputTarget = this.options.inputTarget || element;\n\n    this.handlers = {};\n    this.session = {};\n    this.recognizers = [];\n    this.oldCssProps = {};\n\n    this.element = element;\n    this.input = createInputInstance(this);\n    this.touchAction = new TouchAction(this, this.options.touchAction);\n\n    toggleCssProps(this, true);\n\n    each(this.options.recognizers, function(item) {\n        var recognizer = this.add(new (item[0])(item[1]));\n        item[2] && recognizer.recognizeWith(item[2]);\n        item[3] && recognizer.requireFailure(item[3]);\n    }, this);\n}\n\nManager.prototype = {\n    /**\n     * set options\n     * @param {Object} options\n     * @returns {Manager}\n     */\n    set: function(options) {\n        assign(this.options, options);\n\n        // Options that need a little more setup\n        if (options.touchAction) {\n            this.touchAction.update();\n        }\n        if (options.inputTarget) {\n            // Clean up existing event listeners and reinitialize\n            this.input.destroy();\n            this.input.target = options.inputTarget;\n            this.input.init();\n        }\n        return this;\n    },\n\n    /**\n     * stop recognizing for this session.\n     * This session will be discarded, when a new [input]start event is fired.\n     * When forced, the recognizer cycle is stopped immediately.\n     * @param {Boolean} [force]\n     */\n    stop: function(force) {\n        this.session.stopped = force ? FORCED_STOP : STOP;\n    },\n\n    /**\n     * run the recognizers!\n     * called by the inputHandler function on every movement of the pointers (touches)\n     * it walks through all the recognizers and tries to detect the gesture that is being made\n     * @param {Object} inputData\n     */\n    recognize: function(inputData) {\n        var session = this.session;\n        if (session.stopped) {\n            return;\n        }\n\n        // run the touch-action polyfill\n        this.touchAction.preventDefaults(inputData);\n\n        var recognizer;\n        var recognizers = this.recognizers;\n\n        // this holds the recognizer that is being recognized.\n        // so the recognizer's state needs to be BEGAN, CHANGED, ENDED or RECOGNIZED\n        // if no recognizer is detecting a thing, it is set to `null`\n        var curRecognizer = session.curRecognizer;\n\n        // reset when the last recognizer is recognized\n        // or when we're in a new session\n        if (!curRecognizer || (curRecognizer && curRecognizer.state & STATE_RECOGNIZED)) {\n            curRecognizer = session.curRecognizer = null;\n        }\n\n        var i = 0;\n        while (i < recognizers.length) {\n            recognizer = recognizers[i];\n\n            // find out if we are allowed try to recognize the input for this one.\n            // 1.   allow if the session is NOT forced stopped (see the .stop() method)\n            // 2.   allow if we still haven't recognized a gesture in this session, or the this recognizer is the one\n            //      that is being recognized.\n            // 3.   allow if the recognizer is allowed to run simultaneous with the current recognized recognizer.\n            //      this can be setup with the `recognizeWith()` method on the recognizer.\n            if (session.stopped !== FORCED_STOP && ( // 1\n                    !curRecognizer || recognizer == curRecognizer || // 2\n                    recognizer.canRecognizeWith(curRecognizer))) { // 3\n                recognizer.recognize(inputData);\n            } else {\n                recognizer.reset();\n            }\n\n            // if the recognizer has been recognizing the input as a valid gesture, we want to store this one as the\n            // current active recognizer. but only if we don't already have an active recognizer\n            if (!curRecognizer && recognizer.state & (STATE_BEGAN | STATE_CHANGED | STATE_ENDED)) {\n                curRecognizer = session.curRecognizer = recognizer;\n            }\n            i++;\n        }\n    },\n\n    /**\n     * get a recognizer by its event name.\n     * @param {Recognizer|String} recognizer\n     * @returns {Recognizer|Null}\n     */\n    get: function(recognizer) {\n        if (recognizer instanceof Recognizer) {\n            return recognizer;\n        }\n\n        var recognizers = this.recognizers;\n        for (var i = 0; i < recognizers.length; i++) {\n            if (recognizers[i].options.event == recognizer) {\n                return recognizers[i];\n            }\n        }\n        return null;\n    },\n\n    /**\n     * add a recognizer to the manager\n     * existing recognizers with the same event name will be removed\n     * @param {Recognizer} recognizer\n     * @returns {Recognizer|Manager}\n     */\n    add: function(recognizer) {\n        if (invokeArrayArg(recognizer, 'add', this)) {\n            return this;\n        }\n\n        // remove existing\n        var existing = this.get(recognizer.options.event);\n        if (existing) {\n            this.remove(existing);\n        }\n\n        this.recognizers.push(recognizer);\n        recognizer.manager = this;\n\n        this.touchAction.update();\n        return recognizer;\n    },\n\n    /**\n     * remove a recognizer by name or instance\n     * @param {Recognizer|String} recognizer\n     * @returns {Manager}\n     */\n    remove: function(recognizer) {\n        if (invokeArrayArg(recognizer, 'remove', this)) {\n            return this;\n        }\n\n        recognizer = this.get(recognizer);\n\n        // let's make sure this recognizer exists\n        if (recognizer) {\n            var recognizers = this.recognizers;\n            var index = inArray(recognizers, recognizer);\n\n            if (index !== -1) {\n                recognizers.splice(index, 1);\n                this.touchAction.update();\n            }\n        }\n\n        return this;\n    },\n\n    /**\n     * bind event\n     * @param {String} events\n     * @param {Function} handler\n     * @returns {EventEmitter} this\n     */\n    on: function(events, handler) {\n        if (events === undefined) {\n            return;\n        }\n        if (handler === undefined) {\n            return;\n        }\n\n        var handlers = this.handlers;\n        each(splitStr(events), function(event) {\n            handlers[event] = handlers[event] || [];\n            handlers[event].push(handler);\n        });\n        return this;\n    },\n\n    /**\n     * unbind event, leave emit blank to remove all handlers\n     * @param {String} events\n     * @param {Function} [handler]\n     * @returns {EventEmitter} this\n     */\n    off: function(events, handler) {\n        if (events === undefined) {\n            return;\n        }\n\n        var handlers = this.handlers;\n        each(splitStr(events), function(event) {\n            if (!handler) {\n                delete handlers[event];\n            } else {\n                handlers[event] && handlers[event].splice(inArray(handlers[event], handler), 1);\n            }\n        });\n        return this;\n    },\n\n    /**\n     * emit event to the listeners\n     * @param {String} event\n     * @param {Object} data\n     */\n    emit: function(event, data) {\n        // we also want to trigger dom events\n        if (this.options.domEvents) {\n            triggerDomEvent(event, data);\n        }\n\n        // no handlers, so skip it all\n        var handlers = this.handlers[event] && this.handlers[event].slice();\n        if (!handlers || !handlers.length) {\n            return;\n        }\n\n        data.type = event;\n        data.preventDefault = function() {\n            data.srcEvent.preventDefault();\n        };\n\n        var i = 0;\n        while (i < handlers.length) {\n            handlers[i](data);\n            i++;\n        }\n    },\n\n    /**\n     * destroy the manager and unbinds all events\n     * it doesn't unbind dom events, that is the user own responsibility\n     */\n    destroy: function() {\n        this.element && toggleCssProps(this, false);\n\n        this.handlers = {};\n        this.session = {};\n        this.input.destroy();\n        this.element = null;\n    }\n};\n\n/**\n * add/remove the css properties as defined in manager.options.cssProps\n * @param {Manager} manager\n * @param {Boolean} add\n */\nfunction toggleCssProps(manager, add) {\n    var element = manager.element;\n    if (!element.style) {\n        return;\n    }\n    var prop;\n    each(manager.options.cssProps, function(value, name) {\n        prop = prefixed(element.style, name);\n        if (add) {\n            manager.oldCssProps[prop] = element.style[prop];\n            element.style[prop] = value;\n        } else {\n            element.style[prop] = manager.oldCssProps[prop] || '';\n        }\n    });\n    if (!add) {\n        manager.oldCssProps = {};\n    }\n}\n\n/**\n * trigger dom event\n * @param {String} event\n * @param {Object} data\n */\nfunction triggerDomEvent(event, data) {\n    var gestureEvent = document.createEvent('Event');\n    gestureEvent.initEvent(event, true, true);\n    gestureEvent.gesture = data;\n    data.target.dispatchEvent(gestureEvent);\n}\n\nassign(Hammer, {\n    INPUT_START: INPUT_START,\n    INPUT_MOVE: INPUT_MOVE,\n    INPUT_END: INPUT_END,\n    INPUT_CANCEL: INPUT_CANCEL,\n\n    STATE_POSSIBLE: STATE_POSSIBLE,\n    STATE_BEGAN: STATE_BEGAN,\n    STATE_CHANGED: STATE_CHANGED,\n    STATE_ENDED: STATE_ENDED,\n    STATE_RECOGNIZED: STATE_RECOGNIZED,\n    STATE_CANCELLED: STATE_CANCELLED,\n    STATE_FAILED: STATE_FAILED,\n\n    DIRECTION_NONE: DIRECTION_NONE,\n    DIRECTION_LEFT: DIRECTION_LEFT,\n    DIRECTION_RIGHT: DIRECTION_RIGHT,\n    DIRECTION_UP: DIRECTION_UP,\n    DIRECTION_DOWN: DIRECTION_DOWN,\n    DIRECTION_HORIZONTAL: DIRECTION_HORIZONTAL,\n    DIRECTION_VERTICAL: DIRECTION_VERTICAL,\n    DIRECTION_ALL: DIRECTION_ALL,\n\n    Manager: Manager,\n    Input: Input,\n    TouchAction: TouchAction,\n\n    TouchInput: TouchInput,\n    MouseInput: MouseInput,\n    PointerEventInput: PointerEventInput,\n    TouchMouseInput: TouchMouseInput,\n    SingleTouchInput: SingleTouchInput,\n\n    Recognizer: Recognizer,\n    AttrRecognizer: AttrRecognizer,\n    Tap: TapRecognizer,\n    Pan: PanRecognizer,\n    Swipe: SwipeRecognizer,\n    Pinch: PinchRecognizer,\n    Rotate: RotateRecognizer,\n    Press: PressRecognizer,\n\n    on: addEventListeners,\n    off: removeEventListeners,\n    each: each,\n    merge: merge,\n    extend: extend,\n    assign: assign,\n    inherit: inherit,\n    bindFn: bindFn,\n    prefixed: prefixed\n});\n\n// this prevents errors when Hammer is loaded in the presence of an AMD\n//  style loader but by script tag, not by the loader.\nvar freeGlobal = (typeof window !== 'undefined' ? window : (typeof self !== 'undefined' ? self : {})); // jshint ignore:line\nfreeGlobal.Hammer = Hammer;\n\nif (typeof define === 'function' && define.amd) {\n    define(function() {\n        return Hammer;\n    });\n} else if (typeof module != 'undefined' && module.exports) {\n    module.exports = Hammer;\n} else {\n    window[exportName] = Hammer;\n}\n\n})(window, document, 'Hammer');\n","/* Web Font Loader v1.6.28 - (c) Adobe Systems, Google. License: Apache 2.0 */(function(){function aa(a,b,c){return a.call.apply(a.bind,arguments)}function ba(a,b,c){if(!a)throw Error();if(2<arguments.length){var d=Array.prototype.slice.call(arguments,2);return function(){var c=Array.prototype.slice.call(arguments);Array.prototype.unshift.apply(c,d);return a.apply(b,c)}}return function(){return a.apply(b,arguments)}}function p(a,b,c){p=Function.prototype.bind&&-1!=Function.prototype.bind.toString().indexOf(\"native code\")?aa:ba;return p.apply(null,arguments)}var q=Date.now||function(){return+new Date};function ca(a,b){this.a=a;this.o=b||a;this.c=this.o.document}var da=!!window.FontFace;function t(a,b,c,d){b=a.c.createElement(b);if(c)for(var e in c)c.hasOwnProperty(e)&&(\"style\"==e?b.style.cssText=c[e]:b.setAttribute(e,c[e]));d&&b.appendChild(a.c.createTextNode(d));return b}function u(a,b,c){a=a.c.getElementsByTagName(b)[0];a||(a=document.documentElement);a.insertBefore(c,a.lastChild)}function v(a){a.parentNode&&a.parentNode.removeChild(a)}\nfunction w(a,b,c){b=b||[];c=c||[];for(var d=a.className.split(/\\s+/),e=0;e<b.length;e+=1){for(var f=!1,g=0;g<d.length;g+=1)if(b[e]===d[g]){f=!0;break}f||d.push(b[e])}b=[];for(e=0;e<d.length;e+=1){f=!1;for(g=0;g<c.length;g+=1)if(d[e]===c[g]){f=!0;break}f||b.push(d[e])}a.className=b.join(\" \").replace(/\\s+/g,\" \").replace(/^\\s+|\\s+$/,\"\")}function y(a,b){for(var c=a.className.split(/\\s+/),d=0,e=c.length;d<e;d++)if(c[d]==b)return!0;return!1}\nfunction ea(a){return a.o.location.hostname||a.a.location.hostname}function z(a,b,c){function d(){m&&e&&f&&(m(g),m=null)}b=t(a,\"link\",{rel:\"stylesheet\",href:b,media:\"all\"});var e=!1,f=!0,g=null,m=c||null;da?(b.onload=function(){e=!0;d()},b.onerror=function(){e=!0;g=Error(\"Stylesheet failed to load\");d()}):setTimeout(function(){e=!0;d()},0);u(a,\"head\",b)}\nfunction A(a,b,c,d){var e=a.c.getElementsByTagName(\"head\")[0];if(e){var f=t(a,\"script\",{src:b}),g=!1;f.onload=f.onreadystatechange=function(){g||this.readyState&&\"loaded\"!=this.readyState&&\"complete\"!=this.readyState||(g=!0,c&&c(null),f.onload=f.onreadystatechange=null,\"HEAD\"==f.parentNode.tagName&&e.removeChild(f))};e.appendChild(f);setTimeout(function(){g||(g=!0,c&&c(Error(\"Script load timeout\")))},d||5E3);return f}return null};function B(){this.a=0;this.c=null}function C(a){a.a++;return function(){a.a--;D(a)}}function E(a,b){a.c=b;D(a)}function D(a){0==a.a&&a.c&&(a.c(),a.c=null)};function F(a){this.a=a||\"-\"}F.prototype.c=function(a){for(var b=[],c=0;c<arguments.length;c++)b.push(arguments[c].replace(/[\\W_]+/g,\"\").toLowerCase());return b.join(this.a)};function G(a,b){this.c=a;this.f=4;this.a=\"n\";var c=(b||\"n4\").match(/^([nio])([1-9])$/i);c&&(this.a=c[1],this.f=parseInt(c[2],10))}function fa(a){return H(a)+\" \"+(a.f+\"00\")+\" 300px \"+I(a.c)}function I(a){var b=[];a=a.split(/,\\s*/);for(var c=0;c<a.length;c++){var d=a[c].replace(/['\"]/g,\"\");-1!=d.indexOf(\" \")||/^\\d/.test(d)?b.push(\"'\"+d+\"'\"):b.push(d)}return b.join(\",\")}function J(a){return a.a+a.f}function H(a){var b=\"normal\";\"o\"===a.a?b=\"oblique\":\"i\"===a.a&&(b=\"italic\");return b}\nfunction ga(a){var b=4,c=\"n\",d=null;a&&((d=a.match(/(normal|oblique|italic)/i))&&d[1]&&(c=d[1].substr(0,1).toLowerCase()),(d=a.match(/([1-9]00|normal|bold)/i))&&d[1]&&(/bold/i.test(d[1])?b=7:/[1-9]00/.test(d[1])&&(b=parseInt(d[1].substr(0,1),10))));return c+b};function ha(a,b){this.c=a;this.f=a.o.document.documentElement;this.h=b;this.a=new F(\"-\");this.j=!1!==b.events;this.g=!1!==b.classes}function ia(a){a.g&&w(a.f,[a.a.c(\"wf\",\"loading\")]);K(a,\"loading\")}function L(a){if(a.g){var b=y(a.f,a.a.c(\"wf\",\"active\")),c=[],d=[a.a.c(\"wf\",\"loading\")];b||c.push(a.a.c(\"wf\",\"inactive\"));w(a.f,c,d)}K(a,\"inactive\")}function K(a,b,c){if(a.j&&a.h[b])if(c)a.h[b](c.c,J(c));else a.h[b]()};function ja(){this.c={}}function ka(a,b,c){var d=[],e;for(e in b)if(b.hasOwnProperty(e)){var f=a.c[e];f&&d.push(f(b[e],c))}return d};function M(a,b){this.c=a;this.f=b;this.a=t(this.c,\"span\",{\"aria-hidden\":\"true\"},this.f)}function N(a){u(a.c,\"body\",a.a)}function O(a){return\"display:block;position:absolute;top:-9999px;left:-9999px;font-size:300px;width:auto;height:auto;line-height:normal;margin:0;padding:0;font-variant:normal;white-space:nowrap;font-family:\"+I(a.c)+\";\"+(\"font-style:\"+H(a)+\";font-weight:\"+(a.f+\"00\")+\";\")};function P(a,b,c,d,e,f){this.g=a;this.j=b;this.a=d;this.c=c;this.f=e||3E3;this.h=f||void 0}P.prototype.start=function(){var a=this.c.o.document,b=this,c=q(),d=new Promise(function(d,e){function f(){q()-c>=b.f?e():a.fonts.load(fa(b.a),b.h).then(function(a){1<=a.length?d():setTimeout(f,25)},function(){e()})}f()}),e=null,f=new Promise(function(a,d){e=setTimeout(d,b.f)});Promise.race([f,d]).then(function(){e&&(clearTimeout(e),e=null);b.g(b.a)},function(){b.j(b.a)})};function Q(a,b,c,d,e,f,g){this.v=a;this.B=b;this.c=c;this.a=d;this.s=g||\"BESbswy\";this.f={};this.w=e||3E3;this.u=f||null;this.m=this.j=this.h=this.g=null;this.g=new M(this.c,this.s);this.h=new M(this.c,this.s);this.j=new M(this.c,this.s);this.m=new M(this.c,this.s);a=new G(this.a.c+\",serif\",J(this.a));a=O(a);this.g.a.style.cssText=a;a=new G(this.a.c+\",sans-serif\",J(this.a));a=O(a);this.h.a.style.cssText=a;a=new G(\"serif\",J(this.a));a=O(a);this.j.a.style.cssText=a;a=new G(\"sans-serif\",J(this.a));a=\nO(a);this.m.a.style.cssText=a;N(this.g);N(this.h);N(this.j);N(this.m)}var R={D:\"serif\",C:\"sans-serif\"},S=null;function T(){if(null===S){var a=/AppleWebKit\\/([0-9]+)(?:\\.([0-9]+))/.exec(window.navigator.userAgent);S=!!a&&(536>parseInt(a[1],10)||536===parseInt(a[1],10)&&11>=parseInt(a[2],10))}return S}Q.prototype.start=function(){this.f.serif=this.j.a.offsetWidth;this.f[\"sans-serif\"]=this.m.a.offsetWidth;this.A=q();U(this)};\nfunction la(a,b,c){for(var d in R)if(R.hasOwnProperty(d)&&b===a.f[R[d]]&&c===a.f[R[d]])return!0;return!1}function U(a){var b=a.g.a.offsetWidth,c=a.h.a.offsetWidth,d;(d=b===a.f.serif&&c===a.f[\"sans-serif\"])||(d=T()&&la(a,b,c));d?q()-a.A>=a.w?T()&&la(a,b,c)&&(null===a.u||a.u.hasOwnProperty(a.a.c))?V(a,a.v):V(a,a.B):ma(a):V(a,a.v)}function ma(a){setTimeout(p(function(){U(this)},a),50)}function V(a,b){setTimeout(p(function(){v(this.g.a);v(this.h.a);v(this.j.a);v(this.m.a);b(this.a)},a),0)};function W(a,b,c){this.c=a;this.a=b;this.f=0;this.m=this.j=!1;this.s=c}var X=null;W.prototype.g=function(a){var b=this.a;b.g&&w(b.f,[b.a.c(\"wf\",a.c,J(a).toString(),\"active\")],[b.a.c(\"wf\",a.c,J(a).toString(),\"loading\"),b.a.c(\"wf\",a.c,J(a).toString(),\"inactive\")]);K(b,\"fontactive\",a);this.m=!0;na(this)};\nW.prototype.h=function(a){var b=this.a;if(b.g){var c=y(b.f,b.a.c(\"wf\",a.c,J(a).toString(),\"active\")),d=[],e=[b.a.c(\"wf\",a.c,J(a).toString(),\"loading\")];c||d.push(b.a.c(\"wf\",a.c,J(a).toString(),\"inactive\"));w(b.f,d,e)}K(b,\"fontinactive\",a);na(this)};function na(a){0==--a.f&&a.j&&(a.m?(a=a.a,a.g&&w(a.f,[a.a.c(\"wf\",\"active\")],[a.a.c(\"wf\",\"loading\"),a.a.c(\"wf\",\"inactive\")]),K(a,\"active\")):L(a.a))};function oa(a){this.j=a;this.a=new ja;this.h=0;this.f=this.g=!0}oa.prototype.load=function(a){this.c=new ca(this.j,a.context||this.j);this.g=!1!==a.events;this.f=!1!==a.classes;pa(this,new ha(this.c,a),a)};\nfunction qa(a,b,c,d,e){var f=0==--a.h;(a.f||a.g)&&setTimeout(function(){var a=e||null,m=d||null||{};if(0===c.length&&f)L(b.a);else{b.f+=c.length;f&&(b.j=f);var h,l=[];for(h=0;h<c.length;h++){var k=c[h],n=m[k.c],r=b.a,x=k;r.g&&w(r.f,[r.a.c(\"wf\",x.c,J(x).toString(),\"loading\")]);K(r,\"fontloading\",x);r=null;if(null===X)if(window.FontFace){var x=/Gecko.*Firefox\\/(\\d+)/.exec(window.navigator.userAgent),xa=/OS X.*Version\\/10\\..*Safari/.exec(window.navigator.userAgent)&&/Apple/.exec(window.navigator.vendor);\nX=x?42<parseInt(x[1],10):xa?!1:!0}else X=!1;X?r=new P(p(b.g,b),p(b.h,b),b.c,k,b.s,n):r=new Q(p(b.g,b),p(b.h,b),b.c,k,b.s,a,n);l.push(r)}for(h=0;h<l.length;h++)l[h].start()}},0)}function pa(a,b,c){var d=[],e=c.timeout;ia(b);var d=ka(a.a,c,a.c),f=new W(a.c,b,e);a.h=d.length;b=0;for(c=d.length;b<c;b++)d[b].load(function(b,d,c){qa(a,f,b,d,c)})};function ra(a,b){this.c=a;this.a=b}\nra.prototype.load=function(a){function b(){if(f[\"__mti_fntLst\"+d]){var c=f[\"__mti_fntLst\"+d](),e=[],h;if(c)for(var l=0;l<c.length;l++){var k=c[l].fontfamily;void 0!=c[l].fontStyle&&void 0!=c[l].fontWeight?(h=c[l].fontStyle+c[l].fontWeight,e.push(new G(k,h))):e.push(new G(k))}a(e)}else setTimeout(function(){b()},50)}var c=this,d=c.a.projectId,e=c.a.version;if(d){var f=c.c.o;A(this.c,(c.a.api||\"https://fast.fonts.net/jsapi\")+\"/\"+d+\".js\"+(e?\"?v=\"+e:\"\"),function(e){e?a([]):(f[\"__MonotypeConfiguration__\"+\nd]=function(){return c.a},b())}).id=\"__MonotypeAPIScript__\"+d}else a([])};function sa(a,b){this.c=a;this.a=b}sa.prototype.load=function(a){var b,c,d=this.a.urls||[],e=this.a.families||[],f=this.a.testStrings||{},g=new B;b=0;for(c=d.length;b<c;b++)z(this.c,d[b],C(g));var m=[];b=0;for(c=e.length;b<c;b++)if(d=e[b].split(\":\"),d[1])for(var h=d[1].split(\",\"),l=0;l<h.length;l+=1)m.push(new G(d[0],h[l]));else m.push(new G(d[0]));E(g,function(){a(m,f)})};function ta(a,b){a?this.c=a:this.c=ua;this.a=[];this.f=[];this.g=b||\"\"}var ua=\"https://fonts.googleapis.com/css\";function va(a,b){for(var c=b.length,d=0;d<c;d++){var e=b[d].split(\":\");3==e.length&&a.f.push(e.pop());var f=\"\";2==e.length&&\"\"!=e[1]&&(f=\":\");a.a.push(e.join(f))}}\nfunction wa(a){if(0==a.a.length)throw Error(\"No fonts to load!\");if(-1!=a.c.indexOf(\"kit=\"))return a.c;for(var b=a.a.length,c=[],d=0;d<b;d++)c.push(a.a[d].replace(/ /g,\"+\"));b=a.c+\"?family=\"+c.join(\"%7C\");0<a.f.length&&(b+=\"&subset=\"+a.f.join(\",\"));0<a.g.length&&(b+=\"&text=\"+encodeURIComponent(a.g));return b};function ya(a){this.f=a;this.a=[];this.c={}}\nvar za={latin:\"BESbswy\",\"latin-ext\":\"\\u00e7\\u00f6\\u00fc\\u011f\\u015f\",cyrillic:\"\\u0439\\u044f\\u0416\",greek:\"\\u03b1\\u03b2\\u03a3\",khmer:\"\\u1780\\u1781\\u1782\",Hanuman:\"\\u1780\\u1781\\u1782\"},Aa={thin:\"1\",extralight:\"2\",\"extra-light\":\"2\",ultralight:\"2\",\"ultra-light\":\"2\",light:\"3\",regular:\"4\",book:\"4\",medium:\"5\",\"semi-bold\":\"6\",semibold:\"6\",\"demi-bold\":\"6\",demibold:\"6\",bold:\"7\",\"extra-bold\":\"8\",extrabold:\"8\",\"ultra-bold\":\"8\",ultrabold:\"8\",black:\"9\",heavy:\"9\",l:\"3\",r:\"4\",b:\"7\"},Ba={i:\"i\",italic:\"i\",n:\"n\",normal:\"n\"},\nCa=/^(thin|(?:(?:extra|ultra)-?)?light|regular|book|medium|(?:(?:semi|demi|extra|ultra)-?)?bold|black|heavy|l|r|b|[1-9]00)?(n|i|normal|italic)?$/;\nfunction Da(a){for(var b=a.f.length,c=0;c<b;c++){var d=a.f[c].split(\":\"),e=d[0].replace(/\\+/g,\" \"),f=[\"n4\"];if(2<=d.length){var g;var m=d[1];g=[];if(m)for(var m=m.split(\",\"),h=m.length,l=0;l<h;l++){var k;k=m[l];if(k.match(/^[\\w-]+$/)){var n=Ca.exec(k.toLowerCase());if(null==n)k=\"\";else{k=n[2];k=null==k||\"\"==k?\"n\":Ba[k];n=n[1];if(null==n||\"\"==n)n=\"4\";else var r=Aa[n],n=r?r:isNaN(n)?\"4\":n.substr(0,1);k=[k,n].join(\"\")}}else k=\"\";k&&g.push(k)}0<g.length&&(f=g);3==d.length&&(d=d[2],g=[],d=d?d.split(\",\"):\ng,0<d.length&&(d=za[d[0]])&&(a.c[e]=d))}a.c[e]||(d=za[e])&&(a.c[e]=d);for(d=0;d<f.length;d+=1)a.a.push(new G(e,f[d]))}};function Ea(a,b){this.c=a;this.a=b}var Fa={Arimo:!0,Cousine:!0,Tinos:!0};Ea.prototype.load=function(a){var b=new B,c=this.c,d=new ta(this.a.api,this.a.text),e=this.a.families;va(d,e);var f=new ya(e);Da(f);z(c,wa(d),C(b));E(b,function(){a(f.a,f.c,Fa)})};function Ga(a,b){this.c=a;this.a=b}Ga.prototype.load=function(a){var b=this.a.id,c=this.c.o;b?A(this.c,(this.a.api||\"https://use.typekit.net\")+\"/\"+b+\".js\",function(b){if(b)a([]);else if(c.Typekit&&c.Typekit.config&&c.Typekit.config.fn){b=c.Typekit.config.fn;for(var e=[],f=0;f<b.length;f+=2)for(var g=b[f],m=b[f+1],h=0;h<m.length;h++)e.push(new G(g,m[h]));try{c.Typekit.load({events:!1,classes:!1,async:!0})}catch(l){}a(e)}},2E3):a([])};function Ha(a,b){this.c=a;this.f=b;this.a=[]}Ha.prototype.load=function(a){var b=this.f.id,c=this.c.o,d=this;b?(c.__webfontfontdeckmodule__||(c.__webfontfontdeckmodule__={}),c.__webfontfontdeckmodule__[b]=function(b,c){for(var g=0,m=c.fonts.length;g<m;++g){var h=c.fonts[g];d.a.push(new G(h.name,ga(\"font-weight:\"+h.weight+\";font-style:\"+h.style)))}a(d.a)},A(this.c,(this.f.api||\"https://f.fontdeck.com/s/css/js/\")+ea(this.c)+\"/\"+b+\".js\",function(b){b&&a([])})):a([])};var Y=new oa(window);Y.a.c.custom=function(a,b){return new sa(b,a)};Y.a.c.fontdeck=function(a,b){return new Ha(b,a)};Y.a.c.monotype=function(a,b){return new ra(b,a)};Y.a.c.typekit=function(a,b){return new Ga(b,a)};Y.a.c.google=function(a,b){return new Ea(b,a)};var Z={load:p(Y.load,Y)};\"function\"===typeof define&&define.amd?define(function(){return Z}):\"undefined\"!==typeof module&&module.exports?module.exports=Z:(window.WebFont=Z,window.WebFontConfig&&Y.load(window.WebFontConfig));}());\n"]}