{"version":3,"sources":["webpack:///dist/theme.min.js","webpack:///webpack/bootstrap 7c2777c3addcce4ae91a","webpack:///../~/jquery/dist/jquery.js","webpack:///./Viewport.js","webpack:///./Change.js","webpack:///../vendor/dotimeout/jquery.ba-dotimeout.min.js","webpack:///../~/slick-carousel/slick/slick.js","webpack:///./BackgroundImage.js","webpack:///./CalendarFeed.js","webpack:///./DistrictAlert.js","webpack:///./Drupal.js","webpack:///./Expanded.js","webpack:///./FixNavigation.js","webpack:///./Gallery.js","webpack:///./Header.js","webpack:///./Menu.js","webpack:///./MobileMenu.js","webpack:///./Notification.js","webpack:///./Parallax.js","webpack:///./Placeholder.js","webpack:///./PopupAlert.js","webpack:///./SmartFooter.js","webpack:///./StoriesSlider.js","webpack:///./Strip.js","webpack:///./TermNavigation.js","webpack:///./Toolbar.js","webpack:///./Translate.js","webpack:///./TwitterFeed.js","webpack:///./Video.js","webpack:///../~/dd-templates/js/ddTemplates.js","webpack:///./theme.js","webpack:///../~/headroom.js/dist/headroom.js","webpack:///../~/moment/moment.js","webpack:///../~/webpack/buildin/module.js"],"names":["modules","__webpack_require__","moduleId","installedModules","exports","module","i","l","call","m","c","value","d","name","getter","o","Object","defineProperty","configurable","enumerable","get","n","__esModule","object","property","prototype","hasOwnProperty","p","s","__WEBPACK_AMD_DEFINE_ARRAY__","__WEBPACK_AMD_DEFINE_RESULT__","global","factory","document","w","Error","window","this","noGlobal","isArrayLike","obj","length","type","jQuery","isWindow","winnow","elements","qualifier","not","isFunction","grep","elem","nodeType","risSimple","test","filter","inArray","sibling","cur","dir","createOptions","options","each","match","rnotwhite","_","flag","detach","addEventListener","removeEventListener","completed","detachEvent","event","readyState","ready","dataAttr","key","data","undefined","replace","rmultiDash","toLowerCase","getAttribute","rbrace","parseJSON","e","isEmptyDataObject","isEmptyObject","internalData","pvt","acceptData","ret","thisCache","internalKey","expando","isNode","cache","id","deletedIds","pop","guid","toJSON","noop","extend","camelCase","internalRemoveData","isArray","concat","map","split","cleanData","support","deleteExpando","adjustCSS","prop","valueParts","tween","adjusted","scale","maxIterations","currentValue","css","initial","unit","cssNumber","initialInUnit","rcssNum","exec","style","start","end","createSafeFragment","list","nodeNames","safeFrag","createDocumentFragment","createElement","getAll","context","tag","elems","found","getElementsByTagName","querySelectorAll","childNodes","nodeName","push","merge","setGlobalEval","refElements","_data","fixDefaultChecked","rcheckableType","defaultChecked","checked","buildFragment","scripts","selection","ignored","j","contains","tmp","tbody","wrap","safe","nodes","rhtml","appendChild","rtagName","wrapMap","_default","innerHTML","htmlPrefilter","lastChild","leadingWhitespace","rleadingWhitespace","createTextNode","rtbody","firstChild","removeChild","textContent","appendChecked","ownerDocument","rscriptType","returnTrue","returnFalse","safeActiveElement","activeElement","err","on","types","selector","fn","one","origFn","off","apply","arguments","add","manipulationTarget","content","disableScript","find","attr","restoreScript","rscriptTypeMasked","removeAttribute","cloneCopyEvent","src","dest","hasData","oldData","curData","events","handle","fixCloneNodeIssues","noCloneEvent","removeEvent","text","parentNode","outerHTML","html5Clone","trim","defaultSelected","selected","defaultValue","domManip","collection","args","callback","first","node","hasScripts","doc","fragment","iNoClone","checkClone","rchecked","index","self","eq","html","clone","_evalUrl","globalEval","rcleanScript","remove","keepData","actualDisplay","appendTo","body","display","defaultDisplay","elemdisplay","iframe","documentElement","contentWindow","contentDocument","write","close","addGetHookIf","conditionFn","hookFn","vendorPropName","emptyStyle","capName","charAt","toUpperCase","slice","cssPrefixes","showHide","show","hidden","values","isHidden","setPositiveNumber","subtract","matches","rnumsplit","Math","max","augmentWidthOrHeight","extra","isBorderBox","styles","val","cssExpand","getWidthOrHeight","valueIsBorderBox","offsetWidth","offsetHeight","getStyles","boxSizing","curCSS","rnumnonpx","boxSizingReliable","parseFloat","Tween","easing","init","createFxNow","setTimeout","fxNow","now","genFx","includeWidth","which","attrs","height","opacity","width","createTween","animation","Animation","tweeners","defaultPrefilter","props","opts","toggle","hooks","oldfire","anim","orig","dataShow","queue","_queueHooks","unqueued","empty","fire","always","overflow","overflowX","overflowY","inlineBlockNeedsLayout","zoom","shrinkWrapBlocks","rfxtypes","done","hide","_removeData","propFilter","specialEasing","cssHooks","expand","properties","result","stopped","prefilters","deferred","Deferred","tick","currentTime","remaining","startTime","duration","temp","percent","tweens","run","notifyWith","resolveWith","promise","originalProperties","originalOptions","stop","gotoEnd","rejectWith","proxy","fx","timer","progress","complete","fail","getClass","addToPrefiltersOrTransports","structure","dataTypeExpression","func","dataType","dataTypes","unshift","inspectPrefiltersOrTransports","jqXHR","inspect","inspected","prefilterOrFactory","dataTypeOrTransport","seekingTransport","transports","ajaxExtend","target","deep","flatOptions","ajaxSettings","ajaxHandleResponses","responses","firstDataType","ct","finalDataType","contents","shift","mimeType","getResponseHeader","converters","ajaxConvert","response","isSuccess","conv2","current","conv","prev","responseFields","dataFilter","state","error","getDisplay","filterHidden","buildParams","prefix","traditional","v","rbracket","createStandardXHR","XMLHttpRequest","createActiveXHR","ActiveXObject","getWindow","defaultView","parentWindow","indexOf","class2type","toString","hasOwn","rtrim","rmsPrefix","rdashAlpha","fcamelCase","all","letter","jquery","constructor","toArray","num","pushStack","prevObject","last","len","sort","splice","copyIsArray","copy","isPlainObject","random","isReady","msg","Array","isNumeric","realStringObj","ownFirst","execScript","string","makeArray","arr","results","second","invert","callbackExpect","arg","Date","Symbol","iterator","Sizzle","seed","nid","nidselect","groups","newSelector","newContext","preferredDoc","setDocument","documentIsHTML","rquickExpr","getElementById","getElementsByClassName","qsa","compilerCache","rbuggyQSA","rescape","setAttribute","tokenize","ridentifier","toSelector","join","rsibling","testContext","qsaError","select","createCache","keys","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","dirrunsUnique","uniqueSort","getText","isXML","compile","sortInput","hasDuplicate","docElem","rbuggyMatches","classCache","tokenCache","sortOrder","push_native","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","String","fromCharCode","unloadHandler","els","hasCompare","parent","top","attachEvent","className","createComment","getById","getElementsByName","attrId","getAttributeNode","input","matchesSelector","webkitMatchesSelector","mozMatchesSelector","oMatchesSelector","msMatchesSelector","disconnectedMatch","compareDocumentPosition","adown","bup","compare","sortDetached","aup","ap","bp","expr","specified","duplicates","detectDuplicates","sortStable","nodeValue","selectors","createPseudo",">"," ","+","~","excess","unquoted","nodeNameSelector","pattern","operator","check","what","simple","forward","ofType","nodeIndex","useCache","pseudo","idx","matched","has","innerText","lang","elemLang","hash","location","root","focus","hasFocus","href","tabIndex","enabled","disabled","selectedIndex","header","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","rneedsContext","rsingleTag","rootjQuery","parseHTML","rparentsprev","guaranteedUnique","children","next","targets","closest","pos","prevAll","addBack","parents","parentsUntil","nextAll","nextUntil","prevUntil","reverse","Callbacks","firing","memory","fired","locked","firingIndex","once","stopOnFalse","disable","lock","fireWith","tuples","then","fns","newDefer","tuple","returned","notify","resolve","reject","pipe","stateString","when","subordinate","progressValues","progressContexts","resolveContexts","resolveValues","updateFunc","readyList","readyWait","holdReady","hold","wait","triggerHandler","doScroll","frameElement","doScrollCheck","container","cssText","noData","applet ","embed ","object ","removeData","dequeue","startLength","setter","clearQueue","count","defer","shrinkWrapBlocksVal","pnum","source","el","access","chainable","emptyGet","raw","bulk","htmlSerialize","cloneNode","noCloneChecked","option","legend","area","param","thead","tr","col","td","optgroup","tfoot","colgroup","caption","th","eventName","change","focusin","rformElems","rkeyEvent","rmouseEvent","rfocusMorph","rtypenamespace","t","handleObjIn","special","eventHandle","handleObj","handlers","namespaces","origType","elemData","triggered","dispatch","delegateType","bindType","namespace","delegateCount","setup","mappedTypes","origCount","teardown","trigger","onlyHandlers","ontype","bubbleType","eventPath","Event","isTrigger","rnamespace","noBubble","isPropagationStopped","preventDefault","isDefaultPrevented","fix","handlerQueue","delegateTarget","preDispatch","currentTarget","isImmediatePropagationStopped","stopPropagation","postDispatch","sel","isNaN","originalEvent","fixHook","fixHooks","mouseHooks","keyHooks","srcElement","metaKey","original","charCode","keyCode","eventDoc","fromElement","pageX","clientX","scrollLeft","clientLeft","pageY","clientY","scrollTop","clientTop","relatedTarget","toElement","load","blur","click","beforeunload","returnValue","simulate","isSimulated","defaultPrevented","timeStamp","cancelBubble","stopImmediatePropagation","mouseenter","mouseleave","pointerenter","pointerleave","related","form","_submitBubble","propertyName","_justChanged","attaches","rinlinejQuery","rnoshimcache","rxhtmlTag","rnoInnerhtml","safeFragment","fragmentDiv","dataAndEvents","deepDataAndEvents","destElements","srcElements","inPage","forceAcceptData","append","prepend","insertBefore","before","after","replaceWith","replaceChild","prependTo","insertAfter","replaceAll","insert","HTML","BODY","rmargin","swap","old","computeStyleTests","divStyle","pixelPositionVal","boxSizingReliableVal","reliableMarginLeftVal","pixelMarginRightVal","reliableMarginRightVal","getComputedStyle","marginLeft","marginRight","reliableHiddenOffsetsVal","getClientRects","borderCollapse","cssFloat","backgroundClip","clearCloneStyle","MozBoxSizing","WebkitBoxSizing","reliableHiddenOffsets","pixelMarginRight","pixelPosition","reliableMarginRight","reliableMarginLeft","rposition","view","opener","computed","minWidth","maxWidth","getPropertyValue","currentStyle","left","rs","rsLeft","runtimeStyle","pixelLeft","ralpha","ropacity","rdisplayswap","cssShow","position","visibility","cssNormalTransform","letterSpacing","fontWeight","animationIterationCount","columnCount","fillOpacity","flexGrow","flexShrink","lineHeight","order","orphans","widows","zIndex","cssProps","float","origName","set","isFinite","$1","getBoundingClientRect","margin","padding","border","suffix","expanded","parts","propHooks","eased","step","linear","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","getSetAttribute","hrefNormalized","checkOn","optSelected","enctype","optDisabled","radioValue","rreturn","rspaces","valHooks","optionSet","scrollHeight","nodeHook","boolHook","ruseDefault","getSetInput","removeAttr","nType","attrHooks","propName","attrNames","propFix","setAttributeNode","createAttribute","coords","contenteditable","rfocusable","rclickable","removeProp","tabindex","parseInt","for","class","rclass","addClass","classes","curValue","clazz","finalValue","removeClass","toggleClass","stateVal","classNames","hasClass","hover","fnOver","fnOut","nonce","rquery","rvalidtokens","JSON","parse","requireNonComma","depth","str","comma","open","Function","parseXML","DOMParser","parseFromString","async","loadXML","rhash","rts","rheaders","rlocalProtocol","rnoContent","rprotocol","rurl","allTypes","ajaxLocation","ajaxLocParts","active","lastModified","etag","url","isLocal","processData","contentType","accepts","json","* text","text html","text json","text xml","ajaxSetup","settings","ajaxPrefilter","ajaxTransport","ajax","status","nativeStatusText","headers","success","modified","statusText","timeoutTimer","transport","responseHeadersString","ifModified","cacheURL","callbackContext","statusCode","fireGlobals","globalEventContext","completeDeferred","responseHeaders","requestHeaders","requestHeadersNames","strAbort","getAllResponseHeaders","setRequestHeader","lname","overrideMimeType","code","abort","finalText","method","crossDomain","hasContent","beforeSend","send","getJSON","getScript","throws","wrapAll","wrapInner","unwrap","visible","r20","rCRLF","rsubmitterTypes","rsubmittable","encodeURIComponent","serialize","serializeArray","xhr","documentMode","xhrId","xhrCallbacks","xhrSupported","cors","username","xhrFields","isAbort","onreadystatechange","responseText","script","text script","head","scriptCharset","charset","onload","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","bind","unbind","delegate","undelegate","size","andSelf","_jQuery","_$","$","noConflict","Viewport","_jquery2","default","mobileState","getCurrentState","ticking","addListeners","_jquery","setCurrentState","innerWidth","update","currentState","previousState","changeCallbacks","mobileCallbacks","desktopCallbacks","requestTick","requestAnimationFrame","onMobileChange","onDesktopChange","onChange","Change","listen","callbacks","request","h","f","k","g","q","__WEBPACK_AMD_DEFINE_FACTORY__","Slick","element","dataSettings","defaults","accessibility","adaptiveHeight","appendArrows","appendDots","arrows","asNavFor","prevArrow","nextArrow","autoplay","autoplaySpeed","centerMode","centerPadding","cssEase","customPaging","slider","dots","dotsClass","draggable","edgeFriction","fade","focusOnSelect","infinite","initialSlide","lazyLoad","mobileFirst","pauseOnHover","pauseOnFocus","pauseOnDotsHover","respondTo","responsive","rows","rtl","slide","slidesPerRow","slidesToShow","slidesToScroll","swipe","swipeToSlide","touchMove","touchThreshold","useCSS","useTransform","variableWidth","vertical","verticalSwiping","waitForAnimate","initials","animating","dragging","autoPlayTimer","currentDirection","currentLeft","currentSlide","direction","$dots","listWidth","listHeight","loadIndex","$nextArrow","$prevArrow","slideCount","slideWidth","$slideTrack","$slides","sliding","slideOffset","swipeLeft","$list","touchObject","transformsEnabled","unslicked","activeBreakpoint","animType","animProp","breakpoints","breakpointSettings","cssTransitions","focussed","interrupted","paused","positionProp","rowCount","shouldClick","$slider","$slidesCache","transformType","transitionType","visibilityChange","windowWidth","windowTimer","mozHidden","webkitHidden","autoPlay","autoPlayClear","autoPlayIterator","changeSlide","clickHandler","selectHandler","setPosition","swipeHandler","dragHandler","keyHandler","instanceUid","htmlExpr","registerBreakpoints","activateADA","aria-hidden","addSlide","slickAdd","markup","addBefore","unload","reinit","animateHeight","targetHeight","outerHeight","animateSlide","targetLeft","animProps","animStart","ceil","applyTransition","disableTransition","getNavTarget","slick","slideHandler","transition","slideTo","buildArrows","aria-disabled","buildDots","dot","getDotCount","buildOut","setupInfinite","updateDots","setSlideClasses","buildRows","newSlides","numOfSlides","originalSlides","slidesPerSection","row","checkResponsive","forceUpdate","breakpoint","targetBreakpoint","respondToWidth","triggerBreakpoint","sliderWidth","min","unslick","refresh","dontAnimate","indexOffset","unevenOffset","$target","message","checkNavigable","navigables","prevNavigable","getNavigableIndexes","cleanUpEvents","interrupt","cleanUpSlideEvents","orientationChange","resize","cleanUpRows","destroy","fadeSlide","slideIndex","fadeSlideOut","filterSlides","slickFilter","focusHandler","$sf","getCurrent","slickCurrentSlide","breakPoint","counter","pagerQty","getLeft","verticalHeight","targetSlide","verticalOffset","floor","offsetLeft","outerWidth","getOption","slickGetOption","indexes","getSlick","getSlideCount","swipedSlide","centerOffset","abs","goTo","slickGoTo","creation","setProps","startLoad","loadSlider","initializeEvents","updateArrows","initADA","role","aria-describedby","aria-selected","aria-controls","initArrowEvents","initDotEvents","initSlideEvents","action","initUI","tagName","loadImages","imagesScope","imageSource","imageToLoad","onerror","loadRange","cloneRange","rangeStart","rangeEnd","progressiveLazyLoad","slickNext","pause","slickPause","play","slickPlay","postSlide","slickPrev","tryCount","$imgsToLoad","initializing","lastVisibleIndex","currentBreakpoint","responsiveSettings","windowDelay","removeSlide","slickRemove","removeBefore","removeAll","setCSS","x","y","positionProps","setDimensions","setFade","right","setHeight","setOption","slickSetOption","item","bodyStyle","WebkitTransition","MozTransition","msTransition","OTransform","perspectiveProperty","webkitPerspective","MozTransform","MozPerspective","webkitTransform","msTransform","transform","allSlides","remainder","infiniteCount","targetElement","sync","animSlide","oldSlide","slideLeft","navTarget","swipeDirection","xDist","yDist","r","swipeAngle","startX","curX","startY","curY","atan2","round","swipeEnd","swipeLength","edgeHit","minSwipe","fingerCount","touches","swipeStart","swipeMove","positionOffset","sqrt","pow","unfilterSlides","slickUnfilter","fromBreakpoint","_classCallCheck","instance","Constructor","TypeError","BackgroundImage","$element","_interopRequireDefault","CalendarFeed","_extends","getFilters","assign","_moment","_moment2","storageKey","paginationLabel","filtersLabel","filterByPostTypes","useFilters","defaultFilters","All","buildCalendar","createFilters","$posts","currentYear","currentMonth","$group","post","$post","dates","oDates","datetime","date","month","format","mon","day","dow","year","$year","$tile","isSameMonth","isSameDay","isSameYear","filterHandler","_this","$filters","ids","getDefaultData","getCustomizedData","currentFilter","sessionStorage","getItem","substr","decodeURIComponent","$filter","$show","setItem","$shown","$ctrl","_types","_ids","regex","aTypes","aResults","_createClass","defineProperties","descriptor","writable","protoProps","staticProps","DistrictAlert","$instance","getAlert","areWeThere","createKey","getVariable","setVariable","pathname","behaviors","documentIsReady","Drupal","behavior","console","log","DrupalAMD","Expanded","FixNavigation","process","$parent","$children","$orphans","Gallery","$gallery","build","Header","headroom","_headroom2","_headroom","tolerance","pinned","unpinned","notTop","bottom","notBottom","onPin","onUnpin","onTop","onNotTop","onBottom","onNotBottom","Menu","$menus","getMenus","over","out","_Viewport","_Viewport2","hoverInit","hoverDelay","doTimeout","MobileMenu","$roots","getRootMenus","onClick","displayActiveMenus","shouldExpand","Notification","getPost","Parallax","register","_Change","_Change2","Placholder","$label","$input","placeholder","Footer","$footprint","StoriesSlider","createSlider","Stripper","strip","TermNavigation","onHeaderClick","addPatties","$filteredMenus","onMenuClick","Toolbar","$body","getBody","$menuBtn","getBtn","$searchBtn","$searchBox","getBox","searchText","menuHandler","searchHandler","resetSearchInput","menu","search","$searchText","typeOutPlaceholderText","_this2","Translate","google","translateElement","$desktop","getDesktopPlacement","$mobile","getMobilePlacement","googleTranslateInit","translate","TranslateElement","$gt","pageLanguage","layout","FloatPosition","BOTTOM_RIGHT","requestData","slickSettings","TwitterFeed","sendRequest","$tweets","Video","video","playing","playPause","$playBtn","addPlayBtn","$pauseBtn","addPauseBtn","$bgVideo","getVideo","$destination","getDestination","showVideoAtThisBreakpoint","playBtn","pauseBtn","isMobileDevice","addVideo","navigator","userAgent","$source","$check","sources","$video","substring","lastIndexOf","addControls","setPlayState","setPauseState","photoGalleryPID","relatedLinks","itemAppearsIn","fullNodeRelatedLinks","bundledReferringContent","lexiconGlossary","subtermOverviews","nodeMeta","imageCaptions","slideshowIcons","expandingDates","DDTemplates","_defaults","isNodeView","defineApplicableBehaviors","addEnabledBehavior","term","$appearingNav","$nodeFields","$relatedLinks","$block","$node","$meta","$items","$visible","meta","$dates","$link","$container","$image","$field","$img","_ddTemplates","_ddTemplates2","_Menu","_Menu2","_Drupal","_Drupal2","_Header","_Header2","_Gallery","_Gallery2","_Toolbar","_Toolbar2","_MobileMenu","_MobileMenu2","_SmartFooter","_SmartFooter2","_CalendarFeed","_CalendarFeed2","_FixNavigation","_FixNavigation2","_TermNavigation","_TermNavigation2","_Strip","_Strip2","_Notification","_Notification2","_DistrictAlert","_DistrictAlert2","_PopupAlert","_PopupAlert2","_BackgroundImage","_BackgroundImage2","_Placeholder","_Placeholder2","_Parallax","_Parallax2","_Expanded","_Expanded2","_TwitterFeed","_TwitterFeed2","_StoriesSlider","_StoriesSlider2","_Translate","_Translate2","_Video","_Video2","postUrl","wrapper","newLink","newElement","mobileMenu","PopupAlert","toolbar","Placeholder","footer","smartFooter","termNavigation","gallery","calendarFeed","$map","$nav","digitaldcoreCreateSiteMap","Debouncer","isDOMElement","replacement","normalizeTolerance","down","up","Headroom","lastKnownScrollY","scroller","initialised","features","classList","rAF","webkitRequestAnimationFrame","mozRequestAnimationFrame","rafCallback","handleEvent","cutsTheMustard","debouncer","getScrollY","unpin","pin","getViewportHeight","innerHeight","clientHeight","getElementPhysicalHeight","elm","getScrollerPhysicalHeight","getDocumentHeight","getElementHeight","getScrollerHeight","isOutOfBounds","currentScrollY","pastTop","pastBottom","toleranceExceeded","shouldUnpin","scrollingDown","pastOffset","shouldPin","scrollingUp","scrollDirection","hookCallback","isObject","isObjectEmpty","isUndefined","isNumber","isDate","res","hasOwnProp","valueOf","createUTC","locale","strict","createLocalOrUTC","utc","defaultParsingFlags","unusedTokens","unusedInput","charsLeftOver","nullInput","invalidMonth","invalidFormat","userInvalidated","iso","parsedDateParts","meridiem","rfc2822","weekdayMismatch","getParsingFlags","_pf","isValid","_isValid","flags","parsedParts","some$1","isNowValid","_d","getTime","invalidWeekday","_strict","bigHour","isFrozen","createInvalid","NaN","copyConfig","from","_isAMomentObject","_i","_f","_l","_tzm","_isUTC","_offset","_locale","momentProperties","Moment","config","updateInProgress","updateOffset","isMoment","absFloor","number","toInt","argumentForCoercion","coercedNumber","compareArrays","array1","array2","dontConvert","lengthDiff","diffs","warn","suppressDeprecationWarnings","deprecate","firstTime","deprecationHandler","stack","deprecateSimple","deprecations","_config","_dayOfMonthOrdinalParseLenient","_dayOfMonthOrdinalParse","_ordinalParse","mergeConfigs","parentConfig","childConfig","Locale","calendar","mom","output","_calendar","longDateFormat","_longDateFormat","formatUpper","invalidDate","_invalidDate","ordinal","_ordinal","relativeTime","withoutSuffix","isFuture","_relativeTime","pastFuture","addUnitAlias","shorthand","lowerCase","aliases","normalizeUnits","units","normalizeObjectUnits","inputObject","normalizedProp","normalizedInput","addUnitPriority","priority","priorities","getPrioritizedUnits","unitsObj","u","makeGetSet","keepTime","set$1","stringGet","stringSet","prioritized","zeroFill","targetLength","forceSign","absNumber","zerosToFill","addFormatToken","padded","formatTokenFunctions","localeData","removeFormattingTokens","makeFormatFunction","array","formattingTokens","formatMoment","expandFormat","formatFunctions","replaceLongDateFormatTokens","localFormattingTokens","lastIndex","addRegexToken","strictRegex","regexes","isStrict","getParseRegexForToken","unescapeFormat","regexEscape","p1","p2","p3","p4","addParseToken","addWeekParseToken","_w","addTimeToArrayFromToken","_a","daysInMonth","UTC","getUTCDate","localeMonths","_months","isFormat","MONTHS_IN_FORMAT","localeMonthsShort","_monthsShort","handleStrictParse","monthName","ii","llc","toLocaleLowerCase","_monthsParse","_longMonthsParse","_shortMonthsParse","monthsShort","months","indexOf$1","localeMonthsParse","_monthsParseExact","setMonth","dayOfMonth","monthsParse","getSetMonth","getDaysInMonth","monthsShortRegex","computeMonthsParse","_monthsShortStrictRegex","_monthsShortRegex","defaultMonthsShortRegex","monthsRegex","_monthsStrictRegex","_monthsRegex","defaultMonthsRegex","cmpLenRev","shortPieces","longPieces","mixedPieces","daysInYear","isLeapYear","getIsLeapYear","createDate","M","ms","getFullYear","setFullYear","createUTCDate","getUTCFullYear","setUTCFullYear","firstWeekOffset","doy","fwd","getUTCDay","dayOfYearFromWeeks","week","weekday","resYear","resDayOfYear","localWeekday","weekOffset","dayOfYear","weekOfYear","resWeek","weeksInYear","weekOffsetNext","localeWeek","_week","localeFirstDayOfWeek","localeFirstDayOfYear","getSetWeek","getSetISOWeek","parseWeekday","weekdaysParse","parseIsoWeekday","localeWeekdays","_weekdays","localeWeekdaysShort","_weekdaysShort","localeWeekdaysMin","_weekdaysMin","handleStrictParse$1","weekdayName","_weekdaysParse","_shortWeekdaysParse","_minWeekdaysParse","weekdaysMin","weekdaysShort","weekdays","localeWeekdaysParse","_weekdaysParseExact","_fullWeekdaysParse","getSetDayOfWeek","getDay","getSetLocaleDayOfWeek","getSetISODayOfWeek","weekdaysRegex","computeWeekdaysParse","_weekdaysStrictRegex","_weekdaysRegex","defaultWeekdaysRegex","weekdaysShortRegex","_weekdaysShortStrictRegex","_weekdaysShortRegex","defaultWeekdaysShortRegex","weekdaysMinRegex","_weekdaysMinStrictRegex","_weekdaysMinRegex","defaultWeekdaysMinRegex","minp","shortp","longp","minPieces","hFormat","hours","kFormat","lowercase","minutes","matchMeridiem","_meridiemParse","localeIsPM","localeMeridiem","isLower","normalizeLocale","chooseLocale","names","loadLocale","oldLocale","locales","globalLocale","_abbr","getSetGlobalLocale","getLocale","defineLocale","baseConfig","abbr","parentLocale","localeFamilies","forEach","updateLocale","listLocales","keys$1","checkOverflow","MONTH","DATE","YEAR","HOUR","MINUTE","SECOND","MILLISECOND","_overflowDayOfYear","_overflowWeeks","WEEK","_overflowWeekday","WEEKDAY","configFromISO","allowTime","dateFormat","timeFormat","tzFormat","extendedIsoRegex","basicIsoRegex","isoDates","isoTimes","tzRegex","configFromStringAndFormat","configFromRFC2822","dayFormat","timezone","timezoneIndex","timezones"," GMT"," EDT"," EST"," CDT"," CST"," MDT"," MST"," PDT"," PST","military","basicRfcRegex","momentDate","momentDay","configFromString","aspNetJsonRegex","createFromInputFallback","currentDateArray","nowValue","_useUTC","getUTCMonth","getMonth","getDate","configFromArray","currentDate","yearToUse","dayOfYearFromWeekInfo","_dayOfYear","_nextDay","setUTCMinutes","getUTCMinutes","weekYear","weekdayOverflow","GG","W","E","createLocal","curWeek","gg","ISO_8601","RFC_2822","parsedInput","skipped","stringLength","totalParsedInputLength","_meridiem","meridiemFixWrap","hour","isPm","meridiemHour","isPM","configFromStringAndArray","tempConfig","bestMoment","scoreToBeat","currentScore","score","configFromObject","minute","millisecond","createFromConfig","prepareConfig","preparse","configFromInput","isUTC","pickBy","moments","isDurationValid","ordering","unitHasDecimal","isValid$1","createInvalid$1","createDuration","Duration","years","quarters","quarter","weeks","days","seconds","milliseconds","_milliseconds","_days","_bubble","isDuration","absRound","separator","utcOffset","sign","offsetFromString","chunk","chunkOffset","cloneWithOffset","model","setTime","local","getDateOffset","getTimezoneOffset","getSetOffset","keepLocalTime","keepMinutes","localAdjust","matchShortOffset","_changeInProgress","addSubtract","getSetZone","setOffsetToUTC","setOffsetToLocal","setOffsetToParsedOffset","tZone","matchOffset","hasAlignedHourOffset","isDaylightSavingTime","isDaylightSavingTimeShifted","_isDSTShifted","other","isUtcOffset","isUtc","diffRes","aspNetRegex","isoRegex","parseIso","momentsDifference","inp","positiveMomentsDifference","isAfter","isBefore","createAdder","period","dur","isAdding","getCalendarFormat","myMoment","calendar$1","formats","sod","startOf","calendarFormat","localInput","endOf","isBetween","inclusivity","isSame","inputMs","isSameOrAfter","isSameOrBefore","asFloat","that","zoneDelta","delta","monthDiff","anchor2","adjust","wholeMonthDiff","anchor","toISOString","toDate","zone","inputString","defaultFormatUtc","defaultFormat","postformat","humanize","fromNow","toNow","newLocaleData","isoWeekday","unix","toObject","isValid$2","parsingFlags","invalidAt","creationData","addWeekYearFormatToken","getSetWeekYear","getSetWeekYearHelper","getSetISOWeekYear","isoWeek","getISOWeeksInYear","getWeeksInYear","weekInfo","weeksTarget","setWeekAll","dayOfYearData","getSetQuarter","getSetDayOfYear","parseMs","getZoneAbbr","getZoneName","createUnix","createInZone","parseZone","preParsePostFormat","get$1","field","listMonthsImpl","listWeekdaysImpl","localeSorted","listMonths","listMonthsShort","listWeekdays","listWeekdaysShort","listWeekdaysMin","mathAbs","addSubtract$1","add$1","subtract$1","absCeil","bubble","monthsFromDays","monthsToDays","daysToMonths","as","valueOf$1","makeAs","alias","get$2","makeGetter","substituteTimeAgo","relativeTime$1","posNegDuration","thresholds","ss","getSetRelativeTimeRounding","roundingFunction","getSetRelativeTimeThreshold","threshold","limit","withSuffix","toISOString$1","abs$1","Y","D","total","asSeconds","some","fun","defaultCalendar","sameDay","nextDay","nextWeek","lastDay","lastWeek","sameElse","defaultLongDateFormat","LTS","LT","L","LL","LLL","LLLL","defaultDayOfMonthOrdinalParse","defaultRelativeTime","future","past","mm","hh","dd","MM","yy","match1","match2","match3","match4","match6","match1to2","match3to4","match5to6","match1to3","match1to4","match1to6","matchUnsigned","matchSigned","matchTimestamp","matchWord","defaultLocaleMonths","defaultLocaleMonthsShort","parseTwoDigitYear","getSetYear","defaultLocaleWeek","defaultLocaleWeekdays","defaultLocaleWeekdaysShort","defaultLocaleWeekdaysMin","kInput","_isPm","pos1","pos2","defaultLocaleMeridiemParse","getSetHour","dayOfMonthOrdinalParse","meridiemParse","prototypeMin","prototypeMax","invalid","isoWeekYear","getSetDayOfMonth","getSetMinute","getSetSecond","getSetMillisecond","proto","isoWeeks","isoWeeksInYear","isDST","zoneAbbr","zoneName","isDSTShifted","proto$1","firstDayOfYear","firstDayOfWeek","langData","asMilliseconds","asMinutes","asHours","asDays","asWeeks","asMonths","asYears","proto$2","toIsoString","version","relativeTimeRounding","relativeTimeThreshold","webpackPolyfill","paths"],"mappings":"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","file":"dist/theme.min.js","sourcesContent":["/******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n/******/\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n/******/\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId]) {\n/******/ \t\t\treturn installedModules[moduleId].exports;\n/******/ \t\t}\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\ti: moduleId,\n/******/ \t\t\tl: false,\n/******/ \t\t\texports: {}\n/******/ \t\t};\n/******/\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n/******/\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.l = true;\n/******/\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n/******/\n/******/\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n/******/\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n/******/\n/******/ \t// identity function for calling harmony imports with the correct context\n/******/ \t__webpack_require__.i = function(value) { return value; };\n/******/\n/******/ \t// define getter function for harmony exports\n/******/ \t__webpack_require__.d = function(exports, name, getter) {\n/******/ \t\tif(!__webpack_require__.o(exports, name)) {\n/******/ \t\t\tObject.defineProperty(exports, name, {\n/******/ \t\t\t\tconfigurable: false,\n/******/ \t\t\t\tenumerable: true,\n/******/ \t\t\t\tget: getter\n/******/ \t\t\t});\n/******/ \t\t}\n/******/ \t};\n/******/\n/******/ \t// getDefaultExport function for compatibility with non-harmony modules\n/******/ \t__webpack_require__.n = function(module) {\n/******/ \t\tvar getter = module && module.__esModule ?\n/******/ \t\t\tfunction getDefault() { return module['default']; } :\n/******/ \t\t\tfunction getModuleExports() { return module; };\n/******/ \t\t__webpack_require__.d(getter, 'a', getter);\n/******/ \t\treturn getter;\n/******/ \t};\n/******/\n/******/ \t// Object.prototype.hasOwnProperty.call\n/******/ \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n/******/\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(__webpack_require__.s = 28);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!\n * jQuery JavaScript Library v1.12.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:17Z\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 deletedIds = [];\n\nvar document = window.document;\n\nvar slice = deletedIds.slice;\n\nvar concat = deletedIds.concat;\n\nvar push = deletedIds.push;\n\nvar indexOf = deletedIds.indexOf;\n\nvar class2type = {};\n\nvar toString = class2type.toString;\n\nvar hasOwn = class2type.hasOwnProperty;\n\nvar support = {};\n\n\n\nvar\n\tversion = \"1.12.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, IE<9\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: deletedIds.sort,\n\tsplice: deletedIds.splice\n};\n\njQuery.extend = jQuery.fn.extend = function() {\n\tvar src, copyIsArray, copy, name, options, 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\t// See test/unit/core.js for details concerning isFunction.\n\t// Since version 1.3, DOM methods and functions like alert\n\t// aren't supported. They return false on IE (#2968).\n\tisFunction: function( obj ) {\n\t\treturn jQuery.type( obj ) === \"function\";\n\t},\n\n\tisArray: Array.isArray || function( obj ) {\n\t\treturn jQuery.type( obj ) === \"array\";\n\t},\n\n\tisWindow: function( obj ) {\n\t\t/* jshint eqeqeq: false */\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\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\tisPlainObject: function( obj ) {\n\t\tvar key;\n\n\t\t// Must be an Object.\n\t\t// Because of IE, we also have to check the presence of the constructor property.\n\t\t// Make sure that DOM nodes and window objects don't pass through, as well\n\t\tif ( !obj || jQuery.type( obj ) !== \"object\" || obj.nodeType || jQuery.isWindow( obj ) ) {\n\t\t\treturn false;\n\t\t}\n\n\t\ttry {\n\n\t\t\t// Not own constructor property must be Object\n\t\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\t\treturn false;\n\t\t\t}\n\t\t} catch ( e ) {\n\n\t\t\t// IE8,9 Will throw exceptions on certain host objects #9897\n\t\t\treturn false;\n\t\t}\n\n\t\t// Support: IE<9\n\t\t// Handle iteration over inherited properties before own properties.\n\t\tif ( !support.ownFirst ) {\n\t\t\tfor ( key in obj ) {\n\t\t\t\treturn hasOwn.call( obj, key );\n\t\t\t}\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\ttype: function( obj ) {\n\t\tif ( obj == null ) {\n\t\t\treturn obj + \"\";\n\t\t}\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// Workarounds based on findings by Jim Driscoll\n\t// http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context\n\tglobalEval: function( data ) {\n\t\tif ( data && jQuery.trim( data ) ) {\n\n\t\t\t// We use execScript on Internet Explorer\n\t\t\t// We use an anonymous function so that context is window\n\t\t\t// rather than jQuery in Firefox\n\t\t\t( window.execScript || function( data ) {\n\t\t\t\twindow[ \"eval\" ].call( window, data ); // jscs:ignore requireDotNotation\n\t\t\t} )( data );\n\t\t}\n\t},\n\n\t// Convert dashed to camelCase; used by the css and data modules\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, IE<9\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\tvar len;\n\n\t\tif ( arr ) {\n\t\t\tif ( indexOf ) {\n\t\t\t\treturn indexOf.call( arr, elem, i );\n\t\t\t}\n\n\t\t\tlen = arr.length;\n\t\t\ti = i ? i < 0 ? Math.max( 0, len + i ) : i : 0;\n\n\t\t\tfor ( ; i < len; i++ ) {\n\n\t\t\t\t// Skip accessing in sparse arrays\n\t\t\t\tif ( i in arr && arr[ i ] === elem ) {\n\t\t\t\t\treturn i;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn -1;\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\twhile ( j < len ) {\n\t\t\tfirst[ i++ ] = second[ j++ ];\n\t\t}\n\n\t\t// Support: IE<9\n\t\t// Workaround casting of .length to NaN on otherwise arraylike objects (e.g., NodeLists)\n\t\tif ( len !== len ) {\n\t\t\twhile ( second[ j ] !== undefined ) {\n\t\t\t\tfirst[ i++ ] = second[ j++ ];\n\t\t\t}\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 args, proxy, tmp;\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: function() {\n\t\treturn +( new Date() );\n\t},\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 ] = deletedIds[ 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 ( jQuery.inArray( elem, qualifier ) > -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\tret = [],\n\t\t\tself = this,\n\t\t\tlen = self.length;\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// 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.charAt( 0 ) === \"<\" &&\n\t\t\t\tselector.charAt( 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// 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// Check parentNode to catch when Blackberry 4.6 returns\n\t\t\t\t\t// nodes that are no longer in the document #6963\n\t\t\t\t\tif ( elem && elem.parentNode ) {\n\n\t\t\t\t\t\t// Handle the case where IE and Opera return items\n\t\t\t\t\t\t// by name instead of ID\n\t\t\t\t\t\tif ( elem.id !== match[ 2 ] ) {\n\t\t\t\t\t\t\treturn rootjQuery.find( selector );\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Otherwise, we 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 typeof 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 i,\n\t\t\ttargets = jQuery( target, this ),\n\t\t\tlen = targets.length;\n\n\t\treturn this.filter( function() {\n\t\t\tfor ( i = 0; i < len; 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\n\t// the matched set of elements\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 jQuery.inArray( this[ 0 ], jQuery( elem ) );\n\t\t}\n\n\t\t// Locate the position of the desired element\n\t\treturn jQuery.inArray(\n\n\t\t\t// If it receives a jQuery object, the first element is used\n\t\t\telem.jquery ? elem[ 0 ] : elem, this );\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\tdo {\n\t\tcur = cur[ dir ];\n\t} while ( cur && cur.nodeType !== 1 );\n\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 jQuery.nodeName( elem, \"iframe\" ) ?\n\t\t\telem.contentDocument || elem.contentWindow.document :\n\t\t\tjQuery.merge( [], elem.childNodes );\n\t}\n}, function( name, fn ) {\n\tjQuery.fn[ name ] = function( until, selector ) {\n\t\tvar ret = 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\tret = jQuery.filter( selector, ret );\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\tret = jQuery.uniqueSort( ret );\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\tret = ret.reverse();\n\t\t\t}\n\t\t}\n\n\t\treturn this.pushStack( ret );\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 = true;\n\t\t\t\tif ( !memory ) {\n\t\t\t\t\tself.disable();\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\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 * Clean-up method for dom ready events\n */\nfunction detach() {\n\tif ( document.addEventListener ) {\n\t\tdocument.removeEventListener( \"DOMContentLoaded\", completed );\n\t\twindow.removeEventListener( \"load\", completed );\n\n\t} else {\n\t\tdocument.detachEvent( \"onreadystatechange\", completed );\n\t\twindow.detachEvent( \"onload\", completed );\n\t}\n}\n\n/**\n * The ready event handler and self cleanup method\n */\nfunction completed() {\n\n\t// readyState === \"complete\" is good enough for us to call the dom ready in oldIE\n\tif ( document.addEventListener ||\n\t\twindow.event.type === \"load\" ||\n\t\tdocument.readyState === \"complete\" ) {\n\n\t\tdetach();\n\t\tjQuery.ready();\n\t}\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: IE6-10\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// Standards-based browsers support DOMContentLoaded\n\t\t} else if ( document.addEventListener ) {\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\n\t\t// If IE event model is used\n\t\t} else {\n\n\t\t\t// Ensure firing before onload, maybe late but safe also for iframes\n\t\t\tdocument.attachEvent( \"onreadystatechange\", completed );\n\n\t\t\t// A fallback to window.onload, that will always work\n\t\t\twindow.attachEvent( \"onload\", completed );\n\n\t\t\t// If IE and not a frame\n\t\t\t// continually check to see if the document is ready\n\t\t\tvar top = false;\n\n\t\t\ttry {\n\t\t\t\ttop = window.frameElement == null && document.documentElement;\n\t\t\t} catch ( e ) {}\n\n\t\t\tif ( top && top.doScroll ) {\n\t\t\t\t( function doScrollCheck() {\n\t\t\t\t\tif ( !jQuery.isReady ) {\n\n\t\t\t\t\t\ttry {\n\n\t\t\t\t\t\t\t// Use the trick by Diego Perini\n\t\t\t\t\t\t\t// http://javascript.nwbox.com/IEContentLoaded/\n\t\t\t\t\t\t\ttop.doScroll( \"left\" );\n\t\t\t\t\t\t} catch ( e ) {\n\t\t\t\t\t\t\treturn window.setTimeout( doScrollCheck, 50 );\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// detach all dom ready events\n\t\t\t\t\t\tdetach();\n\n\t\t\t\t\t\t// and execute any waiting functions\n\t\t\t\t\t\tjQuery.ready();\n\t\t\t\t\t}\n\t\t\t\t} )();\n\t\t\t}\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// Support: IE<9\n// Iteration over object's inherited properties before its own\nvar i;\nfor ( i in jQuery( support ) ) {\n\tbreak;\n}\nsupport.ownFirst = i === \"0\";\n\n// Note: most support tests are defined in their respective modules.\n// false until the test is run\nsupport.inlineBlockNeedsLayout = false;\n\n// Execute ASAP in case we need to set body.style.zoom\njQuery( function() {\n\n\t// Minified: var a,b,c,d\n\tvar val, div, body, container;\n\n\tbody = document.getElementsByTagName( \"body\" )[ 0 ];\n\tif ( !body || !body.style ) {\n\n\t\t// Return for frameset docs that don't have a body\n\t\treturn;\n\t}\n\n\t// Setup\n\tdiv = document.createElement( \"div\" );\n\tcontainer = document.createElement( \"div\" );\n\tcontainer.style.cssText = \"position:absolute;border:0;width:0;height:0;top:0;left:-9999px\";\n\tbody.appendChild( container ).appendChild( div );\n\n\tif ( typeof div.style.zoom !== \"undefined\" ) {\n\n\t\t// Support: IE<8\n\t\t// Check if natively block-level elements act like inline-block\n\t\t// elements when setting their display to 'inline' and giving\n\t\t// them layout\n\t\tdiv.style.cssText = \"display:inline;margin:0;border:0;padding:1px;width:1px;zoom:1\";\n\n\t\tsupport.inlineBlockNeedsLayout = val = div.offsetWidth === 3;\n\t\tif ( val ) {\n\n\t\t\t// Prevent IE 6 from affecting layout for positioned elements #11048\n\t\t\t// Prevent IE from shrinking the body in IE 7 mode #12869\n\t\t\t// Support: IE<8\n\t\t\tbody.style.zoom = 1;\n\t\t}\n\t}\n\n\tbody.removeChild( container );\n} );\n\n\n( function() {\n\tvar div = document.createElement( \"div\" );\n\n\t// Support: IE<9\n\tsupport.deleteExpando = true;\n\ttry {\n\t\tdelete div.test;\n\t} catch ( e ) {\n\t\tsupport.deleteExpando = false;\n\t}\n\n\t// Null elements to avoid leaks in IE.\n\tdiv = null;\n} )();\nvar acceptData = function( elem ) {\n\tvar noData = jQuery.noData[ ( elem.nodeName + \" \" ).toLowerCase() ],\n\t\tnodeType = +elem.nodeType || 1;\n\n\t// Do not set data on non-element DOM nodes because it will not be cleared (#8335).\n\treturn nodeType !== 1 && nodeType !== 9 ?\n\t\tfalse :\n\n\t\t// Nodes accept data unless otherwise specified; rejection can be conditional\n\t\t!noData || noData !== true && elem.getAttribute( \"classid\" ) === noData;\n};\n\n\n\n\nvar rbrace = /^(?:\\{[\\w\\W]*\\}|\\[[\\w\\W]*\\])$/,\n\trmultiDash = /([A-Z])/g;\n\nfunction dataAttr( elem, key, data ) {\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\n\t\tvar name = \"data-\" + key.replace( rmultiDash, \"-$1\" ).toLowerCase();\n\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\tjQuery.data( elem, key, data );\n\n\t\t} else {\n\t\t\tdata = undefined;\n\t\t}\n\t}\n\n\treturn data;\n}\n\n// checks a cache object for emptiness\nfunction isEmptyDataObject( obj ) {\n\tvar name;\n\tfor ( name in obj ) {\n\n\t\t// if the public data object is empty, the private is still empty\n\t\tif ( name === \"data\" && jQuery.isEmptyObject( obj[ name ] ) ) {\n\t\t\tcontinue;\n\t\t}\n\t\tif ( name !== \"toJSON\" ) {\n\t\t\treturn false;\n\t\t}\n\t}\n\n\treturn true;\n}\n\nfunction internalData( elem, name, data, pvt /* Internal Use Only */ ) {\n\tif ( !acceptData( elem ) ) {\n\t\treturn;\n\t}\n\n\tvar ret, thisCache,\n\t\tinternalKey = jQuery.expando,\n\n\t\t// We have to handle DOM nodes and JS objects differently because IE6-7\n\t\t// can't GC object references properly across the DOM-JS boundary\n\t\tisNode = elem.nodeType,\n\n\t\t// Only DOM nodes need the global jQuery cache; JS object data is\n\t\t// attached directly to the object so GC can occur automatically\n\t\tcache = isNode ? jQuery.cache : elem,\n\n\t\t// Only defining an ID for JS objects if its cache already exists allows\n\t\t// the code to shortcut on the same path as a DOM node with no cache\n\t\tid = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey;\n\n\t// Avoid doing any more work than we need to when trying to get data on an\n\t// object that has no data at all\n\tif ( ( !id || !cache[ id ] || ( !pvt && !cache[ id ].data ) ) &&\n\t\tdata === undefined && typeof name === \"string\" ) {\n\t\treturn;\n\t}\n\n\tif ( !id ) {\n\n\t\t// Only DOM nodes need a new unique ID for each element since their data\n\t\t// ends up in the global cache\n\t\tif ( isNode ) {\n\t\t\tid = elem[ internalKey ] = deletedIds.pop() || jQuery.guid++;\n\t\t} else {\n\t\t\tid = internalKey;\n\t\t}\n\t}\n\n\tif ( !cache[ id ] ) {\n\n\t\t// Avoid exposing jQuery metadata on plain JS objects when the object\n\t\t// is serialized using JSON.stringify\n\t\tcache[ id ] = isNode ? {} : { toJSON: jQuery.noop };\n\t}\n\n\t// An object can be passed to jQuery.data instead of a key/value pair; this gets\n\t// shallow copied over onto the existing cache\n\tif ( typeof name === \"object\" || typeof name === \"function\" ) {\n\t\tif ( pvt ) {\n\t\t\tcache[ id ] = jQuery.extend( cache[ id ], name );\n\t\t} else {\n\t\t\tcache[ id ].data = jQuery.extend( cache[ id ].data, name );\n\t\t}\n\t}\n\n\tthisCache = cache[ id ];\n\n\t// jQuery data() is stored in a separate object inside the object's internal data\n\t// cache in order to avoid key collisions between internal data and user-defined\n\t// data.\n\tif ( !pvt ) {\n\t\tif ( !thisCache.data ) {\n\t\t\tthisCache.data = {};\n\t\t}\n\n\t\tthisCache = thisCache.data;\n\t}\n\n\tif ( data !== undefined ) {\n\t\tthisCache[ jQuery.camelCase( name ) ] = data;\n\t}\n\n\t// Check for both converted-to-camel and non-converted data property names\n\t// If a data property was specified\n\tif ( typeof name === \"string\" ) {\n\n\t\t// First Try to find as-is property data\n\t\tret = thisCache[ name ];\n\n\t\t// Test for null|undefined property data\n\t\tif ( ret == null ) {\n\n\t\t\t// Try to find the camelCased property\n\t\t\tret = thisCache[ jQuery.camelCase( name ) ];\n\t\t}\n\t} else {\n\t\tret = thisCache;\n\t}\n\n\treturn ret;\n}\n\nfunction internalRemoveData( elem, name, pvt ) {\n\tif ( !acceptData( elem ) ) {\n\t\treturn;\n\t}\n\n\tvar thisCache, i,\n\t\tisNode = elem.nodeType,\n\n\t\t// See jQuery.data for more information\n\t\tcache = isNode ? jQuery.cache : elem,\n\t\tid = isNode ? elem[ jQuery.expando ] : jQuery.expando;\n\n\t// If there is already no cache entry for this object, there is no\n\t// purpose in continuing\n\tif ( !cache[ id ] ) {\n\t\treturn;\n\t}\n\n\tif ( name ) {\n\n\t\tthisCache = pvt ? cache[ id ] : cache[ id ].data;\n\n\t\tif ( thisCache ) {\n\n\t\t\t// Support array or space separated string names for data keys\n\t\t\tif ( !jQuery.isArray( name ) ) {\n\n\t\t\t\t// try the string as a key before any manipulation\n\t\t\t\tif ( name in thisCache ) {\n\t\t\t\t\tname = [ name ];\n\t\t\t\t} else {\n\n\t\t\t\t\t// split the camel cased version by spaces unless a key with the spaces exists\n\t\t\t\t\tname = jQuery.camelCase( name );\n\t\t\t\t\tif ( name in thisCache ) {\n\t\t\t\t\t\tname = [ name ];\n\t\t\t\t\t} else {\n\t\t\t\t\t\tname = name.split( \" \" );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else {\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 = name.concat( jQuery.map( name, jQuery.camelCase ) );\n\t\t\t}\n\n\t\t\ti = name.length;\n\t\t\twhile ( i-- ) {\n\t\t\t\tdelete thisCache[ name[ i ] ];\n\t\t\t}\n\n\t\t\t// If there is no data left in the cache, we want to continue\n\t\t\t// and let the cache object itself get destroyed\n\t\t\tif ( pvt ? !isEmptyDataObject( thisCache ) : !jQuery.isEmptyObject( thisCache ) ) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t}\n\t}\n\n\t// See jQuery.data for more information\n\tif ( !pvt ) {\n\t\tdelete cache[ id ].data;\n\n\t\t// Don't destroy the parent cache unless the internal data object\n\t\t// had been the only thing left in it\n\t\tif ( !isEmptyDataObject( cache[ id ] ) ) {\n\t\t\treturn;\n\t\t}\n\t}\n\n\t// Destroy the cache\n\tif ( isNode ) {\n\t\tjQuery.cleanData( [ elem ], true );\n\n\t// Use delete when supported for expandos or `cache` is not a window per isWindow (#10080)\n\t/* jshint eqeqeq: false */\n\t} else if ( support.deleteExpando || cache != cache.window ) {\n\t\t/* jshint eqeqeq: true */\n\t\tdelete cache[ id ];\n\n\t// When all else fails, undefined\n\t} else {\n\t\tcache[ id ] = undefined;\n\t}\n}\n\njQuery.extend( {\n\tcache: {},\n\n\t// The following elements (space-suffixed to avoid Object.prototype collisions)\n\t// throw uncatchable exceptions if you attempt to set expando properties\n\tnoData: {\n\t\t\"applet \": true,\n\t\t\"embed \": true,\n\n\t\t// ...but Flash objects (which have this classid) *can* handle expandos\n\t\t\"object \": \"clsid:D27CDB6E-AE6D-11cf-96B8-444553540000\"\n\t},\n\n\thasData: function( elem ) {\n\t\telem = elem.nodeType ? jQuery.cache[ elem[ jQuery.expando ] ] : elem[ jQuery.expando ];\n\t\treturn !!elem && !isEmptyDataObject( elem );\n\t},\n\n\tdata: function( elem, name, data ) {\n\t\treturn internalData( elem, name, data );\n\t},\n\n\tremoveData: function( elem, name ) {\n\t\treturn internalRemoveData( elem, name );\n\t},\n\n\t// For internal use only.\n\t_data: function( elem, name, data ) {\n\t\treturn internalData( elem, name, data, true );\n\t},\n\n\t_removeData: function( elem, name ) {\n\t\treturn internalRemoveData( elem, name, true );\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// Special expections of .data basically thwart jQuery.access,\n\t\t// so implement the relevant behavior ourselves\n\n\t\t// Gets all values\n\t\tif ( key === undefined ) {\n\t\t\tif ( this.length ) {\n\t\t\t\tdata = jQuery.data( elem );\n\n\t\t\t\tif ( elem.nodeType === 1 && !jQuery._data( elem, \"parsedAttrs\" ) ) {\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\tjQuery._data( elem, \"parsedAttrs\", 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\tjQuery.data( this, key );\n\t\t\t} );\n\t\t}\n\n\t\treturn arguments.length > 1 ?\n\n\t\t\t// Sets one value\n\t\t\tthis.each( function() {\n\t\t\t\tjQuery.data( this, key, value );\n\t\t\t} ) :\n\n\t\t\t// Gets one value\n\t\t\t// Try to fetch any internally stored data first\n\t\t\telem ? dataAttr( elem, key, jQuery.data( elem, key ) ) : undefined;\n\t},\n\n\tremoveData: function( key ) {\n\t\treturn this.each( function() {\n\t\t\tjQuery.removeData( 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 = jQuery._data( 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 = jQuery._data( 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 intended for public consumption - generates a queueHooks object,\n\t// or returns the current one\n\t_queueHooks: function( elem, type ) {\n\t\tvar key = type + \"queueHooks\";\n\t\treturn jQuery._data( elem, key ) || jQuery._data( elem, key, {\n\t\t\tempty: jQuery.Callbacks( \"once memory\" ).add( function() {\n\t\t\t\tjQuery._removeData( elem, type + \"queue\" );\n\t\t\t\tjQuery._removeData( elem, 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 = jQuery._data( 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} );\n\n\n( function() {\n\tvar shrinkWrapBlocksVal;\n\n\tsupport.shrinkWrapBlocks = function() {\n\t\tif ( shrinkWrapBlocksVal != null ) {\n\t\t\treturn shrinkWrapBlocksVal;\n\t\t}\n\n\t\t// Will be changed later if needed.\n\t\tshrinkWrapBlocksVal = false;\n\n\t\t// Minified: var b,c,d\n\t\tvar div, body, container;\n\n\t\tbody = document.getElementsByTagName( \"body\" )[ 0 ];\n\t\tif ( !body || !body.style ) {\n\n\t\t\t// Test fired too early or in an unsupported environment, exit.\n\t\t\treturn;\n\t\t}\n\n\t\t// Setup\n\t\tdiv = document.createElement( \"div\" );\n\t\tcontainer = document.createElement( \"div\" );\n\t\tcontainer.style.cssText = \"position:absolute;border:0;width:0;height:0;top:0;left:-9999px\";\n\t\tbody.appendChild( container ).appendChild( div );\n\n\t\t// Support: IE6\n\t\t// Check if elements with layout shrink-wrap their children\n\t\tif ( typeof div.style.zoom !== \"undefined\" ) {\n\n\t\t\t// Reset CSS: box-sizing; display; margin; border\n\t\t\tdiv.style.cssText =\n\n\t\t\t\t// Support: Firefox<29, Android 2.3\n\t\t\t\t// Vendor-prefix box-sizing\n\t\t\t\t\"-webkit-box-sizing:content-box;-moz-box-sizing:content-box;\" +\n\t\t\t\t\"box-sizing:content-box;display:block;margin:0;border:0;\" +\n\t\t\t\t\"padding:1px;width:1px;zoom:1\";\n\t\t\tdiv.appendChild( document.createElement( \"div\" ) ).style.width = \"5px\";\n\t\t\tshrinkWrapBlocksVal = div.offsetWidth !== 3;\n\t\t}\n\n\t\tbody.removeChild( container );\n\n\t\treturn shrinkWrapBlocksVal;\n\t};\n\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}\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\tlength = 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 < length; i++ ) {\n\t\t\t\tfn(\n\t\t\t\t\telems[ i ],\n\t\t\t\t\tkey,\n\t\t\t\t\traw ? value : value.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\tlength ? fn( elems[ 0 ], key ) : emptyGet;\n};\nvar rcheckableType = ( /^(?:checkbox|radio)$/i );\n\nvar rtagName = ( /<([\\w:-]+)/ );\n\nvar rscriptType = ( /^$|\\/(?:java|ecma)script/i );\n\nvar rleadingWhitespace = ( /^\\s+/ );\n\nvar nodeNames = \"abbr|article|aside|audio|bdi|canvas|data|datalist|\" +\n\t\t\"details|dialog|figcaption|figure|footer|header|hgroup|main|\" +\n\t\t\"mark|meter|nav|output|picture|progress|section|summary|template|time|video\";\n\n\n\nfunction createSafeFragment( document ) {\n\tvar list = nodeNames.split( \"|\" ),\n\t\tsafeFrag = document.createDocumentFragment();\n\n\tif ( safeFrag.createElement ) {\n\t\twhile ( list.length ) {\n\t\t\tsafeFrag.createElement(\n\t\t\t\tlist.pop()\n\t\t\t);\n\t\t}\n\t}\n\treturn safeFrag;\n}\n\n\n( function() {\n\tvar div = document.createElement( \"div\" ),\n\t\tfragment = document.createDocumentFragment(),\n\t\tinput = document.createElement( \"input\" );\n\n\t// Setup\n\tdiv.innerHTML = \"  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>\";\n\n\t// IE strips leading whitespace when .innerHTML is used\n\tsupport.leadingWhitespace = div.firstChild.nodeType === 3;\n\n\t// Make sure that tbody elements aren't automatically inserted\n\t// IE will insert them into empty tables\n\tsupport.tbody = !div.getElementsByTagName( \"tbody\" ).length;\n\n\t// Make sure that link elements get serialized correctly by innerHTML\n\t// This requires a wrapper element in IE\n\tsupport.htmlSerialize = !!div.getElementsByTagName( \"link\" ).length;\n\n\t// Makes sure cloning an html5 element does not cause problems\n\t// Where outerHTML is undefined, this still works\n\tsupport.html5Clone =\n\t\tdocument.createElement( \"nav\" ).cloneNode( true ).outerHTML !== \"<:nav></:nav>\";\n\n\t// Check if a disconnected checkbox will retain its checked\n\t// value of true after appended to the DOM (IE6/7)\n\tinput.type = \"checkbox\";\n\tinput.checked = true;\n\tfragment.appendChild( input );\n\tsupport.appendChecked = input.checked;\n\n\t// Make sure textarea (and checkbox) defaultValue is properly cloned\n\t// Support: IE6-IE11+\n\tdiv.innerHTML = \"<textarea>x</textarea>\";\n\tsupport.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;\n\n\t// #11217 - WebKit loses check when the name is after the checked attribute\n\tfragment.appendChild( div );\n\n\t// Support: Windows Web Apps (WWA)\n\t// `name` and `type` must use .setAttribute for WWA (#14901)\n\tinput = document.createElement( \"input\" );\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, iOS 5.1, Android 4.x, Android 2.3\n\t// old WebKit doesn't clone checked state correctly in fragments\n\tsupport.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;\n\n\t// Support: IE<9\n\t// Cloned elements keep attachEvent handlers, we use addEventListener on IE9+\n\tsupport.noCloneEvent = !!div.addEventListener;\n\n\t// Support: IE<9\n\t// Since attributes and properties are the same in IE,\n\t// cleanData must set properties to undefined rather than use removeAttribute\n\tdiv[ jQuery.expando ] = 1;\n\tsupport.attributes = !div.getAttribute( jQuery.expando );\n} )();\n\n\n// We have to close these tags to support XHTML (#13200)\nvar wrapMap = {\n\toption: [ 1, \"<select multiple='multiple'>\", \"</select>\" ],\n\tlegend: [ 1, \"<fieldset>\", \"</fieldset>\" ],\n\tarea: [ 1, \"<map>\", \"</map>\" ],\n\n\t// Support: IE8\n\tparam: [ 1, \"<object>\", \"</object>\" ],\n\tthead: [ 1, \"<table>\", \"</table>\" ],\n\ttr: [ 2, \"<table><tbody>\", \"</tbody></table>\" ],\n\tcol: [ 2, \"<table><tbody></tbody><colgroup>\", \"</colgroup></table>\" ],\n\ttd: [ 3, \"<table><tbody><tr>\", \"</tr></tbody></table>\" ],\n\n\t// IE6-8 can't serialize link, script, style, or any html5 (NoScope) tags,\n\t// unless wrapped in a div with non-breaking characters in front of it.\n\t_default: support.htmlSerialize ? [ 0, \"\", \"\" ] : [ 1, \"X<div>\", \"</div>\" ]\n};\n\n// Support: IE8-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\tvar elems, elem,\n\t\ti = 0,\n\t\tfound = 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\tundefined;\n\n\tif ( !found ) {\n\t\tfor ( found = [], elems = context.childNodes || context;\n\t\t\t( elem = elems[ i ] ) != null;\n\t\t\ti++\n\t\t) {\n\t\t\tif ( !tag || jQuery.nodeName( elem, tag ) ) {\n\t\t\t\tfound.push( elem );\n\t\t\t} else {\n\t\t\t\tjQuery.merge( found, getAll( elem, tag ) );\n\t\t\t}\n\t\t}\n\t}\n\n\treturn tag === undefined || tag && jQuery.nodeName( context, tag ) ?\n\t\tjQuery.merge( [ context ], found ) :\n\t\tfound;\n}\n\n\n// Mark scripts as having already been evaluated\nfunction setGlobalEval( elems, refElements ) {\n\tvar elem,\n\t\ti = 0;\n\tfor ( ; ( elem = elems[ i ] ) != null; i++ ) {\n\t\tjQuery._data(\n\t\t\telem,\n\t\t\t\"globalEval\",\n\t\t\t!refElements || jQuery._data( refElements[ i ], \"globalEval\" )\n\t\t);\n\t}\n}\n\n\nvar rhtml = /<|&#?\\w+;/,\n\trtbody = /<tbody/i;\n\nfunction fixDefaultChecked( elem ) {\n\tif ( rcheckableType.test( elem.type ) ) {\n\t\telem.defaultChecked = elem.checked;\n\t}\n}\n\nfunction buildFragment( elems, context, scripts, selection, ignored ) {\n\tvar j, elem, contains,\n\t\ttmp, tag, tbody, wrap,\n\t\tl = elems.length,\n\n\t\t// Ensure a safe fragment\n\t\tsafe = createSafeFragment( context ),\n\n\t\tnodes = [],\n\t\ti = 0;\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\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 || safe.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\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// Manually add leading whitespace removed by IE\n\t\t\t\tif ( !support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {\n\t\t\t\t\tnodes.push( context.createTextNode( rleadingWhitespace.exec( elem )[ 0 ] ) );\n\t\t\t\t}\n\n\t\t\t\t// Remove IE's autoinserted <tbody> from table fragments\n\t\t\t\tif ( !support.tbody ) {\n\n\t\t\t\t\t// String was a <table>, *may* have spurious <tbody>\n\t\t\t\t\telem = tag === \"table\" && !rtbody.test( elem ) ?\n\t\t\t\t\t\ttmp.firstChild :\n\n\t\t\t\t\t\t// String was a bare <thead> or <tfoot>\n\t\t\t\t\t\twrap[ 1 ] === \"<table>\" && !rtbody.test( elem ) ?\n\t\t\t\t\t\t\ttmp :\n\t\t\t\t\t\t\t0;\n\n\t\t\t\t\tj = elem && elem.childNodes.length;\n\t\t\t\t\twhile ( j-- ) {\n\t\t\t\t\t\tif ( jQuery.nodeName( ( tbody = elem.childNodes[ j ] ), \"tbody\" ) &&\n\t\t\t\t\t\t\t!tbody.childNodes.length ) {\n\n\t\t\t\t\t\t\telem.removeChild( tbody );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tjQuery.merge( nodes, tmp.childNodes );\n\n\t\t\t\t// Fix #12392 for WebKit and IE > 9\n\t\t\t\ttmp.textContent = \"\";\n\n\t\t\t\t// Fix #12392 for oldIE\n\t\t\t\twhile ( tmp.firstChild ) {\n\t\t\t\t\ttmp.removeChild( tmp.firstChild );\n\t\t\t\t}\n\n\t\t\t\t// Remember the top-level container for proper cleanup\n\t\t\t\ttmp = safe.lastChild;\n\t\t\t}\n\t\t}\n\t}\n\n\t// Fix #11356: Clear elements from fragment\n\tif ( tmp ) {\n\t\tsafe.removeChild( tmp );\n\t}\n\n\t// Reset defaultChecked for any radios and checkboxes\n\t// about to be appended to the DOM in IE 6/7 (#8060)\n\tif ( !support.appendChecked ) {\n\t\tjQuery.grep( getAll( nodes, \"input\" ), fixDefaultChecked );\n\t}\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\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( safe.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\ttmp = null;\n\n\treturn safe;\n}\n\n\n( function() {\n\tvar i, eventName,\n\t\tdiv = document.createElement( \"div\" );\n\n\t// Support: IE<9 (lack submit/change bubble), Firefox (lack focus(in | out) events)\n\tfor ( i in { submit: true, change: true, focusin: true } ) {\n\t\teventName = \"on\" + i;\n\n\t\tif ( !( support[ i ] = eventName in window ) ) {\n\n\t\t\t// Beware of CSP restrictions (https://developer.mozilla.org/en/Security/CSP)\n\t\t\tdiv.setAttribute( eventName, \"t\" );\n\t\t\tsupport[ i ] = div.attributes[ eventName ].expando === false;\n\t\t}\n\t}\n\n\t// Null elements to avoid leaks in IE.\n\tdiv = null;\n} )();\n\n\nvar rformElems = /^(?:input|select|textarea)$/i,\n\trkeyEvent = /^key/,\n\trmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/,\n\trfocusMorph = /^(?:focusinfocus|focusoutblur)$/,\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\t\tvar tmp, events, t, handleObjIn,\n\t\t\tspecial, eventHandle, handleObj,\n\t\t\thandlers, type, namespaces, origType,\n\t\t\telemData = jQuery._data( 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\" &&\n\t\t\t\t\t( !e || jQuery.event.triggered !== e.type ) ?\n\t\t\t\t\tjQuery.event.dispatch.apply( eventHandle.elem, arguments ) :\n\t\t\t\t\tundefined;\n\t\t\t};\n\n\t\t\t// Add elem as a property of the handle fn to prevent a memory leak\n\t\t\t// with IE non-native events\n\t\t\teventHandle.elem = elem;\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/attachEvent 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\t// Bind the global event handler to the element\n\t\t\t\t\tif ( elem.addEventListener ) {\n\t\t\t\t\t\telem.addEventListener( type, eventHandle, false );\n\n\t\t\t\t\t} else if ( elem.attachEvent ) {\n\t\t\t\t\t\telem.attachEvent( \"on\" + 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\t// Nullify elem to prevent memory leaks in IE\n\t\telem = null;\n\t},\n\n\t// Detach an event or set of events from an element\n\tremove: function( elem, types, handler, selector, mappedTypes ) {\n\t\tvar j, handleObj, tmp,\n\t\t\torigCount, t, events,\n\t\t\tspecial, handlers, type,\n\t\t\tnamespaces, origType,\n\t\t\telemData = jQuery.hasData( elem ) && jQuery._data( 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 the expando if it's no longer used\n\t\tif ( jQuery.isEmptyObject( events ) ) {\n\t\t\tdelete elemData.handle;\n\n\t\t\t// removeData also checks for emptiness and clears the expando if empty\n\t\t\t// so use it instead of delete\n\t\t\tjQuery._removeData( elem, \"events\" );\n\t\t}\n\t},\n\n\ttrigger: function( event, data, elem, onlyHandlers ) {\n\t\tvar handle, ontype, cur,\n\t\t\tbubbleType, special, tmp, i,\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 = ( jQuery._data( cur, \"events\" ) || {} )[ event.type ] &&\n\t\t\t\tjQuery._data( cur, \"handle\" );\n\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 (\n\t\t\t\t( !special._default ||\n\t\t\t\t special._default.apply( eventPath.pop(), data ) === false\n\t\t\t\t) && acceptData( elem )\n\t\t\t) {\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// Can't use an .isFunction() check here because IE6/7 fails that test.\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 && 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\ttry {\n\t\t\t\t\t\telem[ type ]();\n\t\t\t\t\t} catch ( e ) {\n\n\t\t\t\t\t\t// IE<9 dies on focus/blur to hidden element (#1486,#12518)\n\t\t\t\t\t\t// only reproducible on winXP IE8 native, not IE9 in IE8 mode\n\t\t\t\t\t}\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\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 = ( jQuery._data( 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\t/* jshint eqeqeq: false */\n\t\t\tfor ( ; cur != this; cur = cur.parentNode || this ) {\n\t\t\t\t/* jshint eqeqeq: true */\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\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: IE<9\n\t\t// Fix target property (#1925)\n\t\tif ( !event.target ) {\n\t\t\tevent.target = originalEvent.srcElement || document;\n\t\t}\n\n\t\t// Support: Safari 6-8+\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\t// Support: IE<9\n\t\t// For mouse/key events, metaKey==false if it's undefined (#3368, #11328)\n\t\tevent.metaKey = !!event.metaKey;\n\n\t\treturn fixHook.filter ? fixHook.filter( event, originalEvent ) : event;\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 fromElement offsetX offsetY \" +\n\t\t\t\"pageX pageY screenX screenY toElement\" ).split( \" \" ),\n\t\tfilter: function( event, original ) {\n\t\t\tvar body, eventDoc, doc,\n\t\t\t\tbutton = original.button,\n\t\t\t\tfromElement = original.fromElement;\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 relatedTarget, if necessary\n\t\t\tif ( !event.relatedTarget && fromElement ) {\n\t\t\t\tevent.relatedTarget = fromElement === event.target ?\n\t\t\t\t\toriginal.toElement :\n\t\t\t\t\tfromElement;\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\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\ttry {\n\t\t\t\t\t\tthis.focus();\n\t\t\t\t\t\treturn false;\n\t\t\t\t\t} catch ( e ) {\n\n\t\t\t\t\t\t// Support: IE<9\n\t\t\t\t\t\t// If we error on focus to hidden element (#1486, #12518),\n\t\t\t\t\t\t// let .trigger() run the handlers\n\t\t\t\t\t}\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 ( jQuery.nodeName( this, \"input\" ) && this.type === \"checkbox\" && this.click ) {\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\t// Piggyback on a donor event to simulate a different one\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\n\t\t\t\t// Previously, `originalEvent: {}` was set here, so stopPropagation call\n\t\t\t\t// would not be triggered on donor event, since in our own\n\t\t\t\t// jQuery.event.stopPropagation function we had a check for existence of\n\t\t\t\t// originalEvent.stopPropagation method, so, consequently it would be a noop.\n\t\t\t\t//\n\t\t\t\t// Guard for simulated events was moved to jQuery.event.stopPropagation function\n\t\t\t\t// since `originalEvent` should point to the original event for the\n\t\t\t\t// constancy with other events and for more focused logic\n\t\t\t}\n\t\t);\n\n\t\tjQuery.event.trigger( e, null, elem );\n\n\t\tif ( e.isDefaultPrevented() ) {\n\t\t\tevent.preventDefault();\n\t\t}\n\t}\n};\n\njQuery.removeEvent = document.removeEventListener ?\n\tfunction( elem, type, handle ) {\n\n\t\t// This \"if\" is needed for plain objects\n\t\tif ( elem.removeEventListener ) {\n\t\t\telem.removeEventListener( type, handle );\n\t\t}\n\t} :\n\tfunction( elem, type, handle ) {\n\t\tvar name = \"on\" + type;\n\n\t\tif ( elem.detachEvent ) {\n\n\t\t\t// #8545, #7054, preventing memory leaks for custom events in IE6-8\n\t\t\t// detachEvent needed property on element, by name of that event,\n\t\t\t// to properly expose it to GC\n\t\t\tif ( typeof elem[ name ] === \"undefined\" ) {\n\t\t\t\telem[ name ] = null;\n\t\t\t}\n\n\t\t\telem.detachEvent( name, handle );\n\t\t}\n\t};\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: IE < 9, 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\n\tpreventDefault: function() {\n\t\tvar e = this.originalEvent;\n\n\t\tthis.isDefaultPrevented = returnTrue;\n\t\tif ( !e ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// If preventDefault exists, run it on the original event\n\t\tif ( e.preventDefault ) {\n\t\t\te.preventDefault();\n\n\t\t// Support: IE\n\t\t// Otherwise set the returnValue property of the original event to false\n\t\t} else {\n\t\t\te.returnValue = false;\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\treturn;\n\t\t}\n\n\t\t// If stopPropagation exists, run it on the original event\n\t\tif ( e.stopPropagation ) {\n\t\t\te.stopPropagation();\n\t\t}\n\n\t\t// Support: IE\n\t\t// Set the cancelBubble property of the original event to true\n\t\te.cancelBubble = true;\n\t},\n\tstopImmediatePropagation: function() {\n\t\tvar e = this.originalEvent;\n\n\t\tthis.isImmediatePropagationStopped = returnTrue;\n\n\t\tif ( e && e.stopImmediatePropagation ) {\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\n// IE submit delegation\nif ( !support.submit ) {\n\n\tjQuery.event.special.submit = {\n\t\tsetup: function() {\n\n\t\t\t// Only need this for delegated form submit events\n\t\t\tif ( jQuery.nodeName( this, \"form\" ) ) {\n\t\t\t\treturn false;\n\t\t\t}\n\n\t\t\t// Lazy-add a submit handler when a descendant form may potentially be submitted\n\t\t\tjQuery.event.add( this, \"click._submit keypress._submit\", function( e ) {\n\n\t\t\t\t// Node name check avoids a VML-related crash in IE (#9807)\n\t\t\t\tvar elem = e.target,\n\t\t\t\t\tform = jQuery.nodeName( elem, \"input\" ) || jQuery.nodeName( elem, \"button\" ) ?\n\n\t\t\t\t\t\t// Support: IE <=8\n\t\t\t\t\t\t// We use jQuery.prop instead of elem.form\n\t\t\t\t\t\t// to allow fixing the IE8 delegated submit issue (gh-2332)\n\t\t\t\t\t\t// by 3rd party polyfills/workarounds.\n\t\t\t\t\t\tjQuery.prop( elem, \"form\" ) :\n\t\t\t\t\t\tundefined;\n\n\t\t\t\tif ( form && !jQuery._data( form, \"submit\" ) ) {\n\t\t\t\t\tjQuery.event.add( form, \"submit._submit\", function( event ) {\n\t\t\t\t\t\tevent._submitBubble = true;\n\t\t\t\t\t} );\n\t\t\t\t\tjQuery._data( form, \"submit\", true );\n\t\t\t\t}\n\t\t\t} );\n\n\t\t\t// return undefined since we don't need an event listener\n\t\t},\n\n\t\tpostDispatch: function( event ) {\n\n\t\t\t// If form was submitted by the user, bubble the event up the tree\n\t\t\tif ( event._submitBubble ) {\n\t\t\t\tdelete event._submitBubble;\n\t\t\t\tif ( this.parentNode && !event.isTrigger ) {\n\t\t\t\t\tjQuery.event.simulate( \"submit\", this.parentNode, event );\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\n\t\tteardown: function() {\n\n\t\t\t// Only need this for delegated form submit events\n\t\t\tif ( jQuery.nodeName( this, \"form\" ) ) {\n\t\t\t\treturn false;\n\t\t\t}\n\n\t\t\t// Remove delegated handlers; cleanData eventually reaps submit handlers attached above\n\t\t\tjQuery.event.remove( this, \"._submit\" );\n\t\t}\n\t};\n}\n\n// IE change delegation and checkbox/radio fix\nif ( !support.change ) {\n\n\tjQuery.event.special.change = {\n\n\t\tsetup: function() {\n\n\t\t\tif ( rformElems.test( this.nodeName ) ) {\n\n\t\t\t\t// IE doesn't fire change on a check/radio until blur; trigger it on click\n\t\t\t\t// after a propertychange. Eat the blur-change in special.change.handle.\n\t\t\t\t// This still fires onchange a second time for check/radio after blur.\n\t\t\t\tif ( this.type === \"checkbox\" || this.type === \"radio\" ) {\n\t\t\t\t\tjQuery.event.add( this, \"propertychange._change\", function( event ) {\n\t\t\t\t\t\tif ( event.originalEvent.propertyName === \"checked\" ) {\n\t\t\t\t\t\t\tthis._justChanged = true;\n\t\t\t\t\t\t}\n\t\t\t\t\t} );\n\t\t\t\t\tjQuery.event.add( this, \"click._change\", function( event ) {\n\t\t\t\t\t\tif ( this._justChanged && !event.isTrigger ) {\n\t\t\t\t\t\t\tthis._justChanged = false;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Allow triggered, simulated change events (#11500)\n\t\t\t\t\t\tjQuery.event.simulate( \"change\", this, event );\n\t\t\t\t\t} );\n\t\t\t\t}\n\t\t\t\treturn false;\n\t\t\t}\n\n\t\t\t// Delegated event; lazy-add a change handler on descendant inputs\n\t\t\tjQuery.event.add( this, \"beforeactivate._change\", function( e ) {\n\t\t\t\tvar elem = e.target;\n\n\t\t\t\tif ( rformElems.test( elem.nodeName ) && !jQuery._data( elem, \"change\" ) ) {\n\t\t\t\t\tjQuery.event.add( elem, \"change._change\", function( event ) {\n\t\t\t\t\t\tif ( this.parentNode && !event.isSimulated && !event.isTrigger ) {\n\t\t\t\t\t\t\tjQuery.event.simulate( \"change\", this.parentNode, event );\n\t\t\t\t\t\t}\n\t\t\t\t\t} );\n\t\t\t\t\tjQuery._data( elem, \"change\", true );\n\t\t\t\t}\n\t\t\t} );\n\t\t},\n\n\t\thandle: function( event ) {\n\t\t\tvar elem = event.target;\n\n\t\t\t// Swallow native change events from checkbox/radio, we already triggered them above\n\t\t\tif ( this !== elem || event.isSimulated || event.isTrigger ||\n\t\t\t\t( elem.type !== \"radio\" && elem.type !== \"checkbox\" ) ) {\n\n\t\t\t\treturn event.handleObj.handler.apply( this, arguments );\n\t\t\t}\n\t\t},\n\n\t\tteardown: function() {\n\t\t\tjQuery.event.remove( this, \"._change\" );\n\n\t\t\treturn !rformElems.test( this.nodeName );\n\t\t}\n\t};\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 = jQuery._data( 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\tjQuery._data( 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 = jQuery._data( 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\tjQuery._removeData( doc, fix );\n\t\t\t\t} else {\n\t\t\t\t\tjQuery._data( doc, fix, attaches );\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\t} );\n}\n\njQuery.fn.extend( {\n\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\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\nvar rinlinejQuery = / jQuery\\d+=\"(?:null|\\d+)\"/g,\n\trnoshimcache = new RegExp( \"<(?:\" + nodeNames + \")[\\\\s/>]\", \"i\" ),\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\tsafeFragment = createSafeFragment( document ),\n\tfragmentDiv = safeFragment.appendChild( document.createElement( \"div\" ) );\n\n// Support: IE<8\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 = ( jQuery.find.attr( elem, \"type\" ) !== null ) + \"/\" + elem.type;\n\treturn elem;\n}\nfunction restoreScript( elem ) {\n\tvar match = rscriptTypeMasked.exec( elem.type );\n\tif ( match ) {\n\t\telem.type = match[ 1 ];\n\t} else {\n\t\telem.removeAttribute( \"type\" );\n\t}\n\treturn elem;\n}\n\nfunction cloneCopyEvent( src, dest ) {\n\tif ( dest.nodeType !== 1 || !jQuery.hasData( src ) ) {\n\t\treturn;\n\t}\n\n\tvar type, i, l,\n\t\toldData = jQuery._data( src ),\n\t\tcurData = jQuery._data( dest, oldData ),\n\t\tevents = oldData.events;\n\n\tif ( events ) {\n\t\tdelete curData.handle;\n\t\tcurData.events = {};\n\n\t\tfor ( type in events ) {\n\t\t\tfor ( i = 0, l = events[ type ].length; i < l; i++ ) {\n\t\t\t\tjQuery.event.add( dest, type, events[ type ][ i ] );\n\t\t\t}\n\t\t}\n\t}\n\n\t// make the cloned public data object a copy from the original\n\tif ( curData.data ) {\n\t\tcurData.data = jQuery.extend( {}, curData.data );\n\t}\n}\n\nfunction fixCloneNodeIssues( src, dest ) {\n\tvar nodeName, e, data;\n\n\t// We do not need to do anything for non-Elements\n\tif ( dest.nodeType !== 1 ) {\n\t\treturn;\n\t}\n\n\tnodeName = dest.nodeName.toLowerCase();\n\n\t// IE6-8 copies events bound via attachEvent when using cloneNode.\n\tif ( !support.noCloneEvent && dest[ jQuery.expando ] ) {\n\t\tdata = jQuery._data( dest );\n\n\t\tfor ( e in data.events ) {\n\t\t\tjQuery.removeEvent( dest, e, data.handle );\n\t\t}\n\n\t\t// Event data gets referenced instead of copied if the expando gets copied too\n\t\tdest.removeAttribute( jQuery.expando );\n\t}\n\n\t// IE blanks contents when cloning scripts, and tries to evaluate newly-set text\n\tif ( nodeName === \"script\" && dest.text !== src.text ) {\n\t\tdisableScript( dest ).text = src.text;\n\t\trestoreScript( dest );\n\n\t// IE6-10 improperly clones children of object elements using classid.\n\t// IE10 throws NoModificationAllowedError if parent is null, #12132.\n\t} else if ( nodeName === \"object\" ) {\n\t\tif ( dest.parentNode ) {\n\t\t\tdest.outerHTML = src.outerHTML;\n\t\t}\n\n\t\t// This path appears unavoidable for IE9. When cloning an object\n\t\t// element in IE9, the outerHTML strategy above is not sufficient.\n\t\t// If the src has innerHTML and the destination does not,\n\t\t// copy the src.innerHTML into the dest.innerHTML. #10324\n\t\tif ( support.html5Clone && ( src.innerHTML && !jQuery.trim( dest.innerHTML ) ) ) {\n\t\t\tdest.innerHTML = src.innerHTML;\n\t\t}\n\n\t} else if ( nodeName === \"input\" && rcheckableType.test( src.type ) ) {\n\n\t\t// IE6-8 fails to persist the checked state of a cloned checkbox\n\t\t// or radio button. Worse, IE6-7 fail to give the cloned element\n\t\t// a checked appearance if the defaultChecked value isn't also set\n\n\t\tdest.defaultChecked = dest.checked = src.checked;\n\n\t\t// IE6-7 get confused and end up setting the value of a cloned\n\t\t// checkbox/radio button to an empty string instead of \"on\"\n\t\tif ( dest.value !== src.value ) {\n\t\t\tdest.value = src.value;\n\t\t}\n\n\t// IE6-8 fails to return the selected option to the default selected\n\t// state when cloning options\n\t} else if ( nodeName === \"option\" ) {\n\t\tdest.defaultSelected = dest.selected = src.defaultSelected;\n\n\t// IE6-8 fails to set the defaultValue to the correct value when\n\t// cloning other types of input fields\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 first, node, hasScripts,\n\t\tscripts, doc, fragment,\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!jQuery._data( 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(\n\t\t\t\t\t\t\t\t( node.text || node.textContent || node.innerHTML || \"\" )\n\t\t\t\t\t\t\t\t\t.replace( rcleanScript, \"\" )\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\n\t\t\t// Fix #11809: Avoid leaking memory\n\t\t\tfragment = first = null;\n\t\t}\n\t}\n\n\treturn collection;\n}\n\nfunction remove( elem, selector, keepData ) {\n\tvar node,\n\t\telems = selector ? jQuery.filter( selector, elem ) : elem,\n\t\ti = 0;\n\n\tfor ( ; ( node = elems[ i ] ) != null; i++ ) {\n\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 destElements, node, clone, i, srcElements,\n\t\t\tinPage = jQuery.contains( elem.ownerDocument, elem );\n\n\t\tif ( support.html5Clone || jQuery.isXMLDoc( elem ) ||\n\t\t\t!rnoshimcache.test( \"<\" + elem.nodeName + \">\" ) ) {\n\n\t\t\tclone = elem.cloneNode( true );\n\n\t\t// IE<=8 does not properly clone detached, unknown element nodes\n\t\t} else {\n\t\t\tfragmentDiv.innerHTML = elem.outerHTML;\n\t\t\tfragmentDiv.removeChild( clone = fragmentDiv.firstChild );\n\t\t}\n\n\t\tif ( ( !support.noCloneEvent || !support.noCloneChecked ) &&\n\t\t\t\t( elem.nodeType === 1 || elem.nodeType === 11 ) && !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\t// Fix all IE cloning issues\n\t\t\tfor ( i = 0; ( node = srcElements[ i ] ) != null; ++i ) {\n\n\t\t\t\t// Ensure that the destination node is not null; Fixes #9587\n\t\t\t\tif ( destElements[ i ] ) {\n\t\t\t\t\tfixCloneNodeIssues( node, destElements[ i ] );\n\t\t\t\t}\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; ( node = srcElements[ i ] ) != null; i++ ) {\n\t\t\t\t\tcloneCopyEvent( node, 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\tdestElements = srcElements = node = null;\n\n\t\t// Return the cloned set\n\t\treturn clone;\n\t},\n\n\tcleanData: function( elems, /* internal */ forceAcceptData ) {\n\t\tvar elem, type, id, data,\n\t\t\ti = 0,\n\t\t\tinternalKey = jQuery.expando,\n\t\t\tcache = jQuery.cache,\n\t\t\tattributes = support.attributes,\n\t\t\tspecial = jQuery.event.special;\n\n\t\tfor ( ; ( elem = elems[ i ] ) != null; i++ ) {\n\t\t\tif ( forceAcceptData || acceptData( elem ) ) {\n\n\t\t\t\tid = elem[ internalKey ];\n\t\t\t\tdata = id && cache[ id ];\n\n\t\t\t\tif ( data ) {\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// Remove cache only if it was not already removed by jQuery.event.remove\n\t\t\t\t\tif ( cache[ id ] ) {\n\n\t\t\t\t\t\tdelete cache[ id ];\n\n\t\t\t\t\t\t// Support: IE<9\n\t\t\t\t\t\t// IE does not allow us to delete expando properties from nodes\n\t\t\t\t\t\t// IE creates expando attributes along with the property\n\t\t\t\t\t\t// IE does not have a removeAttribute function on Document nodes\n\t\t\t\t\t\tif ( !attributes && typeof elem.removeAttribute !== \"undefined\" ) {\n\t\t\t\t\t\t\telem.removeAttribute( internalKey );\n\n\t\t\t\t\t\t// Webkit & Blink performance suffers when deleting properties\n\t\t\t\t\t\t// from DOM nodes, so set to undefined instead\n\t\t\t\t\t\t// https://code.google.com/p/chromium/issues/detail?id=378607\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\telem[ internalKey ] = undefined;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tdeletedIds.push( id );\n\t\t\t\t\t}\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().append(\n\t\t\t\t\t( this[ 0 ] && this[ 0 ].ownerDocument || document ).createTextNode( value )\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\n\t\t\t// Remove element nodes and prevent memory leaks\n\t\t\tif ( elem.nodeType === 1 ) {\n\t\t\t\tjQuery.cleanData( getAll( elem, false ) );\n\t\t\t}\n\n\t\t\t// Remove any remaining nodes\n\t\t\twhile ( elem.firstChild ) {\n\t\t\t\telem.removeChild( elem.firstChild );\n\t\t\t}\n\n\t\t\t// If this is a select, ensure that it displays empty (#12336)\n\t\t\t// Support: IE<9\n\t\t\tif ( elem.options && jQuery.nodeName( elem, \"select\" ) ) {\n\t\t\t\telem.options.length = 0;\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 ) {\n\t\t\t\treturn elem.nodeType === 1 ?\n\t\t\t\t\telem.innerHTML.replace( rinlinejQuery, \"\" ) :\n\t\t\t\t\tundefined;\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( support.htmlSerialize || !rnoshimcache.test( value )  ) &&\n\t\t\t\t( support.leadingWhitespace || !rleadingWhitespace.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\n\t\t\t\t\t\t// Remove element nodes and prevent memory leaks\n\t\t\t\t\t\telem = this[ i ] || {};\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\ti = 0,\n\t\t\tret = [],\n\t\t\tinsert = jQuery( selector ),\n\t\t\tlast = insert.length - 1;\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// Modern browsers can apply jQuery collections as arrays, but oldIE needs a .get()\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 ].contentWindow || iframe[ 0 ].contentDocument ).document;\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 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, pixelMarginRightVal, boxSizingReliableVal,\n\t\treliableHiddenOffsetsVal, reliableMarginRightVal, 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\tdiv.style.cssText = \"float:left;opacity:.5\";\n\n\t// Support: IE<9\n\t// Make sure that element opacity exists (as opposed to filter)\n\tsupport.opacity = div.style.opacity === \"0.5\";\n\n\t// Verify style float existence\n\t// (IE uses styleFloat instead of cssFloat)\n\tsupport.cssFloat = !!div.style.cssFloat;\n\n\tdiv.style.backgroundClip = \"content-box\";\n\tdiv.cloneNode( true ).style.backgroundClip = \"\";\n\tsupport.clearCloneStyle = div.style.backgroundClip === \"content-box\";\n\n\tcontainer = document.createElement( \"div\" );\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\tdiv.innerHTML = \"\";\n\tcontainer.appendChild( div );\n\n\t// Support: Firefox<29, Android 2.3\n\t// Vendor-prefix box-sizing\n\tsupport.boxSizing = div.style.boxSizing === \"\" || div.style.MozBoxSizing === \"\" ||\n\t\tdiv.style.WebkitBoxSizing === \"\";\n\n\tjQuery.extend( support, {\n\t\treliableHiddenOffsets: function() {\n\t\t\tif ( pixelPositionVal == null ) {\n\t\t\t\tcomputeStyleTests();\n\t\t\t}\n\t\t\treturn reliableHiddenOffsetsVal;\n\t\t},\n\n\t\tboxSizingReliable: function() {\n\n\t\t\t// We're checking for pixelPositionVal here instead of boxSizingReliableVal\n\t\t\t// since that compresses better and they're computed together anyway.\n\t\t\tif ( pixelPositionVal == null ) {\n\t\t\t\tcomputeStyleTests();\n\t\t\t}\n\t\t\treturn boxSizingReliableVal;\n\t\t},\n\n\t\tpixelMarginRight: function() {\n\n\t\t\t// Support: Android 4.0-4.3\n\t\t\tif ( pixelPositionVal == null ) {\n\t\t\t\tcomputeStyleTests();\n\t\t\t}\n\t\t\treturn pixelMarginRightVal;\n\t\t},\n\n\t\tpixelPosition: function() {\n\t\t\tif ( pixelPositionVal == null ) {\n\t\t\t\tcomputeStyleTests();\n\t\t\t}\n\t\t\treturn pixelPositionVal;\n\t\t},\n\n\t\treliableMarginRight: function() {\n\n\t\t\t// Support: Android 2.3\n\t\t\tif ( pixelPositionVal == null ) {\n\t\t\t\tcomputeStyleTests();\n\t\t\t}\n\t\t\treturn reliableMarginRightVal;\n\t\t},\n\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 ( pixelPositionVal == null ) {\n\t\t\t\tcomputeStyleTests();\n\t\t\t}\n\t\t\treturn reliableMarginLeftVal;\n\t\t}\n\t} );\n\n\tfunction computeStyleTests() {\n\t\tvar contents, divStyle,\n\t\t\tdocumentElement = document.documentElement;\n\n\t\t// Setup\n\t\tdocumentElement.appendChild( container );\n\n\t\tdiv.style.cssText =\n\n\t\t\t// Support: Android 2.3\n\t\t\t// Vendor-prefix box-sizing\n\t\t\t\"-webkit-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\n\t\t// Support: IE<9\n\t\t// Assume reasonable values in the absence of getComputedStyle\n\t\tpixelPositionVal = boxSizingReliableVal = reliableMarginLeftVal = false;\n\t\tpixelMarginRightVal = reliableMarginRightVal = true;\n\n\t\t// Check for getComputedStyle so that this code is not run in IE<9.\n\t\tif ( window.getComputedStyle ) {\n\t\t\tdivStyle = window.getComputedStyle( div );\n\t\t\tpixelPositionVal = ( divStyle || {} ).top !== \"1%\";\n\t\t\treliableMarginLeftVal = ( divStyle || {} ).marginLeft === \"2px\";\n\t\t\tboxSizingReliableVal = ( divStyle || { width: \"4px\" } ).width === \"4px\";\n\n\t\t\t// Support: Android 4.0 - 4.3 only\n\t\t\t// Some styles come back with percentage values, even though they shouldn't\n\t\t\tdiv.style.marginRight = \"50%\";\n\t\t\tpixelMarginRightVal = ( divStyle || { marginRight: \"4px\" } ).marginRight === \"4px\";\n\n\t\t\t// Support: Android 2.3 only\n\t\t\t// 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\tcontents = div.appendChild( document.createElement( \"div\" ) );\n\n\t\t\t// Reset CSS: box-sizing; display; margin; border; padding\n\t\t\tcontents.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;-moz-box-sizing:content-box;\" +\n\t\t\t\t\"box-sizing:content-box;display:block;margin:0;border:0;padding:0\";\n\t\t\tcontents.style.marginRight = contents.style.width = \"0\";\n\t\t\tdiv.style.width = \"1px\";\n\n\t\t\treliableMarginRightVal =\n\t\t\t\t!parseFloat( ( window.getComputedStyle( contents ) || {} ).marginRight );\n\n\t\t\tdiv.removeChild( contents );\n\t\t}\n\n\t\t// Support: IE6-8\n\t\t// First check that getClientRects works as expected\n\t\t// Check if table cells still have offsetWidth/Height when they are set\n\t\t// to display:none and there are still other visible table cells in a\n\t\t// table row; if so, offsetWidth/Height are not reliable for use when\n\t\t// determining if an element has been hidden directly using\n\t\t// display:none (it is still safe to use offsets if a parent element is\n\t\t// hidden; don safety goggles and see bug #4512 for more information).\n\t\tdiv.style.display = \"none\";\n\t\treliableHiddenOffsetsVal = div.getClientRects().length === 0;\n\t\tif ( reliableHiddenOffsetsVal ) {\n\t\t\tdiv.style.display = \"\";\n\t\t\tdiv.innerHTML = \"<table><tr><td></td><td>t</td></tr></table>\";\n\t\t\tdiv.childNodes[ 0 ].style.borderCollapse = \"separate\";\n\t\t\tcontents = div.getElementsByTagName( \"td\" );\n\t\t\tcontents[ 0 ].style.cssText = \"margin:0;border:0;padding:0;display:none\";\n\t\t\treliableHiddenOffsetsVal = contents[ 0 ].offsetHeight === 0;\n\t\t\tif ( reliableHiddenOffsetsVal ) {\n\t\t\t\tcontents[ 0 ].style.display = \"\";\n\t\t\t\tcontents[ 1 ].style.display = \"none\";\n\t\t\t\treliableHiddenOffsetsVal = contents[ 0 ].offsetHeight === 0;\n\t\t\t}\n\t\t}\n\n\t\t// Teardown\n\t\tdocumentElement.removeChild( container );\n\t}\n\n} )();\n\n\nvar getStyles, curCSS,\n\trposition = /^(top|right|bottom|left)$/;\n\nif ( window.getComputedStyle ) {\n\tgetStyles = 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\n\tcurCSS = function( elem, name, computed ) {\n\t\tvar width, minWidth, maxWidth, ret,\n\t\t\tstyle = elem.style;\n\n\t\tcomputed = computed || getStyles( elem );\n\n\t\t// getPropertyValue is only needed for .css('filter') in IE9, see #12537\n\t\tret = computed ? computed.getPropertyValue( name ) || computed[ name ] : undefined;\n\n\t\t// Support: Opera 12.1x only\n\t\t// Fall back to style even without computed\n\t\t// computed is undefined for elems on document fragments\n\t\tif ( ( ret === \"\" || ret === undefined ) && !jQuery.contains( elem.ownerDocument, elem ) ) {\n\t\t\tret = jQuery.style( elem, name );\n\t\t}\n\n\t\tif ( computed ) {\n\n\t\t\t// A tribute to the \"awesome hack by Dean Edwards\"\n\t\t\t// Chrome < 17 and Safari 5.0 uses \"computed value\"\n\t\t\t// instead of \"used value\" for margin-right\n\t\t\t// Safari 5.1.7 (at least) returns percentage for a larger set of values,\n\t\t\t// but width seems to be reliably pixels\n\t\t\t// this is against the CSSOM draft spec:\n\t\t\t// http://dev.w3.org/csswg/cssom/#resolved-values\n\t\t\tif ( !support.pixelMarginRight() && rnumnonpx.test( ret ) && rmargin.test( name ) ) {\n\n\t\t\t\t// Remember the original values\n\t\t\t\twidth = style.width;\n\t\t\t\tminWidth = style.minWidth;\n\t\t\t\tmaxWidth = style.maxWidth;\n\n\t\t\t\t// Put in the new values to get a computed value out\n\t\t\t\tstyle.minWidth = style.maxWidth = style.width = ret;\n\t\t\t\tret = computed.width;\n\n\t\t\t\t// Revert the changed values\n\t\t\t\tstyle.width = width;\n\t\t\t\tstyle.minWidth = minWidth;\n\t\t\t\tstyle.maxWidth = maxWidth;\n\t\t\t}\n\t\t}\n\n\t\t// Support: IE\n\t\t// IE returns zIndex value as an integer.\n\t\treturn ret === undefined ?\n\t\t\tret :\n\t\t\tret + \"\";\n\t};\n} else if ( documentElement.currentStyle ) {\n\tgetStyles = function( elem ) {\n\t\treturn elem.currentStyle;\n\t};\n\n\tcurCSS = function( elem, name, computed ) {\n\t\tvar left, rs, rsLeft, ret,\n\t\t\tstyle = elem.style;\n\n\t\tcomputed = computed || getStyles( elem );\n\t\tret = computed ? computed[ name ] : undefined;\n\n\t\t// Avoid setting ret to empty string here\n\t\t// so we don't default to auto\n\t\tif ( ret == null && style && style[ name ] ) {\n\t\t\tret = style[ name ];\n\t\t}\n\n\t\t// From the awesome hack by Dean Edwards\n\t\t// http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291\n\n\t\t// If we're not dealing with a regular pixel number\n\t\t// but a number that has a weird ending, we need to convert it to pixels\n\t\t// but not position css attributes, as those are\n\t\t// proportional to the parent element instead\n\t\t// and we can't measure the parent instead because it\n\t\t// might trigger a \"stacking dolls\" problem\n\t\tif ( rnumnonpx.test( ret ) && !rposition.test( name ) ) {\n\n\t\t\t// Remember the original values\n\t\t\tleft = style.left;\n\t\t\trs = elem.runtimeStyle;\n\t\t\trsLeft = rs && rs.left;\n\n\t\t\t// Put in the new values to get a computed value out\n\t\t\tif ( rsLeft ) {\n\t\t\t\trs.left = elem.currentStyle.left;\n\t\t\t}\n\t\t\tstyle.left = name === \"fontSize\" ? \"1em\" : ret;\n\t\t\tret = style.pixelLeft + \"px\";\n\n\t\t\t// Revert the changed values\n\t\t\tstyle.left = left;\n\t\t\tif ( rsLeft ) {\n\t\t\t\trs.left = rsLeft;\n\t\t\t}\n\t\t}\n\n\t\t// Support: IE\n\t\t// IE returns zIndex value as an integer.\n\t\treturn ret === undefined ?\n\t\t\tret :\n\t\t\tret + \"\" || \"auto\";\n\t};\n}\n\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\tralpha = /alpha\\([^)]*\\)/i,\n\tropacity = /opacity\\s*=\\s*([^)]*)/i,\n\n\t// swappable if display is none or starts with table except\n\t// \"table\", \"table-cell\", or \"table-caption\"\n\t// see here for display values:\n\t// https://developer.mozilla.org/en-US/docs/CSS/display\n\trdisplayswap = /^(none|table(?!-c[ea]).+)/,\n\trnumsplit = new RegExp( \"^(\" + pnum + \")(.*)$\", \"i\" ),\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\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.charAt( 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 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 ] = jQuery._data( 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 ] =\n\t\t\t\t\tjQuery._data( elem, \"olddisplay\", defaultDisplay( elem.nodeName ) );\n\t\t\t}\n\t\t} else {\n\t\t\thidden = isHidden( elem );\n\n\t\t\tif ( display && display !== \"none\" || !hidden ) {\n\t\t\t\tjQuery._data(\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\nfunction setPositiveNumber( elem, value, subtract ) {\n\tvar matches = rnumsplit.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[ 1 ] - ( subtract || 0 ) ) + ( matches[ 2 ] || \"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 = support.boxSizing &&\n\t\t\tjQuery.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// we need the 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\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\n\t\t// normalize float css property\n\t\t\"float\": support.cssFloat ? \"cssFloat\" : \"styleFloat\"\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\n\t\t// followed by the 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. See: #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// Fixes #8908, it can be done more correctly by specifing setters in cssHooks,\n\t\t\t// but it would mean to define eight\n\t\t\t// (for every problematic property) identical functions\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\t// Support: IE\n\t\t\t\t// Swallow errors from 'invalid' CSS values (#5509)\n\t\t\t\ttry {\n\t\t\t\t\tstyle[ name ] = value;\n\t\t\t\t} catch ( e ) {}\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 num, val, 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// gets hook for the prefixed version\n\t\t// followed by the unprefixed version\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// Return, converting to number 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// however, it must have a current display style that would benefit from this\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 styles = extra && getStyles( elem );\n\t\t\treturn setPositiveNumber( elem, value, extra ?\n\t\t\t\taugmentWidthOrHeight(\n\t\t\t\t\telem,\n\t\t\t\t\tname,\n\t\t\t\t\textra,\n\t\t\t\t\tsupport.boxSizing &&\n\t\t\t\t\t\tjQuery.css( elem, \"boxSizing\", false, styles ) === \"border-box\",\n\t\t\t\t\tstyles\n\t\t\t\t) : 0\n\t\t\t);\n\t\t}\n\t};\n} );\n\nif ( !support.opacity ) {\n\tjQuery.cssHooks.opacity = {\n\t\tget: function( elem, computed ) {\n\n\t\t\t// IE uses filters for opacity\n\t\t\treturn ropacity.test( ( computed && elem.currentStyle ?\n\t\t\t\telem.currentStyle.filter :\n\t\t\t\telem.style.filter ) || \"\" ) ?\n\t\t\t\t\t( 0.01 * parseFloat( RegExp.$1 ) ) + \"\" :\n\t\t\t\t\tcomputed ? \"1\" : \"\";\n\t\t},\n\n\t\tset: function( elem, value ) {\n\t\t\tvar style = elem.style,\n\t\t\t\tcurrentStyle = elem.currentStyle,\n\t\t\t\topacity = jQuery.isNumeric( value ) ? \"alpha(opacity=\" + value * 100 + \")\" : \"\",\n\t\t\t\tfilter = currentStyle && currentStyle.filter || style.filter || \"\";\n\n\t\t\t// IE has trouble with opacity if it does not have layout\n\t\t\t// Force it by setting the zoom level\n\t\t\tstyle.zoom = 1;\n\n\t\t\t// if setting opacity to 1, and no other filters exist -\n\t\t\t// attempt to remove filter attribute #6652\n\t\t\t// if value === \"\", then remove inline opacity #12685\n\t\t\tif ( ( value >= 1 || value === \"\" ) &&\n\t\t\t\t\tjQuery.trim( filter.replace( ralpha, \"\" ) ) === \"\" &&\n\t\t\t\t\tstyle.removeAttribute ) {\n\n\t\t\t\t// Setting style.filter to null, \"\" & \" \" still leave \"filter:\" in the cssText\n\t\t\t\t// if \"filter:\" is present at all, clearType is disabled, we want to avoid this\n\t\t\t\t// style.removeAttribute is IE Only, but so apparently is this code path...\n\t\t\t\tstyle.removeAttribute( \"filter\" );\n\n\t\t\t\t// if there is no filter style applied in a css rule\n\t\t\t\t// or unset inline opacity, we are done\n\t\t\t\tif ( value === \"\" || currentStyle && !currentStyle.filter ) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// otherwise, set new filter values\n\t\t\tstyle.filter = ralpha.test( filter ) ?\n\t\t\t\tfilter.replace( ralpha, opacity ) :\n\t\t\t\tfilter + \" \" + opacity;\n\t\t}\n\t};\n}\n\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\njQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft,\n\tfunction( elem, computed ) {\n\t\tif ( computed ) {\n\t\t\treturn (\n\t\t\t\tparseFloat( curCSS( elem, \"marginLeft\" ) ) ||\n\n\t\t\t\t// Support: IE<=11+\n\t\t\t\t// Running getBoundingClientRect on a disconnected node in IE throws an error\n\t\t\t\t// Support: IE8 only\n\t\t\t\t// getClientRects() errors on disconnected elems\n\t\t\t\t( jQuery.contains( elem.ownerDocument, elem ) ?\n\t\t\t\t\telem.getBoundingClientRect().left -\n\t\t\t\t\t\tswap( elem, { marginLeft: 0 }, function() {\n\t\t\t\t\t\t\treturn elem.getBoundingClientRect().left;\n\t\t\t\t\t\t} ) :\n\t\t\t\t\t0\n\t\t\t\t)\n\t\t\t) + \"px\";\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// so, 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 - use cssHook if its there - use .style if its\n\t\t\t// 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: IE <=9\n// Panic based approach to setting things on disconnected nodes\n\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\tattrs = { height: type },\n\t\ti = 0;\n\n\t// if we include width, step value is 1 to do all cssExpand values,\n\t// if we don't include width, 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 = jQuery._data( 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// doing this makes sure that the complete handler will be called\n\t\t\t// 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 IE does 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\tjQuery._data( elem, \"olddisplay\" ) || defaultDisplay( elem.nodeName ) : display;\n\n\t\tif ( checkDisplay === \"inline\" && jQuery.css( elem, \"float\" ) === \"none\" ) {\n\n\t\t\t// inline-level elements accept inline-block;\n\t\t\t// block-level elements need to be inline with layout\n\t\t\tif ( !support.inlineBlockNeedsLayout || defaultDisplay( elem.nodeName ) === \"inline\" ) {\n\t\t\t\tstyle.display = \"inline-block\";\n\t\t\t} else {\n\t\t\t\tstyle.zoom = 1;\n\t\t\t}\n\t\t}\n\t}\n\n\tif ( opts.overflow ) {\n\t\tstyle.overflow = \"hidden\";\n\t\tif ( !support.shrinkWrapBlocks() ) {\n\t\t\tanim.always( function() {\n\t\t\t\tstyle.overflow = opts.overflow[ 0 ];\n\t\t\t\tstyle.overflowX = opts.overflow[ 1 ];\n\t\t\t\tstyle.overflowY = opts.overflow[ 2 ];\n\t\t\t} );\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 = jQuery._data( 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\t\t\tjQuery._removeData( 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 wont overwrite keys already present.\n\t\t\t// also - reusing 'index' from above 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\n\t\t\t\t// 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\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\" ? opt.duration :\n\t\topt.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 || jQuery._data( 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 = jQuery._data( 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 will dequeue\n\t\t\t// 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 = jQuery._data( 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\ttimers = jQuery.timers,\n\t\ti = 0;\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;\n\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\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 a,\n\t\tinput = document.createElement( \"input\" ),\n\t\tdiv = document.createElement( \"div\" ),\n\t\tselect = document.createElement( \"select\" ),\n\t\topt = select.appendChild( document.createElement( \"option\" ) );\n\n\t// Setup\n\tdiv = document.createElement( \"div\" );\n\tdiv.setAttribute( \"className\", \"t\" );\n\tdiv.innerHTML = \"  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>\";\n\ta = div.getElementsByTagName( \"a\" )[ 0 ];\n\n\t// Support: Windows Web Apps (WWA)\n\t// `type` must use .setAttribute for WWA (#14901)\n\tinput.setAttribute( \"type\", \"checkbox\" );\n\tdiv.appendChild( input );\n\n\ta = div.getElementsByTagName( \"a\" )[ 0 ];\n\n\t// First batch of tests.\n\ta.style.cssText = \"top:1px\";\n\n\t// Test setAttribute on camelCase class.\n\t// If it works, we need attrFixes when doing get/setAttribute (ie6/7)\n\tsupport.getSetAttribute = div.className !== \"t\";\n\n\t// Get the style information from getAttribute\n\t// (IE uses .cssText instead)\n\tsupport.style = /top/.test( a.getAttribute( \"style\" ) );\n\n\t// Make sure that URLs aren't manipulated\n\t// (IE normalizes it by default)\n\tsupport.hrefNormalized = a.getAttribute( \"href\" ) === \"/a\";\n\n\t// Check the default checkbox/radio value (\"\" on WebKit; \"on\" elsewhere)\n\tsupport.checkOn = !!input.value;\n\n\t// Make sure that a selected-by-default option has a working selected property.\n\t// (WebKit defaults to false instead of true, IE too, if it's in an optgroup)\n\tsupport.optSelected = opt.selected;\n\n\t// Tests for enctype support on a form (#6743)\n\tsupport.enctype = !!document.createElement( \"form\" ).enctype;\n\n\t// Make sure that the options inside disabled selects aren't marked as disabled\n\t// (WebKit marks them as disabled)\n\tselect.disabled = true;\n\tsupport.optDisabled = !opt.disabled;\n\n\t// Support: IE8 only\n\t// Check if we can trust getAttribute(\"value\")\n\tinput = document.createElement( \"input\" );\n\tinput.setAttribute( \"value\", \"\" );\n\tsupport.input = input.getAttribute( \"value\" ) === \"\";\n\n\t// Check if an input maintains its value after becoming a radio\n\tinput.value = \"t\";\n\tinput.setAttribute( \"type\", \"radio\" );\n\tsupport.radioValue = input.value === \"t\";\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 (\n\t\t\t\t\thooks &&\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\t\t\t} else if ( typeof val === \"number\" ) {\n\t\t\t\tval += \"\";\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\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// oldIE 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 :\n\t\t\t\t\t\t\t\toption.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\n\t\t\t\t\tif ( jQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1 ) {\n\n\t\t\t\t\t\t// Support: IE6\n\t\t\t\t\t\t// When new option element is added to select box we need to\n\t\t\t\t\t\t// force reflow of newly added node in order to workaround delay\n\t\t\t\t\t\t// of initialization properties\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\toption.selected = optionSet = true;\n\n\t\t\t\t\t\t} catch ( _ ) {\n\n\t\t\t\t\t\t\t// Will be executed only in IE6\n\t\t\t\t\t\t\toption.scrollHeight;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t} else {\n\t\t\t\t\t\toption.selected = false;\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\n\t\t\t\treturn options;\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\nvar nodeHook, boolHook,\n\tattrHandle = jQuery.expr.attrHandle,\n\truseDefault = /^(?:checked|selected)$/i,\n\tgetSetAttribute = support.getSetAttribute,\n\tgetSetInput = support.input;\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 : nodeHook );\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\n\t\t\t\t\t// Setting the type on a radio button after the value resets the value in IE8-9\n\t\t\t\t\t// Reset value to default in case type is set after value during creation\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\tif ( getSetInput && getSetAttribute || !ruseDefault.test( name ) ) {\n\t\t\t\t\t\telem[ propName ] = false;\n\n\t\t\t\t\t// Support: IE<9\n\t\t\t\t\t// Also clear defaultChecked/defaultSelected (if appropriate)\n\t\t\t\t\t} else {\n\t\t\t\t\t\telem[ jQuery.camelCase( \"default-\" + name ) ] =\n\t\t\t\t\t\t\telem[ propName ] = false;\n\t\t\t\t\t}\n\n\t\t\t\t// See #9699 for explanation of this approach (setting first, then removal)\n\t\t\t\t} else {\n\t\t\t\t\tjQuery.attr( elem, name, \"\" );\n\t\t\t\t}\n\n\t\t\t\telem.removeAttribute( getSetAttribute ? name : propName );\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 if ( getSetInput && getSetAttribute || !ruseDefault.test( name ) ) {\n\n\t\t\t// IE<8 needs the *property* name\n\t\t\telem.setAttribute( !getSetAttribute && jQuery.propFix[ name ] || name, name );\n\n\t\t} else {\n\n\t\t\t// Support: IE<9\n\t\t\t// Use defaultChecked and defaultSelected for oldIE\n\t\t\telem[ jQuery.camelCase( \"default-\" + name ) ] = elem[ name ] = true;\n\t\t}\n\t\treturn name;\n\t}\n};\n\njQuery.each( jQuery.expr.match.bool.source.match( /\\w+/g ), function( i, name ) {\n\tvar getter = attrHandle[ name ] || jQuery.find.attr;\n\n\tif ( getSetInput && getSetAttribute || !ruseDefault.test( name ) ) {\n\t\tattrHandle[ name ] = function( elem, name, isXML ) {\n\t\t\tvar ret, handle;\n\t\t\tif ( !isXML ) {\n\n\t\t\t\t// Avoid an infinite loop by temporarily removing this function from the getter\n\t\t\t\thandle = attrHandle[ name ];\n\t\t\t\tattrHandle[ name ] = ret;\n\t\t\t\tret = getter( elem, name, isXML ) != null ?\n\t\t\t\t\tname.toLowerCase() :\n\t\t\t\t\tnull;\n\t\t\t\tattrHandle[ name ] = handle;\n\t\t\t}\n\t\t\treturn ret;\n\t\t};\n\t} else {\n\t\tattrHandle[ name ] = function( elem, name, isXML ) {\n\t\t\tif ( !isXML ) {\n\t\t\t\treturn elem[ jQuery.camelCase( \"default-\" + name ) ] ?\n\t\t\t\t\tname.toLowerCase() :\n\t\t\t\t\tnull;\n\t\t\t}\n\t\t};\n\t}\n} );\n\n// fix oldIE attroperties\nif ( !getSetInput || !getSetAttribute ) {\n\tjQuery.attrHooks.value = {\n\t\tset: function( elem, value, name ) {\n\t\t\tif ( jQuery.nodeName( elem, \"input\" ) ) {\n\n\t\t\t\t// Does not return so that setAttribute is also used\n\t\t\t\telem.defaultValue = value;\n\t\t\t} else {\n\n\t\t\t\t// Use nodeHook if defined (#1954); otherwise setAttribute is fine\n\t\t\t\treturn nodeHook && nodeHook.set( elem, value, name );\n\t\t\t}\n\t\t}\n\t};\n}\n\n// IE6/7 do not support getting/setting some attributes with get/setAttribute\nif ( !getSetAttribute ) {\n\n\t// Use this for any attribute in IE6/7\n\t// This fixes almost every IE6/7 issue\n\tnodeHook = {\n\t\tset: function( elem, value, name ) {\n\n\t\t\t// Set the existing or create a new attribute node\n\t\t\tvar ret = elem.getAttributeNode( name );\n\t\t\tif ( !ret ) {\n\t\t\t\telem.setAttributeNode(\n\t\t\t\t\t( ret = elem.ownerDocument.createAttribute( name ) )\n\t\t\t\t);\n\t\t\t}\n\n\t\t\tret.value = value += \"\";\n\n\t\t\t// Break association with cloned elements by also using setAttribute (#9646)\n\t\t\tif ( name === \"value\" || value === elem.getAttribute( name ) ) {\n\t\t\t\treturn value;\n\t\t\t}\n\t\t}\n\t};\n\n\t// Some attributes are constructed with empty-string values when not defined\n\tattrHandle.id = attrHandle.name = attrHandle.coords =\n\t\tfunction( elem, name, isXML ) {\n\t\t\tvar ret;\n\t\t\tif ( !isXML ) {\n\t\t\t\treturn ( ret = elem.getAttributeNode( name ) ) && ret.value !== \"\" ?\n\t\t\t\t\tret.value :\n\t\t\t\t\tnull;\n\t\t\t}\n\t\t};\n\n\t// Fixing value retrieval on a button requires this module\n\tjQuery.valHooks.button = {\n\t\tget: function( elem, name ) {\n\t\t\tvar ret = elem.getAttributeNode( name );\n\t\t\tif ( ret && ret.specified ) {\n\t\t\t\treturn ret.value;\n\t\t\t}\n\t\t},\n\t\tset: nodeHook.set\n\t};\n\n\t// Set contenteditable to false on removals(#10429)\n\t// Setting to empty string throws an error as an invalid value\n\tjQuery.attrHooks.contenteditable = {\n\t\tset: function( elem, value, name ) {\n\t\t\tnodeHook.set( elem, value === \"\" ? false : value, name );\n\t\t}\n\t};\n\n\t// Set width and height to auto instead of 0 on empty string( Bug #8150 )\n\t// This is for removals\n\tjQuery.each( [ \"width\", \"height\" ], function( i, name ) {\n\t\tjQuery.attrHooks[ name ] = {\n\t\t\tset: function( elem, value ) {\n\t\t\t\tif ( value === \"\" ) {\n\t\t\t\t\telem.setAttribute( name, \"auto\" );\n\t\t\t\t\treturn value;\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\t} );\n}\n\nif ( !support.style ) {\n\tjQuery.attrHooks.style = {\n\t\tget: function( elem ) {\n\n\t\t\t// Return undefined in the case of empty string\n\t\t\t// Note: IE uppercases css property names, but if we were to .toLowerCase()\n\t\t\t// .cssText, that would destroy case sensitivity in URL's, like in \"background\"\n\t\t\treturn elem.style.cssText || undefined;\n\t\t},\n\t\tset: function( elem, value ) {\n\t\t\treturn ( elem.style.cssText = value + \"\" );\n\t\t}\n\t};\n}\n\n\n\n\nvar rfocusable = /^(?:input|select|textarea|button|object)$/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\tname = jQuery.propFix[ name ] || name;\n\t\treturn this.each( function() {\n\n\t\t\t// try/catch handles cases where IE balks (such as removing a property on window)\n\t\t\ttry {\n\t\t\t\tthis[ name ] = undefined;\n\t\t\t\tdelete this[ name ];\n\t\t\t} catch ( e ) {}\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// Some attributes require a special call on IE\n// http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx\nif ( !support.hrefNormalized ) {\n\n\t// href/src property should get the full normalized URL (#10299/#12915)\n\tjQuery.each( [ \"href\", \"src\" ], function( i, name ) {\n\t\tjQuery.propHooks[ name ] = {\n\t\t\tget: function( elem ) {\n\t\t\t\treturn elem.getAttribute( name, 4 );\n\t\t\t}\n\t\t};\n\t} );\n}\n\n// Support: Safari, IE9+\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\n\t\t\tif ( parent ) {\n\t\t\t\tparent.selectedIndex;\n\n\t\t\t\t// Make sure that it also works with optgroups, see #5701\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\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// IE6/7 call enctype encoding\nif ( !support.enctype ) {\n\tjQuery.propFix.enctype = \"encoding\";\n}\n\n\n\n\nvar rclass = /[\\t\\r\\n\\f]/g;\n\nfunction getClass( elem ) {\n\treturn jQuery.attr( elem, \"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\tjQuery.attr( elem, \"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\tjQuery.attr( elem, \"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\tjQuery._data( 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\tjQuery.attr( this, \"class\",\n\t\t\t\t\tclassName || value === false ?\n\t\t\t\t\t\"\" :\n\t\t\t\t\tjQuery._data( this, \"__className__\" ) || \"\"\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\n// Return jQuery for attributes-only inclusion\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\nvar location = window.location;\n\nvar nonce = jQuery.now();\n\nvar rquery = ( /\\?/ );\n\n\n\nvar rvalidtokens = /(,)|(\\[|{)|(}|])|\"(?:[^\"\\\\\\r\\n]|\\\\[\"\\\\\\/bfnrt]|\\\\u[\\da-fA-F]{4})*\"\\s*:?|true|false|null|-?(?!0\\d)\\d+(?:\\.\\d+|)(?:[eE][+-]?\\d+|)/g;\n\njQuery.parseJSON = function( data ) {\n\n\t// Attempt to parse using the native JSON parser first\n\tif ( window.JSON && window.JSON.parse ) {\n\n\t\t// Support: Android 2.3\n\t\t// Workaround failure to string-cast null input\n\t\treturn window.JSON.parse( data + \"\" );\n\t}\n\n\tvar requireNonComma,\n\t\tdepth = null,\n\t\tstr = jQuery.trim( data + \"\" );\n\n\t// Guard against invalid (and possibly dangerous) input by ensuring that nothing remains\n\t// after removing valid tokens\n\treturn str && !jQuery.trim( str.replace( rvalidtokens, function( token, comma, open, close ) {\n\n\t\t// Force termination if we see a misplaced comma\n\t\tif ( requireNonComma && comma ) {\n\t\t\tdepth = 0;\n\t\t}\n\n\t\t// Perform no more replacements after returning to outermost depth\n\t\tif ( depth === 0 ) {\n\t\t\treturn token;\n\t\t}\n\n\t\t// Commas must not follow \"[\", \"{\", or \",\"\n\t\trequireNonComma = open || comma;\n\n\t\t// Determine new depth\n\t\t// array/object open (\"[\" or \"{\"): depth += true - false (increment)\n\t\t// array/object close (\"]\" or \"}\"): depth += false - true (decrement)\n\t\t// other cases (\",\" or primitive): depth += true - true (numeric cast)\n\t\tdepth += !close - !open;\n\n\t\t// Remove this token\n\t\treturn \"\";\n\t} ) ) ?\n\t\t( Function( \"return \" + str ) )() :\n\t\tjQuery.error( \"Invalid JSON: \" + data );\n};\n\n\n// Cross-browser xml parsing\njQuery.parseXML = function( data ) {\n\tvar xml, tmp;\n\tif ( !data || typeof data !== \"string\" ) {\n\t\treturn null;\n\t}\n\ttry {\n\t\tif ( window.DOMParser ) { // Standard\n\t\t\ttmp = new window.DOMParser();\n\t\t\txml = tmp.parseFromString( data, \"text/xml\" );\n\t\t} else { // IE\n\t\t\txml = new window.ActiveXObject( \"Microsoft.XMLDOM\" );\n\t\t\txml.async = \"false\";\n\t\t\txml.loadXML( data );\n\t\t}\n\t} catch ( e ) {\n\t\txml = undefined;\n\t}\n\tif ( !xml || !xml.documentElement || 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\n\t// IE leaves an \\r character at EOL\n\trheaders = /^(.*?):[ \\t]*([^\\r\\n]*)\\r?$/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\trurl = /^([\\w.+-]+:)(?:\\/\\/(?:[^\\/?#]*@|)([^\\/?#:]*)(?::(\\d+)|)|)/,\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// Document location\n\tajaxLocation = location.href,\n\n\t// Segment location into parts\n\tajaxLocParts = rurl.exec( ajaxLocation.toLowerCase() ) || [];\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.charAt( 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 deep, key,\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\tvar firstDataType, ct, finalDataType, type,\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\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\" ] ) { // jscs:ignore requireDotNotation\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: ajaxLocation,\n\t\ttype: \"GET\",\n\t\tisLocal: rlocalProtocol.test( ajaxLocParts[ 1 ] ),\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\n\n\t\t\t// Cross-domain detection vars\n\t\t\tparts,\n\n\t\t\t// Loop variable\n\t\t\ti,\n\n\t\t\t// URL without anti-cache param\n\t\t\tcacheURL,\n\n\t\t\t// Response headers as string\n\t\t\tresponseHeadersString,\n\n\t\t\t// timeout handle\n\t\t\ttimeoutTimer,\n\n\t\t\t// To know if global events are to be dispatched\n\t\t\tfireGlobals,\n\n\t\t\ttransport,\n\n\t\t\t// Response headers\n\t\t\tresponseHeaders,\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 (#5866: IE7 issue with protocol-less urls)\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 || ajaxLocation ) + \"\" )\n\t\t\t.replace( rhash, \"\" )\n\t\t\t.replace( rprotocol, ajaxLocParts[ 1 ] + \"//\" );\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 we have a protocol:host:port mismatch\n\t\tif ( s.crossDomain == null ) {\n\t\t\tparts = rurl.exec( s.url.toLowerCase() );\n\t\t\ts.crossDomain = !!( parts &&\n\t\t\t\t( parts[ 1 ] !== ajaxLocParts[ 1 ] || parts[ 2 ] !== ajaxLocParts[ 2 ] ||\n\t\t\t\t\t( parts[ 3 ] || ( parts[ 1 ] === \"http:\" ? \"80\" : \"443\" ) ) !==\n\t\t\t\t\t\t( ajaxLocParts[ 3 ] || ( ajaxLocParts[ 1 ] === \"http:\" ? \"80\" : \"443\" ) ) )\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// We extract error from statusText\n\t\t\t\t// then normalize statusText and status 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\tcache: true,\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\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\tvar wrap = 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.firstChild && elem.firstChild.nodeType === 1 ) {\n\t\t\t\t\telem = elem.firstChild;\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\nfunction getDisplay( elem ) {\n\treturn elem.style && elem.style.display || jQuery.css( elem, \"display\" );\n}\n\nfunction filterHidden( elem ) {\n\n\t// Disconnected elements are considered hidden\n\tif ( !jQuery.contains( elem.ownerDocument || document, elem ) ) {\n\t\treturn true;\n\t}\n\twhile ( elem && elem.nodeType === 1 ) {\n\t\tif ( getDisplay( elem ) === \"none\" || elem.type === \"hidden\" ) {\n\t\t\treturn true;\n\t\t}\n\t\telem = elem.parentNode;\n\t}\n\treturn false;\n}\n\njQuery.expr.filters.hidden = function( elem ) {\n\n\t// Support: Opera <= 12.12\n\t// Opera reports offsetWidths and offsetHeights less than zero on some elements\n\treturn support.reliableHiddenOffsets() ?\n\t\t( elem.offsetWidth <= 0 && elem.offsetHeight <= 0 &&\n\t\t\t!elem.getClientRects().length ) :\n\t\t\tfilterHidden( elem );\n};\n\njQuery.expr.filters.visible = function( elem ) {\n\treturn !jQuery.expr.filters.hidden( elem );\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\n// Create the request object\n// (This is still attached to ajaxSettings for backward compatibility)\njQuery.ajaxSettings.xhr = window.ActiveXObject !== undefined ?\n\n\t// Support: IE6-IE8\n\tfunction() {\n\n\t\t// XHR cannot access local files, always use ActiveX for that case\n\t\tif ( this.isLocal ) {\n\t\t\treturn createActiveXHR();\n\t\t}\n\n\t\t// Support: IE 9-11\n\t\t// IE seems to error on cross-domain PATCH requests when ActiveX XHR\n\t\t// is used. In IE 9+ always use the native XHR.\n\t\t// Note: this condition won't catch Edge as it doesn't define\n\t\t// document.documentMode but it also doesn't support ActiveX so it won't\n\t\t// reach this code.\n\t\tif ( document.documentMode > 8 ) {\n\t\t\treturn createStandardXHR();\n\t\t}\n\n\t\t// Support: IE<9\n\t\t// oldIE XHR does not support non-RFC2616 methods (#13240)\n\t\t// See http://msdn.microsoft.com/en-us/library/ie/ms536648(v=vs.85).aspx\n\t\t// and http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9\n\t\t// Although this check for six methods instead of eight\n\t\t// since IE also does not support \"trace\" and \"connect\"\n\t\treturn /^(get|post|head|put|delete|options)$/i.test( this.type ) &&\n\t\t\tcreateStandardXHR() || createActiveXHR();\n\t} :\n\n\t// For all other browsers, use the standard XMLHttpRequest object\n\tcreateStandardXHR;\n\nvar xhrId = 0,\n\txhrCallbacks = {},\n\txhrSupported = jQuery.ajaxSettings.xhr();\n\n// Support: IE<10\n// Open requests must be manually aborted on unload (#5280)\n// See https://support.microsoft.com/kb/2856746 for more info\nif ( window.attachEvent ) {\n\twindow.attachEvent( \"onunload\", function() {\n\t\tfor ( var key in xhrCallbacks ) {\n\t\t\txhrCallbacks[ key ]( undefined, true );\n\t\t}\n\t} );\n}\n\n// Determine support properties\nsupport.cors = !!xhrSupported && ( \"withCredentials\" in xhrSupported );\nxhrSupported = support.ajax = !!xhrSupported;\n\n// Create transport if the browser can provide an xhr\nif ( xhrSupported ) {\n\n\tjQuery.ajaxTransport( function( options ) {\n\n\t\t// Cross domain only allowed if supported through XMLHttpRequest\n\t\tif ( !options.crossDomain || support.cors ) {\n\n\t\t\tvar callback;\n\n\t\t\treturn {\n\t\t\t\tsend: function( headers, complete ) {\n\t\t\t\t\tvar i,\n\t\t\t\t\t\txhr = options.xhr(),\n\t\t\t\t\t\tid = ++xhrId;\n\n\t\t\t\t\t// Open the socket\n\t\t\t\t\txhr.open(\n\t\t\t\t\t\toptions.type,\n\t\t\t\t\t\toptions.url,\n\t\t\t\t\t\toptions.async,\n\t\t\t\t\t\toptions.username,\n\t\t\t\t\t\toptions.password\n\t\t\t\t\t);\n\n\t\t\t\t\t// Apply custom fields if provided\n\t\t\t\t\tif ( options.xhrFields ) {\n\t\t\t\t\t\tfor ( i in options.xhrFields ) {\n\t\t\t\t\t\t\txhr[ i ] = options.xhrFields[ i ];\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Override mime type if needed\n\t\t\t\t\tif ( options.mimeType && xhr.overrideMimeType ) {\n\t\t\t\t\t\txhr.overrideMimeType( options.mimeType );\n\t\t\t\t\t}\n\n\t\t\t\t\t// X-Requested-With header\n\t\t\t\t\t// For cross-domain requests, seeing as conditions for a preflight are\n\t\t\t\t\t// akin to a jigsaw puzzle, we simply never set it to be sure.\n\t\t\t\t\t// (it can always be set on a per-request basis or even using ajaxSetup)\n\t\t\t\t\t// For same-domain requests, won't change header if already provided.\n\t\t\t\t\tif ( !options.crossDomain && !headers[ \"X-Requested-With\" ] ) {\n\t\t\t\t\t\theaders[ \"X-Requested-With\" ] = \"XMLHttpRequest\";\n\t\t\t\t\t}\n\n\t\t\t\t\t// Set headers\n\t\t\t\t\tfor ( i in headers ) {\n\n\t\t\t\t\t\t// Support: IE<9\n\t\t\t\t\t\t// IE's ActiveXObject throws a 'Type Mismatch' exception when setting\n\t\t\t\t\t\t// request header to a null-value.\n\t\t\t\t\t\t//\n\t\t\t\t\t\t// To keep consistent with other XHR implementations, cast the value\n\t\t\t\t\t\t// to string and ignore `undefined`.\n\t\t\t\t\t\tif ( headers[ i ] !== undefined ) {\n\t\t\t\t\t\t\txhr.setRequestHeader( i, headers[ i ] + \"\" );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Do send the request\n\t\t\t\t\t// This may raise an exception which is actually\n\t\t\t\t\t// handled in jQuery.ajax (so no try/catch here)\n\t\t\t\t\txhr.send( ( options.hasContent && options.data ) || null );\n\n\t\t\t\t\t// Listener\n\t\t\t\t\tcallback = function( _, isAbort ) {\n\t\t\t\t\t\tvar status, statusText, responses;\n\n\t\t\t\t\t\t// Was never called and is aborted or complete\n\t\t\t\t\t\tif ( callback && ( isAbort || xhr.readyState === 4 ) ) {\n\n\t\t\t\t\t\t\t// Clean up\n\t\t\t\t\t\t\tdelete xhrCallbacks[ id ];\n\t\t\t\t\t\t\tcallback = undefined;\n\t\t\t\t\t\t\txhr.onreadystatechange = jQuery.noop;\n\n\t\t\t\t\t\t\t// Abort manually if needed\n\t\t\t\t\t\t\tif ( isAbort ) {\n\t\t\t\t\t\t\t\tif ( xhr.readyState !== 4 ) {\n\t\t\t\t\t\t\t\t\txhr.abort();\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\tresponses = {};\n\t\t\t\t\t\t\t\tstatus = xhr.status;\n\n\t\t\t\t\t\t\t\t// Support: IE<10\n\t\t\t\t\t\t\t\t// Accessing binary-data responseText throws an exception\n\t\t\t\t\t\t\t\t// (#11426)\n\t\t\t\t\t\t\t\tif ( typeof xhr.responseText === \"string\" ) {\n\t\t\t\t\t\t\t\t\tresponses.text = xhr.responseText;\n\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t// Firefox throws an exception when accessing\n\t\t\t\t\t\t\t\t// statusText for faulty cross-domain requests\n\t\t\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\t\t\tstatusText = xhr.statusText;\n\t\t\t\t\t\t\t\t} catch ( e ) {\n\n\t\t\t\t\t\t\t\t\t// We normalize with Webkit giving an empty statusText\n\t\t\t\t\t\t\t\t\tstatusText = \"\";\n\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t// Filter status for non standard behaviors\n\n\t\t\t\t\t\t\t\t// If the request is local and we have data: assume a success\n\t\t\t\t\t\t\t\t// (success with no data won't get notified, that's the best we\n\t\t\t\t\t\t\t\t// can do given current implementations)\n\t\t\t\t\t\t\t\tif ( !status && options.isLocal && !options.crossDomain ) {\n\t\t\t\t\t\t\t\t\tstatus = responses.text ? 200 : 404;\n\n\t\t\t\t\t\t\t\t// IE - #1450: sometimes returns 1223 when it should be 204\n\t\t\t\t\t\t\t\t} else if ( status === 1223 ) {\n\t\t\t\t\t\t\t\t\tstatus = 204;\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// Call complete if needed\n\t\t\t\t\t\tif ( responses ) {\n\t\t\t\t\t\t\tcomplete( status, statusText, responses, xhr.getAllResponseHeaders() );\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\n\t\t\t\t\t// Do send the request\n\t\t\t\t\t// `xhr.send` may raise an exception, but it will be\n\t\t\t\t\t// handled in jQuery.ajax (so no try/catch here)\n\t\t\t\t\tif ( !options.async ) {\n\n\t\t\t\t\t\t// If we're in sync mode we fire the callback\n\t\t\t\t\t\tcallback();\n\t\t\t\t\t} else if ( xhr.readyState === 4 ) {\n\n\t\t\t\t\t\t// (IE6 & IE7) if it's in cache and has been\n\t\t\t\t\t\t// retrieved directly we need to fire the callback\n\t\t\t\t\t\twindow.setTimeout( callback );\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\t// Register the callback, but delay it in case `xhr.send` throws\n\t\t\t\t\t\t// Add to the list of active xhr callbacks\n\t\t\t\t\t\txhr.onreadystatechange = xhrCallbacks[ id ] = callback;\n\t\t\t\t\t}\n\t\t\t\t},\n\n\t\t\t\tabort: function() {\n\t\t\t\t\tif ( callback ) {\n\t\t\t\t\t\tcallback( undefined, true );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t};\n\t\t}\n\t} );\n}\n\n// Functions to create xhrs\nfunction createStandardXHR() {\n\ttry {\n\t\treturn new window.XMLHttpRequest();\n\t} catch ( e ) {}\n}\n\nfunction createActiveXHR() {\n\ttry {\n\t\treturn new window.ActiveXObject( \"Microsoft.XMLHTTP\" );\n\t} catch ( e ) {}\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 global\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\ts.global = false;\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\n\t\tvar script,\n\t\t\thead = document.head || jQuery( \"head\" )[ 0 ] || document.documentElement;\n\n\t\treturn {\n\n\t\t\tsend: function( _, callback ) {\n\n\t\t\t\tscript = document.createElement( \"script\" );\n\n\t\t\t\tscript.async = true;\n\n\t\t\t\tif ( s.scriptCharset ) {\n\t\t\t\t\tscript.charset = s.scriptCharset;\n\t\t\t\t}\n\n\t\t\t\tscript.src = s.url;\n\n\t\t\t\t// Attach handlers for all browsers\n\t\t\t\tscript.onload = script.onreadystatechange = function( _, isAbort ) {\n\n\t\t\t\t\tif ( isAbort || !script.readyState || /loaded|complete/.test( script.readyState ) ) {\n\n\t\t\t\t\t\t// Handle memory leak in IE\n\t\t\t\t\t\tscript.onload = script.onreadystatechange = null;\n\n\t\t\t\t\t\t// Remove the script\n\t\t\t\t\t\tif ( script.parentNode ) {\n\t\t\t\t\t\t\tscript.parentNode.removeChild( script );\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Dereference the script\n\t\t\t\t\t\tscript = null;\n\n\t\t\t\t\t\t// Callback if not abort\n\t\t\t\t\t\tif ( !isAbort ) {\n\t\t\t\t\t\t\tcallback( 200, \"success\" );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t};\n\n\t\t\t\t// Circumvent IE6 bugs with base elements (#2709 and #4378) by prepending\n\t\t\t\t// Use native DOM manipulation to avoid our domManip AJAX trickery\n\t\t\t\thead.insertBefore( script, head.firstChild );\n\t\t\t},\n\n\t\t\tabort: function() {\n\t\t\t\tif ( script ) {\n\t\t\t\t\tscript.onload( undefined, true );\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// data: 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, url.length ) );\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/**\n * Gets a window from an element\n */\nfunction getWindow( elem ) {\n\treturn jQuery.isWindow( elem ) ?\n\t\telem :\n\t\telem.nodeType === 9 ?\n\t\t\telem.defaultView || elem.parentWindow :\n\t\t\tfalse;\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\tjQuery.inArray( \"auto\", [ curCSSTop, curCSSLeft ] ) > -1;\n\n\t\t// need to be able to calculate position if either top or left\n\t\t// 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\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\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\tbox = { top: 0, left: 0 },\n\t\t\telem = this[ 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\t// If we don't have gBCR, just use 0,0 rather than error\n\t\t// BlackBerry 5, iOS 3 (original iPhone)\n\t\tif ( typeof elem.getBoundingClientRect !== \"undefined\" ) {\n\t\t\tbox = elem.getBoundingClientRect();\n\t\t}\n\t\twin = getWindow( doc );\n\t\treturn {\n\t\t\ttop: box.top  + ( win.pageYOffset || docElem.scrollTop )  - ( docElem.clientTop  || 0 ),\n\t\t\tleft: box.left + ( win.pageXOffset || docElem.scrollLeft ) - ( docElem.clientLeft || 0 )\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\tparentOffset = { top: 0, left: 0 },\n\t\t\telem = this[ 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// we assume that getBoundingClientRect is available when computed position is fixed\n\t\t\toffset = elem.getBoundingClientRect();\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\t// note: when an element has margin: auto the offsetLeft and marginLeft\n\t\t// are the same in Safari causing offset.left to incorrectly be 0\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\toffsetParent: function() {\n\t\treturn this.map( function() {\n\t\t\tvar offsetParent = this.offsetParent;\n\n\t\t\twhile ( offsetParent && ( !jQuery.nodeName( offsetParent, \"html\" ) &&\n\t\t\t\tjQuery.css( offsetParent, \"position\" ) === \"static\" ) ) {\n\t\t\t\toffsetParent = offsetParent.offsetParent;\n\t\t\t}\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 = /Y/.test( 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 ? ( prop in win ) ? win[ prop ] :\n\t\t\t\t\twin.document.documentElement[ method ] :\n\t\t\t\t\telem[ 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 : jQuery( win ).scrollLeft(),\n\t\t\t\t\ttop ? val : jQuery( win ).scrollTop()\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, null );\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// getComputedStyle returns percent when specified for top/left/bottom/right\n// rather than make the css module depend on the offset module, we 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\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\t// unfortunately, this causes bug #3838 in IE6/8 only,\n\t\t\t\t\t// but there is currently no good, small way to fix it.\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} );\n\n// The number of elements contained in the matched element set\njQuery.fn.size = function() {\n\treturn this.length;\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 ( true ) {\n\t!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = function() {\n\t\treturn jQuery;\n\t}.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\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\n// AMD (#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\n/***/ }),\n/* 1 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _jquery = __webpack_require__(0);\n\nvar _jquery2 = _interopRequireDefault(_jquery);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar breakpoint = 1024;\n\nfunction Viewport() {\n  this.change = _jquery2.default.proxy(this.change, this);\n  this.mobileState = this.getCurrentState();\n  this.ticking = false;\n  this.addListeners();\n}\n\nViewport.prototype = {\n  setCurrentState: function setCurrentState(state) {\n    this.mobileState = state;\n  },\n  getCurrentState: function getCurrentState() {\n    return window.innerWidth < breakpoint;\n  },\n  update: function update() {\n    this.ticking = false;\n    var currentState = this.getCurrentState();\n    var previousState = this.mobileState;\n\n    // Announce screen has changed\n    if (this.changeCallbacks) {\n      this.changeCallbacks.fire();\n    }\n\n    // Check to see if the view state has changed\n    if (currentState !== previousState) {\n      this.setCurrentState(currentState);\n\n      // Announce screen has changed to mobile mode\n      if (this.mobileCallbacks && this.mobileState) {\n        this.mobileCallbacks.fire();\n      }\n\n      // Announce screen has changed to desktop mode\n      if (this.desktopCallbacks && !this.mobileState) {\n        this.desktopCallbacks.fire();\n      }\n    }\n  },\n  change: function change() {\n    this.requestTick();\n  },\n  requestTick: function requestTick() {\n    if (!this.ticking) {\n      requestAnimationFrame(this.update.bind(this));\n      this.ticking = true;\n    }\n  },\n  onMobileChange: function onMobileChange(callback) {\n    if (!this.mobileCallbacks) {\n      this.mobileCallbacks = _jquery2.default.Callbacks('memory');\n    }\n    this.mobileCallbacks.add(callback);\n    return this;\n  },\n  onDesktopChange: function onDesktopChange(callback) {\n    if (!this.desktopCallbacks) {\n      this.desktopCallbacks = _jquery2.default.Callbacks('memory');\n    }\n    this.desktopCallbacks.add(callback);\n    return this;\n  },\n  onChange: function onChange(callback) {\n    if (!this.changeCallbacks) {\n      this.changeCallbacks = _jquery2.default.Callbacks('memory');\n    }\n    this.changeCallbacks.add(callback);\n    return this;\n  },\n  addListeners: function addListeners() {\n    (0, _jquery2.default)(window).on('resize orientationchange', this.change);\n  }\n};\n\nexports.default = new Viewport();\n\n/***/ }),\n/* 2 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _jquery = __webpack_require__(0);\n\nvar _jquery2 = _interopRequireDefault(_jquery);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction Change() {\n  this.change = _jquery2.default.proxy(this.change, this);\n  this.ticking = false;\n  this.listen();\n}\n\nChange.prototype = {\n  update: function update() {\n    this.ticking = false;\n    if (this.callbacks) {\n      this.callbacks.fire();\n    }\n  },\n  change: function change() {\n    this.request();\n  },\n  request: function request() {\n    if (!this.ticking) {\n      requestAnimationFrame(this.update.bind(this));\n      this.ticking = true;\n    }\n  },\n  onChange: function onChange(callback) {\n    if (!this.callbacks) {\n      this.callbacks = _jquery2.default.Callbacks('memory');\n    }\n    this.callbacks.add(callback);\n    return this;\n  },\n  listen: function listen() {\n    (0, _jquery2.default)(window).on('scroll resize orientationchange', this.change);\n  }\n};\n\nexports.default = new Change();\n\n/***/ }),\n/* 3 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/*** IMPORTS FROM imports-loader ***/\nvar jQuery = __webpack_require__(0);\nvar $ = __webpack_require__(0);\n(function() {\n\n/*\n * jQuery doTimeout: Like setTimeout, but better! - v1.0 - 3/3/2010\n * http://benalman.com/projects/jquery-dotimeout-plugin/\n * \n * Copyright (c) 2010 \"Cowboy\" Ben Alman\n * Dual licensed under the MIT and GPL licenses.\n * http://benalman.com/about/license/\n */\n(function($){var a={},c=\"doTimeout\",d=Array.prototype.slice;$[c]=function(){return b.apply(window,[0].concat(d.call(arguments)))};$.fn[c]=function(){var f=d.call(arguments),e=b.apply(this,[c+f[0]].concat(f));return typeof f[0]===\"number\"||typeof f[1]===\"number\"?this:e};function b(l){var m=this,h,k={},g=l?$.fn:$,n=arguments,i=4,f=n[1],j=n[2],p=n[3];if(typeof f!==\"string\"){i--;f=l=0;j=n[1];p=n[2]}if(l){h=m.eq(0);h.data(l,k=h.data(l)||{})}else{if(f){k=a[f]||(a[f]={})}}k.id&&clearTimeout(k.id);delete k.id;function e(){if(l){h.removeData(l)}else{if(f){delete a[f]}}}function o(){k.id=setTimeout(function(){k.fn()},j)}if(p){k.fn=function(q){if(typeof p===\"string\"){p=g[p]}p.apply(m,d.call(n,i))===true&&!q?o():e()};o()}else{if(k.fn){j===undefined?e():k.fn(j===false);return true}else{e()}}}})(jQuery);\n\n}.call(window));\n\n/***/ }),\n/* 4 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*\n     _ _      _       _\n ___| (_) ___| | __  (_)___\n/ __| | |/ __| |/ /  | / __|\n\\__ \\ | | (__|   < _ | \\__ \\\n|___/_|_|\\___|_|\\_(_)/ |___/\n                   |__/\n\n Version: 1.6.0\n  Author: Ken Wheeler\n Website: http://kenwheeler.github.io\n    Docs: http://kenwheeler.github.io/slick\n    Repo: http://github.com/kenwheeler/slick\n  Issues: http://github.com/kenwheeler/slick/issues\n\n */\n/* global window, document, define, jQuery, setInterval, clearInterval */\n(function(factory) {\n    'use strict';\n    if (true) {\n        !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(0)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?\n\t\t\t\t(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n    } else if (typeof exports !== 'undefined') {\n        module.exports = factory(require('jquery'));\n    } else {\n        factory(jQuery);\n    }\n\n}(function($) {\n    'use strict';\n    var Slick = window.Slick || {};\n\n    Slick = (function() {\n\n        var instanceUid = 0;\n\n        function Slick(element, settings) {\n\n            var _ = this, dataSettings;\n\n            _.defaults = {\n                accessibility: true,\n                adaptiveHeight: false,\n                appendArrows: $(element),\n                appendDots: $(element),\n                arrows: true,\n                asNavFor: null,\n                prevArrow: '<button type=\"button\" data-role=\"none\" class=\"slick-prev\" aria-label=\"Previous\" tabindex=\"0\" role=\"button\">Previous</button>',\n                nextArrow: '<button type=\"button\" data-role=\"none\" class=\"slick-next\" aria-label=\"Next\" tabindex=\"0\" role=\"button\">Next</button>',\n                autoplay: false,\n                autoplaySpeed: 3000,\n                centerMode: false,\n                centerPadding: '50px',\n                cssEase: 'ease',\n                customPaging: function(slider, i) {\n                    return $('<button type=\"button\" data-role=\"none\" role=\"button\" tabindex=\"0\" />').text(i + 1);\n                },\n                dots: false,\n                dotsClass: 'slick-dots',\n                draggable: true,\n                easing: 'linear',\n                edgeFriction: 0.35,\n                fade: false,\n                focusOnSelect: false,\n                infinite: true,\n                initialSlide: 0,\n                lazyLoad: 'ondemand',\n                mobileFirst: false,\n                pauseOnHover: true,\n                pauseOnFocus: true,\n                pauseOnDotsHover: false,\n                respondTo: 'window',\n                responsive: null,\n                rows: 1,\n                rtl: false,\n                slide: '',\n                slidesPerRow: 1,\n                slidesToShow: 1,\n                slidesToScroll: 1,\n                speed: 500,\n                swipe: true,\n                swipeToSlide: false,\n                touchMove: true,\n                touchThreshold: 5,\n                useCSS: true,\n                useTransform: true,\n                variableWidth: false,\n                vertical: false,\n                verticalSwiping: false,\n                waitForAnimate: true,\n                zIndex: 1000\n            };\n\n            _.initials = {\n                animating: false,\n                dragging: false,\n                autoPlayTimer: null,\n                currentDirection: 0,\n                currentLeft: null,\n                currentSlide: 0,\n                direction: 1,\n                $dots: null,\n                listWidth: null,\n                listHeight: null,\n                loadIndex: 0,\n                $nextArrow: null,\n                $prevArrow: null,\n                slideCount: null,\n                slideWidth: null,\n                $slideTrack: null,\n                $slides: null,\n                sliding: false,\n                slideOffset: 0,\n                swipeLeft: null,\n                $list: null,\n                touchObject: {},\n                transformsEnabled: false,\n                unslicked: false\n            };\n\n            $.extend(_, _.initials);\n\n            _.activeBreakpoint = null;\n            _.animType = null;\n            _.animProp = null;\n            _.breakpoints = [];\n            _.breakpointSettings = [];\n            _.cssTransitions = false;\n            _.focussed = false;\n            _.interrupted = false;\n            _.hidden = 'hidden';\n            _.paused = true;\n            _.positionProp = null;\n            _.respondTo = null;\n            _.rowCount = 1;\n            _.shouldClick = true;\n            _.$slider = $(element);\n            _.$slidesCache = null;\n            _.transformType = null;\n            _.transitionType = null;\n            _.visibilityChange = 'visibilitychange';\n            _.windowWidth = 0;\n            _.windowTimer = null;\n\n            dataSettings = $(element).data('slick') || {};\n\n            _.options = $.extend({}, _.defaults, settings, dataSettings);\n\n            _.currentSlide = _.options.initialSlide;\n\n            _.originalSettings = _.options;\n\n            if (typeof document.mozHidden !== 'undefined') {\n                _.hidden = 'mozHidden';\n                _.visibilityChange = 'mozvisibilitychange';\n            } else if (typeof document.webkitHidden !== 'undefined') {\n                _.hidden = 'webkitHidden';\n                _.visibilityChange = 'webkitvisibilitychange';\n            }\n\n            _.autoPlay = $.proxy(_.autoPlay, _);\n            _.autoPlayClear = $.proxy(_.autoPlayClear, _);\n            _.autoPlayIterator = $.proxy(_.autoPlayIterator, _);\n            _.changeSlide = $.proxy(_.changeSlide, _);\n            _.clickHandler = $.proxy(_.clickHandler, _);\n            _.selectHandler = $.proxy(_.selectHandler, _);\n            _.setPosition = $.proxy(_.setPosition, _);\n            _.swipeHandler = $.proxy(_.swipeHandler, _);\n            _.dragHandler = $.proxy(_.dragHandler, _);\n            _.keyHandler = $.proxy(_.keyHandler, _);\n\n            _.instanceUid = instanceUid++;\n\n            // A simple way to check for HTML strings\n            // Strict HTML recognition (must start with <)\n            // Extracted from jQuery v1.11 source\n            _.htmlExpr = /^(?:\\s*(<[\\w\\W]+>)[^>]*)$/;\n\n\n            _.registerBreakpoints();\n            _.init(true);\n\n        }\n\n        return Slick;\n\n    }());\n\n    Slick.prototype.activateADA = function() {\n        var _ = this;\n\n        _.$slideTrack.find('.slick-active').attr({\n            'aria-hidden': 'false'\n        }).find('a, input, button, select').attr({\n            'tabindex': '0'\n        });\n\n    };\n\n    Slick.prototype.addSlide = Slick.prototype.slickAdd = function(markup, index, addBefore) {\n\n        var _ = this;\n\n        if (typeof(index) === 'boolean') {\n            addBefore = index;\n            index = null;\n        } else if (index < 0 || (index >= _.slideCount)) {\n            return false;\n        }\n\n        _.unload();\n\n        if (typeof(index) === 'number') {\n            if (index === 0 && _.$slides.length === 0) {\n                $(markup).appendTo(_.$slideTrack);\n            } else if (addBefore) {\n                $(markup).insertBefore(_.$slides.eq(index));\n            } else {\n                $(markup).insertAfter(_.$slides.eq(index));\n            }\n        } else {\n            if (addBefore === true) {\n                $(markup).prependTo(_.$slideTrack);\n            } else {\n                $(markup).appendTo(_.$slideTrack);\n            }\n        }\n\n        _.$slides = _.$slideTrack.children(this.options.slide);\n\n        _.$slideTrack.children(this.options.slide).detach();\n\n        _.$slideTrack.append(_.$slides);\n\n        _.$slides.each(function(index, element) {\n            $(element).attr('data-slick-index', index);\n        });\n\n        _.$slidesCache = _.$slides;\n\n        _.reinit();\n\n    };\n\n    Slick.prototype.animateHeight = function() {\n        var _ = this;\n        if (_.options.slidesToShow === 1 && _.options.adaptiveHeight === true && _.options.vertical === false) {\n            var targetHeight = _.$slides.eq(_.currentSlide).outerHeight(true);\n            _.$list.animate({\n                height: targetHeight\n            }, _.options.speed);\n        }\n    };\n\n    Slick.prototype.animateSlide = function(targetLeft, callback) {\n\n        var animProps = {},\n            _ = this;\n\n        _.animateHeight();\n\n        if (_.options.rtl === true && _.options.vertical === false) {\n            targetLeft = -targetLeft;\n        }\n        if (_.transformsEnabled === false) {\n            if (_.options.vertical === false) {\n                _.$slideTrack.animate({\n                    left: targetLeft\n                }, _.options.speed, _.options.easing, callback);\n            } else {\n                _.$slideTrack.animate({\n                    top: targetLeft\n                }, _.options.speed, _.options.easing, callback);\n            }\n\n        } else {\n\n            if (_.cssTransitions === false) {\n                if (_.options.rtl === true) {\n                    _.currentLeft = -(_.currentLeft);\n                }\n                $({\n                    animStart: _.currentLeft\n                }).animate({\n                    animStart: targetLeft\n                }, {\n                    duration: _.options.speed,\n                    easing: _.options.easing,\n                    step: function(now) {\n                        now = Math.ceil(now);\n                        if (_.options.vertical === false) {\n                            animProps[_.animType] = 'translate(' +\n                                now + 'px, 0px)';\n                            _.$slideTrack.css(animProps);\n                        } else {\n                            animProps[_.animType] = 'translate(0px,' +\n                                now + 'px)';\n                            _.$slideTrack.css(animProps);\n                        }\n                    },\n                    complete: function() {\n                        if (callback) {\n                            callback.call();\n                        }\n                    }\n                });\n\n            } else {\n\n                _.applyTransition();\n                targetLeft = Math.ceil(targetLeft);\n\n                if (_.options.vertical === false) {\n                    animProps[_.animType] = 'translate3d(' + targetLeft + 'px, 0px, 0px)';\n                } else {\n                    animProps[_.animType] = 'translate3d(0px,' + targetLeft + 'px, 0px)';\n                }\n                _.$slideTrack.css(animProps);\n\n                if (callback) {\n                    setTimeout(function() {\n\n                        _.disableTransition();\n\n                        callback.call();\n                    }, _.options.speed);\n                }\n\n            }\n\n        }\n\n    };\n\n    Slick.prototype.getNavTarget = function() {\n\n        var _ = this,\n            asNavFor = _.options.asNavFor;\n\n        if ( asNavFor && asNavFor !== null ) {\n            asNavFor = $(asNavFor).not(_.$slider);\n        }\n\n        return asNavFor;\n\n    };\n\n    Slick.prototype.asNavFor = function(index) {\n\n        var _ = this,\n            asNavFor = _.getNavTarget();\n\n        if ( asNavFor !== null && typeof asNavFor === 'object' ) {\n            asNavFor.each(function() {\n                var target = $(this).slick('getSlick');\n                if(!target.unslicked) {\n                    target.slideHandler(index, true);\n                }\n            });\n        }\n\n    };\n\n    Slick.prototype.applyTransition = function(slide) {\n\n        var _ = this,\n            transition = {};\n\n        if (_.options.fade === false) {\n            transition[_.transitionType] = _.transformType + ' ' + _.options.speed + 'ms ' + _.options.cssEase;\n        } else {\n            transition[_.transitionType] = 'opacity ' + _.options.speed + 'ms ' + _.options.cssEase;\n        }\n\n        if (_.options.fade === false) {\n            _.$slideTrack.css(transition);\n        } else {\n            _.$slides.eq(slide).css(transition);\n        }\n\n    };\n\n    Slick.prototype.autoPlay = function() {\n\n        var _ = this;\n\n        _.autoPlayClear();\n\n        if ( _.slideCount > _.options.slidesToShow ) {\n            _.autoPlayTimer = setInterval( _.autoPlayIterator, _.options.autoplaySpeed );\n        }\n\n    };\n\n    Slick.prototype.autoPlayClear = function() {\n\n        var _ = this;\n\n        if (_.autoPlayTimer) {\n            clearInterval(_.autoPlayTimer);\n        }\n\n    };\n\n    Slick.prototype.autoPlayIterator = function() {\n\n        var _ = this,\n            slideTo = _.currentSlide + _.options.slidesToScroll;\n\n        if ( !_.paused && !_.interrupted && !_.focussed ) {\n\n            if ( _.options.infinite === false ) {\n\n                if ( _.direction === 1 && ( _.currentSlide + 1 ) === ( _.slideCount - 1 )) {\n                    _.direction = 0;\n                }\n\n                else if ( _.direction === 0 ) {\n\n                    slideTo = _.currentSlide - _.options.slidesToScroll;\n\n                    if ( _.currentSlide - 1 === 0 ) {\n                        _.direction = 1;\n                    }\n\n                }\n\n            }\n\n            _.slideHandler( slideTo );\n\n        }\n\n    };\n\n    Slick.prototype.buildArrows = function() {\n\n        var _ = this;\n\n        if (_.options.arrows === true ) {\n\n            _.$prevArrow = $(_.options.prevArrow).addClass('slick-arrow');\n            _.$nextArrow = $(_.options.nextArrow).addClass('slick-arrow');\n\n            if( _.slideCount > _.options.slidesToShow ) {\n\n                _.$prevArrow.removeClass('slick-hidden').removeAttr('aria-hidden tabindex');\n                _.$nextArrow.removeClass('slick-hidden').removeAttr('aria-hidden tabindex');\n\n                if (_.htmlExpr.test(_.options.prevArrow)) {\n                    _.$prevArrow.prependTo(_.options.appendArrows);\n                }\n\n                if (_.htmlExpr.test(_.options.nextArrow)) {\n                    _.$nextArrow.appendTo(_.options.appendArrows);\n                }\n\n                if (_.options.infinite !== true) {\n                    _.$prevArrow\n                        .addClass('slick-disabled')\n                        .attr('aria-disabled', 'true');\n                }\n\n            } else {\n\n                _.$prevArrow.add( _.$nextArrow )\n\n                    .addClass('slick-hidden')\n                    .attr({\n                        'aria-disabled': 'true',\n                        'tabindex': '-1'\n                    });\n\n            }\n\n        }\n\n    };\n\n    Slick.prototype.buildDots = function() {\n\n        var _ = this,\n            i, dot;\n\n        if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {\n\n            _.$slider.addClass('slick-dotted');\n\n            dot = $('<ul />').addClass(_.options.dotsClass);\n\n            for (i = 0; i <= _.getDotCount(); i += 1) {\n                dot.append($('<li />').append(_.options.customPaging.call(this, _, i)));\n            }\n\n            _.$dots = dot.appendTo(_.options.appendDots);\n\n            _.$dots.find('li').first().addClass('slick-active').attr('aria-hidden', 'false');\n\n        }\n\n    };\n\n    Slick.prototype.buildOut = function() {\n\n        var _ = this;\n\n        _.$slides =\n            _.$slider\n                .children( _.options.slide + ':not(.slick-cloned)')\n                .addClass('slick-slide');\n\n        _.slideCount = _.$slides.length;\n\n        _.$slides.each(function(index, element) {\n            $(element)\n                .attr('data-slick-index', index)\n                .data('originalStyling', $(element).attr('style') || '');\n        });\n\n        _.$slider.addClass('slick-slider');\n\n        _.$slideTrack = (_.slideCount === 0) ?\n            $('<div class=\"slick-track\"/>').appendTo(_.$slider) :\n            _.$slides.wrapAll('<div class=\"slick-track\"/>').parent();\n\n        _.$list = _.$slideTrack.wrap(\n            '<div aria-live=\"polite\" class=\"slick-list\"/>').parent();\n        _.$slideTrack.css('opacity', 0);\n\n        if (_.options.centerMode === true || _.options.swipeToSlide === true) {\n            _.options.slidesToScroll = 1;\n        }\n\n        $('img[data-lazy]', _.$slider).not('[src]').addClass('slick-loading');\n\n        _.setupInfinite();\n\n        _.buildArrows();\n\n        _.buildDots();\n\n        _.updateDots();\n\n\n        _.setSlideClasses(typeof _.currentSlide === 'number' ? _.currentSlide : 0);\n\n        if (_.options.draggable === true) {\n            _.$list.addClass('draggable');\n        }\n\n    };\n\n    Slick.prototype.buildRows = function() {\n\n        var _ = this, a, b, c, newSlides, numOfSlides, originalSlides,slidesPerSection;\n\n        newSlides = document.createDocumentFragment();\n        originalSlides = _.$slider.children();\n\n        if(_.options.rows > 1) {\n\n            slidesPerSection = _.options.slidesPerRow * _.options.rows;\n            numOfSlides = Math.ceil(\n                originalSlides.length / slidesPerSection\n            );\n\n            for(a = 0; a < numOfSlides; a++){\n                var slide = document.createElement('div');\n                for(b = 0; b < _.options.rows; b++) {\n                    var row = document.createElement('div');\n                    for(c = 0; c < _.options.slidesPerRow; c++) {\n                        var target = (a * slidesPerSection + ((b * _.options.slidesPerRow) + c));\n                        if (originalSlides.get(target)) {\n                            row.appendChild(originalSlides.get(target));\n                        }\n                    }\n                    slide.appendChild(row);\n                }\n                newSlides.appendChild(slide);\n            }\n\n            _.$slider.empty().append(newSlides);\n            _.$slider.children().children().children()\n                .css({\n                    'width':(100 / _.options.slidesPerRow) + '%',\n                    'display': 'inline-block'\n                });\n\n        }\n\n    };\n\n    Slick.prototype.checkResponsive = function(initial, forceUpdate) {\n\n        var _ = this,\n            breakpoint, targetBreakpoint, respondToWidth, triggerBreakpoint = false;\n        var sliderWidth = _.$slider.width();\n        var windowWidth = window.innerWidth || $(window).width();\n\n        if (_.respondTo === 'window') {\n            respondToWidth = windowWidth;\n        } else if (_.respondTo === 'slider') {\n            respondToWidth = sliderWidth;\n        } else if (_.respondTo === 'min') {\n            respondToWidth = Math.min(windowWidth, sliderWidth);\n        }\n\n        if ( _.options.responsive &&\n            _.options.responsive.length &&\n            _.options.responsive !== null) {\n\n            targetBreakpoint = null;\n\n            for (breakpoint in _.breakpoints) {\n                if (_.breakpoints.hasOwnProperty(breakpoint)) {\n                    if (_.originalSettings.mobileFirst === false) {\n                        if (respondToWidth < _.breakpoints[breakpoint]) {\n                            targetBreakpoint = _.breakpoints[breakpoint];\n                        }\n                    } else {\n                        if (respondToWidth > _.breakpoints[breakpoint]) {\n                            targetBreakpoint = _.breakpoints[breakpoint];\n                        }\n                    }\n                }\n            }\n\n            if (targetBreakpoint !== null) {\n                if (_.activeBreakpoint !== null) {\n                    if (targetBreakpoint !== _.activeBreakpoint || forceUpdate) {\n                        _.activeBreakpoint =\n                            targetBreakpoint;\n                        if (_.breakpointSettings[targetBreakpoint] === 'unslick') {\n                            _.unslick(targetBreakpoint);\n                        } else {\n                            _.options = $.extend({}, _.originalSettings,\n                                _.breakpointSettings[\n                                    targetBreakpoint]);\n                            if (initial === true) {\n                                _.currentSlide = _.options.initialSlide;\n                            }\n                            _.refresh(initial);\n                        }\n                        triggerBreakpoint = targetBreakpoint;\n                    }\n                } else {\n                    _.activeBreakpoint = targetBreakpoint;\n                    if (_.breakpointSettings[targetBreakpoint] === 'unslick') {\n                        _.unslick(targetBreakpoint);\n                    } else {\n                        _.options = $.extend({}, _.originalSettings,\n                            _.breakpointSettings[\n                                targetBreakpoint]);\n                        if (initial === true) {\n                            _.currentSlide = _.options.initialSlide;\n                        }\n                        _.refresh(initial);\n                    }\n                    triggerBreakpoint = targetBreakpoint;\n                }\n            } else {\n                if (_.activeBreakpoint !== null) {\n                    _.activeBreakpoint = null;\n                    _.options = _.originalSettings;\n                    if (initial === true) {\n                        _.currentSlide = _.options.initialSlide;\n                    }\n                    _.refresh(initial);\n                    triggerBreakpoint = targetBreakpoint;\n                }\n            }\n\n            // only trigger breakpoints during an actual break. not on initialize.\n            if( !initial && triggerBreakpoint !== false ) {\n                _.$slider.trigger('breakpoint', [_, triggerBreakpoint]);\n            }\n        }\n\n    };\n\n    Slick.prototype.changeSlide = function(event, dontAnimate) {\n\n        var _ = this,\n            $target = $(event.currentTarget),\n            indexOffset, slideOffset, unevenOffset;\n\n        // If target is a link, prevent default action.\n        if($target.is('a')) {\n            event.preventDefault();\n        }\n\n        // If target is not the <li> element (ie: a child), find the <li>.\n        if(!$target.is('li')) {\n            $target = $target.closest('li');\n        }\n\n        unevenOffset = (_.slideCount % _.options.slidesToScroll !== 0);\n        indexOffset = unevenOffset ? 0 : (_.slideCount - _.currentSlide) % _.options.slidesToScroll;\n\n        switch (event.data.message) {\n\n            case 'previous':\n                slideOffset = indexOffset === 0 ? _.options.slidesToScroll : _.options.slidesToShow - indexOffset;\n                if (_.slideCount > _.options.slidesToShow) {\n                    _.slideHandler(_.currentSlide - slideOffset, false, dontAnimate);\n                }\n                break;\n\n            case 'next':\n                slideOffset = indexOffset === 0 ? _.options.slidesToScroll : indexOffset;\n                if (_.slideCount > _.options.slidesToShow) {\n                    _.slideHandler(_.currentSlide + slideOffset, false, dontAnimate);\n                }\n                break;\n\n            case 'index':\n                var index = event.data.index === 0 ? 0 :\n                    event.data.index || $target.index() * _.options.slidesToScroll;\n\n                _.slideHandler(_.checkNavigable(index), false, dontAnimate);\n                $target.children().trigger('focus');\n                break;\n\n            default:\n                return;\n        }\n\n    };\n\n    Slick.prototype.checkNavigable = function(index) {\n\n        var _ = this,\n            navigables, prevNavigable;\n\n        navigables = _.getNavigableIndexes();\n        prevNavigable = 0;\n        if (index > navigables[navigables.length - 1]) {\n            index = navigables[navigables.length - 1];\n        } else {\n            for (var n in navigables) {\n                if (index < navigables[n]) {\n                    index = prevNavigable;\n                    break;\n                }\n                prevNavigable = navigables[n];\n            }\n        }\n\n        return index;\n    };\n\n    Slick.prototype.cleanUpEvents = function() {\n\n        var _ = this;\n\n        if (_.options.dots && _.$dots !== null) {\n\n            $('li', _.$dots)\n                .off('click.slick', _.changeSlide)\n                .off('mouseenter.slick', $.proxy(_.interrupt, _, true))\n                .off('mouseleave.slick', $.proxy(_.interrupt, _, false));\n\n        }\n\n        _.$slider.off('focus.slick blur.slick');\n\n        if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {\n            _.$prevArrow && _.$prevArrow.off('click.slick', _.changeSlide);\n            _.$nextArrow && _.$nextArrow.off('click.slick', _.changeSlide);\n        }\n\n        _.$list.off('touchstart.slick mousedown.slick', _.swipeHandler);\n        _.$list.off('touchmove.slick mousemove.slick', _.swipeHandler);\n        _.$list.off('touchend.slick mouseup.slick', _.swipeHandler);\n        _.$list.off('touchcancel.slick mouseleave.slick', _.swipeHandler);\n\n        _.$list.off('click.slick', _.clickHandler);\n\n        $(document).off(_.visibilityChange, _.visibility);\n\n        _.cleanUpSlideEvents();\n\n        if (_.options.accessibility === true) {\n            _.$list.off('keydown.slick', _.keyHandler);\n        }\n\n        if (_.options.focusOnSelect === true) {\n            $(_.$slideTrack).children().off('click.slick', _.selectHandler);\n        }\n\n        $(window).off('orientationchange.slick.slick-' + _.instanceUid, _.orientationChange);\n\n        $(window).off('resize.slick.slick-' + _.instanceUid, _.resize);\n\n        $('[draggable!=true]', _.$slideTrack).off('dragstart', _.preventDefault);\n\n        $(window).off('load.slick.slick-' + _.instanceUid, _.setPosition);\n        $(document).off('ready.slick.slick-' + _.instanceUid, _.setPosition);\n\n    };\n\n    Slick.prototype.cleanUpSlideEvents = function() {\n\n        var _ = this;\n\n        _.$list.off('mouseenter.slick', $.proxy(_.interrupt, _, true));\n        _.$list.off('mouseleave.slick', $.proxy(_.interrupt, _, false));\n\n    };\n\n    Slick.prototype.cleanUpRows = function() {\n\n        var _ = this, originalSlides;\n\n        if(_.options.rows > 1) {\n            originalSlides = _.$slides.children().children();\n            originalSlides.removeAttr('style');\n            _.$slider.empty().append(originalSlides);\n        }\n\n    };\n\n    Slick.prototype.clickHandler = function(event) {\n\n        var _ = this;\n\n        if (_.shouldClick === false) {\n            event.stopImmediatePropagation();\n            event.stopPropagation();\n            event.preventDefault();\n        }\n\n    };\n\n    Slick.prototype.destroy = function(refresh) {\n\n        var _ = this;\n\n        _.autoPlayClear();\n\n        _.touchObject = {};\n\n        _.cleanUpEvents();\n\n        $('.slick-cloned', _.$slider).detach();\n\n        if (_.$dots) {\n            _.$dots.remove();\n        }\n\n\n        if ( _.$prevArrow && _.$prevArrow.length ) {\n\n            _.$prevArrow\n                .removeClass('slick-disabled slick-arrow slick-hidden')\n                .removeAttr('aria-hidden aria-disabled tabindex')\n                .css('display','');\n\n            if ( _.htmlExpr.test( _.options.prevArrow )) {\n                _.$prevArrow.remove();\n            }\n        }\n\n        if ( _.$nextArrow && _.$nextArrow.length ) {\n\n            _.$nextArrow\n                .removeClass('slick-disabled slick-arrow slick-hidden')\n                .removeAttr('aria-hidden aria-disabled tabindex')\n                .css('display','');\n\n            if ( _.htmlExpr.test( _.options.nextArrow )) {\n                _.$nextArrow.remove();\n            }\n\n        }\n\n\n        if (_.$slides) {\n\n            _.$slides\n                .removeClass('slick-slide slick-active slick-center slick-visible slick-current')\n                .removeAttr('aria-hidden')\n                .removeAttr('data-slick-index')\n                .each(function(){\n                    $(this).attr('style', $(this).data('originalStyling'));\n                });\n\n            _.$slideTrack.children(this.options.slide).detach();\n\n            _.$slideTrack.detach();\n\n            _.$list.detach();\n\n            _.$slider.append(_.$slides);\n        }\n\n        _.cleanUpRows();\n\n        _.$slider.removeClass('slick-slider');\n        _.$slider.removeClass('slick-initialized');\n        _.$slider.removeClass('slick-dotted');\n\n        _.unslicked = true;\n\n        if(!refresh) {\n            _.$slider.trigger('destroy', [_]);\n        }\n\n    };\n\n    Slick.prototype.disableTransition = function(slide) {\n\n        var _ = this,\n            transition = {};\n\n        transition[_.transitionType] = '';\n\n        if (_.options.fade === false) {\n            _.$slideTrack.css(transition);\n        } else {\n            _.$slides.eq(slide).css(transition);\n        }\n\n    };\n\n    Slick.prototype.fadeSlide = function(slideIndex, callback) {\n\n        var _ = this;\n\n        if (_.cssTransitions === false) {\n\n            _.$slides.eq(slideIndex).css({\n                zIndex: _.options.zIndex\n            });\n\n            _.$slides.eq(slideIndex).animate({\n                opacity: 1\n            }, _.options.speed, _.options.easing, callback);\n\n        } else {\n\n            _.applyTransition(slideIndex);\n\n            _.$slides.eq(slideIndex).css({\n                opacity: 1,\n                zIndex: _.options.zIndex\n            });\n\n            if (callback) {\n                setTimeout(function() {\n\n                    _.disableTransition(slideIndex);\n\n                    callback.call();\n                }, _.options.speed);\n            }\n\n        }\n\n    };\n\n    Slick.prototype.fadeSlideOut = function(slideIndex) {\n\n        var _ = this;\n\n        if (_.cssTransitions === false) {\n\n            _.$slides.eq(slideIndex).animate({\n                opacity: 0,\n                zIndex: _.options.zIndex - 2\n            }, _.options.speed, _.options.easing);\n\n        } else {\n\n            _.applyTransition(slideIndex);\n\n            _.$slides.eq(slideIndex).css({\n                opacity: 0,\n                zIndex: _.options.zIndex - 2\n            });\n\n        }\n\n    };\n\n    Slick.prototype.filterSlides = Slick.prototype.slickFilter = function(filter) {\n\n        var _ = this;\n\n        if (filter !== null) {\n\n            _.$slidesCache = _.$slides;\n\n            _.unload();\n\n            _.$slideTrack.children(this.options.slide).detach();\n\n            _.$slidesCache.filter(filter).appendTo(_.$slideTrack);\n\n            _.reinit();\n\n        }\n\n    };\n\n    Slick.prototype.focusHandler = function() {\n\n        var _ = this;\n\n        _.$slider\n            .off('focus.slick blur.slick')\n            .on('focus.slick blur.slick',\n                '*:not(.slick-arrow)', function(event) {\n\n            event.stopImmediatePropagation();\n            var $sf = $(this);\n\n            setTimeout(function() {\n\n                if( _.options.pauseOnFocus ) {\n                    _.focussed = $sf.is(':focus');\n                    _.autoPlay();\n                }\n\n            }, 0);\n\n        });\n    };\n\n    Slick.prototype.getCurrent = Slick.prototype.slickCurrentSlide = function() {\n\n        var _ = this;\n        return _.currentSlide;\n\n    };\n\n    Slick.prototype.getDotCount = function() {\n\n        var _ = this;\n\n        var breakPoint = 0;\n        var counter = 0;\n        var pagerQty = 0;\n\n        if (_.options.infinite === true) {\n            while (breakPoint < _.slideCount) {\n                ++pagerQty;\n                breakPoint = counter + _.options.slidesToScroll;\n                counter += _.options.slidesToScroll <= _.options.slidesToShow ? _.options.slidesToScroll : _.options.slidesToShow;\n            }\n        } else if (_.options.centerMode === true) {\n            pagerQty = _.slideCount;\n        } else if(!_.options.asNavFor) {\n            pagerQty = 1 + Math.ceil((_.slideCount - _.options.slidesToShow) / _.options.slidesToScroll);\n        }else {\n            while (breakPoint < _.slideCount) {\n                ++pagerQty;\n                breakPoint = counter + _.options.slidesToScroll;\n                counter += _.options.slidesToScroll <= _.options.slidesToShow ? _.options.slidesToScroll : _.options.slidesToShow;\n            }\n        }\n\n        return pagerQty - 1;\n\n    };\n\n    Slick.prototype.getLeft = function(slideIndex) {\n\n        var _ = this,\n            targetLeft,\n            verticalHeight,\n            verticalOffset = 0,\n            targetSlide;\n\n        _.slideOffset = 0;\n        verticalHeight = _.$slides.first().outerHeight(true);\n\n        if (_.options.infinite === true) {\n            if (_.slideCount > _.options.slidesToShow) {\n                _.slideOffset = (_.slideWidth * _.options.slidesToShow) * -1;\n                verticalOffset = (verticalHeight * _.options.slidesToShow) * -1;\n            }\n            if (_.slideCount % _.options.slidesToScroll !== 0) {\n                if (slideIndex + _.options.slidesToScroll > _.slideCount && _.slideCount > _.options.slidesToShow) {\n                    if (slideIndex > _.slideCount) {\n                        _.slideOffset = ((_.options.slidesToShow - (slideIndex - _.slideCount)) * _.slideWidth) * -1;\n                        verticalOffset = ((_.options.slidesToShow - (slideIndex - _.slideCount)) * verticalHeight) * -1;\n                    } else {\n                        _.slideOffset = ((_.slideCount % _.options.slidesToScroll) * _.slideWidth) * -1;\n                        verticalOffset = ((_.slideCount % _.options.slidesToScroll) * verticalHeight) * -1;\n                    }\n                }\n            }\n        } else {\n            if (slideIndex + _.options.slidesToShow > _.slideCount) {\n                _.slideOffset = ((slideIndex + _.options.slidesToShow) - _.slideCount) * _.slideWidth;\n                verticalOffset = ((slideIndex + _.options.slidesToShow) - _.slideCount) * verticalHeight;\n            }\n        }\n\n        if (_.slideCount <= _.options.slidesToShow) {\n            _.slideOffset = 0;\n            verticalOffset = 0;\n        }\n\n        if (_.options.centerMode === true && _.options.infinite === true) {\n            _.slideOffset += _.slideWidth * Math.floor(_.options.slidesToShow / 2) - _.slideWidth;\n        } else if (_.options.centerMode === true) {\n            _.slideOffset = 0;\n            _.slideOffset += _.slideWidth * Math.floor(_.options.slidesToShow / 2);\n        }\n\n        if (_.options.vertical === false) {\n            targetLeft = ((slideIndex * _.slideWidth) * -1) + _.slideOffset;\n        } else {\n            targetLeft = ((slideIndex * verticalHeight) * -1) + verticalOffset;\n        }\n\n        if (_.options.variableWidth === true) {\n\n            if (_.slideCount <= _.options.slidesToShow || _.options.infinite === false) {\n                targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex);\n            } else {\n                targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex + _.options.slidesToShow);\n            }\n\n            if (_.options.rtl === true) {\n                if (targetSlide[0]) {\n                    targetLeft = (_.$slideTrack.width() - targetSlide[0].offsetLeft - targetSlide.width()) * -1;\n                } else {\n                    targetLeft =  0;\n                }\n            } else {\n                targetLeft = targetSlide[0] ? targetSlide[0].offsetLeft * -1 : 0;\n            }\n\n            if (_.options.centerMode === true) {\n                if (_.slideCount <= _.options.slidesToShow || _.options.infinite === false) {\n                    targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex);\n                } else {\n                    targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex + _.options.slidesToShow + 1);\n                }\n\n                if (_.options.rtl === true) {\n                    if (targetSlide[0]) {\n                        targetLeft = (_.$slideTrack.width() - targetSlide[0].offsetLeft - targetSlide.width()) * -1;\n                    } else {\n                        targetLeft =  0;\n                    }\n                } else {\n                    targetLeft = targetSlide[0] ? targetSlide[0].offsetLeft * -1 : 0;\n                }\n\n                targetLeft += (_.$list.width() - targetSlide.outerWidth()) / 2;\n            }\n        }\n\n        return targetLeft;\n\n    };\n\n    Slick.prototype.getOption = Slick.prototype.slickGetOption = function(option) {\n\n        var _ = this;\n\n        return _.options[option];\n\n    };\n\n    Slick.prototype.getNavigableIndexes = function() {\n\n        var _ = this,\n            breakPoint = 0,\n            counter = 0,\n            indexes = [],\n            max;\n\n        if (_.options.infinite === false) {\n            max = _.slideCount;\n        } else {\n            breakPoint = _.options.slidesToScroll * -1;\n            counter = _.options.slidesToScroll * -1;\n            max = _.slideCount * 2;\n        }\n\n        while (breakPoint < max) {\n            indexes.push(breakPoint);\n            breakPoint = counter + _.options.slidesToScroll;\n            counter += _.options.slidesToScroll <= _.options.slidesToShow ? _.options.slidesToScroll : _.options.slidesToShow;\n        }\n\n        return indexes;\n\n    };\n\n    Slick.prototype.getSlick = function() {\n\n        return this;\n\n    };\n\n    Slick.prototype.getSlideCount = function() {\n\n        var _ = this,\n            slidesTraversed, swipedSlide, centerOffset;\n\n        centerOffset = _.options.centerMode === true ? _.slideWidth * Math.floor(_.options.slidesToShow / 2) : 0;\n\n        if (_.options.swipeToSlide === true) {\n            _.$slideTrack.find('.slick-slide').each(function(index, slide) {\n                if (slide.offsetLeft - centerOffset + ($(slide).outerWidth() / 2) > (_.swipeLeft * -1)) {\n                    swipedSlide = slide;\n                    return false;\n                }\n            });\n\n            slidesTraversed = Math.abs($(swipedSlide).attr('data-slick-index') - _.currentSlide) || 1;\n\n            return slidesTraversed;\n\n        } else {\n            return _.options.slidesToScroll;\n        }\n\n    };\n\n    Slick.prototype.goTo = Slick.prototype.slickGoTo = function(slide, dontAnimate) {\n\n        var _ = this;\n\n        _.changeSlide({\n            data: {\n                message: 'index',\n                index: parseInt(slide)\n            }\n        }, dontAnimate);\n\n    };\n\n    Slick.prototype.init = function(creation) {\n\n        var _ = this;\n\n        if (!$(_.$slider).hasClass('slick-initialized')) {\n\n            $(_.$slider).addClass('slick-initialized');\n\n            _.buildRows();\n            _.buildOut();\n            _.setProps();\n            _.startLoad();\n            _.loadSlider();\n            _.initializeEvents();\n            _.updateArrows();\n            _.updateDots();\n            _.checkResponsive(true);\n            _.focusHandler();\n\n        }\n\n        if (creation) {\n            _.$slider.trigger('init', [_]);\n        }\n\n        if (_.options.accessibility === true) {\n            _.initADA();\n        }\n\n        if ( _.options.autoplay ) {\n\n            _.paused = false;\n            _.autoPlay();\n\n        }\n\n    };\n\n    Slick.prototype.initADA = function() {\n        var _ = this;\n        _.$slides.add(_.$slideTrack.find('.slick-cloned')).attr({\n            'aria-hidden': 'true',\n            'tabindex': '-1'\n        }).find('a, input, button, select').attr({\n            'tabindex': '-1'\n        });\n\n        _.$slideTrack.attr('role', 'listbox');\n\n        _.$slides.not(_.$slideTrack.find('.slick-cloned')).each(function(i) {\n            $(this).attr({\n                'role': 'option',\n                'aria-describedby': 'slick-slide' + _.instanceUid + i + ''\n            });\n        });\n\n        if (_.$dots !== null) {\n            _.$dots.attr('role', 'tablist').find('li').each(function(i) {\n                $(this).attr({\n                    'role': 'presentation',\n                    'aria-selected': 'false',\n                    'aria-controls': 'navigation' + _.instanceUid + i + '',\n                    'id': 'slick-slide' + _.instanceUid + i + ''\n                });\n            })\n                .first().attr('aria-selected', 'true').end()\n                .find('button').attr('role', 'button').end()\n                .closest('div').attr('role', 'toolbar');\n        }\n        _.activateADA();\n\n    };\n\n    Slick.prototype.initArrowEvents = function() {\n\n        var _ = this;\n\n        if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {\n            _.$prevArrow\n               .off('click.slick')\n               .on('click.slick', {\n                    message: 'previous'\n               }, _.changeSlide);\n            _.$nextArrow\n               .off('click.slick')\n               .on('click.slick', {\n                    message: 'next'\n               }, _.changeSlide);\n        }\n\n    };\n\n    Slick.prototype.initDotEvents = function() {\n\n        var _ = this;\n\n        if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {\n            $('li', _.$dots).on('click.slick', {\n                message: 'index'\n            }, _.changeSlide);\n        }\n\n        if ( _.options.dots === true && _.options.pauseOnDotsHover === true ) {\n\n            $('li', _.$dots)\n                .on('mouseenter.slick', $.proxy(_.interrupt, _, true))\n                .on('mouseleave.slick', $.proxy(_.interrupt, _, false));\n\n        }\n\n    };\n\n    Slick.prototype.initSlideEvents = function() {\n\n        var _ = this;\n\n        if ( _.options.pauseOnHover ) {\n\n            _.$list.on('mouseenter.slick', $.proxy(_.interrupt, _, true));\n            _.$list.on('mouseleave.slick', $.proxy(_.interrupt, _, false));\n\n        }\n\n    };\n\n    Slick.prototype.initializeEvents = function() {\n\n        var _ = this;\n\n        _.initArrowEvents();\n\n        _.initDotEvents();\n        _.initSlideEvents();\n\n        _.$list.on('touchstart.slick mousedown.slick', {\n            action: 'start'\n        }, _.swipeHandler);\n        _.$list.on('touchmove.slick mousemove.slick', {\n            action: 'move'\n        }, _.swipeHandler);\n        _.$list.on('touchend.slick mouseup.slick', {\n            action: 'end'\n        }, _.swipeHandler);\n        _.$list.on('touchcancel.slick mouseleave.slick', {\n            action: 'end'\n        }, _.swipeHandler);\n\n        _.$list.on('click.slick', _.clickHandler);\n\n        $(document).on(_.visibilityChange, $.proxy(_.visibility, _));\n\n        if (_.options.accessibility === true) {\n            _.$list.on('keydown.slick', _.keyHandler);\n        }\n\n        if (_.options.focusOnSelect === true) {\n            $(_.$slideTrack).children().on('click.slick', _.selectHandler);\n        }\n\n        $(window).on('orientationchange.slick.slick-' + _.instanceUid, $.proxy(_.orientationChange, _));\n\n        $(window).on('resize.slick.slick-' + _.instanceUid, $.proxy(_.resize, _));\n\n        $('[draggable!=true]', _.$slideTrack).on('dragstart', _.preventDefault);\n\n        $(window).on('load.slick.slick-' + _.instanceUid, _.setPosition);\n        $(document).on('ready.slick.slick-' + _.instanceUid, _.setPosition);\n\n    };\n\n    Slick.prototype.initUI = function() {\n\n        var _ = this;\n\n        if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {\n\n            _.$prevArrow.show();\n            _.$nextArrow.show();\n\n        }\n\n        if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {\n\n            _.$dots.show();\n\n        }\n\n    };\n\n    Slick.prototype.keyHandler = function(event) {\n\n        var _ = this;\n         //Dont slide if the cursor is inside the form fields and arrow keys are pressed\n        if(!event.target.tagName.match('TEXTAREA|INPUT|SELECT')) {\n            if (event.keyCode === 37 && _.options.accessibility === true) {\n                _.changeSlide({\n                    data: {\n                        message: _.options.rtl === true ? 'next' :  'previous'\n                    }\n                });\n            } else if (event.keyCode === 39 && _.options.accessibility === true) {\n                _.changeSlide({\n                    data: {\n                        message: _.options.rtl === true ? 'previous' : 'next'\n                    }\n                });\n            }\n        }\n\n    };\n\n    Slick.prototype.lazyLoad = function() {\n\n        var _ = this,\n            loadRange, cloneRange, rangeStart, rangeEnd;\n\n        function loadImages(imagesScope) {\n\n            $('img[data-lazy]', imagesScope).each(function() {\n\n                var image = $(this),\n                    imageSource = $(this).attr('data-lazy'),\n                    imageToLoad = document.createElement('img');\n\n                imageToLoad.onload = function() {\n\n                    image\n                        .animate({ opacity: 0 }, 100, function() {\n                            image\n                                .attr('src', imageSource)\n                                .animate({ opacity: 1 }, 200, function() {\n                                    image\n                                        .removeAttr('data-lazy')\n                                        .removeClass('slick-loading');\n                                });\n                            _.$slider.trigger('lazyLoaded', [_, image, imageSource]);\n                        });\n\n                };\n\n                imageToLoad.onerror = function() {\n\n                    image\n                        .removeAttr( 'data-lazy' )\n                        .removeClass( 'slick-loading' )\n                        .addClass( 'slick-lazyload-error' );\n\n                    _.$slider.trigger('lazyLoadError', [ _, image, imageSource ]);\n\n                };\n\n                imageToLoad.src = imageSource;\n\n            });\n\n        }\n\n        if (_.options.centerMode === true) {\n            if (_.options.infinite === true) {\n                rangeStart = _.currentSlide + (_.options.slidesToShow / 2 + 1);\n                rangeEnd = rangeStart + _.options.slidesToShow + 2;\n            } else {\n                rangeStart = Math.max(0, _.currentSlide - (_.options.slidesToShow / 2 + 1));\n                rangeEnd = 2 + (_.options.slidesToShow / 2 + 1) + _.currentSlide;\n            }\n        } else {\n            rangeStart = _.options.infinite ? _.options.slidesToShow + _.currentSlide : _.currentSlide;\n            rangeEnd = Math.ceil(rangeStart + _.options.slidesToShow);\n            if (_.options.fade === true) {\n                if (rangeStart > 0) rangeStart--;\n                if (rangeEnd <= _.slideCount) rangeEnd++;\n            }\n        }\n\n        loadRange = _.$slider.find('.slick-slide').slice(rangeStart, rangeEnd);\n        loadImages(loadRange);\n\n        if (_.slideCount <= _.options.slidesToShow) {\n            cloneRange = _.$slider.find('.slick-slide');\n            loadImages(cloneRange);\n        } else\n        if (_.currentSlide >= _.slideCount - _.options.slidesToShow) {\n            cloneRange = _.$slider.find('.slick-cloned').slice(0, _.options.slidesToShow);\n            loadImages(cloneRange);\n        } else if (_.currentSlide === 0) {\n            cloneRange = _.$slider.find('.slick-cloned').slice(_.options.slidesToShow * -1);\n            loadImages(cloneRange);\n        }\n\n    };\n\n    Slick.prototype.loadSlider = function() {\n\n        var _ = this;\n\n        _.setPosition();\n\n        _.$slideTrack.css({\n            opacity: 1\n        });\n\n        _.$slider.removeClass('slick-loading');\n\n        _.initUI();\n\n        if (_.options.lazyLoad === 'progressive') {\n            _.progressiveLazyLoad();\n        }\n\n    };\n\n    Slick.prototype.next = Slick.prototype.slickNext = function() {\n\n        var _ = this;\n\n        _.changeSlide({\n            data: {\n                message: 'next'\n            }\n        });\n\n    };\n\n    Slick.prototype.orientationChange = function() {\n\n        var _ = this;\n\n        _.checkResponsive();\n        _.setPosition();\n\n    };\n\n    Slick.prototype.pause = Slick.prototype.slickPause = function() {\n\n        var _ = this;\n\n        _.autoPlayClear();\n        _.paused = true;\n\n    };\n\n    Slick.prototype.play = Slick.prototype.slickPlay = function() {\n\n        var _ = this;\n\n        _.autoPlay();\n        _.options.autoplay = true;\n        _.paused = false;\n        _.focussed = false;\n        _.interrupted = false;\n\n    };\n\n    Slick.prototype.postSlide = function(index) {\n\n        var _ = this;\n\n        if( !_.unslicked ) {\n\n            _.$slider.trigger('afterChange', [_, index]);\n\n            _.animating = false;\n\n            _.setPosition();\n\n            _.swipeLeft = null;\n\n            if ( _.options.autoplay ) {\n                _.autoPlay();\n            }\n\n            if (_.options.accessibility === true) {\n                _.initADA();\n            }\n\n        }\n\n    };\n\n    Slick.prototype.prev = Slick.prototype.slickPrev = function() {\n\n        var _ = this;\n\n        _.changeSlide({\n            data: {\n                message: 'previous'\n            }\n        });\n\n    };\n\n    Slick.prototype.preventDefault = function(event) {\n\n        event.preventDefault();\n\n    };\n\n    Slick.prototype.progressiveLazyLoad = function( tryCount ) {\n\n        tryCount = tryCount || 1;\n\n        var _ = this,\n            $imgsToLoad = $( 'img[data-lazy]', _.$slider ),\n            image,\n            imageSource,\n            imageToLoad;\n\n        if ( $imgsToLoad.length ) {\n\n            image = $imgsToLoad.first();\n            imageSource = image.attr('data-lazy');\n            imageToLoad = document.createElement('img');\n\n            imageToLoad.onload = function() {\n\n                image\n                    .attr( 'src', imageSource )\n                    .removeAttr('data-lazy')\n                    .removeClass('slick-loading');\n\n                if ( _.options.adaptiveHeight === true ) {\n                    _.setPosition();\n                }\n\n                _.$slider.trigger('lazyLoaded', [ _, image, imageSource ]);\n                _.progressiveLazyLoad();\n\n            };\n\n            imageToLoad.onerror = function() {\n\n                if ( tryCount < 3 ) {\n\n                    /**\n                     * try to load the image 3 times,\n                     * leave a slight delay so we don't get\n                     * servers blocking the request.\n                     */\n                    setTimeout( function() {\n                        _.progressiveLazyLoad( tryCount + 1 );\n                    }, 500 );\n\n                } else {\n\n                    image\n                        .removeAttr( 'data-lazy' )\n                        .removeClass( 'slick-loading' )\n                        .addClass( 'slick-lazyload-error' );\n\n                    _.$slider.trigger('lazyLoadError', [ _, image, imageSource ]);\n\n                    _.progressiveLazyLoad();\n\n                }\n\n            };\n\n            imageToLoad.src = imageSource;\n\n        } else {\n\n            _.$slider.trigger('allImagesLoaded', [ _ ]);\n\n        }\n\n    };\n\n    Slick.prototype.refresh = function( initializing ) {\n\n        var _ = this, currentSlide, lastVisibleIndex;\n\n        lastVisibleIndex = _.slideCount - _.options.slidesToShow;\n\n        // in non-infinite sliders, we don't want to go past the\n        // last visible index.\n        if( !_.options.infinite && ( _.currentSlide > lastVisibleIndex )) {\n            _.currentSlide = lastVisibleIndex;\n        }\n\n        // if less slides than to show, go to start.\n        if ( _.slideCount <= _.options.slidesToShow ) {\n            _.currentSlide = 0;\n\n        }\n\n        currentSlide = _.currentSlide;\n\n        _.destroy(true);\n\n        $.extend(_, _.initials, { currentSlide: currentSlide });\n\n        _.init();\n\n        if( !initializing ) {\n\n            _.changeSlide({\n                data: {\n                    message: 'index',\n                    index: currentSlide\n                }\n            }, false);\n\n        }\n\n    };\n\n    Slick.prototype.registerBreakpoints = function() {\n\n        var _ = this, breakpoint, currentBreakpoint, l,\n            responsiveSettings = _.options.responsive || null;\n\n        if ( $.type(responsiveSettings) === 'array' && responsiveSettings.length ) {\n\n            _.respondTo = _.options.respondTo || 'window';\n\n            for ( breakpoint in responsiveSettings ) {\n\n                l = _.breakpoints.length-1;\n                currentBreakpoint = responsiveSettings[breakpoint].breakpoint;\n\n                if (responsiveSettings.hasOwnProperty(breakpoint)) {\n\n                    // loop through the breakpoints and cut out any existing\n                    // ones with the same breakpoint number, we don't want dupes.\n                    while( l >= 0 ) {\n                        if( _.breakpoints[l] && _.breakpoints[l] === currentBreakpoint ) {\n                            _.breakpoints.splice(l,1);\n                        }\n                        l--;\n                    }\n\n                    _.breakpoints.push(currentBreakpoint);\n                    _.breakpointSettings[currentBreakpoint] = responsiveSettings[breakpoint].settings;\n\n                }\n\n            }\n\n            _.breakpoints.sort(function(a, b) {\n                return ( _.options.mobileFirst ) ? a-b : b-a;\n            });\n\n        }\n\n    };\n\n    Slick.prototype.reinit = function() {\n\n        var _ = this;\n\n        _.$slides =\n            _.$slideTrack\n                .children(_.options.slide)\n                .addClass('slick-slide');\n\n        _.slideCount = _.$slides.length;\n\n        if (_.currentSlide >= _.slideCount && _.currentSlide !== 0) {\n            _.currentSlide = _.currentSlide - _.options.slidesToScroll;\n        }\n\n        if (_.slideCount <= _.options.slidesToShow) {\n            _.currentSlide = 0;\n        }\n\n        _.registerBreakpoints();\n\n        _.setProps();\n        _.setupInfinite();\n        _.buildArrows();\n        _.updateArrows();\n        _.initArrowEvents();\n        _.buildDots();\n        _.updateDots();\n        _.initDotEvents();\n        _.cleanUpSlideEvents();\n        _.initSlideEvents();\n\n        _.checkResponsive(false, true);\n\n        if (_.options.focusOnSelect === true) {\n            $(_.$slideTrack).children().on('click.slick', _.selectHandler);\n        }\n\n        _.setSlideClasses(typeof _.currentSlide === 'number' ? _.currentSlide : 0);\n\n        _.setPosition();\n        _.focusHandler();\n\n        _.paused = !_.options.autoplay;\n        _.autoPlay();\n\n        _.$slider.trigger('reInit', [_]);\n\n    };\n\n    Slick.prototype.resize = function() {\n\n        var _ = this;\n\n        if ($(window).width() !== _.windowWidth) {\n            clearTimeout(_.windowDelay);\n            _.windowDelay = window.setTimeout(function() {\n                _.windowWidth = $(window).width();\n                _.checkResponsive();\n                if( !_.unslicked ) { _.setPosition(); }\n            }, 50);\n        }\n    };\n\n    Slick.prototype.removeSlide = Slick.prototype.slickRemove = function(index, removeBefore, removeAll) {\n\n        var _ = this;\n\n        if (typeof(index) === 'boolean') {\n            removeBefore = index;\n            index = removeBefore === true ? 0 : _.slideCount - 1;\n        } else {\n            index = removeBefore === true ? --index : index;\n        }\n\n        if (_.slideCount < 1 || index < 0 || index > _.slideCount - 1) {\n            return false;\n        }\n\n        _.unload();\n\n        if (removeAll === true) {\n            _.$slideTrack.children().remove();\n        } else {\n            _.$slideTrack.children(this.options.slide).eq(index).remove();\n        }\n\n        _.$slides = _.$slideTrack.children(this.options.slide);\n\n        _.$slideTrack.children(this.options.slide).detach();\n\n        _.$slideTrack.append(_.$slides);\n\n        _.$slidesCache = _.$slides;\n\n        _.reinit();\n\n    };\n\n    Slick.prototype.setCSS = function(position) {\n\n        var _ = this,\n            positionProps = {},\n            x, y;\n\n        if (_.options.rtl === true) {\n            position = -position;\n        }\n        x = _.positionProp == 'left' ? Math.ceil(position) + 'px' : '0px';\n        y = _.positionProp == 'top' ? Math.ceil(position) + 'px' : '0px';\n\n        positionProps[_.positionProp] = position;\n\n        if (_.transformsEnabled === false) {\n            _.$slideTrack.css(positionProps);\n        } else {\n            positionProps = {};\n            if (_.cssTransitions === false) {\n                positionProps[_.animType] = 'translate(' + x + ', ' + y + ')';\n                _.$slideTrack.css(positionProps);\n            } else {\n                positionProps[_.animType] = 'translate3d(' + x + ', ' + y + ', 0px)';\n                _.$slideTrack.css(positionProps);\n            }\n        }\n\n    };\n\n    Slick.prototype.setDimensions = function() {\n\n        var _ = this;\n\n        if (_.options.vertical === false) {\n            if (_.options.centerMode === true) {\n                _.$list.css({\n                    padding: ('0px ' + _.options.centerPadding)\n                });\n            }\n        } else {\n            _.$list.height(_.$slides.first().outerHeight(true) * _.options.slidesToShow);\n            if (_.options.centerMode === true) {\n                _.$list.css({\n                    padding: (_.options.centerPadding + ' 0px')\n                });\n            }\n        }\n\n        _.listWidth = _.$list.width();\n        _.listHeight = _.$list.height();\n\n\n        if (_.options.vertical === false && _.options.variableWidth === false) {\n            _.slideWidth = Math.ceil(_.listWidth / _.options.slidesToShow);\n            _.$slideTrack.width(Math.ceil((_.slideWidth * _.$slideTrack.children('.slick-slide').length)));\n\n        } else if (_.options.variableWidth === true) {\n            _.$slideTrack.width(5000 * _.slideCount);\n        } else {\n            _.slideWidth = Math.ceil(_.listWidth);\n            _.$slideTrack.height(Math.ceil((_.$slides.first().outerHeight(true) * _.$slideTrack.children('.slick-slide').length)));\n        }\n\n        var offset = _.$slides.first().outerWidth(true) - _.$slides.first().width();\n        if (_.options.variableWidth === false) _.$slideTrack.children('.slick-slide').width(_.slideWidth - offset);\n\n    };\n\n    Slick.prototype.setFade = function() {\n\n        var _ = this,\n            targetLeft;\n\n        _.$slides.each(function(index, element) {\n            targetLeft = (_.slideWidth * index) * -1;\n            if (_.options.rtl === true) {\n                $(element).css({\n                    position: 'relative',\n                    right: targetLeft,\n                    top: 0,\n                    zIndex: _.options.zIndex - 2,\n                    opacity: 0\n                });\n            } else {\n                $(element).css({\n                    position: 'relative',\n                    left: targetLeft,\n                    top: 0,\n                    zIndex: _.options.zIndex - 2,\n                    opacity: 0\n                });\n            }\n        });\n\n        _.$slides.eq(_.currentSlide).css({\n            zIndex: _.options.zIndex - 1,\n            opacity: 1\n        });\n\n    };\n\n    Slick.prototype.setHeight = function() {\n\n        var _ = this;\n\n        if (_.options.slidesToShow === 1 && _.options.adaptiveHeight === true && _.options.vertical === false) {\n            var targetHeight = _.$slides.eq(_.currentSlide).outerHeight(true);\n            _.$list.css('height', targetHeight);\n        }\n\n    };\n\n    Slick.prototype.setOption =\n    Slick.prototype.slickSetOption = function() {\n\n        /**\n         * accepts arguments in format of:\n         *\n         *  - for changing a single option's value:\n         *     .slick(\"setOption\", option, value, refresh )\n         *\n         *  - for changing a set of responsive options:\n         *     .slick(\"setOption\", 'responsive', [{}, ...], refresh )\n         *\n         *  - for updating multiple values at once (not responsive)\n         *     .slick(\"setOption\", { 'option': value, ... }, refresh )\n         */\n\n        var _ = this, l, item, option, value, refresh = false, type;\n\n        if( $.type( arguments[0] ) === 'object' ) {\n\n            option =  arguments[0];\n            refresh = arguments[1];\n            type = 'multiple';\n\n        } else if ( $.type( arguments[0] ) === 'string' ) {\n\n            option =  arguments[0];\n            value = arguments[1];\n            refresh = arguments[2];\n\n            if ( arguments[0] === 'responsive' && $.type( arguments[1] ) === 'array' ) {\n\n                type = 'responsive';\n\n            } else if ( typeof arguments[1] !== 'undefined' ) {\n\n                type = 'single';\n\n            }\n\n        }\n\n        if ( type === 'single' ) {\n\n            _.options[option] = value;\n\n\n        } else if ( type === 'multiple' ) {\n\n            $.each( option , function( opt, val ) {\n\n                _.options[opt] = val;\n\n            });\n\n\n        } else if ( type === 'responsive' ) {\n\n            for ( item in value ) {\n\n                if( $.type( _.options.responsive ) !== 'array' ) {\n\n                    _.options.responsive = [ value[item] ];\n\n                } else {\n\n                    l = _.options.responsive.length-1;\n\n                    // loop through the responsive object and splice out duplicates.\n                    while( l >= 0 ) {\n\n                        if( _.options.responsive[l].breakpoint === value[item].breakpoint ) {\n\n                            _.options.responsive.splice(l,1);\n\n                        }\n\n                        l--;\n\n                    }\n\n                    _.options.responsive.push( value[item] );\n\n                }\n\n            }\n\n        }\n\n        if ( refresh ) {\n\n            _.unload();\n            _.reinit();\n\n        }\n\n    };\n\n    Slick.prototype.setPosition = function() {\n\n        var _ = this;\n\n        _.setDimensions();\n\n        _.setHeight();\n\n        if (_.options.fade === false) {\n            _.setCSS(_.getLeft(_.currentSlide));\n        } else {\n            _.setFade();\n        }\n\n        _.$slider.trigger('setPosition', [_]);\n\n    };\n\n    Slick.prototype.setProps = function() {\n\n        var _ = this,\n            bodyStyle = document.body.style;\n\n        _.positionProp = _.options.vertical === true ? 'top' : 'left';\n\n        if (_.positionProp === 'top') {\n            _.$slider.addClass('slick-vertical');\n        } else {\n            _.$slider.removeClass('slick-vertical');\n        }\n\n        if (bodyStyle.WebkitTransition !== undefined ||\n            bodyStyle.MozTransition !== undefined ||\n            bodyStyle.msTransition !== undefined) {\n            if (_.options.useCSS === true) {\n                _.cssTransitions = true;\n            }\n        }\n\n        if ( _.options.fade ) {\n            if ( typeof _.options.zIndex === 'number' ) {\n                if( _.options.zIndex < 3 ) {\n                    _.options.zIndex = 3;\n                }\n            } else {\n                _.options.zIndex = _.defaults.zIndex;\n            }\n        }\n\n        if (bodyStyle.OTransform !== undefined) {\n            _.animType = 'OTransform';\n            _.transformType = '-o-transform';\n            _.transitionType = 'OTransition';\n            if (bodyStyle.perspectiveProperty === undefined && bodyStyle.webkitPerspective === undefined) _.animType = false;\n        }\n        if (bodyStyle.MozTransform !== undefined) {\n            _.animType = 'MozTransform';\n            _.transformType = '-moz-transform';\n            _.transitionType = 'MozTransition';\n            if (bodyStyle.perspectiveProperty === undefined && bodyStyle.MozPerspective === undefined) _.animType = false;\n        }\n        if (bodyStyle.webkitTransform !== undefined) {\n            _.animType = 'webkitTransform';\n            _.transformType = '-webkit-transform';\n            _.transitionType = 'webkitTransition';\n            if (bodyStyle.perspectiveProperty === undefined && bodyStyle.webkitPerspective === undefined) _.animType = false;\n        }\n        if (bodyStyle.msTransform !== undefined) {\n            _.animType = 'msTransform';\n            _.transformType = '-ms-transform';\n            _.transitionType = 'msTransition';\n            if (bodyStyle.msTransform === undefined) _.animType = false;\n        }\n        if (bodyStyle.transform !== undefined && _.animType !== false) {\n            _.animType = 'transform';\n            _.transformType = 'transform';\n            _.transitionType = 'transition';\n        }\n        _.transformsEnabled = _.options.useTransform && (_.animType !== null && _.animType !== false);\n    };\n\n\n    Slick.prototype.setSlideClasses = function(index) {\n\n        var _ = this,\n            centerOffset, allSlides, indexOffset, remainder;\n\n        allSlides = _.$slider\n            .find('.slick-slide')\n            .removeClass('slick-active slick-center slick-current')\n            .attr('aria-hidden', 'true');\n\n        _.$slides\n            .eq(index)\n            .addClass('slick-current');\n\n        if (_.options.centerMode === true) {\n\n            centerOffset = Math.floor(_.options.slidesToShow / 2);\n\n            if (_.options.infinite === true) {\n\n                if (index >= centerOffset && index <= (_.slideCount - 1) - centerOffset) {\n\n                    _.$slides\n                        .slice(index - centerOffset, index + centerOffset + 1)\n                        .addClass('slick-active')\n                        .attr('aria-hidden', 'false');\n\n                } else {\n\n                    indexOffset = _.options.slidesToShow + index;\n                    allSlides\n                        .slice(indexOffset - centerOffset + 1, indexOffset + centerOffset + 2)\n                        .addClass('slick-active')\n                        .attr('aria-hidden', 'false');\n\n                }\n\n                if (index === 0) {\n\n                    allSlides\n                        .eq(allSlides.length - 1 - _.options.slidesToShow)\n                        .addClass('slick-center');\n\n                } else if (index === _.slideCount - 1) {\n\n                    allSlides\n                        .eq(_.options.slidesToShow)\n                        .addClass('slick-center');\n\n                }\n\n            }\n\n            _.$slides\n                .eq(index)\n                .addClass('slick-center');\n\n        } else {\n\n            if (index >= 0 && index <= (_.slideCount - _.options.slidesToShow)) {\n\n                _.$slides\n                    .slice(index, index + _.options.slidesToShow)\n                    .addClass('slick-active')\n                    .attr('aria-hidden', 'false');\n\n            } else if (allSlides.length <= _.options.slidesToShow) {\n\n                allSlides\n                    .addClass('slick-active')\n                    .attr('aria-hidden', 'false');\n\n            } else {\n\n                remainder = _.slideCount % _.options.slidesToShow;\n                indexOffset = _.options.infinite === true ? _.options.slidesToShow + index : index;\n\n                if (_.options.slidesToShow == _.options.slidesToScroll && (_.slideCount - index) < _.options.slidesToShow) {\n\n                    allSlides\n                        .slice(indexOffset - (_.options.slidesToShow - remainder), indexOffset + remainder)\n                        .addClass('slick-active')\n                        .attr('aria-hidden', 'false');\n\n                } else {\n\n                    allSlides\n                        .slice(indexOffset, indexOffset + _.options.slidesToShow)\n                        .addClass('slick-active')\n                        .attr('aria-hidden', 'false');\n\n                }\n\n            }\n\n        }\n\n        if (_.options.lazyLoad === 'ondemand') {\n            _.lazyLoad();\n        }\n\n    };\n\n    Slick.prototype.setupInfinite = function() {\n\n        var _ = this,\n            i, slideIndex, infiniteCount;\n\n        if (_.options.fade === true) {\n            _.options.centerMode = false;\n        }\n\n        if (_.options.infinite === true && _.options.fade === false) {\n\n            slideIndex = null;\n\n            if (_.slideCount > _.options.slidesToShow) {\n\n                if (_.options.centerMode === true) {\n                    infiniteCount = _.options.slidesToShow + 1;\n                } else {\n                    infiniteCount = _.options.slidesToShow;\n                }\n\n                for (i = _.slideCount; i > (_.slideCount -\n                        infiniteCount); i -= 1) {\n                    slideIndex = i - 1;\n                    $(_.$slides[slideIndex]).clone(true).attr('id', '')\n                        .attr('data-slick-index', slideIndex - _.slideCount)\n                        .prependTo(_.$slideTrack).addClass('slick-cloned');\n                }\n                for (i = 0; i < infiniteCount; i += 1) {\n                    slideIndex = i;\n                    $(_.$slides[slideIndex]).clone(true).attr('id', '')\n                        .attr('data-slick-index', slideIndex + _.slideCount)\n                        .appendTo(_.$slideTrack).addClass('slick-cloned');\n                }\n                _.$slideTrack.find('.slick-cloned').find('[id]').each(function() {\n                    $(this).attr('id', '');\n                });\n\n            }\n\n        }\n\n    };\n\n    Slick.prototype.interrupt = function( toggle ) {\n\n        var _ = this;\n\n        if( !toggle ) {\n            _.autoPlay();\n        }\n        _.interrupted = toggle;\n\n    };\n\n    Slick.prototype.selectHandler = function(event) {\n\n        var _ = this;\n\n        var targetElement =\n            $(event.target).is('.slick-slide') ?\n                $(event.target) :\n                $(event.target).parents('.slick-slide');\n\n        var index = parseInt(targetElement.attr('data-slick-index'));\n\n        if (!index) index = 0;\n\n        if (_.slideCount <= _.options.slidesToShow) {\n\n            _.setSlideClasses(index);\n            _.asNavFor(index);\n            return;\n\n        }\n\n        _.slideHandler(index);\n\n    };\n\n    Slick.prototype.slideHandler = function(index, sync, dontAnimate) {\n\n        var targetSlide, animSlide, oldSlide, slideLeft, targetLeft = null,\n            _ = this, navTarget;\n\n        sync = sync || false;\n\n        if (_.animating === true && _.options.waitForAnimate === true) {\n            return;\n        }\n\n        if (_.options.fade === true && _.currentSlide === index) {\n            return;\n        }\n\n        if (_.slideCount <= _.options.slidesToShow) {\n            return;\n        }\n\n        if (sync === false) {\n            _.asNavFor(index);\n        }\n\n        targetSlide = index;\n        targetLeft = _.getLeft(targetSlide);\n        slideLeft = _.getLeft(_.currentSlide);\n\n        _.currentLeft = _.swipeLeft === null ? slideLeft : _.swipeLeft;\n\n        if (_.options.infinite === false && _.options.centerMode === false && (index < 0 || index > _.getDotCount() * _.options.slidesToScroll)) {\n            if (_.options.fade === false) {\n                targetSlide = _.currentSlide;\n                if (dontAnimate !== true) {\n                    _.animateSlide(slideLeft, function() {\n                        _.postSlide(targetSlide);\n                    });\n                } else {\n                    _.postSlide(targetSlide);\n                }\n            }\n            return;\n        } else if (_.options.infinite === false && _.options.centerMode === true && (index < 0 || index > (_.slideCount - _.options.slidesToScroll))) {\n            if (_.options.fade === false) {\n                targetSlide = _.currentSlide;\n                if (dontAnimate !== true) {\n                    _.animateSlide(slideLeft, function() {\n                        _.postSlide(targetSlide);\n                    });\n                } else {\n                    _.postSlide(targetSlide);\n                }\n            }\n            return;\n        }\n\n        if ( _.options.autoplay ) {\n            clearInterval(_.autoPlayTimer);\n        }\n\n        if (targetSlide < 0) {\n            if (_.slideCount % _.options.slidesToScroll !== 0) {\n                animSlide = _.slideCount - (_.slideCount % _.options.slidesToScroll);\n            } else {\n                animSlide = _.slideCount + targetSlide;\n            }\n        } else if (targetSlide >= _.slideCount) {\n            if (_.slideCount % _.options.slidesToScroll !== 0) {\n                animSlide = 0;\n            } else {\n                animSlide = targetSlide - _.slideCount;\n            }\n        } else {\n            animSlide = targetSlide;\n        }\n\n        _.animating = true;\n\n        _.$slider.trigger('beforeChange', [_, _.currentSlide, animSlide]);\n\n        oldSlide = _.currentSlide;\n        _.currentSlide = animSlide;\n\n        _.setSlideClasses(_.currentSlide);\n\n        if ( _.options.asNavFor ) {\n\n            navTarget = _.getNavTarget();\n            navTarget = navTarget.slick('getSlick');\n\n            if ( navTarget.slideCount <= navTarget.options.slidesToShow ) {\n                navTarget.setSlideClasses(_.currentSlide);\n            }\n\n        }\n\n        _.updateDots();\n        _.updateArrows();\n\n        if (_.options.fade === true) {\n            if (dontAnimate !== true) {\n\n                _.fadeSlideOut(oldSlide);\n\n                _.fadeSlide(animSlide, function() {\n                    _.postSlide(animSlide);\n                });\n\n            } else {\n                _.postSlide(animSlide);\n            }\n            _.animateHeight();\n            return;\n        }\n\n        if (dontAnimate !== true) {\n            _.animateSlide(targetLeft, function() {\n                _.postSlide(animSlide);\n            });\n        } else {\n            _.postSlide(animSlide);\n        }\n\n    };\n\n    Slick.prototype.startLoad = function() {\n\n        var _ = this;\n\n        if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {\n\n            _.$prevArrow.hide();\n            _.$nextArrow.hide();\n\n        }\n\n        if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {\n\n            _.$dots.hide();\n\n        }\n\n        _.$slider.addClass('slick-loading');\n\n    };\n\n    Slick.prototype.swipeDirection = function() {\n\n        var xDist, yDist, r, swipeAngle, _ = this;\n\n        xDist = _.touchObject.startX - _.touchObject.curX;\n        yDist = _.touchObject.startY - _.touchObject.curY;\n        r = Math.atan2(yDist, xDist);\n\n        swipeAngle = Math.round(r * 180 / Math.PI);\n        if (swipeAngle < 0) {\n            swipeAngle = 360 - Math.abs(swipeAngle);\n        }\n\n        if ((swipeAngle <= 45) && (swipeAngle >= 0)) {\n            return (_.options.rtl === false ? 'left' : 'right');\n        }\n        if ((swipeAngle <= 360) && (swipeAngle >= 315)) {\n            return (_.options.rtl === false ? 'left' : 'right');\n        }\n        if ((swipeAngle >= 135) && (swipeAngle <= 225)) {\n            return (_.options.rtl === false ? 'right' : 'left');\n        }\n        if (_.options.verticalSwiping === true) {\n            if ((swipeAngle >= 35) && (swipeAngle <= 135)) {\n                return 'down';\n            } else {\n                return 'up';\n            }\n        }\n\n        return 'vertical';\n\n    };\n\n    Slick.prototype.swipeEnd = function(event) {\n\n        var _ = this,\n            slideCount,\n            direction;\n\n        _.dragging = false;\n        _.interrupted = false;\n        _.shouldClick = ( _.touchObject.swipeLength > 10 ) ? false : true;\n\n        if ( _.touchObject.curX === undefined ) {\n            return false;\n        }\n\n        if ( _.touchObject.edgeHit === true ) {\n            _.$slider.trigger('edge', [_, _.swipeDirection() ]);\n        }\n\n        if ( _.touchObject.swipeLength >= _.touchObject.minSwipe ) {\n\n            direction = _.swipeDirection();\n\n            switch ( direction ) {\n\n                case 'left':\n                case 'down':\n\n                    slideCount =\n                        _.options.swipeToSlide ?\n                            _.checkNavigable( _.currentSlide + _.getSlideCount() ) :\n                            _.currentSlide + _.getSlideCount();\n\n                    _.currentDirection = 0;\n\n                    break;\n\n                case 'right':\n                case 'up':\n\n                    slideCount =\n                        _.options.swipeToSlide ?\n                            _.checkNavigable( _.currentSlide - _.getSlideCount() ) :\n                            _.currentSlide - _.getSlideCount();\n\n                    _.currentDirection = 1;\n\n                    break;\n\n                default:\n\n\n            }\n\n            if( direction != 'vertical' ) {\n\n                _.slideHandler( slideCount );\n                _.touchObject = {};\n                _.$slider.trigger('swipe', [_, direction ]);\n\n            }\n\n        } else {\n\n            if ( _.touchObject.startX !== _.touchObject.curX ) {\n\n                _.slideHandler( _.currentSlide );\n                _.touchObject = {};\n\n            }\n\n        }\n\n    };\n\n    Slick.prototype.swipeHandler = function(event) {\n\n        var _ = this;\n\n        if ((_.options.swipe === false) || ('ontouchend' in document && _.options.swipe === false)) {\n            return;\n        } else if (_.options.draggable === false && event.type.indexOf('mouse') !== -1) {\n            return;\n        }\n\n        _.touchObject.fingerCount = event.originalEvent && event.originalEvent.touches !== undefined ?\n            event.originalEvent.touches.length : 1;\n\n        _.touchObject.minSwipe = _.listWidth / _.options\n            .touchThreshold;\n\n        if (_.options.verticalSwiping === true) {\n            _.touchObject.minSwipe = _.listHeight / _.options\n                .touchThreshold;\n        }\n\n        switch (event.data.action) {\n\n            case 'start':\n                _.swipeStart(event);\n                break;\n\n            case 'move':\n                _.swipeMove(event);\n                break;\n\n            case 'end':\n                _.swipeEnd(event);\n                break;\n\n        }\n\n    };\n\n    Slick.prototype.swipeMove = function(event) {\n\n        var _ = this,\n            edgeWasHit = false,\n            curLeft, swipeDirection, swipeLength, positionOffset, touches;\n\n        touches = event.originalEvent !== undefined ? event.originalEvent.touches : null;\n\n        if (!_.dragging || touches && touches.length !== 1) {\n            return false;\n        }\n\n        curLeft = _.getLeft(_.currentSlide);\n\n        _.touchObject.curX = touches !== undefined ? touches[0].pageX : event.clientX;\n        _.touchObject.curY = touches !== undefined ? touches[0].pageY : event.clientY;\n\n        _.touchObject.swipeLength = Math.round(Math.sqrt(\n            Math.pow(_.touchObject.curX - _.touchObject.startX, 2)));\n\n        if (_.options.verticalSwiping === true) {\n            _.touchObject.swipeLength = Math.round(Math.sqrt(\n                Math.pow(_.touchObject.curY - _.touchObject.startY, 2)));\n        }\n\n        swipeDirection = _.swipeDirection();\n\n        if (swipeDirection === 'vertical') {\n            return;\n        }\n\n        if (event.originalEvent !== undefined && _.touchObject.swipeLength > 4) {\n            event.preventDefault();\n        }\n\n        positionOffset = (_.options.rtl === false ? 1 : -1) * (_.touchObject.curX > _.touchObject.startX ? 1 : -1);\n        if (_.options.verticalSwiping === true) {\n            positionOffset = _.touchObject.curY > _.touchObject.startY ? 1 : -1;\n        }\n\n\n        swipeLength = _.touchObject.swipeLength;\n\n        _.touchObject.edgeHit = false;\n\n        if (_.options.infinite === false) {\n            if ((_.currentSlide === 0 && swipeDirection === 'right') || (_.currentSlide >= _.getDotCount() && swipeDirection === 'left')) {\n                swipeLength = _.touchObject.swipeLength * _.options.edgeFriction;\n                _.touchObject.edgeHit = true;\n            }\n        }\n\n        if (_.options.vertical === false) {\n            _.swipeLeft = curLeft + swipeLength * positionOffset;\n        } else {\n            _.swipeLeft = curLeft + (swipeLength * (_.$list.height() / _.listWidth)) * positionOffset;\n        }\n        if (_.options.verticalSwiping === true) {\n            _.swipeLeft = curLeft + swipeLength * positionOffset;\n        }\n\n        if (_.options.fade === true || _.options.touchMove === false) {\n            return false;\n        }\n\n        if (_.animating === true) {\n            _.swipeLeft = null;\n            return false;\n        }\n\n        _.setCSS(_.swipeLeft);\n\n    };\n\n    Slick.prototype.swipeStart = function(event) {\n\n        var _ = this,\n            touches;\n\n        _.interrupted = true;\n\n        if (_.touchObject.fingerCount !== 1 || _.slideCount <= _.options.slidesToShow) {\n            _.touchObject = {};\n            return false;\n        }\n\n        if (event.originalEvent !== undefined && event.originalEvent.touches !== undefined) {\n            touches = event.originalEvent.touches[0];\n        }\n\n        _.touchObject.startX = _.touchObject.curX = touches !== undefined ? touches.pageX : event.clientX;\n        _.touchObject.startY = _.touchObject.curY = touches !== undefined ? touches.pageY : event.clientY;\n\n        _.dragging = true;\n\n    };\n\n    Slick.prototype.unfilterSlides = Slick.prototype.slickUnfilter = function() {\n\n        var _ = this;\n\n        if (_.$slidesCache !== null) {\n\n            _.unload();\n\n            _.$slideTrack.children(this.options.slide).detach();\n\n            _.$slidesCache.appendTo(_.$slideTrack);\n\n            _.reinit();\n\n        }\n\n    };\n\n    Slick.prototype.unload = function() {\n\n        var _ = this;\n\n        $('.slick-cloned', _.$slider).remove();\n\n        if (_.$dots) {\n            _.$dots.remove();\n        }\n\n        if (_.$prevArrow && _.htmlExpr.test(_.options.prevArrow)) {\n            _.$prevArrow.remove();\n        }\n\n        if (_.$nextArrow && _.htmlExpr.test(_.options.nextArrow)) {\n            _.$nextArrow.remove();\n        }\n\n        _.$slides\n            .removeClass('slick-slide slick-active slick-visible slick-current')\n            .attr('aria-hidden', 'true')\n            .css('width', '');\n\n    };\n\n    Slick.prototype.unslick = function(fromBreakpoint) {\n\n        var _ = this;\n        _.$slider.trigger('unslick', [_, fromBreakpoint]);\n        _.destroy();\n\n    };\n\n    Slick.prototype.updateArrows = function() {\n\n        var _ = this,\n            centerOffset;\n\n        centerOffset = Math.floor(_.options.slidesToShow / 2);\n\n        if ( _.options.arrows === true &&\n            _.slideCount > _.options.slidesToShow &&\n            !_.options.infinite ) {\n\n            _.$prevArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');\n            _.$nextArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');\n\n            if (_.currentSlide === 0) {\n\n                _.$prevArrow.addClass('slick-disabled').attr('aria-disabled', 'true');\n                _.$nextArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');\n\n            } else if (_.currentSlide >= _.slideCount - _.options.slidesToShow && _.options.centerMode === false) {\n\n                _.$nextArrow.addClass('slick-disabled').attr('aria-disabled', 'true');\n                _.$prevArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');\n\n            } else if (_.currentSlide >= _.slideCount - 1 && _.options.centerMode === true) {\n\n                _.$nextArrow.addClass('slick-disabled').attr('aria-disabled', 'true');\n                _.$prevArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');\n\n            }\n\n        }\n\n    };\n\n    Slick.prototype.updateDots = function() {\n\n        var _ = this;\n\n        if (_.$dots !== null) {\n\n            _.$dots\n                .find('li')\n                .removeClass('slick-active')\n                .attr('aria-hidden', 'true');\n\n            _.$dots\n                .find('li')\n                .eq(Math.floor(_.currentSlide / _.options.slidesToScroll))\n                .addClass('slick-active')\n                .attr('aria-hidden', 'false');\n\n        }\n\n    };\n\n    Slick.prototype.visibility = function() {\n\n        var _ = this;\n\n        if ( _.options.autoplay ) {\n\n            if ( document[_.hidden] ) {\n\n                _.interrupted = true;\n\n            } else {\n\n                _.interrupted = false;\n\n            }\n\n        }\n\n    };\n\n    $.fn.slick = function() {\n        var _ = this,\n            opt = arguments[0],\n            args = Array.prototype.slice.call(arguments, 1),\n            l = _.length,\n            i,\n            ret;\n        for (i = 0; i < l; i++) {\n            if (typeof opt == 'object' || typeof opt == 'undefined')\n                _[i].slick = new Slick(_[i], opt);\n            else\n                ret = _[i].slick[opt].apply(_[i].slick, args);\n            if (typeof ret != 'undefined') return ret;\n        }\n        return _;\n    };\n\n}));\n\n\n/***/ }),\n/* 5 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _jquery = __webpack_require__(0);\n\nvar _jquery2 = _interopRequireDefault(_jquery);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar selector = '.field-image.c1 img';\n\nvar BackgroundImage = function BackgroundImage(element) {\n  _classCallCheck(this, BackgroundImage);\n\n  this.$element = (0, _jquery2.default)(element);\n  var src = this.$element.find(selector).attr('src');\n  if (src) {\n    this.$element.css('background-image', 'url(' + src + ')');\n  }\n  this.$element.addClass('ready');\n};\n\nexports.default = BackgroundImage;\n\n/***/ }),\n/* 6 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nvar _jquery = __webpack_require__(0);\n\nvar _jquery2 = _interopRequireDefault(_jquery);\n\nvar _moment = __webpack_require__(30);\n\nvar _moment2 = _interopRequireDefault(_moment);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar defaults = {\n  // local storage key used to save the currently applied filter\n  storageKey: 'currentCalendarFilter',\n\n  // Button text displayed as the pagination to the next page of events\n  paginationLabel: 'Load More Events',\n\n  // Mobile only drop down label that houses the filtering options\n  filtersLabel: 'Filter by...',\n\n  // Force the filters to be automatically determined by the post types present in the feed.\n  filterByPostTypes: false,\n\n  // A simple indicator to determine the build out of filters\n  useFilters: false,\n\n  // Used to pass in an object of filters which use key value pairs.\n  // {Object}\n  //   @key: Name that will appear as the filter button text\n  //   @value: ID of post type or navigation term\n  filters: false\n};\n\n// These filters are used if the filterByPostTypes is enabled. Present post\n// types are then added to this object, then the filters are made from those.\nvar defaultFilters = {\n  All: 2\n};\n\nfunction CalendarFeed(element, options) {\n  this.$element = (0, _jquery2.default)(element);\n  this.settings = _extends({}, defaults, options);\n  this.filters = this.getFilters();\n  this.init();\n}\n\nCalendarFeed.prototype = {\n  init: function init() {\n    this.buildCalendar();\n    if (this.settings.useFilters) {\n      this.createFilters();\n    }\n  },\n  buildCalendar: function buildCalendar() {\n    var $posts = this.$element.find('.node');\n    var group = '<div class=\"group\"></div>';\n    var currentYear = null;\n    var currentMonth = '';\n    var $group = void 0;\n\n    // Manage the types of calendar filters being created\n    $posts.each(function (i, post) {\n      var $post = (0, _jquery2.default)(post);\n      var dates = ['start', 'end'];\n      var oDates = {};\n\n      // Parse the start/end timestamps using the moment.js framework\n      _jquery2.default.each(dates, function (j, type) {\n        var datetime = $post.find('time.' + type).attr('datetime');\n        var date = (0, _moment2.default)(datetime);\n        oDates[type] = {\n          month: date.format('MMMM'),\n          mon: date.format('MMM'),\n          day: date.format('D'),\n          dow: date.format('ddd'),\n          year: date.format('YYYY')\n        };\n      });\n\n      // Add the post into a month grouping\n      if (oDates.start.month.length && currentMonth !== oDates.start.month) {\n        currentMonth = oDates.start.month;\n        $group = (0, _jquery2.default)(group);\n        $group.addClass(oDates.start.month.toLowerCase());\n        $group.append('<h3 class=\"group-title\">' + oDates.start.month + '</h3>');\n        $post.before($group);\n\n        // Set year labels followed by the associated months of that year\n        if (oDates.start.year && oDates.start.year > currentYear) {\n          var $year = (0, _jquery2.default)('<span class=\"group-year\">' + oDates.start.year + '</span>');\n          $group.before($year);\n          currentYear = oDates.start.year;\n        }\n      }\n\n      // Dynamically create the date tile for the event display\n      var $tile = $post.find('.event-date-tile');\n      var markup = function markup(data) {\n        return '<span class=\"day-of-week\">' + data.dow + '</span><span class=\"month\">' + data.mon + '</span><span class=\"day\">' + data.day + '</span>';\n      };\n      $tile.find('time.start').html(markup(oDates.start));\n\n      // Handle date ranges\n      if ($tile.is('.range')) {\n        var isSameMonth = oDates.start.month === oDates.end.month;\n        var isSameDay = oDates.start.day === oDates.end.day;\n        var isSameYear = oDates.start.year === oDates.end.year;\n\n        // This identifies an event which begins and ends at different times on the same day\n        if (isSameMonth && isSameDay && isSameYear) {\n          $post.addClass('day-event');\n        }\n\n        // This identifies an event which spans multiple days within the same month\n        if (isSameMonth && !isSameDay && isSameYear) {\n          $post.addClass('multiple-day-event');\n          $tile.find('time.start .day').text(oDates.start.day + '-' + oDates.end.day);\n        }\n\n        // This identifies an event which spans multiple months or maybe a year(s)\n        if (!isSameMonth || !isSameYear) {\n          $post.addClass('multiple-month-event');\n          $tile.find('time.end').html(markup(oDates.end));\n        }\n      }\n\n      // Add the grouped posts to the display\n      $post.appendTo($group);\n    });\n\n    // Alter the text of the next pager button\n    (0, _jquery2.default)('.pager-next a', this.$element).text(this.settings.paginationLabel);\n\n    // Add a helper class\n    this.$element.addClass('ready');\n  },\n  filterHandler: function filterHandler(event) {\n    event.preventDefault();\n    (0, _jquery2.default)(this).next('.filters').toggleClass('expanded');\n  },\n  getFilters: function getFilters() {\n    // If custom filters where passed, use them, if not use the defaults.\n    var data = this.settings.filters ? this.settings.filters : defaultFilters;\n    // If the filter by post types flag is set, force that filtering option.\n    if (this.settings.filterByPostTypes) {\n      data = defaultFilters;\n    }\n    return data;\n  },\n  createFilters: function createFilters() {\n    var _this = this;\n\n    var $element = this.$element;\n    var $posts = $element.find('.node');\n    var $filters = (0, _jquery2.default)('<div class=\"filters\"></div>');\n    var filter = '<div class=\"filter\"></div>';\n    var types = [];\n    var ids = [];\n\n    // Create the proposed filters\n    _jquery2.default.each(this.filters, function (type, id) {\n      types.push(type);\n      ids.push(id);\n    });\n\n    // Using the proposed filters, generate relevant filters of those types\n    // that are actually present or use the semi default, filter by post type.\n    var data = this.settings.filterByPostTypes ? this.getDefaultData(types, ids) : this.getCustomizedData(types, ids);\n\n    // Using the provided date, rebuild the arrays using relevant data.\n    types = data.types;\n    ids = data.ids;\n\n    // Get the latest selected filter.\n    var currentFilter = sessionStorage.getItem(this.settings.storageKey) || ids[0];\n\n    // See if a hash was passed, if so let's filter by that instead later on.\n    var hash = window.location.hash;\n    if (hash.length > 1) {\n      hash = hash.substr(1); // Remove the hash symbol #\n      hash = decodeURIComponent(hash); // Normalize the filter passed\n    }\n\n    // Create filters\n    _jquery2.default.each(types, function (i, type) {\n      var $filter = (0, _jquery2.default)(filter);\n      // Use the type key to identify the associated filter id\n      var id = ids[i];\n\n      // Check to see if this filter is being forced to be filtered by using\n      // a url hash.\n      if (hash.length && hash.toLowerCase() === type.toLowerCase()) {\n        currentFilter = id;\n      }\n\n      // Add the type to the filter\n      $filter.text(type);\n\n      // Add a class name to theme the filter\n      $filter.addClass('show-' + ids[i]);\n\n      // Add the newly created filter\n      $filters.append($filter);\n\n      // Add a click handler\n      $filter.on('click', function () {\n        // Default to all posts in calendar feed\n        var $show = $posts;\n\n        // Filter what posts to display if not all option\n        if (type !== 'All') {\n          $show = $posts.filter(function (j, element) {\n            return _jquery2.default.inArray(type, (0, _jquery2.default)(element).data('types')) !== -1;\n          });\n        }\n\n        // Manage the active filter styling\n        $filters.not(_this).removeClass('active');\n        (0, _jquery2.default)(_this).addClass('active');\n\n        // hide all events that aren't of this type\n        $posts.not($show).stop(true, true).animate({\n          opacity: 'hide',\n          height: 'hide'\n        }, 300).removeClass('show');\n\n        // show all events that are of this type\n        $show.stop(true, true).animate({\n          opacity: 'show',\n          height: 'show'\n        }, 300).addClass('show');\n\n        // Set the current filter into session storage\n        sessionStorage.setItem(_this.settings.storageKey, id);\n        currentFilter = id;\n\n        // Check to see if the event group is empty\n        $element.find('.group').each(function (j, element) {\n          var $shown = (0, _jquery2.default)('.node.show', element);\n          var result = $shown.length ? 'show' : 'hide';\n\n          // Add a helper class for the use with the year function below\n          if ($shown.length) {\n            (0, _jquery2.default)(element).addClass('show');\n          } else {\n            (0, _jquery2.default)(element).removeClass('show');\n          }\n\n          // Manages the visibility of the group\n          (0, _jquery2.default)(element).stop(true, true).animate({\n            opacity: result,\n            height: result\n          }, 300);\n        });\n\n        // Check to see if the group year should display or not\n        $element.find('.group-year').each(function (j, element) {\n          var $shown = (0, _jquery2.default)(element).nextUntil('.group-year').filter('.show');\n          var result = $shown.length ? 'show' : 'hide';\n          (0, _jquery2.default)(element).stop(true, true).animate({\n            opacity: result,\n            height: result\n          }, 300);\n        });\n      });\n    });\n\n    // Add a drop down controller for mobile\n    var $ctrl = (0, _jquery2.default)('<h3 class=\"ctrl\">' + this.settings.filtersLabel + '</h3>');\n    $ctrl.on('click', this.filterHandler);\n\n    // Add the drop down controller for mobile display\n    $element.find('.view-header').append($ctrl, $filters);\n\n    // Make this an jquery array of filters reference rather than a container\n    // reference.\n    $filters = $filters.find('.filter');\n\n    // Simulate a click event for the last or default calendar filter\n    $filters.filter('.show-' + currentFilter).trigger('click');\n  },\n  getDefaultData: function getDefaultData(_types, _ids) {\n    var $element = this.$element;\n    var $posts = $element.find('.node');\n\n    var types = _types;\n    var ids = _ids;\n\n    // Dynamically create the filter types and identify the posts that belong\n    // to each one.\n    $posts.each(function (i, post) {\n      var $post = (0, _jquery2.default)(post);\n\n      // Extract the post type\n      var type = (0, _jquery2.default)('.post-type', post).text();\n\n      // If the post type is the generic Event, set the label to All instead.\n      if (type === 'Event') {\n        type = 'All';\n      }\n\n      var id = 0;\n      var classes = $post.attr('class');\n      var regex = /\\w?pt([0-9]+)/;\n\n      // Make filters by types found if were using the default filters\n      if (regex.test(classes)) {\n        id = regex.exec(classes)[1];\n      }\n\n      // Make filters by post type\n      if (_jquery2.default.inArray(type, types) === -1) {\n        types.push(type);\n        ids.push(id);\n      }\n\n      // Add a data types to identify this when a filter is clicked\n      $post.data('types', [type]);\n    });\n\n    return {\n      types: types,\n      ids: ids\n    };\n  },\n  getCustomizedData: function getCustomizedData(_types, _ids) {\n    var $element = this.$element;\n    var $posts = $element.find('.node');\n    var types = [];\n    var ids = [];\n\n    // Keep track of the types and ids that have been identified within this content.\n    var indexes = [];\n\n    // Dynamically create the filter types and identify the posts that belong\n    // to each one.\n    $posts.each(function (i, post) {\n      var $post = (0, _jquery2.default)(post);\n      var classes = $post.attr('class');\n      var regex = /\\w?[wp]t([0-9]+)/g; // Filter could be either wt or pt.\n      var aTypes = [];\n\n      // Add the post type by default\n      aTypes.push((0, _jquery2.default)('.post-type', post).text());\n\n      // If the post type is the generic Event, set the label to All instead.\n      if (aTypes[0] === 'Event') {\n        aTypes[0] = 'All';\n      }\n\n      // Iterates through all matches made to see what this post should be\n      // filtered by from the filters assigned\n      var aResults = void 0;\n      // eslint-disable-next-line no-cond-assign\n      while ((aResults = regex.exec(classes)) !== null) {\n        var result = parseInt(aResults[1], 10);\n        if (_jquery2.default.inArray(result, _ids) !== -1) {\n          var index = _ids.indexOf(result);\n          // Check to see if index has already been added, if not, add it.\n          if (_jquery2.default.inArray(index, indexes) === -1) {\n            indexes.push(index);\n          }\n          // Add this type to the post since it's been found\n          aTypes.push(_types[index]);\n        }\n      }\n\n      // Add a data id to identify this type when the filter is clicked\n      $post.data('types', aTypes);\n    });\n\n    // Create new types and ids of the relevant types found using the\n    // supplied custom filters\n    _jquery2.default.each(indexes.sort(), function (i, index) {\n      types.push(_types[index]);\n      ids.push(_ids[index]);\n    });\n\n    return {\n      types: types,\n      ids: ids\n    };\n  }\n};\n\nexports.default = CalendarFeed;\n\n/***/ }),\n/* 7 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _jquery = __webpack_require__(0);\n\nvar _jquery2 = _interopRequireDefault(_jquery);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar key = 'has_seen_alert_';\n\nvar DistrictAlert = function () {\n  function DistrictAlert(element) {\n    _classCallCheck(this, DistrictAlert);\n\n    this.$element = (0, _jquery2.default)(element);\n    this.$instance = this.getAlert();\n    this.click = this.click.bind(this);\n    if (this.$instance.length && this.areWeThere) {\n      this.storageKey = this.createKey();\n      if (!this.getVariable()) {\n        this.listen();\n        this.show();\n      }\n    }\n  }\n\n  _createClass(DistrictAlert, [{\n    key: 'getAlert',\n    value: function getAlert() {\n      return this.$element.find('.node');\n    }\n  }, {\n    key: 'createKey',\n    value: function createKey() {\n      var id = this.$instance.attr('id');\n      return key + /(\\d+)/.exec(id)[0];\n    }\n  }, {\n    key: 'getVariable',\n    value: function getVariable() {\n      return sessionStorage.getItem(this.storageKey) || false;\n    }\n  }, {\n    key: 'setVariable',\n    value: function setVariable() {\n      sessionStorage.setItem(this.storageKey, true);\n    }\n  }, {\n    key: 'click',\n    value: function click(event) {\n      this.setVariable();\n      event.stopPropagation();\n\n      if ((0, _jquery2.default)(event.target).is('.block, .node-links')) {\n        event.preventDefault();\n        this.hide();\n      }\n    }\n  }, {\n    key: 'hide',\n    value: function hide() {\n      this.$element.removeClass('show');\n    }\n  }, {\n    key: 'show',\n    value: function show() {\n      this.$element.addClass('show');\n    }\n  }, {\n    key: 'listen',\n    value: function listen() {\n      this.$element.on('click', this.click);\n    }\n  }, {\n    key: 'areWeThere',\n    get: function get() {\n      var url = this.$element.find('.link-read-more a').attr('href');\n      var currentURL = document.location.pathname;\n      return url !== currentURL;\n    }\n  }]);\n\n  return DistrictAlert;\n}();\n\nexports.default = DistrictAlert;\n\n/***/ }),\n/* 8 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _jquery = __webpack_require__(0);\n\nvar _jquery2 = _interopRequireDefault(_jquery);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar behaviors = void 0; /* global Drupal */\n\nvar documentIsReady = false;\n\n/**\n * Allows a Drupal behavior to be added from an AMD-style module. The behavior\n * will be executed when:\n * - As soon as the DOM is ready, if the DOM is not ready when the behavior is\n *   added, just like a regular Drupal behavior.\n * - Immediately upon adding, if the DOM is ready (which may happen since\n *   AMD-style modules are loaded asynchronously).\n * - When Drupal.attachBehaviors is executed.\n */\nDrupal.behavior = function addDrupalBehavior(fn) {\n  if (!behaviors) {\n    behaviors = _jquery2.default.Callbacks();\n    documentIsReady = false;\n\n    (0, _jquery2.default)(document).ready(function () {\n      documentIsReady = true;\n      // eslint-disable-next-line no-console\n      console.log('Executing behaviors that were added before DOM was ready');\n      behaviors.fire(document);\n\n      // Now that we know the document is ready, add ourselves to Drupal's\n      // behavior handling.\n      window.Drupal.behaviors.DrupalAMD = function DrupalAMD(context) {\n        // eslint-disable-next-line no-console\n        console.log('Executing behaviors in response to Drupal.attachBehaviors');\n        behaviors.fire(context);\n      };\n    });\n  }\n\n  // Note: we can't use the 'memory' option of jQuery.Callbacks, because we\n  // need control over the argument.\n  if (documentIsReady) {\n    // eslint-disable-next-line no-console\n    console.log('Executing behavior immediately, DOM is already ready');\n    fn(document);\n  }\n\n  behaviors.add(fn);\n  return this;\n};\n\nexports.default = Drupal;\n\n/***/ }),\n/* 9 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _jquery = __webpack_require__(0);\n\nvar _jquery2 = _interopRequireDefault(_jquery);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar defaults = {\n  events: 'click',\n  className: 'expanded',\n  trigger: '.node-header a'\n};\n\nvar Expanded = function () {\n  function Expanded(element, options) {\n    _classCallCheck(this, Expanded);\n\n    this.$element = (0, _jquery2.default)(element);\n    this.settings = _extends({}, defaults, options);\n    this.update = this.update.bind(this);\n    this.listen();\n  }\n\n  _createClass(Expanded, [{\n    key: 'listen',\n    value: function listen() {\n      this.$element.find(this.settings.trigger).bind(this.settings.events, this.update);\n    }\n  }, {\n    key: 'update',\n    value: function update(event) {\n      event.preventDefault(); // prevent native behavior\n      var state = this.$element.hasClass(this.settings.className) ? 'remove' : 'add';\n      this.$element[state + 'Class'](this.settings.className);\n    }\n  }]);\n\n  return Expanded;\n}();\n\nexports.default = Expanded;\n\n/***/ }),\n/* 10 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _jquery = __webpack_require__(0);\n\nvar _jquery2 = _interopRequireDefault(_jquery);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction FixNavigation(element) {\n  this.element = element;\n  this.process();\n  this.ready();\n}\n\nFixNavigation.prototype = {\n  process: function process() {\n    (0, _jquery2.default)('.menuparent, .expanded, .collapsed', this.element).each(function (i, item) {\n      // handles the parent term (if hidden)\n      var $parent = (0, _jquery2.default)(item).children('a');\n      if (!$parent.length || $parent.is('.hidden')) {\n        (0, _jquery2.default)(item).remove();\n      }\n\n      // handles the term to see if it only parents orphans.\n      var $children = (0, _jquery2.default)('> ul > li', item);\n      if (!$parent.is('.hidden') && $children.length) {\n        var $orphans = $children.children('a.hidden');\n        $orphans.parent().remove();\n        if ($orphans.length === $children.length) {\n          (0, _jquery2.default)(item).removeClass('expanded menuparent collapsed');\n          (0, _jquery2.default)(item).children('ul').remove();\n        }\n      }\n    });\n  },\n  ready: function ready() {\n    (0, _jquery2.default)(this.element).addClass('ready');\n  }\n};\n\nexports.default = FixNavigation;\n\n/***/ }),\n/* 11 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _jquery = __webpack_require__(0);\n\nvar _jquery2 = _interopRequireDefault(_jquery);\n\n__webpack_require__(4);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar defaults = {\n  speed: 500,\n  fade: true,\n  slide: '.field-image, a',\n  autoplay: true,\n  autoplaySpeed: 4000,\n  dots: true,\n  arrows: true,\n  slidesToShow: 1,\n  slidesToScroll: 1,\n  responsive: [{\n    breakpoint: 690,\n    settings: {\n      arrows: false\n    }\n  }]\n};\n\n/**\n * Gallery Constructor\n */\nfunction Gallery(element, options) {\n  this.element = element;\n  this.$element = (0, _jquery2.default)(element);\n  this.settings = _jquery2.default.extend(true, defaults, options);\n  this.$gallery = this.build();\n  this.ready();\n}\n\nGallery.prototype = {\n  build: function build() {\n    return this.$element.slick(this.settings);\n  },\n  ready: function ready() {\n    this.$element.addClass('ready');\n  }\n};\n\nexports.default = Gallery;\n\n/***/ }),\n/* 12 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = Header;\n\nvar _headroom = __webpack_require__(29);\n\nvar _headroom2 = _interopRequireDefault(_headroom);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n// Headroom settings\nvar settings = {\n  // vertical offset in px before element is first unpinned\n  offset: 105, // @header-height value @see dtheme/less/variables.less\n  // scroll tolerance in px before state changes\n  tolerance: 5, // or {down: 0, up: 0},\n  // css classes to apply\n  classes: {\n    // when element is initialised\n    initial: 'headroom',\n    // when scrolling up\n    pinned: 'locked',\n    // when scrolling down\n    unpinned: 'unlocked',\n    // when above offset\n    top: 'top',\n    // when below offset\n    notTop: 'not-top',\n    // when at bottom of scoll area\n    bottom: 'bottom',\n    // when not at bottom of scroll area\n    notBottom: 'not-bottom'\n  },\n  // callback when pinned, `this` is headroom object\n  onPin: function onPin() {},\n\n  // callback when unpinned, `this` is headroom object\n  onUnpin: function onUnpin() {},\n\n  // callback when above offset, `this` is headroom object\n  onTop: function onTop() {},\n\n  // callback when below offset, `this` is headroom object\n  onNotTop: function onNotTop() {},\n\n  // callback at bottom of page, `this` is headroom object\n  onBottom: function onBottom() {},\n\n  // callback when moving away from bottom of page, `this` is headroom object\n  onNotBottom: function onNotBottom() {}\n};\n\nfunction Header(element) {\n  // Create a new Headroom instance\n  var headroom = new _headroom2.default(element, settings);\n  // Initialize this Headroom instance\n  headroom.init();\n  // Return back the new instance\n  return headroom;\n}\n\n/***/ }),\n/* 13 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nvar _jquery = __webpack_require__(0);\n\nvar _jquery2 = _interopRequireDefault(_jquery);\n\nvar _Viewport = __webpack_require__(1);\n\nvar _Viewport2 = _interopRequireDefault(_Viewport);\n\n__webpack_require__(3);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar defaults = {\n  hoverInit: 250,\n  hoverDelay: 250,\n  selector: 'li.menuparent'\n};\n\nfunction Menu(element, options) {\n  this.element = element;\n  this.$element = (0, _jquery2.default)(element);\n  this.settings = _extends({}, defaults, options);\n  this.$menus = this.getMenus();\n  this.over = _jquery2.default.proxy(this.over, this);\n  this.out = _jquery2.default.proxy(this.out, this);\n  this.listen();\n}\n\nMenu.prototype = {\n  getMenus: function getMenus() {\n    return this.$element.find(this.settings.selector);\n  },\n  over: function over(event) {\n    var $target = (0, _jquery2.default)(event.currentTarget);\n    if (!_Viewport2.default.mobileState) {\n      $target.doTimeout('hide');\n      $target.doTimeout('show', this.settings.hoverInit, function () {\n        $target.addClass('show');\n      });\n    }\n  },\n  out: function out(event) {\n    var $target = (0, _jquery2.default)(event.currentTarget);\n    if (!_Viewport2.default.mobileState) {\n      $target.doTimeout('show');\n      $target.doTimeout('hide', this.settings.hoverDelay, function () {\n        $target.removeClass('show');\n      });\n    }\n  },\n  listen: function listen() {\n    this.$menus.removeClass('show').on('mouseover', this.over).on('mouseout', this.out).on('focusin', this.over).on('focusout', this.out);\n  }\n};\n\nexports.default = Menu;\n\n/***/ }),\n/* 14 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _jquery = __webpack_require__(0);\n\nvar _jquery2 = _interopRequireDefault(_jquery);\n\nvar _Viewport = __webpack_require__(1);\n\nvar _Viewport2 = _interopRequireDefault(_Viewport);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction MobileMenu(element) {\n  this.element = element;\n  this.$roots = this.getRootMenus();\n  this.onClick = _jquery2.default.proxy(this.onClick, this);\n  this.displayActiveMenus();\n  this.listen();\n}\n\nMobileMenu.prototype = {\n  getRootMenus: function getRootMenus() {\n    return (0, _jquery2.default)('a.depth-1', this.element);\n  },\n  onClick: function onClick(event) {\n    var shouldExpand = (0, _jquery2.default)(event.target).is('.menu-link');\n    if (_Viewport2.default.mobileState && shouldExpand) {\n      (0, _jquery2.default)(event.currentTarget).toggleClass('expand');\n      event.preventDefault();\n    }\n  },\n  displayActiveMenus: function displayActiveMenus() {\n    (0, _jquery2.default)('.active-trail a.depth-1:not(.active)', this.element).addClass('expand');\n  },\n  listen: function listen() {\n    this.$roots.on('click', this.onClick);\n  }\n};\n\nexports.default = MobileMenu;\n\n/***/ }),\n/* 15 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _jquery = __webpack_require__(0);\n\nvar _jquery2 = _interopRequireDefault(_jquery);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar key = 'has_seen_alert_';\n\nfunction Notification(element) {\n  this.$element = (0, _jquery2.default)(element);\n  this.click = _jquery2.default.proxy(this.click, this);\n  this.$instance = this.getPost();\n  // Exit if a notifcation post is not found.\n  if (!this.$instance.length) return;\n  // Proceed ->\n  this.storageKey = this.createKey();\n  if (!this.getVariable() && this.$instance.length) {\n    this.listen();\n    this.show();\n  } else {\n    this.hide();\n  }\n}\n\nNotification.prototype = {\n  getPost: function getPost() {\n    return this.$element.find('.node');\n  },\n  createKey: function createKey() {\n    var id = this.$instance.attr('id');\n    return key + /(\\d+)/.exec(id)[0];\n  },\n  getVariable: function getVariable() {\n    return sessionStorage.getItem(this.storageKey) || false;\n  },\n  setVariable: function setVariable() {\n    sessionStorage.setItem(this.storageKey, true);\n  },\n  click: function click(event) {\n    this.setVariable();\n    event.stopPropagation();\n    if ((0, _jquery2.default)(event.target).is('.block, .block-inner')) {\n      event.preventDefault();\n      this.hide();\n    }\n  },\n  hide: function hide() {\n    this.$element.removeClass('show').addClass('hide');\n  },\n  show: function show() {\n    this.$element.addClass('show');\n  },\n  listen: function listen() {\n    this.$element.on('click', this.click);\n  }\n};\n\nexports.default = Notification;\n\n/***/ }),\n/* 16 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nvar _jquery = __webpack_require__(0);\n\nvar _jquery2 = _interopRequireDefault(_jquery);\n\nvar _Change = __webpack_require__(2);\n\nvar _Change2 = _interopRequireDefault(_Change);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar defaults = {\n  speed: 0.35\n};\n\nfunction Parallax(element, options) {\n  this.$element = (0, _jquery2.default)(element);\n  this.settings = _extends({}, defaults, options);\n  this.register();\n  this.update();\n}\n\nParallax.prototype = {\n  register: function register() {\n    _Change2.default.onChange(this.update.bind(this));\n  },\n  update: function update() {\n    var offset = window.pageYOffset * this.settings.speed;\n    this.$element.css('transform', 'translate3d(0, ' + offset + 'px, 0)');\n  }\n};\n\nexports.default = Parallax;\n\n/***/ }),\n/* 17 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _jquery = __webpack_require__(0);\n\nvar _jquery2 = _interopRequireDefault(_jquery);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar Placholder = function Placholder(element) {\n  _classCallCheck(this, Placholder);\n\n  var $label = (0, _jquery2.default)('label', element);\n  var $input = (0, _jquery2.default)('input, textarea', element);\n  if ($label.length && $input.length) {\n    var placeholder = $label.text().replace(':', '');\n    $input.attr('placeholder', placeholder);\n  }\n};\n\nexports.default = Placholder;\n\n/***/ }),\n/* 18 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _jquery = __webpack_require__(0);\n\nvar _jquery2 = _interopRequireDefault(_jquery);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar key = 'has_seen_popup_';\n\nvar DistrictAlert = function () {\n  function DistrictAlert(element) {\n    _classCallCheck(this, DistrictAlert);\n\n    this.$element = (0, _jquery2.default)(element);\n    this.$instance = this.getAlert();\n    this.click = this.click.bind(this);\n    if (this.$instance.length && this.areWeThere) {\n      this.storageKey = this.createKey();\n      if (!this.getVariable()) {\n        this.listen();\n        this.show();\n      }\n    }\n  }\n\n  _createClass(DistrictAlert, [{\n    key: 'getAlert',\n    value: function getAlert() {\n      return this.$element.find('.node');\n    }\n  }, {\n    key: 'createKey',\n    value: function createKey() {\n      var id = this.$instance.attr('id');\n      return key + /(\\d+)/.exec(id)[0];\n    }\n  }, {\n    key: 'getVariable',\n    value: function getVariable() {\n      return sessionStorage.getItem(this.storageKey) || false;\n    }\n  }, {\n    key: 'setVariable',\n    value: function setVariable() {\n      sessionStorage.setItem(this.storageKey, true);\n    }\n  }, {\n    key: 'click',\n    value: function click(event) {\n      this.setVariable();\n      event.stopPropagation();\n\n      if ((0, _jquery2.default)(event.target).is('.block, .node-links')) {\n        event.preventDefault();\n        this.hide();\n      }\n    }\n  }, {\n    key: 'hide',\n    value: function hide() {\n      this.$element.removeClass('show');\n    }\n  }, {\n    key: 'show',\n    value: function show() {\n      this.$element.addClass('show');\n    }\n  }, {\n    key: 'listen',\n    value: function listen() {\n      this.$element.on('click', this.click);\n    }\n  }, {\n    key: 'areWeThere',\n    get: function get() {\n      var url = this.$element.find('.link-read-more a').attr('href');\n      var currentURL = document.location.pathname;\n      return url !== currentURL;\n    }\n  }]);\n\n  return DistrictAlert;\n}();\n\nexports.default = DistrictAlert;\n\n/***/ }),\n/* 19 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _jquery = __webpack_require__(0);\n\nvar _jquery2 = _interopRequireDefault(_jquery);\n\nvar _Change = __webpack_require__(2);\n\nvar _Change2 = _interopRequireDefault(_Change);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction Footer(element, $footprint) {\n  this.$element = (0, _jquery2.default)(element);\n  this.$footprint = $footprint;\n  this.register();\n  this.update();\n  this.ready();\n}\n\nFooter.prototype = {\n  register: function register() {\n    _Change2.default.onChange(this.update.bind(this));\n  },\n  update: function update() {\n    this.$footprint.height(this.$element.outerHeight());\n  },\n  ready: function ready() {\n    this.$element.addClass('ready');\n  }\n};\n\nexports.default = Footer;\n\n/***/ }),\n/* 20 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _jquery = __webpack_require__(0);\n\nvar _jquery2 = _interopRequireDefault(_jquery);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar defaults = {\n  fade: true,\n  speed: 500,\n  dots: true,\n  arrows: false,\n  responsive: [{\n    breakpoint: 768,\n    settings: {\n      fade: false,\n      speed: 200\n    }\n  }]\n};\n\nvar StoriesSlider = function () {\n  function StoriesSlider(element, options) {\n    _classCallCheck(this, StoriesSlider);\n\n    this.$element = (0, _jquery2.default)(element);\n    this.settings = _extends({}, defaults, options);\n    this.slider = this.createSlider();\n    this.ready();\n  }\n\n  _createClass(StoriesSlider, [{\n    key: 'createSlider',\n    value: function createSlider() {\n      return this.$element.find('.view-content').slick(this.settings);\n    }\n  }, {\n    key: 'ready',\n    value: function ready() {\n      this.$element.addClass('ready');\n    }\n  }]);\n\n  return StoriesSlider;\n}();\n\nexports.default = StoriesSlider;\n\n/***/ }),\n/* 21 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _jquery = __webpack_require__(0);\n\nvar _jquery2 = _interopRequireDefault(_jquery);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction Stripper(element) {\n  this.$element = (0, _jquery2.default)(element);\n  this.strip();\n}\n\nStripper.prototype = {\n  strip: function strip() {\n    this.$element.children().unwrap();\n  }\n};\n\nexports.default = Stripper;\n\n/***/ }),\n/* 22 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _jquery = __webpack_require__(0);\n\nvar _jquery2 = _interopRequireDefault(_jquery);\n\nvar _Viewport = __webpack_require__(1);\n\nvar _Viewport2 = _interopRequireDefault(_Viewport);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction TermNavigation(element) {\n  this.element = element;\n  this.$element = (0, _jquery2.default)(element);\n  this.$menus = this.getMenus();\n  this.onHeaderClick = _jquery2.default.proxy(this.onHeaderClick, this);\n  this.setCurrentState();\n  this.addPatties();\n  this.listen();\n  this.ready();\n}\n\nTermNavigation.prototype = {\n  getMenus: function getMenus() {\n    var $menus = this.$element.find('.block-content .expanded');\n    var $filteredMenus = $menus.has('li a');\n    $menus.removeClass('expanded');\n    $filteredMenus.addClass('expanded');\n    return $filteredMenus;\n  },\n  onHeaderClick: function onHeaderClick(event) {\n    if (_Viewport2.default.mobileState) {\n      this.$element.toggleClass('expanded');\n      event.preventDefault();\n    }\n  },\n  onMenuClick: function onMenuClick(event) {\n    var clickedActivator = (0, _jquery2.default)(event.target).is('.menu-link');\n    if (clickedActivator) {\n      (0, _jquery2.default)(this).parent().toggleClass('expanded collapsed');\n      event.preventDefault();\n    }\n  },\n  addPatties: function addPatties() {\n    var patties = '<span class=\"patty\"></span><span class=\"patty\"></span><span class=\"patty\"></span>';\n    this.$element.find('.block-title a').prepend(patties);\n  },\n  setCurrentState: function setCurrentState() {\n    // set all to collapsed other than the active items\n    this.$menus.not('.active-trail').toggleClass('expanded collapsed');\n  },\n  listen: function listen() {\n    // Add a click handler to control each submenu's visibility\n    this.$menus.find(' > a').bind('click', this.onMenuClick);\n    // Add a click handler to control the mobile dropdown menu\n    this.$element.find('.block-title a').bind('click', this.onHeaderClick);\n  },\n  ready: function ready() {\n    this.$element.addClass('ready');\n  }\n};\n\nexports.default = TermNavigation;\n\n/***/ }),\n/* 23 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _jquery = __webpack_require__(0);\n\nvar _jquery2 = _interopRequireDefault(_jquery);\n\n__webpack_require__(3);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar defaults = {\n  delay: 400,\n  selectors: {\n    menu: '.menu-icon',\n    search: '.search-icon',\n    text: '#edit-box-text',\n    input: '#edit-keywords'\n  }\n};\n\nfunction Toolbar(element, context, options) {\n  this.element = element;\n  this.$element = (0, _jquery2.default)(element);\n  this.settings = _jquery2.default.extend(true, defaults, options);\n  this.$body = this.getBody(context);\n  this.$menuBtn = this.getBtn('menu');\n  this.$searchBtn = this.getBtn('search');\n  this.$searchBox = this.getBox(context);\n  this.searchText = this.getText(context);\n  this.menuHandler = _jquery2.default.proxy(this.menuHandler, this);\n  this.searchHandler = _jquery2.default.proxy(this.searchHandler, this);\n  this.resetSearchInput = _jquery2.default.proxy(this.resetSearchInput, this);\n  this.listen();\n}\n\nToolbar.prototype = {\n  getBody: function getBody(context) {\n    return (0, _jquery2.default)(document.body, context);\n  },\n  getBtn: function getBtn(type) {\n    return (0, _jquery2.default)(this.settings.selectors[type], this.element);\n  },\n  getText: function getText(context) {\n    var $searchText = (0, _jquery2.default)(this.settings.selectors.text, context);\n    // clear out the value since we don't want it displayed\n    var searchText = $searchText.val();\n    $searchText.val('');\n    return searchText;\n  },\n  getBox: function getBox(context) {\n    var $input = (0, _jquery2.default)(this.settings.selectors.input, context);\n    $input.val('');\n    return $input;\n  },\n  menuHandler: function menuHandler() {\n    var active = this.$body.is('.menu-active');\n    this.$body.filter('.search-active').removeClass('search-active');\n    if (active) {\n      this.$body.removeClass('menu-active');\n    } else {\n      this.$body.addClass('menu-active');\n    }\n  },\n  searchHandler: function searchHandler() {\n    var _this = this;\n\n    var active = this.$body.is('.search-active');\n    this.$body.filter('.menu-active').removeClass('menu-active');\n    if (active) {\n      this.$body.removeClass('search-active');\n      // Cancel any search input timeouts that may be running.\n      this.$searchBox.doTimeout('focus');\n      this.$searchBox.doTimeout('typing');\n    } else {\n      this.$body.addClass('search-active');\n      this.$searchBox.attr('placeholder', '');\n      // Focus the search box after a small delay.\n      this.$searchBox.doTimeout('focus', 750, function () {\n        _this.typeOutPlaceholderText();\n      });\n    }\n  },\n  typeOutPlaceholderText: function typeOutPlaceholderText() {\n    var _this2 = this;\n\n    var i = 0;\n    if (!this.$searchBox.val().length) {\n      this.$searchBox.doTimeout('typing', 60, function () {\n        if (i <= _this2.searchText.length) {\n          _this2.$searchBox.attr('placeholder', _this2.searchText.substr(0, i)).focus();\n          i += 1;\n          return true;\n        }\n\n        return false;\n      });\n    }\n  },\n  resetSearchInput: function resetSearchInput() {\n    // This is a workaround to overcome the default dd-search.js search\n    // input scripted behaviors.\n    if (this.searchText === this.$searchBox.val()) {\n      this.$searchBox.val('');\n    }\n  },\n  listen: function listen() {\n    this.$menuBtn.bind('click', this.menuHandler);\n    this.$searchBtn.bind('click', this.searchHandler);\n\n    // Listening so that we can override previously set scripted behaviors.\n    this.$searchBox.bind('blur focus', this.resetSearchInput);\n  }\n};\n\nexports.default = Toolbar;\n\n/***/ }),\n/* 24 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _jquery = __webpack_require__(0);\n\nvar _jquery2 = _interopRequireDefault(_jquery);\n\nvar _Viewport = __webpack_require__(1);\n\nvar _Viewport2 = _interopRequireDefault(_Viewport);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar SELECTOR = '.google-translate';\nvar GOOGLE_TRANSLATE = '.goog-te-gadget';\n\nvar Translate = function () {\n  function Translate(element) {\n    _classCallCheck(this, Translate);\n\n    this.google = null;\n    this.$element = (0, _jquery2.default)(element);\n    this.change = this.change.bind(this);\n    this.translateElement = this.translateElement.bind(this);\n    this.$desktop = this.getDesktopPlacement();\n    this.$mobile = this.getMobilePlacement();\n    this.load();\n  }\n\n  _createClass(Translate, [{\n    key: 'getMobilePlacement',\n    value: function getMobilePlacement() {\n      return this.$element.find('.header-bottom ' + SELECTOR);\n    }\n  }, {\n    key: 'getDesktopPlacement',\n    value: function getDesktopPlacement() {\n      return this.$element.find('.header-top ' + SELECTOR);\n    }\n  }, {\n    key: 'load',\n    value: function load() {\n      var _this = this;\n\n      // Load Google Translate framework.\n      var script = document.createElement('script');\n      script.async = true;\n      script.type = 'text/javascript';\n      script.src = '//translate.google.com/translate_a/element.js?cb=googleTranslateInit';\n      var head = document.getElementsByTagName('head')[0];\n      head.appendChild(script);\n\n      // Add window callback function to signal when the framework is ready.\n      window.googleTranslateInit = function () {\n        _this.google = window.google;\n        _this.translateElement();\n        _this.listen();\n      };\n    }\n  }, {\n    key: 'translateElement',\n    value: function translateElement() {\n      return new this.google.translate.TranslateElement(this.settings, 'google-translate');\n    }\n  }, {\n    key: 'listen',\n    value: function listen() {\n      _Viewport2.default.onChange(this.change);\n      _Viewport2.default.requestTick();\n    }\n  }, {\n    key: 'change',\n    value: function change() {\n      var $gt = this.$element.find(GOOGLE_TRANSLATE);\n      var mode = _Viewport2.default.mobileState ? this.$mobile : this.$desktop;\n      mode.append($gt);\n    }\n  }, {\n    key: 'settings',\n    get: function get() {\n      return {\n        pageLanguage: 'en',\n        layout: this.google.translate.TranslateElement.FloatPosition.BOTTOM_RIGHT\n      };\n    }\n  }]);\n\n  return Translate;\n}();\n\nexports.default = Translate;\n\n/***/ }),\n/* 25 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nvar _jquery = __webpack_require__(0);\n\nvar _jquery2 = _interopRequireDefault(_jquery);\n\n__webpack_require__(4);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar GET_TWEETS_URL = '/dd_twitter_feed/get_tweets';\n\nvar requestData = {\n  cache: true,\n  dataType: 'html'\n};\n\nvar slickSettings = {\n  speed: 200,\n  dots: true,\n  arrows: false,\n  slidesToShow: 3,\n  slidesToScroll: 1,\n  responsive: [{\n    breakpoint: 1024,\n    settings: {\n      slidesToShow: 2,\n      slidesToScroll: 1,\n      variableWidth: true\n    }\n  }, {\n    breakpoint: 768,\n    settings: {\n      slidesToShow: 1,\n      slidesToScroll: 1,\n      adaptiveHeight: true\n    }\n  }]\n};\n\nvar TwitterFeed = function () {\n  function TwitterFeed(element) {\n    _classCallCheck(this, TwitterFeed);\n\n    this.$element = (0, _jquery2.default)(element);\n    this.success = this.success.bind(this);\n    this.complete = this.complete.bind(this);\n    this.request = this.sendRequest();\n  }\n\n  _createClass(TwitterFeed, [{\n    key: 'sendRequest',\n    value: function sendRequest() {\n      return _jquery2.default.ajax(GET_TWEETS_URL, requestData).success(this.success).complete(this.complete);\n    }\n  }, {\n    key: 'success',\n    value: function success(data) {\n      var $tweets = this.$element.find('.tweets');\n      $tweets.html(data);\n      $tweets.slick(slickSettings);\n    }\n  }, {\n    key: 'complete',\n    value: function complete() {\n      this.$element.addClass('ready');\n    }\n  }]);\n\n  return TwitterFeed;\n}();\n\nexports.default = TwitterFeed;\n\n/***/ }),\n/* 26 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nvar _jquery = __webpack_require__(0);\n\nvar _jquery2 = _interopRequireDefault(_jquery);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar defaults = {\n  showVideoAtThisBreakpoint: 720,\n  playBtn: '<button class=\"slick-play slick-btn\" type=\"button\" aria-label=\"Play\">Play</button>',\n  pauseBtn: '<button class=\"slick-pause slick-btn\" type=\"button\" aria-label=\"Pause\">Pause</button>'\n};\n\nfunction Video(element, options) {\n  this.element = element;\n  this.$element = (0, _jquery2.default)(element);\n  this.settings = _extends({}, defaults, options);\n  this.video = null;\n  this.playing = false;\n  this.playPause = this.playPause.bind(this);\n  this.$playBtn = this.addPlayBtn();\n  this.$pauseBtn = this.addPauseBtn();\n  this.$bgVideo = this.getVideo();\n  this.$destination = this.getDestination();\n  this.init();\n}\n\nVideo.prototype = {\n  init: function init() {\n    // if the background element or image isn't found, quit.\n    if (!this.$bgVideo.length || !this.$destination) return;\n    // show if applicable\n    if ((0, _jquery2.default)(window).width() >= this.settings.showVideoAtThisBreakpoint && !this.isMobileDevice()) {\n      this.addVideo();\n    }\n  },\n  isMobileDevice: function isMobileDevice() {\n    return (/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent)\n    );\n  },\n  getVideo: function getVideo() {\n    return this.$element.find('.background-video');\n  },\n  getDestination: function getDestination() {\n    return this.$element.find('.field-image.c1 img');\n  },\n  addPlayBtn: function addPlayBtn() {\n    return (0, _jquery2.default)(this.settings.playBtn);\n  },\n  addPauseBtn: function addPauseBtn() {\n    return (0, _jquery2.default)(this.settings.pauseBtn);\n  },\n  addVideo: function addVideo() {\n    var _this = this;\n\n    var $source = this.$bgVideo.find('.video');\n    var $check = $source.data('src');\n    var sources = void 0;\n    if (typeof $check !== 'undefined') {\n      sources = $source.data('src').replace(/\\s/g, '').split(',');\n    }\n    var $video = (0, _jquery2.default)('<video autoplay loop muted></video>');\n\n    // Assign the video element so we can use it.\n    this.video = $video[0];\n\n    _jquery2.default.each(sources, function (i, src) {\n      var type = src.substring(src.lastIndexOf('.') + 1);\n      $video.append('<source src=\"' + src + '\" type=\"video/' + type + '\">');\n    });\n\n    this.$destination.replaceWith($video);\n\n    // Fired when the browser has finished loading the metadata for the video\n    // and all attributes have been populated.\n    $video.bind('loadeddata', function () {\n      _this.$element.addClass('ready');\n      _this.addControls();\n    });\n\n    // Fired when the video starts playing, for the first time, after being paused\n    // or when restarting.\n    $video.bind('playing', function () {\n      _this.playing = true;\n      _this.setCurrentState();\n    });\n\n    // Add a helper class to possibly style this block differently if a video is present.\n    this.$element.addClass('has-background-video');\n\n    // Delete temp markup\n    this.$bgVideo.remove();\n  },\n  addControls: function addControls() {\n    // Add play and pause the controls and finally add the controls container\n    this.$element.append(this.$playBtn, this.$pauseBtn);\n\n    // Add click handlers to each button to control autoplay functionality\n    this.$playBtn.on('click', this.playPause);\n    this.$pauseBtn.on('click', this.playPause);\n  },\n  playPause: function playPause() {\n    if (this.playing) {\n      this.video.pause();\n      this.playing = false;\n    } else {\n      this.video.play();\n      this.playing = true;\n    }\n    this.setCurrentState();\n  },\n  setPlayState: function setPlayState() {\n    this.$playBtn.attr('aria-hidden', 'false');\n    this.$pauseBtn.attr('aria-hidden', 'true');\n  },\n  setPauseState: function setPauseState() {\n    this.$playBtn.attr('aria-hidden', 'true');\n    this.$pauseBtn.attr('aria-hidden', 'false');\n  },\n  setCurrentState: function setCurrentState() {\n    if (this.playing) {\n      this.setPauseState();\n    } else {\n      this.setPlayState();\n    }\n  }\n};\n\nexports.default = Video;\n\n/***/ }),\n/* 27 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// Define a module that works with CommonJS (Node/Babel) and AMD (RequireJS).\n(function(factory) {\n  if (true) {\n    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(0)], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?\n\t\t\t\t(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n  } else {\n    module.exports = factory(require('jquery'));\n  }\n})(function($) {\n  'use strict';\n\n  var defaults = {\n    photoGalleryPID: 107,\n    behaviors: {\n      relatedLinks: true,\n      itemAppearsIn: true,\n      fullNodeRelatedLinks: true,\n      bundledReferringContent: true,\n      lexiconGlossary: true,\n      subtermOverviews: true,\n      nodeMeta: true,\n      imageCaptions: true,\n      slideshowIcons: true,\n      expandingDates: true\n    }\n  };\n\n  var DDTemplates = function(context, options) {\n    this.context = context;\n    this._defaults = defaults;\n    this.isNodeView = this.isNode(context);\n    this.settings = $.extend(true, defaults, options);\n    this.init();\n  };\n\n  DDTemplates.prototype = {\n    init: function() {\n      var context = this.context;\n      var view = this.isNodeView ? 'node' : 'term';\n      // Global behaviors\n      this.defineApplicableBehaviors('global', context);\n      // Current view behaviors only\n      this.defineApplicableBehaviors(view, context);\n    },\n    /**\n     * Simple check to see if the current body element contains the node class.\n     */\n    isNode: function(context) {\n      return $(document.body, context).is('.n, .section-node');\n    },\n    /**\n     * A way to enable only behaviors the theme requires.\n     */\n    addEnabledBehavior: function(behavior) {\n      var enabled = this.settings.behaviors[behavior];\n      if (enabled) {\n        this[behavior](this.context);\n      }\n      return true;\n    },\n    /**\n     * Segregates behaviors by different types of common views. If they're\n     * enabled, define them in this module.\n     */\n    defineApplicableBehaviors: function(view) {\n      var self = this;\n      var behaviors = {\n        node: [\n          'itemAppearsIn',\n          'fullNodeRelatedLinks',\n          'bundledReferringContent'\n        ],\n        term: [\n          'lexiconGlossary',\n          'subtermOverviews'\n        ],\n        global: [\n          'nodeMeta',\n          'relatedLinks',\n          'imageCaptions',\n          'slideshowIcons',\n          'expandingDates'\n        ]\n      };\n\n      // Cycle through each behavior and only add it if it's enabled\n      $.each(behaviors[view], function(i, behavior) {\n        self.addEnabledBehavior(behavior);\n      });\n\n      return true;\n    },\n    /**\n     * Helper class for theming related links sitewide.\n     * @status DEPRECATED\n     */\n    relatedLinks: function() {},\n    /**\n     * Helper class for theming the appearing navigation block\n     */\n    itemAppearsIn: function(context) {\n      var $appearingNav = $('.appearing-nav', context);\n      var $links = $appearingNav.find('ul.links li');\n      if (!$links.length) {\n        $appearingNav.addClass('placeholder-block');\n      }\n    },\n    /**\n     * Sets the block to show if one or more links are found\n     */\n    fullNodeRelatedLinks: function(context) {\n      var $nodeFields = $('#block-digitaldcore-node_fields',context);\n      var $relatedLinks = $nodeFields.find('.node-links');\n      var numLinks = $relatedLinks.find('.link-related, .link-file').length;\n\n      if (!numLinks) {\n        $relatedLinks.addClass('placeholder-block');\n      }\n    },\n    /**\n     * Hides the blocks if no content is present.\n     */\n    bundledReferringContent: function(context) {\n      var $blocks = $('#block-digitaldcore-node_referring, #block-digitaldcore-node_bundled', context);\n      $blocks.each(function() {\n        var $block = $(this);\n        var $nodes = $block.find('.node-teaser');\n        if (!$nodes.length) {\n          $block.addClass('placeholder-block');\n        }\n      });\n    },\n    /**\n     * Finds the real last meta item and identifies node of visible meta info\n     */\n    nodeMeta: function(context) {\n      var $nodes = $('.node', context);\n      $nodes.each(function() {\n        // Create a meta object\n        var $node = $(this);\n        var $meta = $node.find('.node-upper-meta');\n        var $items = $meta.find('.meta-item');\n\n        // Clean up last classname\n        $items.removeClass('last');\n\n        // Get all visible meta items\n        var $visible = $items.map(function() {\n          return $(this).css('display') !== 'none' ? this : null;\n        });\n\n        // Correctly identify last meta item and label node with the has-meta flag\n        if ($visible.length) {\n          $node.addClass('has-meta');\n          $visible.filter(':last').addClass('last new-dd-templates-functionality');\n        }\n      });\n    },\n    /**\n     * If there is more than two event dates, functionality is added to show and\n     * hide all events within one container.\n     *\n     * Helps cleans up the look of meta data.\n     *\n     * @note:\n     *   This is only enabled for blocks with the 'posts' classname and all\n     *   full post views\n     */\n    expandingDates: function(context) {\n      $('.posts .node, .node-full', context).each(function(i, node) {\n        var $meta = $('.node-meta, .node-upper-meta', node);\n        $meta.each(function(i, meta) {\n          var $meta = $(meta);\n          var $dates = $('.event-date', node);\n          if ($dates.length > 2) {\n            // Create and add functionality to display all other dates\n            var $link = $('<a class=\"meta-item all-dates-link\" href=\"#\">Show all dates</a>');\n            $link.bind('click', function(event) {\n              event.preventDefault();\n              $meta.toggleClass('show-all-dates');\n              $(this).text(\n                $meta.is('.show-all-dates')\n                  ? 'Hide all dates'\n                  : 'Show all dates'\n              );\n            });\n            $link.insertBefore($dates.eq(0));\n\n            // Move all other dates\n            var $container = $('<div class=\"all-dates\"></div>');\n            $dates.appendTo($container);\n            $meta.append($container);\n          }\n        });\n      });\n    },\n    /**\n     * Field image caption control\n     */\n    imageCaptions: function(context) {\n      // Identifies an image that should have a caption added\n      $('.field-image img[title]', context).each(function() {\n        var $image = $(this);\n        var caption = $image.attr('title');\n        // Continue processing this title isn't an empty string\n        if (caption.length) {\n          var $field = $image.parents('.field-image');\n          var $link = $field.find('a');\n          // delete the existing caption if it exists\n          $field.find('.caption').remove();\n          // Add a helper class for theming\n          $field.addClass('has-caption');\n          // Add the caption to the link\n          $link.append('<span class=\"caption\">' + caption + '</span>');\n          // Sets the container link a maximum width so the caption doesn't expand\n          // bigger than the image width\n          //var imgWidth = $image.attr('width');\n          //if (imgWidth && imgWidth > 0) {\n          //  $link.css('max-width', imgWidth + 'px');\n          //}\n        }\n      });\n    },\n    /**\n     * Adds markup to slideshow teasers to show an icon overlay\n     */\n    slideshowIcons: function(context) {\n      var $slideshowNodes = $('.pt' + this.settings.photoGalleryPID + '.node-teaser', context);\n      // cycle through each node instance\n      $slideshowNodes.each(function() {\n        var $images = $(this).find('.field-image');\n        // cycle through each field image instance\n        $images.each(function() {\n          var $img = $(this).find('img');\n          // add a button helper classname\n          $(this).find('a').addClass('slideshow-btn');\n          // prepend the icon overlay\n          $img.before('<i class=\"slideshow-icon\"></i>');\n        });\n      });\n\n    },\n    /**\n     * Adds the has more class to subterm overviews to properly control node-link display\n     */\n    subtermOverviews: function(context) {\n      $('.subterm-overview .node-teaser', context).removeClass('no-more').addClass('has-more');\n    },\n    /**\n     * Helper function to theme the category letters and seperate the sections\n     */\n    lexiconGlossary: function(context) {\n      $('#glossary', context).find('.lexicon-list > a').each(function() {\n        var letter = $(this).attr('id').replace('letter_', '');\n        $(this).html(letter.toUpperCase());\n      });\n    }\n  };\n\n  return DDTemplates;\n\n});\n\n\n/***/ }),\n/* 28 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar _jquery = __webpack_require__(0);\n\nvar _jquery2 = _interopRequireDefault(_jquery);\n\nvar _ddTemplates = __webpack_require__(27);\n\nvar _ddTemplates2 = _interopRequireDefault(_ddTemplates);\n\nvar _Menu = __webpack_require__(13);\n\nvar _Menu2 = _interopRequireDefault(_Menu);\n\nvar _Drupal = __webpack_require__(8);\n\nvar _Drupal2 = _interopRequireDefault(_Drupal);\n\nvar _Header = __webpack_require__(12);\n\nvar _Header2 = _interopRequireDefault(_Header);\n\nvar _Gallery = __webpack_require__(11);\n\nvar _Gallery2 = _interopRequireDefault(_Gallery);\n\nvar _Toolbar = __webpack_require__(23);\n\nvar _Toolbar2 = _interopRequireDefault(_Toolbar);\n\nvar _MobileMenu = __webpack_require__(14);\n\nvar _MobileMenu2 = _interopRequireDefault(_MobileMenu);\n\nvar _SmartFooter = __webpack_require__(19);\n\nvar _SmartFooter2 = _interopRequireDefault(_SmartFooter);\n\nvar _CalendarFeed = __webpack_require__(6);\n\nvar _CalendarFeed2 = _interopRequireDefault(_CalendarFeed);\n\nvar _FixNavigation = __webpack_require__(10);\n\nvar _FixNavigation2 = _interopRequireDefault(_FixNavigation);\n\nvar _TermNavigation = __webpack_require__(22);\n\nvar _TermNavigation2 = _interopRequireDefault(_TermNavigation);\n\nvar _Strip = __webpack_require__(21);\n\nvar _Strip2 = _interopRequireDefault(_Strip);\n\nvar _Notification = __webpack_require__(15);\n\nvar _Notification2 = _interopRequireDefault(_Notification);\n\nvar _DistrictAlert = __webpack_require__(7);\n\nvar _DistrictAlert2 = _interopRequireDefault(_DistrictAlert);\n\nvar _PopupAlert = __webpack_require__(18);\n\nvar _PopupAlert2 = _interopRequireDefault(_PopupAlert);\n\nvar _BackgroundImage = __webpack_require__(5);\n\nvar _BackgroundImage2 = _interopRequireDefault(_BackgroundImage);\n\nvar _Placeholder = __webpack_require__(17);\n\nvar _Placeholder2 = _interopRequireDefault(_Placeholder);\n\nvar _Parallax = __webpack_require__(16);\n\nvar _Parallax2 = _interopRequireDefault(_Parallax);\n\nvar _Expanded = __webpack_require__(9);\n\nvar _Expanded2 = _interopRequireDefault(_Expanded);\n\nvar _TwitterFeed = __webpack_require__(25);\n\nvar _TwitterFeed2 = _interopRequireDefault(_TwitterFeed);\n\nvar _StoriesSlider = __webpack_require__(20);\n\nvar _StoriesSlider2 = _interopRequireDefault(_StoriesSlider);\n\nvar _Translate = __webpack_require__(24);\n\nvar _Translate2 = _interopRequireDefault(_Translate);\n\nvar _Video = __webpack_require__(26);\n\nvar _Video2 = _interopRequireDefault(_Video);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n// Add the theme behaviors\n\n// Relative theme specific imports\n\n// Relative imports\n// Absolute imports\n_Drupal2.default.behavior(function (context) {\n  // Helpers\n\n  var $body = (0, _jquery2.default)(document.body, context);\n\n  // DD Template Behaviors\n\n  // eslint-disable-next-line no-new\n  new _ddTemplates2.default(context);\n\n  // Fix our damn menus from displaying orphaned children\n\n  (0, _jquery2.default)('.primary-navigation, .term-nav', context).each(function (i, element) {\n    if (!element.FixNavigation) {\n      element.FixNavigation = new _FixNavigation2.default(element);\n    }\n  });\n\n  // Get bundled content from URL\n  var postUrl = (0, _jquery2.default)('.hero.banner .node-header a', context).attr('href');\n  _jquery2.default.get(postUrl, function (data) {\n    var elements = (0, _jquery2.default)(data);\n    var bundledContent = (0, _jquery2.default)('.bundled-posts article', elements);\n    bundledContent.each(function (i, element) {\n      (0, _jquery2.default)('.bundled-wrapper').append(element);\n    });\n\n    // Add a wrapper around bundled content items that contains a URL to the node\n    (0, _jquery2.default)('.hero.banner .node-inner', context).each(function (i, element) {\n      (0, _jquery2.default)('.bundled-wrapper .links', element).each(function (j, item) {\n        var wrapper = (0, _jquery2.default)(item).parent().parent().parent();\n        var newLink = document.createElement('a');\n        (0, _jquery2.default)(newLink).addClass('wrapped-link');\n        (0, _jquery2.default)(newLink).attr('href', (0, _jquery2.default)(item).find('.link-read-more a').attr('href'));\n        wrapper.wrap(newLink);\n      });\n    });\n  });\n\n  // Add wrapper for bundled content\n  (0, _jquery2.default)('.hero.banner .views-row .node-inner', context).each(function (i, element) {\n    var d = document.createElement('div');\n    (0, _jquery2.default)(d).addClass('bundled-wrapper');\n    (0, _jquery2.default)(d).appendTo(element);\n  });\n\n  // Move .node-image to another parent\n  (0, _jquery2.default)('.hero.banner .node-image', context).each(function (i, element) {\n    (0, _jquery2.default)('.hero.banner article').append(element);\n  });\n\n  (0, _jquery2.default)('.hero.banner .node-inner', context).each(function (i, element) {\n    var elements = (0, _jquery2.default)(element).find('.node-upper-meta, .node-header, .node-content, .node-links');\n    var newElement = document.createElement('div');\n    (0, _jquery2.default)(newElement).addClass('content-inner');\n    (0, _jquery2.default)(elements).each(function (j, item) {\n      newElement.append(item);\n    });\n    element.append(newElement);\n  });\n\n  // Main/Primary Site Navigation\n  (0, _jquery2.default)('#block-nice_menus-3', context).each(function (i, element) {\n    if (!element.menu && !element.mobileMenu) {\n      element.menu = new _Menu2.default(element);\n      element.mobileMenu = new _MobileMenu2.default(element);\n    }\n  });\n\n  // Notifications\n\n  (0, _jquery2.default)('#block-views_blocks-term-block_1-4', context).each(function (i, element) {\n    if (!element.Notification) {\n      element.Notification = new _Notification2.default(element);\n    }\n  });\n\n  // District Alerts\n\n  (0, _jquery2.default)('#block-views_blocks-term-block_1-11', context).each(function (i, element) {\n    if (!element.DistrictAlert) {\n      element.DistrictAlert = new _DistrictAlert2.default(element);\n    }\n  });\n\n  // Popup Alert\n\n  (0, _jquery2.default)('.popup-alert', context).each(function (i, element) {\n    if (!element.PopupAlert) {\n      element.PopupAlert = new _PopupAlert2.default(element);\n    }\n  });\n\n  // Resource Slidemenus\n\n  (0, _jquery2.default)('.slidemenu.block .views-row', context).each(function (i, element) {\n    if (!element.Expanded) {\n      element.Expanded = new _Expanded2.default(element);\n    }\n  });\n\n  // Twitter Feed\n\n  (0, _jquery2.default)('.twitter-feed', context).each(function (i, element) {\n    if (!element.TwitterFeed) {\n      element.TwitterFeed = new _TwitterFeed2.default(element);\n    }\n  });\n\n  // Stories Slider\n\n  (0, _jquery2.default)('#block-views_blocks-term-block_1-8', context).each(function (i, element) {\n    if (!element.StoriesSlider) {\n      element.StoriesSlider = new _StoriesSlider2.default(element);\n    }\n  });\n\n  // Controls the states of the menu and search states\n\n  (0, _jquery2.default)('.site-toolbar', context).each(function (i, element) {\n    if (!element.toolbar) {\n      element.toolbar = new _Toolbar2.default(element);\n    }\n  });\n\n  // Controls the page overlay display\n\n  (0, _jquery2.default)('.overlay', context).bind('click', function () {\n    $body.removeClass('menu-active search-active');\n  });\n\n  // Hero and Term Banner Parallax Backgrounds\n\n  (0, _jquery2.default)('.banner.block .field-image a', context).each(function (i, element) {\n    if (!element.Parallax) {\n      element.Parallax = new _Parallax2.default(element);\n      $body.addClass('has-banner');\n    }\n  });\n\n  // Hero Banner Video Backgrounds\n\n  (0, _jquery2.default)('#block-views_blocks-term-block_1-6', context).each(function (i, element) {\n    if (!element.Video) {\n      element.Video = new _Video2.default(element);\n    }\n  });\n\n  // Pod Background Images\n\n  (0, _jquery2.default)('.pods.block .node, .home-pods.block .node', context).each(function (i, element) {\n    if (!element.BackgroundImage) {\n      element.BackgroundImage = new _BackgroundImage2.default(element);\n    }\n  });\n\n  // Add placeholder text to all text and textarea components.\n\n  (0, _jquery2.default)('.node-webform .type-textfield, .node-webform .type-textarea', context).each(function (i, element) {\n    if (!element.Placeholder) {\n      element.Placeholder = new _Placeholder2.default(element);\n    }\n  });\n\n  // Fixed Header using Headroom.js\n\n  (0, _jquery2.default)('.headroom', context).each(function (i, element) {\n    if (!element.headroom) {\n      element.headroom = new _Header2.default(element);\n    }\n  });\n\n  // Smart Footer\n\n  (0, _jquery2.default)('.page-footer', context).each(function (i, footer) {\n    var $footprint = (0, _jquery2.default)('.footprint', context);\n    if (!footer.smartFooter && $footprint.length) {\n      footer.smartFooter = new _SmartFooter2.default(footer, $footprint);\n    }\n  });\n\n  // Term Navigation\n\n  (0, _jquery2.default)('.term-nav', context).each(function (i, element) {\n    if (!element.termNavigation) {\n      element.termNavigation = new _TermNavigation2.default(element);\n    }\n  });\n\n  // Photo Galleries\n\n  (0, _jquery2.default)('.node-content .photo-gallery, .photo-gallery .node-image, .photo-gallery .node-upper-image', context).each(function (i, element) {\n    if (!element.gallery) {\n      element.gallery = new _Gallery2.default(element);\n    }\n  });\n\n  // Calendar of Events View\n\n  (0, _jquery2.default)('.calendar-feed', context).each(function (i, element) {\n    if (!element.calendarFeed) {\n      element.calendarFeed = new _CalendarFeed2.default(element);\n    }\n  });\n\n  // Strip various header links\n\n  (0, _jquery2.default)('.footer-links .node-header a, .overview .node-header a', context).each(function (i, element) {\n    if (!element.strip) {\n      element.strip = new _Strip2.default(element);\n    }\n  });\n\n  // Relocate Google Translate dependent on viewport\n  (0, _jquery2.default)('.page-header', context).each(function (i, element) {\n    if (!element.Translate) {\n      element.Translate = new _Translate2.default(element);\n    }\n  });\n\n  // Add Sitemap output using the digitaldcore.js function\n\n  var $map = (0, _jquery2.default)('#sitemap', context);\n  var $nav = (0, _jquery2.default)('#sitemap .content', context);\n\n  if ($map.length && $nav.length) {\n    _Drupal2.default.digitaldcoreCreateSiteMap($map, $nav);\n    $map.addClass('ready');\n  }\n});\n\n/***/ }),\n/* 29 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!\n * headroom.js v0.9.3 - Give your page some headroom. Hide your header until you need it\n * Copyright (c) 2016 Nick Williams - http://wicky.nillia.ms/headroom.js\n * License: MIT\n */\n\n(function(root, factory) {\n  'use strict';\n\n  if (true) {\n    // AMD. Register as an anonymous module.\n    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?\n\t\t\t\t(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n  }\n  else if (typeof exports === 'object') {\n    // COMMONJS\n    module.exports = factory();\n  }\n  else {\n    // BROWSER\n    root.Headroom = factory();\n  }\n}(this, function() {\n  'use strict';\n\n  /* exported features */\n  \n  var features = {\n    bind : !!(function(){}.bind),\n    classList : 'classList' in document.documentElement,\n    rAF : !!(window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame)\n  };\n  window.requestAnimationFrame = window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame;\n  \n  /**\n   * Handles debouncing of events via requestAnimationFrame\n   * @see http://www.html5rocks.com/en/tutorials/speed/animations/\n   * @param {Function} callback The callback to handle whichever event\n   */\n  function Debouncer (callback) {\n    this.callback = callback;\n    this.ticking = false;\n  }\n  Debouncer.prototype = {\n    constructor : Debouncer,\n  \n    /**\n     * dispatches the event to the supplied callback\n     * @private\n     */\n    update : function() {\n      this.callback && this.callback();\n      this.ticking = false;\n    },\n  \n    /**\n     * ensures events don't get stacked\n     * @private\n     */\n    requestTick : function() {\n      if(!this.ticking) {\n        requestAnimationFrame(this.rafCallback || (this.rafCallback = this.update.bind(this)));\n        this.ticking = true;\n      }\n    },\n  \n    /**\n     * Attach this as the event listeners\n     */\n    handleEvent : function() {\n      this.requestTick();\n    }\n  };\n  /**\n   * Check if object is part of the DOM\n   * @constructor\n   * @param {Object} obj element to check\n   */\n  function isDOMElement(obj) {\n    return obj && typeof window !== 'undefined' && (obj === window || obj.nodeType);\n  }\n  \n  /**\n   * Helper function for extending objects\n   */\n  function extend (object /*, objectN ... */) {\n    if(arguments.length <= 0) {\n      throw new Error('Missing arguments in extend function');\n    }\n  \n    var result = object || {},\n        key,\n        i;\n  \n    for (i = 1; i < arguments.length; i++) {\n      var replacement = arguments[i] || {};\n  \n      for (key in replacement) {\n        // Recurse into object except if the object is a DOM element\n        if(typeof result[key] === 'object' && ! isDOMElement(result[key])) {\n          result[key] = extend(result[key], replacement[key]);\n        }\n        else {\n          result[key] = result[key] || replacement[key];\n        }\n      }\n    }\n  \n    return result;\n  }\n  \n  /**\n   * Helper function for normalizing tolerance option to object format\n   */\n  function normalizeTolerance (t) {\n    return t === Object(t) ? t : { down : t, up : t };\n  }\n  \n  /**\n   * UI enhancement for fixed headers.\n   * Hides header when scrolling down\n   * Shows header when scrolling up\n   * @constructor\n   * @param {DOMElement} elem the header element\n   * @param {Object} options options for the widget\n   */\n  function Headroom (elem, options) {\n    options = extend(options, Headroom.options);\n  \n    this.lastKnownScrollY = 0;\n    this.elem             = elem;\n    this.tolerance        = normalizeTolerance(options.tolerance);\n    this.classes          = options.classes;\n    this.offset           = options.offset;\n    this.scroller         = options.scroller;\n    this.initialised      = false;\n    this.onPin            = options.onPin;\n    this.onUnpin          = options.onUnpin;\n    this.onTop            = options.onTop;\n    this.onNotTop         = options.onNotTop;\n    this.onBottom         = options.onBottom;\n    this.onNotBottom      = options.onNotBottom;\n  }\n  Headroom.prototype = {\n    constructor : Headroom,\n  \n    /**\n     * Initialises the widget\n     */\n    init : function() {\n      if(!Headroom.cutsTheMustard) {\n        return;\n      }\n  \n      this.debouncer = new Debouncer(this.update.bind(this));\n      this.elem.classList.add(this.classes.initial);\n  \n      // defer event registration to handle browser \n      // potentially restoring previous scroll position\n      setTimeout(this.attachEvent.bind(this), 100);\n  \n      return this;\n    },\n  \n    /**\n     * Unattaches events and removes any classes that were added\n     */\n    destroy : function() {\n      var classes = this.classes;\n  \n      this.initialised = false;\n      this.elem.classList.remove(classes.unpinned, classes.pinned, classes.top, classes.notTop, classes.initial);\n      this.scroller.removeEventListener('scroll', this.debouncer, false);\n    },\n  \n    /**\n     * Attaches the scroll event\n     * @private\n     */\n    attachEvent : function() {\n      if(!this.initialised){\n        this.lastKnownScrollY = this.getScrollY();\n        this.initialised = true;\n        this.scroller.addEventListener('scroll', this.debouncer, false);\n  \n        this.debouncer.handleEvent();\n      }\n    },\n    \n    /**\n     * Unpins the header if it's currently pinned\n     */\n    unpin : function() {\n      var classList = this.elem.classList,\n        classes = this.classes;\n      \n      if(classList.contains(classes.pinned) || !classList.contains(classes.unpinned)) {\n        classList.add(classes.unpinned);\n        classList.remove(classes.pinned);\n        this.onUnpin && this.onUnpin.call(this);\n      }\n    },\n  \n    /**\n     * Pins the header if it's currently unpinned\n     */\n    pin : function() {\n      var classList = this.elem.classList,\n        classes = this.classes;\n      \n      if(classList.contains(classes.unpinned)) {\n        classList.remove(classes.unpinned);\n        classList.add(classes.pinned);\n        this.onPin && this.onPin.call(this);\n      }\n    },\n  \n    /**\n     * Handles the top states\n     */\n    top : function() {\n      var classList = this.elem.classList,\n        classes = this.classes;\n      \n      if(!classList.contains(classes.top)) {\n        classList.add(classes.top);\n        classList.remove(classes.notTop);\n        this.onTop && this.onTop.call(this);\n      }\n    },\n  \n    /**\n     * Handles the not top state\n     */\n    notTop : function() {\n      var classList = this.elem.classList,\n        classes = this.classes;\n      \n      if(!classList.contains(classes.notTop)) {\n        classList.add(classes.notTop);\n        classList.remove(classes.top);\n        this.onNotTop && this.onNotTop.call(this);\n      }\n    },\n  \n    bottom : function() {\n      var classList = this.elem.classList,\n        classes = this.classes;\n      \n      if(!classList.contains(classes.bottom)) {\n        classList.add(classes.bottom);\n        classList.remove(classes.notBottom);\n        this.onBottom && this.onBottom.call(this);\n      }\n    },\n  \n    /**\n     * Handles the not top state\n     */\n    notBottom : function() {\n      var classList = this.elem.classList,\n        classes = this.classes;\n      \n      if(!classList.contains(classes.notBottom)) {\n        classList.add(classes.notBottom);\n        classList.remove(classes.bottom);\n        this.onNotBottom && this.onNotBottom.call(this);\n      }\n    },\n  \n    /**\n     * Gets the Y scroll position\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/Window.scrollY\n     * @return {Number} pixels the page has scrolled along the Y-axis\n     */\n    getScrollY : function() {\n      return (this.scroller.pageYOffset !== undefined)\n        ? this.scroller.pageYOffset\n        : (this.scroller.scrollTop !== undefined)\n          ? this.scroller.scrollTop\n          : (document.documentElement || document.body.parentNode || document.body).scrollTop;\n    },\n  \n    /**\n     * Gets the height of the viewport\n     * @see http://andylangton.co.uk/blog/development/get-viewport-size-width-and-height-javascript\n     * @return {int} the height of the viewport in pixels\n     */\n    getViewportHeight : function () {\n      return window.innerHeight\n        || document.documentElement.clientHeight\n        || document.body.clientHeight;\n    },\n  \n    /**\n     * Gets the physical height of the DOM element\n     * @param  {Object}  elm the element to calculate the physical height of which\n     * @return {int}     the physical height of the element in pixels\n     */\n    getElementPhysicalHeight : function (elm) {\n      return Math.max(\n        elm.offsetHeight,\n        elm.clientHeight\n      );\n    },\n  \n    /**\n     * Gets the physical height of the scroller element\n     * @return {int} the physical height of the scroller element in pixels\n     */\n    getScrollerPhysicalHeight : function () {\n      return (this.scroller === window || this.scroller === document.body)\n        ? this.getViewportHeight()\n        : this.getElementPhysicalHeight(this.scroller);\n    },\n  \n    /**\n     * Gets the height of the document\n     * @see http://james.padolsey.com/javascript/get-document-height-cross-browser/\n     * @return {int} the height of the document in pixels\n     */\n    getDocumentHeight : function () {\n      var body = document.body,\n        documentElement = document.documentElement;\n    \n      return Math.max(\n        body.scrollHeight, documentElement.scrollHeight,\n        body.offsetHeight, documentElement.offsetHeight,\n        body.clientHeight, documentElement.clientHeight\n      );\n    },\n  \n    /**\n     * Gets the height of the DOM element\n     * @param  {Object}  elm the element to calculate the height of which\n     * @return {int}     the height of the element in pixels\n     */\n    getElementHeight : function (elm) {\n      return Math.max(\n        elm.scrollHeight,\n        elm.offsetHeight,\n        elm.clientHeight\n      );\n    },\n  \n    /**\n     * Gets the height of the scroller element\n     * @return {int} the height of the scroller element in pixels\n     */\n    getScrollerHeight : function () {\n      return (this.scroller === window || this.scroller === document.body)\n        ? this.getDocumentHeight()\n        : this.getElementHeight(this.scroller);\n    },\n  \n    /**\n     * determines if the scroll position is outside of document boundaries\n     * @param  {int}  currentScrollY the current y scroll position\n     * @return {bool} true if out of bounds, false otherwise\n     */\n    isOutOfBounds : function (currentScrollY) {\n      var pastTop  = currentScrollY < 0,\n        pastBottom = currentScrollY + this.getScrollerPhysicalHeight() > this.getScrollerHeight();\n      \n      return pastTop || pastBottom;\n    },\n  \n    /**\n     * determines if the tolerance has been exceeded\n     * @param  {int} currentScrollY the current scroll y position\n     * @return {bool} true if tolerance exceeded, false otherwise\n     */\n    toleranceExceeded : function (currentScrollY, direction) {\n      return Math.abs(currentScrollY-this.lastKnownScrollY) >= this.tolerance[direction];\n    },\n  \n    /**\n     * determine if it is appropriate to unpin\n     * @param  {int} currentScrollY the current y scroll position\n     * @param  {bool} toleranceExceeded has the tolerance been exceeded?\n     * @return {bool} true if should unpin, false otherwise\n     */\n    shouldUnpin : function (currentScrollY, toleranceExceeded) {\n      var scrollingDown = currentScrollY > this.lastKnownScrollY,\n        pastOffset = currentScrollY >= this.offset;\n  \n      return scrollingDown && pastOffset && toleranceExceeded;\n    },\n  \n    /**\n     * determine if it is appropriate to pin\n     * @param  {int} currentScrollY the current y scroll position\n     * @param  {bool} toleranceExceeded has the tolerance been exceeded?\n     * @return {bool} true if should pin, false otherwise\n     */\n    shouldPin : function (currentScrollY, toleranceExceeded) {\n      var scrollingUp  = currentScrollY < this.lastKnownScrollY,\n        pastOffset = currentScrollY <= this.offset;\n  \n      return (scrollingUp && toleranceExceeded) || pastOffset;\n    },\n  \n    /**\n     * Handles updating the state of the widget\n     */\n    update : function() {\n      var currentScrollY  = this.getScrollY(),\n        scrollDirection = currentScrollY > this.lastKnownScrollY ? 'down' : 'up',\n        toleranceExceeded = this.toleranceExceeded(currentScrollY, scrollDirection);\n  \n      if(this.isOutOfBounds(currentScrollY)) { // Ignore bouncy scrolling in OSX\n        return;\n      }\n  \n      if (currentScrollY <= this.offset ) {\n        this.top();\n      } else {\n        this.notTop();\n      }\n  \n      if(currentScrollY + this.getViewportHeight() >= this.getScrollerHeight()) {\n        this.bottom();\n      }\n      else {\n        this.notBottom();\n      }\n  \n      if(this.shouldUnpin(currentScrollY, toleranceExceeded)) {\n        this.unpin();\n      }\n      else if(this.shouldPin(currentScrollY, toleranceExceeded)) {\n        this.pin();\n      }\n  \n      this.lastKnownScrollY = currentScrollY;\n    }\n  };\n  /**\n   * Default options\n   * @type {Object}\n   */\n  Headroom.options = {\n    tolerance : {\n      up : 0,\n      down : 0\n    },\n    offset : 0,\n    scroller: window,\n    classes : {\n      pinned : 'headroom--pinned',\n      unpinned : 'headroom--unpinned',\n      top : 'headroom--top',\n      notTop : 'headroom--not-top',\n      bottom : 'headroom--bottom',\n      notBottom : 'headroom--not-bottom',\n      initial : 'headroom'\n    }\n  };\n  Headroom.cutsTheMustard = typeof features !== 'undefined' && features.rAF && features.bind && features.classList;\n\n  return Headroom;\n}));\n\n/***/ }),\n/* 30 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(module) {//! moment.js\n//! version : 2.18.1\n//! authors : Tim Wood, Iskren Chernev, Moment.js contributors\n//! license : MIT\n//! momentjs.com\n\n;(function (global, factory) {\n     true ? module.exports = factory() :\n    typeof define === 'function' && define.amd ? define(factory) :\n    global.moment = factory()\n}(this, (function () { 'use strict';\n\nvar hookCallback;\n\nfunction hooks () {\n    return hookCallback.apply(null, arguments);\n}\n\n// This is done to register the method called with moment()\n// without creating circular dependencies.\nfunction setHookCallback (callback) {\n    hookCallback = callback;\n}\n\nfunction isArray(input) {\n    return input instanceof Array || Object.prototype.toString.call(input) === '[object Array]';\n}\n\nfunction isObject(input) {\n    // IE8 will treat undefined and null as object if it wasn't for\n    // input != null\n    return input != null && Object.prototype.toString.call(input) === '[object Object]';\n}\n\nfunction isObjectEmpty(obj) {\n    var k;\n    for (k in obj) {\n        // even if its not own property I'd still call it non-empty\n        return false;\n    }\n    return true;\n}\n\nfunction isUndefined(input) {\n    return input === void 0;\n}\n\nfunction isNumber(input) {\n    return typeof input === 'number' || Object.prototype.toString.call(input) === '[object Number]';\n}\n\nfunction isDate(input) {\n    return input instanceof Date || Object.prototype.toString.call(input) === '[object Date]';\n}\n\nfunction map(arr, fn) {\n    var res = [], i;\n    for (i = 0; i < arr.length; ++i) {\n        res.push(fn(arr[i], i));\n    }\n    return res;\n}\n\nfunction hasOwnProp(a, b) {\n    return Object.prototype.hasOwnProperty.call(a, b);\n}\n\nfunction extend(a, b) {\n    for (var i in b) {\n        if (hasOwnProp(b, i)) {\n            a[i] = b[i];\n        }\n    }\n\n    if (hasOwnProp(b, 'toString')) {\n        a.toString = b.toString;\n    }\n\n    if (hasOwnProp(b, 'valueOf')) {\n        a.valueOf = b.valueOf;\n    }\n\n    return a;\n}\n\nfunction createUTC (input, format, locale, strict) {\n    return createLocalOrUTC(input, format, locale, strict, true).utc();\n}\n\nfunction defaultParsingFlags() {\n    // We need to deep clone this object.\n    return {\n        empty           : false,\n        unusedTokens    : [],\n        unusedInput     : [],\n        overflow        : -2,\n        charsLeftOver   : 0,\n        nullInput       : false,\n        invalidMonth    : null,\n        invalidFormat   : false,\n        userInvalidated : false,\n        iso             : false,\n        parsedDateParts : [],\n        meridiem        : null,\n        rfc2822         : false,\n        weekdayMismatch : false\n    };\n}\n\nfunction getParsingFlags(m) {\n    if (m._pf == null) {\n        m._pf = defaultParsingFlags();\n    }\n    return m._pf;\n}\n\nvar some;\nif (Array.prototype.some) {\n    some = Array.prototype.some;\n} else {\n    some = function (fun) {\n        var t = Object(this);\n        var len = t.length >>> 0;\n\n        for (var i = 0; i < len; i++) {\n            if (i in t && fun.call(this, t[i], i, t)) {\n                return true;\n            }\n        }\n\n        return false;\n    };\n}\n\nvar some$1 = some;\n\nfunction isValid(m) {\n    if (m._isValid == null) {\n        var flags = getParsingFlags(m);\n        var parsedParts = some$1.call(flags.parsedDateParts, function (i) {\n            return i != null;\n        });\n        var isNowValid = !isNaN(m._d.getTime()) &&\n            flags.overflow < 0 &&\n            !flags.empty &&\n            !flags.invalidMonth &&\n            !flags.invalidWeekday &&\n            !flags.nullInput &&\n            !flags.invalidFormat &&\n            !flags.userInvalidated &&\n            (!flags.meridiem || (flags.meridiem && parsedParts));\n\n        if (m._strict) {\n            isNowValid = isNowValid &&\n                flags.charsLeftOver === 0 &&\n                flags.unusedTokens.length === 0 &&\n                flags.bigHour === undefined;\n        }\n\n        if (Object.isFrozen == null || !Object.isFrozen(m)) {\n            m._isValid = isNowValid;\n        }\n        else {\n            return isNowValid;\n        }\n    }\n    return m._isValid;\n}\n\nfunction createInvalid (flags) {\n    var m = createUTC(NaN);\n    if (flags != null) {\n        extend(getParsingFlags(m), flags);\n    }\n    else {\n        getParsingFlags(m).userInvalidated = true;\n    }\n\n    return m;\n}\n\n// Plugins that add properties should also add the key here (null value),\n// so we can properly clone ourselves.\nvar momentProperties = hooks.momentProperties = [];\n\nfunction copyConfig(to, from) {\n    var i, prop, val;\n\n    if (!isUndefined(from._isAMomentObject)) {\n        to._isAMomentObject = from._isAMomentObject;\n    }\n    if (!isUndefined(from._i)) {\n        to._i = from._i;\n    }\n    if (!isUndefined(from._f)) {\n        to._f = from._f;\n    }\n    if (!isUndefined(from._l)) {\n        to._l = from._l;\n    }\n    if (!isUndefined(from._strict)) {\n        to._strict = from._strict;\n    }\n    if (!isUndefined(from._tzm)) {\n        to._tzm = from._tzm;\n    }\n    if (!isUndefined(from._isUTC)) {\n        to._isUTC = from._isUTC;\n    }\n    if (!isUndefined(from._offset)) {\n        to._offset = from._offset;\n    }\n    if (!isUndefined(from._pf)) {\n        to._pf = getParsingFlags(from);\n    }\n    if (!isUndefined(from._locale)) {\n        to._locale = from._locale;\n    }\n\n    if (momentProperties.length > 0) {\n        for (i = 0; i < momentProperties.length; i++) {\n            prop = momentProperties[i];\n            val = from[prop];\n            if (!isUndefined(val)) {\n                to[prop] = val;\n            }\n        }\n    }\n\n    return to;\n}\n\nvar updateInProgress = false;\n\n// Moment prototype object\nfunction Moment(config) {\n    copyConfig(this, config);\n    this._d = new Date(config._d != null ? config._d.getTime() : NaN);\n    if (!this.isValid()) {\n        this._d = new Date(NaN);\n    }\n    // Prevent infinite loop in case updateOffset creates new moment\n    // objects.\n    if (updateInProgress === false) {\n        updateInProgress = true;\n        hooks.updateOffset(this);\n        updateInProgress = false;\n    }\n}\n\nfunction isMoment (obj) {\n    return obj instanceof Moment || (obj != null && obj._isAMomentObject != null);\n}\n\nfunction absFloor (number) {\n    if (number < 0) {\n        // -0 -> 0\n        return Math.ceil(number) || 0;\n    } else {\n        return Math.floor(number);\n    }\n}\n\nfunction toInt(argumentForCoercion) {\n    var coercedNumber = +argumentForCoercion,\n        value = 0;\n\n    if (coercedNumber !== 0 && isFinite(coercedNumber)) {\n        value = absFloor(coercedNumber);\n    }\n\n    return value;\n}\n\n// compare two arrays, return the number of differences\nfunction compareArrays(array1, array2, dontConvert) {\n    var len = Math.min(array1.length, array2.length),\n        lengthDiff = Math.abs(array1.length - array2.length),\n        diffs = 0,\n        i;\n    for (i = 0; i < len; i++) {\n        if ((dontConvert && array1[i] !== array2[i]) ||\n            (!dontConvert && toInt(array1[i]) !== toInt(array2[i]))) {\n            diffs++;\n        }\n    }\n    return diffs + lengthDiff;\n}\n\nfunction warn(msg) {\n    if (hooks.suppressDeprecationWarnings === false &&\n            (typeof console !==  'undefined') && console.warn) {\n        console.warn('Deprecation warning: ' + msg);\n    }\n}\n\nfunction deprecate(msg, fn) {\n    var firstTime = true;\n\n    return extend(function () {\n        if (hooks.deprecationHandler != null) {\n            hooks.deprecationHandler(null, msg);\n        }\n        if (firstTime) {\n            var args = [];\n            var arg;\n            for (var i = 0; i < arguments.length; i++) {\n                arg = '';\n                if (typeof arguments[i] === 'object') {\n                    arg += '\\n[' + i + '] ';\n                    for (var key in arguments[0]) {\n                        arg += key + ': ' + arguments[0][key] + ', ';\n                    }\n                    arg = arg.slice(0, -2); // Remove trailing comma and space\n                } else {\n                    arg = arguments[i];\n                }\n                args.push(arg);\n            }\n            warn(msg + '\\nArguments: ' + Array.prototype.slice.call(args).join('') + '\\n' + (new Error()).stack);\n            firstTime = false;\n        }\n        return fn.apply(this, arguments);\n    }, fn);\n}\n\nvar deprecations = {};\n\nfunction deprecateSimple(name, msg) {\n    if (hooks.deprecationHandler != null) {\n        hooks.deprecationHandler(name, msg);\n    }\n    if (!deprecations[name]) {\n        warn(msg);\n        deprecations[name] = true;\n    }\n}\n\nhooks.suppressDeprecationWarnings = false;\nhooks.deprecationHandler = null;\n\nfunction isFunction(input) {\n    return input instanceof Function || Object.prototype.toString.call(input) === '[object Function]';\n}\n\nfunction set (config) {\n    var prop, i;\n    for (i in config) {\n        prop = config[i];\n        if (isFunction(prop)) {\n            this[i] = prop;\n        } else {\n            this['_' + i] = prop;\n        }\n    }\n    this._config = config;\n    // Lenient ordinal parsing accepts just a number in addition to\n    // number + (possibly) stuff coming from _dayOfMonthOrdinalParse.\n    // TODO: Remove \"ordinalParse\" fallback in next major release.\n    this._dayOfMonthOrdinalParseLenient = new RegExp(\n        (this._dayOfMonthOrdinalParse.source || this._ordinalParse.source) +\n            '|' + (/\\d{1,2}/).source);\n}\n\nfunction mergeConfigs(parentConfig, childConfig) {\n    var res = extend({}, parentConfig), prop;\n    for (prop in childConfig) {\n        if (hasOwnProp(childConfig, prop)) {\n            if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) {\n                res[prop] = {};\n                extend(res[prop], parentConfig[prop]);\n                extend(res[prop], childConfig[prop]);\n            } else if (childConfig[prop] != null) {\n                res[prop] = childConfig[prop];\n            } else {\n                delete res[prop];\n            }\n        }\n    }\n    for (prop in parentConfig) {\n        if (hasOwnProp(parentConfig, prop) &&\n                !hasOwnProp(childConfig, prop) &&\n                isObject(parentConfig[prop])) {\n            // make sure changes to properties don't modify parent config\n            res[prop] = extend({}, res[prop]);\n        }\n    }\n    return res;\n}\n\nfunction Locale(config) {\n    if (config != null) {\n        this.set(config);\n    }\n}\n\nvar keys;\n\nif (Object.keys) {\n    keys = Object.keys;\n} else {\n    keys = function (obj) {\n        var i, res = [];\n        for (i in obj) {\n            if (hasOwnProp(obj, i)) {\n                res.push(i);\n            }\n        }\n        return res;\n    };\n}\n\nvar keys$1 = keys;\n\nvar defaultCalendar = {\n    sameDay : '[Today at] LT',\n    nextDay : '[Tomorrow at] LT',\n    nextWeek : 'dddd [at] LT',\n    lastDay : '[Yesterday at] LT',\n    lastWeek : '[Last] dddd [at] LT',\n    sameElse : 'L'\n};\n\nfunction calendar (key, mom, now) {\n    var output = this._calendar[key] || this._calendar['sameElse'];\n    return isFunction(output) ? output.call(mom, now) : output;\n}\n\nvar defaultLongDateFormat = {\n    LTS  : 'h:mm:ss A',\n    LT   : 'h:mm A',\n    L    : 'MM/DD/YYYY',\n    LL   : 'MMMM D, YYYY',\n    LLL  : 'MMMM D, YYYY h:mm A',\n    LLLL : 'dddd, MMMM D, YYYY h:mm A'\n};\n\nfunction longDateFormat (key) {\n    var format = this._longDateFormat[key],\n        formatUpper = this._longDateFormat[key.toUpperCase()];\n\n    if (format || !formatUpper) {\n        return format;\n    }\n\n    this._longDateFormat[key] = formatUpper.replace(/MMMM|MM|DD|dddd/g, function (val) {\n        return val.slice(1);\n    });\n\n    return this._longDateFormat[key];\n}\n\nvar defaultInvalidDate = 'Invalid date';\n\nfunction invalidDate () {\n    return this._invalidDate;\n}\n\nvar defaultOrdinal = '%d';\nvar defaultDayOfMonthOrdinalParse = /\\d{1,2}/;\n\nfunction ordinal (number) {\n    return this._ordinal.replace('%d', number);\n}\n\nvar defaultRelativeTime = {\n    future : 'in %s',\n    past   : '%s ago',\n    s  : 'a few seconds',\n    ss : '%d seconds',\n    m  : 'a minute',\n    mm : '%d minutes',\n    h  : 'an hour',\n    hh : '%d hours',\n    d  : 'a day',\n    dd : '%d days',\n    M  : 'a month',\n    MM : '%d months',\n    y  : 'a year',\n    yy : '%d years'\n};\n\nfunction relativeTime (number, withoutSuffix, string, isFuture) {\n    var output = this._relativeTime[string];\n    return (isFunction(output)) ?\n        output(number, withoutSuffix, string, isFuture) :\n        output.replace(/%d/i, number);\n}\n\nfunction pastFuture (diff, output) {\n    var format = this._relativeTime[diff > 0 ? 'future' : 'past'];\n    return isFunction(format) ? format(output) : format.replace(/%s/i, output);\n}\n\nvar aliases = {};\n\nfunction addUnitAlias (unit, shorthand) {\n    var lowerCase = unit.toLowerCase();\n    aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit;\n}\n\nfunction normalizeUnits(units) {\n    return typeof units === 'string' ? aliases[units] || aliases[units.toLowerCase()] : undefined;\n}\n\nfunction normalizeObjectUnits(inputObject) {\n    var normalizedInput = {},\n        normalizedProp,\n        prop;\n\n    for (prop in inputObject) {\n        if (hasOwnProp(inputObject, prop)) {\n            normalizedProp = normalizeUnits(prop);\n            if (normalizedProp) {\n                normalizedInput[normalizedProp] = inputObject[prop];\n            }\n        }\n    }\n\n    return normalizedInput;\n}\n\nvar priorities = {};\n\nfunction addUnitPriority(unit, priority) {\n    priorities[unit] = priority;\n}\n\nfunction getPrioritizedUnits(unitsObj) {\n    var units = [];\n    for (var u in unitsObj) {\n        units.push({unit: u, priority: priorities[u]});\n    }\n    units.sort(function (a, b) {\n        return a.priority - b.priority;\n    });\n    return units;\n}\n\nfunction makeGetSet (unit, keepTime) {\n    return function (value) {\n        if (value != null) {\n            set$1(this, unit, value);\n            hooks.updateOffset(this, keepTime);\n            return this;\n        } else {\n            return get(this, unit);\n        }\n    };\n}\n\nfunction get (mom, unit) {\n    return mom.isValid() ?\n        mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]() : NaN;\n}\n\nfunction set$1 (mom, unit, value) {\n    if (mom.isValid()) {\n        mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value);\n    }\n}\n\n// MOMENTS\n\nfunction stringGet (units) {\n    units = normalizeUnits(units);\n    if (isFunction(this[units])) {\n        return this[units]();\n    }\n    return this;\n}\n\n\nfunction stringSet (units, value) {\n    if (typeof units === 'object') {\n        units = normalizeObjectUnits(units);\n        var prioritized = getPrioritizedUnits(units);\n        for (var i = 0; i < prioritized.length; i++) {\n            this[prioritized[i].unit](units[prioritized[i].unit]);\n        }\n    } else {\n        units = normalizeUnits(units);\n        if (isFunction(this[units])) {\n            return this[units](value);\n        }\n    }\n    return this;\n}\n\nfunction zeroFill(number, targetLength, forceSign) {\n    var absNumber = '' + Math.abs(number),\n        zerosToFill = targetLength - absNumber.length,\n        sign = number >= 0;\n    return (sign ? (forceSign ? '+' : '') : '-') +\n        Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) + absNumber;\n}\n\nvar formattingTokens = /(\\[[^\\[]*\\])|(\\\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g;\n\nvar localFormattingTokens = /(\\[[^\\[]*\\])|(\\\\)?(LTS|LT|LL?L?L?|l{1,4})/g;\n\nvar formatFunctions = {};\n\nvar formatTokenFunctions = {};\n\n// token:    'M'\n// padded:   ['MM', 2]\n// ordinal:  'Mo'\n// callback: function () { this.month() + 1 }\nfunction addFormatToken (token, padded, ordinal, callback) {\n    var func = callback;\n    if (typeof callback === 'string') {\n        func = function () {\n            return this[callback]();\n        };\n    }\n    if (token) {\n        formatTokenFunctions[token] = func;\n    }\n    if (padded) {\n        formatTokenFunctions[padded[0]] = function () {\n            return zeroFill(func.apply(this, arguments), padded[1], padded[2]);\n        };\n    }\n    if (ordinal) {\n        formatTokenFunctions[ordinal] = function () {\n            return this.localeData().ordinal(func.apply(this, arguments), token);\n        };\n    }\n}\n\nfunction removeFormattingTokens(input) {\n    if (input.match(/\\[[\\s\\S]/)) {\n        return input.replace(/^\\[|\\]$/g, '');\n    }\n    return input.replace(/\\\\/g, '');\n}\n\nfunction makeFormatFunction(format) {\n    var array = format.match(formattingTokens), i, length;\n\n    for (i = 0, length = array.length; i < length; i++) {\n        if (formatTokenFunctions[array[i]]) {\n            array[i] = formatTokenFunctions[array[i]];\n        } else {\n            array[i] = removeFormattingTokens(array[i]);\n        }\n    }\n\n    return function (mom) {\n        var output = '', i;\n        for (i = 0; i < length; i++) {\n            output += isFunction(array[i]) ? array[i].call(mom, format) : array[i];\n        }\n        return output;\n    };\n}\n\n// format date using native date object\nfunction formatMoment(m, format) {\n    if (!m.isValid()) {\n        return m.localeData().invalidDate();\n    }\n\n    format = expandFormat(format, m.localeData());\n    formatFunctions[format] = formatFunctions[format] || makeFormatFunction(format);\n\n    return formatFunctions[format](m);\n}\n\nfunction expandFormat(format, locale) {\n    var i = 5;\n\n    function replaceLongDateFormatTokens(input) {\n        return locale.longDateFormat(input) || input;\n    }\n\n    localFormattingTokens.lastIndex = 0;\n    while (i >= 0 && localFormattingTokens.test(format)) {\n        format = format.replace(localFormattingTokens, replaceLongDateFormatTokens);\n        localFormattingTokens.lastIndex = 0;\n        i -= 1;\n    }\n\n    return format;\n}\n\nvar match1         = /\\d/;            //       0 - 9\nvar match2         = /\\d\\d/;          //      00 - 99\nvar match3         = /\\d{3}/;         //     000 - 999\nvar match4         = /\\d{4}/;         //    0000 - 9999\nvar match6         = /[+-]?\\d{6}/;    // -999999 - 999999\nvar match1to2      = /\\d\\d?/;         //       0 - 99\nvar match3to4      = /\\d\\d\\d\\d?/;     //     999 - 9999\nvar match5to6      = /\\d\\d\\d\\d\\d\\d?/; //   99999 - 999999\nvar match1to3      = /\\d{1,3}/;       //       0 - 999\nvar match1to4      = /\\d{1,4}/;       //       0 - 9999\nvar match1to6      = /[+-]?\\d{1,6}/;  // -999999 - 999999\n\nvar matchUnsigned  = /\\d+/;           //       0 - inf\nvar matchSigned    = /[+-]?\\d+/;      //    -inf - inf\n\nvar matchOffset    = /Z|[+-]\\d\\d:?\\d\\d/gi; // +00:00 -00:00 +0000 -0000 or Z\nvar matchShortOffset = /Z|[+-]\\d\\d(?::?\\d\\d)?/gi; // +00 -00 +00:00 -00:00 +0000 -0000 or Z\n\nvar matchTimestamp = /[+-]?\\d+(\\.\\d{1,3})?/; // 123456789 123456789.123\n\n// any word (or two) characters or numbers including two/three word month in arabic.\n// includes scottish gaelic two word and hyphenated months\nvar matchWord = /[0-9]*['a-z\\u00A0-\\u05FF\\u0700-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF]+|[\\u0600-\\u06FF\\/]+(\\s*?[\\u0600-\\u06FF]+){1,2}/i;\n\n\nvar regexes = {};\n\nfunction addRegexToken (token, regex, strictRegex) {\n    regexes[token] = isFunction(regex) ? regex : function (isStrict, localeData) {\n        return (isStrict && strictRegex) ? strictRegex : regex;\n    };\n}\n\nfunction getParseRegexForToken (token, config) {\n    if (!hasOwnProp(regexes, token)) {\n        return new RegExp(unescapeFormat(token));\n    }\n\n    return regexes[token](config._strict, config._locale);\n}\n\n// Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript\nfunction unescapeFormat(s) {\n    return regexEscape(s.replace('\\\\', '').replace(/\\\\(\\[)|\\\\(\\])|\\[([^\\]\\[]*)\\]|\\\\(.)/g, function (matched, p1, p2, p3, p4) {\n        return p1 || p2 || p3 || p4;\n    }));\n}\n\nfunction regexEscape(s) {\n    return s.replace(/[-\\/\\\\^$*+?.()|[\\]{}]/g, '\\\\$&');\n}\n\nvar tokens = {};\n\nfunction addParseToken (token, callback) {\n    var i, func = callback;\n    if (typeof token === 'string') {\n        token = [token];\n    }\n    if (isNumber(callback)) {\n        func = function (input, array) {\n            array[callback] = toInt(input);\n        };\n    }\n    for (i = 0; i < token.length; i++) {\n        tokens[token[i]] = func;\n    }\n}\n\nfunction addWeekParseToken (token, callback) {\n    addParseToken(token, function (input, array, config, token) {\n        config._w = config._w || {};\n        callback(input, config._w, config, token);\n    });\n}\n\nfunction addTimeToArrayFromToken(token, input, config) {\n    if (input != null && hasOwnProp(tokens, token)) {\n        tokens[token](input, config._a, config, token);\n    }\n}\n\nvar YEAR = 0;\nvar MONTH = 1;\nvar DATE = 2;\nvar HOUR = 3;\nvar MINUTE = 4;\nvar SECOND = 5;\nvar MILLISECOND = 6;\nvar WEEK = 7;\nvar WEEKDAY = 8;\n\nvar indexOf;\n\nif (Array.prototype.indexOf) {\n    indexOf = Array.prototype.indexOf;\n} else {\n    indexOf = function (o) {\n        // I know\n        var i;\n        for (i = 0; i < this.length; ++i) {\n            if (this[i] === o) {\n                return i;\n            }\n        }\n        return -1;\n    };\n}\n\nvar indexOf$1 = indexOf;\n\nfunction daysInMonth(year, month) {\n    return new Date(Date.UTC(year, month + 1, 0)).getUTCDate();\n}\n\n// FORMATTING\n\naddFormatToken('M', ['MM', 2], 'Mo', function () {\n    return this.month() + 1;\n});\n\naddFormatToken('MMM', 0, 0, function (format) {\n    return this.localeData().monthsShort(this, format);\n});\n\naddFormatToken('MMMM', 0, 0, function (format) {\n    return this.localeData().months(this, format);\n});\n\n// ALIASES\n\naddUnitAlias('month', 'M');\n\n// PRIORITY\n\naddUnitPriority('month', 8);\n\n// PARSING\n\naddRegexToken('M',    match1to2);\naddRegexToken('MM',   match1to2, match2);\naddRegexToken('MMM',  function (isStrict, locale) {\n    return locale.monthsShortRegex(isStrict);\n});\naddRegexToken('MMMM', function (isStrict, locale) {\n    return locale.monthsRegex(isStrict);\n});\n\naddParseToken(['M', 'MM'], function (input, array) {\n    array[MONTH] = toInt(input) - 1;\n});\n\naddParseToken(['MMM', 'MMMM'], function (input, array, config, token) {\n    var month = config._locale.monthsParse(input, token, config._strict);\n    // if we didn't find a month name, mark the date as invalid.\n    if (month != null) {\n        array[MONTH] = month;\n    } else {\n        getParsingFlags(config).invalidMonth = input;\n    }\n});\n\n// LOCALES\n\nvar MONTHS_IN_FORMAT = /D[oD]?(\\[[^\\[\\]]*\\]|\\s)+MMMM?/;\nvar defaultLocaleMonths = 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_');\nfunction localeMonths (m, format) {\n    if (!m) {\n        return isArray(this._months) ? this._months :\n            this._months['standalone'];\n    }\n    return isArray(this._months) ? this._months[m.month()] :\n        this._months[(this._months.isFormat || MONTHS_IN_FORMAT).test(format) ? 'format' : 'standalone'][m.month()];\n}\n\nvar defaultLocaleMonthsShort = 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_');\nfunction localeMonthsShort (m, format) {\n    if (!m) {\n        return isArray(this._monthsShort) ? this._monthsShort :\n            this._monthsShort['standalone'];\n    }\n    return isArray(this._monthsShort) ? this._monthsShort[m.month()] :\n        this._monthsShort[MONTHS_IN_FORMAT.test(format) ? 'format' : 'standalone'][m.month()];\n}\n\nfunction handleStrictParse(monthName, format, strict) {\n    var i, ii, mom, llc = monthName.toLocaleLowerCase();\n    if (!this._monthsParse) {\n        // this is not used\n        this._monthsParse = [];\n        this._longMonthsParse = [];\n        this._shortMonthsParse = [];\n        for (i = 0; i < 12; ++i) {\n            mom = createUTC([2000, i]);\n            this._shortMonthsParse[i] = this.monthsShort(mom, '').toLocaleLowerCase();\n            this._longMonthsParse[i] = this.months(mom, '').toLocaleLowerCase();\n        }\n    }\n\n    if (strict) {\n        if (format === 'MMM') {\n            ii = indexOf$1.call(this._shortMonthsParse, llc);\n            return ii !== -1 ? ii : null;\n        } else {\n            ii = indexOf$1.call(this._longMonthsParse, llc);\n            return ii !== -1 ? ii : null;\n        }\n    } else {\n        if (format === 'MMM') {\n            ii = indexOf$1.call(this._shortMonthsParse, llc);\n            if (ii !== -1) {\n                return ii;\n            }\n            ii = indexOf$1.call(this._longMonthsParse, llc);\n            return ii !== -1 ? ii : null;\n        } else {\n            ii = indexOf$1.call(this._longMonthsParse, llc);\n            if (ii !== -1) {\n                return ii;\n            }\n            ii = indexOf$1.call(this._shortMonthsParse, llc);\n            return ii !== -1 ? ii : null;\n        }\n    }\n}\n\nfunction localeMonthsParse (monthName, format, strict) {\n    var i, mom, regex;\n\n    if (this._monthsParseExact) {\n        return handleStrictParse.call(this, monthName, format, strict);\n    }\n\n    if (!this._monthsParse) {\n        this._monthsParse = [];\n        this._longMonthsParse = [];\n        this._shortMonthsParse = [];\n    }\n\n    // TODO: add sorting\n    // Sorting makes sure if one month (or abbr) is a prefix of another\n    // see sorting in computeMonthsParse\n    for (i = 0; i < 12; i++) {\n        // make the regex if we don't have it already\n        mom = createUTC([2000, i]);\n        if (strict && !this._longMonthsParse[i]) {\n            this._longMonthsParse[i] = new RegExp('^' + this.months(mom, '').replace('.', '') + '$', 'i');\n            this._shortMonthsParse[i] = new RegExp('^' + this.monthsShort(mom, '').replace('.', '') + '$', 'i');\n        }\n        if (!strict && !this._monthsParse[i]) {\n            regex = '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, '');\n            this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i');\n        }\n        // test the regex\n        if (strict && format === 'MMMM' && this._longMonthsParse[i].test(monthName)) {\n            return i;\n        } else if (strict && format === 'MMM' && this._shortMonthsParse[i].test(monthName)) {\n            return i;\n        } else if (!strict && this._monthsParse[i].test(monthName)) {\n            return i;\n        }\n    }\n}\n\n// MOMENTS\n\nfunction setMonth (mom, value) {\n    var dayOfMonth;\n\n    if (!mom.isValid()) {\n        // No op\n        return mom;\n    }\n\n    if (typeof value === 'string') {\n        if (/^\\d+$/.test(value)) {\n            value = toInt(value);\n        } else {\n            value = mom.localeData().monthsParse(value);\n            // TODO: Another silent failure?\n            if (!isNumber(value)) {\n                return mom;\n            }\n        }\n    }\n\n    dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value));\n    mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth);\n    return mom;\n}\n\nfunction getSetMonth (value) {\n    if (value != null) {\n        setMonth(this, value);\n        hooks.updateOffset(this, true);\n        return this;\n    } else {\n        return get(this, 'Month');\n    }\n}\n\nfunction getDaysInMonth () {\n    return daysInMonth(this.year(), this.month());\n}\n\nvar defaultMonthsShortRegex = matchWord;\nfunction monthsShortRegex (isStrict) {\n    if (this._monthsParseExact) {\n        if (!hasOwnProp(this, '_monthsRegex')) {\n            computeMonthsParse.call(this);\n        }\n        if (isStrict) {\n            return this._monthsShortStrictRegex;\n        } else {\n            return this._monthsShortRegex;\n        }\n    } else {\n        if (!hasOwnProp(this, '_monthsShortRegex')) {\n            this._monthsShortRegex = defaultMonthsShortRegex;\n        }\n        return this._monthsShortStrictRegex && isStrict ?\n            this._monthsShortStrictRegex : this._monthsShortRegex;\n    }\n}\n\nvar defaultMonthsRegex = matchWord;\nfunction monthsRegex (isStrict) {\n    if (this._monthsParseExact) {\n        if (!hasOwnProp(this, '_monthsRegex')) {\n            computeMonthsParse.call(this);\n        }\n        if (isStrict) {\n            return this._monthsStrictRegex;\n        } else {\n            return this._monthsRegex;\n        }\n    } else {\n        if (!hasOwnProp(this, '_monthsRegex')) {\n            this._monthsRegex = defaultMonthsRegex;\n        }\n        return this._monthsStrictRegex && isStrict ?\n            this._monthsStrictRegex : this._monthsRegex;\n    }\n}\n\nfunction computeMonthsParse () {\n    function cmpLenRev(a, b) {\n        return b.length - a.length;\n    }\n\n    var shortPieces = [], longPieces = [], mixedPieces = [],\n        i, mom;\n    for (i = 0; i < 12; i++) {\n        // make the regex if we don't have it already\n        mom = createUTC([2000, i]);\n        shortPieces.push(this.monthsShort(mom, ''));\n        longPieces.push(this.months(mom, ''));\n        mixedPieces.push(this.months(mom, ''));\n        mixedPieces.push(this.monthsShort(mom, ''));\n    }\n    // Sorting makes sure if one month (or abbr) is a prefix of another it\n    // will match the longer piece.\n    shortPieces.sort(cmpLenRev);\n    longPieces.sort(cmpLenRev);\n    mixedPieces.sort(cmpLenRev);\n    for (i = 0; i < 12; i++) {\n        shortPieces[i] = regexEscape(shortPieces[i]);\n        longPieces[i] = regexEscape(longPieces[i]);\n    }\n    for (i = 0; i < 24; i++) {\n        mixedPieces[i] = regexEscape(mixedPieces[i]);\n    }\n\n    this._monthsRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');\n    this._monthsShortRegex = this._monthsRegex;\n    this._monthsStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');\n    this._monthsShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');\n}\n\n// FORMATTING\n\naddFormatToken('Y', 0, 0, function () {\n    var y = this.year();\n    return y <= 9999 ? '' + y : '+' + y;\n});\n\naddFormatToken(0, ['YY', 2], 0, function () {\n    return this.year() % 100;\n});\n\naddFormatToken(0, ['YYYY',   4],       0, 'year');\naddFormatToken(0, ['YYYYY',  5],       0, 'year');\naddFormatToken(0, ['YYYYYY', 6, true], 0, 'year');\n\n// ALIASES\n\naddUnitAlias('year', 'y');\n\n// PRIORITIES\n\naddUnitPriority('year', 1);\n\n// PARSING\n\naddRegexToken('Y',      matchSigned);\naddRegexToken('YY',     match1to2, match2);\naddRegexToken('YYYY',   match1to4, match4);\naddRegexToken('YYYYY',  match1to6, match6);\naddRegexToken('YYYYYY', match1to6, match6);\n\naddParseToken(['YYYYY', 'YYYYYY'], YEAR);\naddParseToken('YYYY', function (input, array) {\n    array[YEAR] = input.length === 2 ? hooks.parseTwoDigitYear(input) : toInt(input);\n});\naddParseToken('YY', function (input, array) {\n    array[YEAR] = hooks.parseTwoDigitYear(input);\n});\naddParseToken('Y', function (input, array) {\n    array[YEAR] = parseInt(input, 10);\n});\n\n// HELPERS\n\nfunction daysInYear(year) {\n    return isLeapYear(year) ? 366 : 365;\n}\n\nfunction isLeapYear(year) {\n    return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;\n}\n\n// HOOKS\n\nhooks.parseTwoDigitYear = function (input) {\n    return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);\n};\n\n// MOMENTS\n\nvar getSetYear = makeGetSet('FullYear', true);\n\nfunction getIsLeapYear () {\n    return isLeapYear(this.year());\n}\n\nfunction createDate (y, m, d, h, M, s, ms) {\n    // can't just apply() to create a date:\n    // https://stackoverflow.com/q/181348\n    var date = new Date(y, m, d, h, M, s, ms);\n\n    // the date constructor remaps years 0-99 to 1900-1999\n    if (y < 100 && y >= 0 && isFinite(date.getFullYear())) {\n        date.setFullYear(y);\n    }\n    return date;\n}\n\nfunction createUTCDate (y) {\n    var date = new Date(Date.UTC.apply(null, arguments));\n\n    // the Date.UTC function remaps years 0-99 to 1900-1999\n    if (y < 100 && y >= 0 && isFinite(date.getUTCFullYear())) {\n        date.setUTCFullYear(y);\n    }\n    return date;\n}\n\n// start-of-first-week - start-of-year\nfunction firstWeekOffset(year, dow, doy) {\n    var // first-week day -- which january is always in the first week (4 for iso, 1 for other)\n        fwd = 7 + dow - doy,\n        // first-week day local weekday -- which local weekday is fwd\n        fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7;\n\n    return -fwdlw + fwd - 1;\n}\n\n// https://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday\nfunction dayOfYearFromWeeks(year, week, weekday, dow, doy) {\n    var localWeekday = (7 + weekday - dow) % 7,\n        weekOffset = firstWeekOffset(year, dow, doy),\n        dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset,\n        resYear, resDayOfYear;\n\n    if (dayOfYear <= 0) {\n        resYear = year - 1;\n        resDayOfYear = daysInYear(resYear) + dayOfYear;\n    } else if (dayOfYear > daysInYear(year)) {\n        resYear = year + 1;\n        resDayOfYear = dayOfYear - daysInYear(year);\n    } else {\n        resYear = year;\n        resDayOfYear = dayOfYear;\n    }\n\n    return {\n        year: resYear,\n        dayOfYear: resDayOfYear\n    };\n}\n\nfunction weekOfYear(mom, dow, doy) {\n    var weekOffset = firstWeekOffset(mom.year(), dow, doy),\n        week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1,\n        resWeek, resYear;\n\n    if (week < 1) {\n        resYear = mom.year() - 1;\n        resWeek = week + weeksInYear(resYear, dow, doy);\n    } else if (week > weeksInYear(mom.year(), dow, doy)) {\n        resWeek = week - weeksInYear(mom.year(), dow, doy);\n        resYear = mom.year() + 1;\n    } else {\n        resYear = mom.year();\n        resWeek = week;\n    }\n\n    return {\n        week: resWeek,\n        year: resYear\n    };\n}\n\nfunction weeksInYear(year, dow, doy) {\n    var weekOffset = firstWeekOffset(year, dow, doy),\n        weekOffsetNext = firstWeekOffset(year + 1, dow, doy);\n    return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;\n}\n\n// FORMATTING\n\naddFormatToken('w', ['ww', 2], 'wo', 'week');\naddFormatToken('W', ['WW', 2], 'Wo', 'isoWeek');\n\n// ALIASES\n\naddUnitAlias('week', 'w');\naddUnitAlias('isoWeek', 'W');\n\n// PRIORITIES\n\naddUnitPriority('week', 5);\naddUnitPriority('isoWeek', 5);\n\n// PARSING\n\naddRegexToken('w',  match1to2);\naddRegexToken('ww', match1to2, match2);\naddRegexToken('W',  match1to2);\naddRegexToken('WW', match1to2, match2);\n\naddWeekParseToken(['w', 'ww', 'W', 'WW'], function (input, week, config, token) {\n    week[token.substr(0, 1)] = toInt(input);\n});\n\n// HELPERS\n\n// LOCALES\n\nfunction localeWeek (mom) {\n    return weekOfYear(mom, this._week.dow, this._week.doy).week;\n}\n\nvar defaultLocaleWeek = {\n    dow : 0, // Sunday is the first day of the week.\n    doy : 6  // The week that contains Jan 1st is the first week of the year.\n};\n\nfunction localeFirstDayOfWeek () {\n    return this._week.dow;\n}\n\nfunction localeFirstDayOfYear () {\n    return this._week.doy;\n}\n\n// MOMENTS\n\nfunction getSetWeek (input) {\n    var week = this.localeData().week(this);\n    return input == null ? week : this.add((input - week) * 7, 'd');\n}\n\nfunction getSetISOWeek (input) {\n    var week = weekOfYear(this, 1, 4).week;\n    return input == null ? week : this.add((input - week) * 7, 'd');\n}\n\n// FORMATTING\n\naddFormatToken('d', 0, 'do', 'day');\n\naddFormatToken('dd', 0, 0, function (format) {\n    return this.localeData().weekdaysMin(this, format);\n});\n\naddFormatToken('ddd', 0, 0, function (format) {\n    return this.localeData().weekdaysShort(this, format);\n});\n\naddFormatToken('dddd', 0, 0, function (format) {\n    return this.localeData().weekdays(this, format);\n});\n\naddFormatToken('e', 0, 0, 'weekday');\naddFormatToken('E', 0, 0, 'isoWeekday');\n\n// ALIASES\n\naddUnitAlias('day', 'd');\naddUnitAlias('weekday', 'e');\naddUnitAlias('isoWeekday', 'E');\n\n// PRIORITY\naddUnitPriority('day', 11);\naddUnitPriority('weekday', 11);\naddUnitPriority('isoWeekday', 11);\n\n// PARSING\n\naddRegexToken('d',    match1to2);\naddRegexToken('e',    match1to2);\naddRegexToken('E',    match1to2);\naddRegexToken('dd',   function (isStrict, locale) {\n    return locale.weekdaysMinRegex(isStrict);\n});\naddRegexToken('ddd',   function (isStrict, locale) {\n    return locale.weekdaysShortRegex(isStrict);\n});\naddRegexToken('dddd',   function (isStrict, locale) {\n    return locale.weekdaysRegex(isStrict);\n});\n\naddWeekParseToken(['dd', 'ddd', 'dddd'], function (input, week, config, token) {\n    var weekday = config._locale.weekdaysParse(input, token, config._strict);\n    // if we didn't get a weekday name, mark the date as invalid\n    if (weekday != null) {\n        week.d = weekday;\n    } else {\n        getParsingFlags(config).invalidWeekday = input;\n    }\n});\n\naddWeekParseToken(['d', 'e', 'E'], function (input, week, config, token) {\n    week[token] = toInt(input);\n});\n\n// HELPERS\n\nfunction parseWeekday(input, locale) {\n    if (typeof input !== 'string') {\n        return input;\n    }\n\n    if (!isNaN(input)) {\n        return parseInt(input, 10);\n    }\n\n    input = locale.weekdaysParse(input);\n    if (typeof input === 'number') {\n        return input;\n    }\n\n    return null;\n}\n\nfunction parseIsoWeekday(input, locale) {\n    if (typeof input === 'string') {\n        return locale.weekdaysParse(input) % 7 || 7;\n    }\n    return isNaN(input) ? null : input;\n}\n\n// LOCALES\n\nvar defaultLocaleWeekdays = 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_');\nfunction localeWeekdays (m, format) {\n    if (!m) {\n        return isArray(this._weekdays) ? this._weekdays :\n            this._weekdays['standalone'];\n    }\n    return isArray(this._weekdays) ? this._weekdays[m.day()] :\n        this._weekdays[this._weekdays.isFormat.test(format) ? 'format' : 'standalone'][m.day()];\n}\n\nvar defaultLocaleWeekdaysShort = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_');\nfunction localeWeekdaysShort (m) {\n    return (m) ? this._weekdaysShort[m.day()] : this._weekdaysShort;\n}\n\nvar defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_');\nfunction localeWeekdaysMin (m) {\n    return (m) ? this._weekdaysMin[m.day()] : this._weekdaysMin;\n}\n\nfunction handleStrictParse$1(weekdayName, format, strict) {\n    var i, ii, mom, llc = weekdayName.toLocaleLowerCase();\n    if (!this._weekdaysParse) {\n        this._weekdaysParse = [];\n        this._shortWeekdaysParse = [];\n        this._minWeekdaysParse = [];\n\n        for (i = 0; i < 7; ++i) {\n            mom = createUTC([2000, 1]).day(i);\n            this._minWeekdaysParse[i] = this.weekdaysMin(mom, '').toLocaleLowerCase();\n            this._shortWeekdaysParse[i] = this.weekdaysShort(mom, '').toLocaleLowerCase();\n            this._weekdaysParse[i] = this.weekdays(mom, '').toLocaleLowerCase();\n        }\n    }\n\n    if (strict) {\n        if (format === 'dddd') {\n            ii = indexOf$1.call(this._weekdaysParse, llc);\n            return ii !== -1 ? ii : null;\n        } else if (format === 'ddd') {\n            ii = indexOf$1.call(this._shortWeekdaysParse, llc);\n            return ii !== -1 ? ii : null;\n        } else {\n            ii = indexOf$1.call(this._minWeekdaysParse, llc);\n            return ii !== -1 ? ii : null;\n        }\n    } else {\n        if (format === 'dddd') {\n            ii = indexOf$1.call(this._weekdaysParse, llc);\n            if (ii !== -1) {\n                return ii;\n            }\n            ii = indexOf$1.call(this._shortWeekdaysParse, llc);\n            if (ii !== -1) {\n                return ii;\n            }\n            ii = indexOf$1.call(this._minWeekdaysParse, llc);\n            return ii !== -1 ? ii : null;\n        } else if (format === 'ddd') {\n            ii = indexOf$1.call(this._shortWeekdaysParse, llc);\n            if (ii !== -1) {\n                return ii;\n            }\n            ii = indexOf$1.call(this._weekdaysParse, llc);\n            if (ii !== -1) {\n                return ii;\n            }\n            ii = indexOf$1.call(this._minWeekdaysParse, llc);\n            return ii !== -1 ? ii : null;\n        } else {\n            ii = indexOf$1.call(this._minWeekdaysParse, llc);\n            if (ii !== -1) {\n                return ii;\n            }\n            ii = indexOf$1.call(this._weekdaysParse, llc);\n            if (ii !== -1) {\n                return ii;\n            }\n            ii = indexOf$1.call(this._shortWeekdaysParse, llc);\n            return ii !== -1 ? ii : null;\n        }\n    }\n}\n\nfunction localeWeekdaysParse (weekdayName, format, strict) {\n    var i, mom, regex;\n\n    if (this._weekdaysParseExact) {\n        return handleStrictParse$1.call(this, weekdayName, format, strict);\n    }\n\n    if (!this._weekdaysParse) {\n        this._weekdaysParse = [];\n        this._minWeekdaysParse = [];\n        this._shortWeekdaysParse = [];\n        this._fullWeekdaysParse = [];\n    }\n\n    for (i = 0; i < 7; i++) {\n        // make the regex if we don't have it already\n\n        mom = createUTC([2000, 1]).day(i);\n        if (strict && !this._fullWeekdaysParse[i]) {\n            this._fullWeekdaysParse[i] = new RegExp('^' + this.weekdays(mom, '').replace('.', '\\.?') + '$', 'i');\n            this._shortWeekdaysParse[i] = new RegExp('^' + this.weekdaysShort(mom, '').replace('.', '\\.?') + '$', 'i');\n            this._minWeekdaysParse[i] = new RegExp('^' + this.weekdaysMin(mom, '').replace('.', '\\.?') + '$', 'i');\n        }\n        if (!this._weekdaysParse[i]) {\n            regex = '^' + this.weekdays(mom, '') + '|^' + this.weekdaysShort(mom, '') + '|^' + this.weekdaysMin(mom, '');\n            this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i');\n        }\n        // test the regex\n        if (strict && format === 'dddd' && this._fullWeekdaysParse[i].test(weekdayName)) {\n            return i;\n        } else if (strict && format === 'ddd' && this._shortWeekdaysParse[i].test(weekdayName)) {\n            return i;\n        } else if (strict && format === 'dd' && this._minWeekdaysParse[i].test(weekdayName)) {\n            return i;\n        } else if (!strict && this._weekdaysParse[i].test(weekdayName)) {\n            return i;\n        }\n    }\n}\n\n// MOMENTS\n\nfunction getSetDayOfWeek (input) {\n    if (!this.isValid()) {\n        return input != null ? this : NaN;\n    }\n    var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay();\n    if (input != null) {\n        input = parseWeekday(input, this.localeData());\n        return this.add(input - day, 'd');\n    } else {\n        return day;\n    }\n}\n\nfunction getSetLocaleDayOfWeek (input) {\n    if (!this.isValid()) {\n        return input != null ? this : NaN;\n    }\n    var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7;\n    return input == null ? weekday : this.add(input - weekday, 'd');\n}\n\nfunction getSetISODayOfWeek (input) {\n    if (!this.isValid()) {\n        return input != null ? this : NaN;\n    }\n\n    // behaves the same as moment#day except\n    // as a getter, returns 7 instead of 0 (1-7 range instead of 0-6)\n    // as a setter, sunday should belong to the previous week.\n\n    if (input != null) {\n        var weekday = parseIsoWeekday(input, this.localeData());\n        return this.day(this.day() % 7 ? weekday : weekday - 7);\n    } else {\n        return this.day() || 7;\n    }\n}\n\nvar defaultWeekdaysRegex = matchWord;\nfunction weekdaysRegex (isStrict) {\n    if (this._weekdaysParseExact) {\n        if (!hasOwnProp(this, '_weekdaysRegex')) {\n            computeWeekdaysParse.call(this);\n        }\n        if (isStrict) {\n            return this._weekdaysStrictRegex;\n        } else {\n            return this._weekdaysRegex;\n        }\n    } else {\n        if (!hasOwnProp(this, '_weekdaysRegex')) {\n            this._weekdaysRegex = defaultWeekdaysRegex;\n        }\n        return this._weekdaysStrictRegex && isStrict ?\n            this._weekdaysStrictRegex : this._weekdaysRegex;\n    }\n}\n\nvar defaultWeekdaysShortRegex = matchWord;\nfunction weekdaysShortRegex (isStrict) {\n    if (this._weekdaysParseExact) {\n        if (!hasOwnProp(this, '_weekdaysRegex')) {\n            computeWeekdaysParse.call(this);\n        }\n        if (isStrict) {\n            return this._weekdaysShortStrictRegex;\n        } else {\n            return this._weekdaysShortRegex;\n        }\n    } else {\n        if (!hasOwnProp(this, '_weekdaysShortRegex')) {\n            this._weekdaysShortRegex = defaultWeekdaysShortRegex;\n        }\n        return this._weekdaysShortStrictRegex && isStrict ?\n            this._weekdaysShortStrictRegex : this._weekdaysShortRegex;\n    }\n}\n\nvar defaultWeekdaysMinRegex = matchWord;\nfunction weekdaysMinRegex (isStrict) {\n    if (this._weekdaysParseExact) {\n        if (!hasOwnProp(this, '_weekdaysRegex')) {\n            computeWeekdaysParse.call(this);\n        }\n        if (isStrict) {\n            return this._weekdaysMinStrictRegex;\n        } else {\n            return this._weekdaysMinRegex;\n        }\n    } else {\n        if (!hasOwnProp(this, '_weekdaysMinRegex')) {\n            this._weekdaysMinRegex = defaultWeekdaysMinRegex;\n        }\n        return this._weekdaysMinStrictRegex && isStrict ?\n            this._weekdaysMinStrictRegex : this._weekdaysMinRegex;\n    }\n}\n\n\nfunction computeWeekdaysParse () {\n    function cmpLenRev(a, b) {\n        return b.length - a.length;\n    }\n\n    var minPieces = [], shortPieces = [], longPieces = [], mixedPieces = [],\n        i, mom, minp, shortp, longp;\n    for (i = 0; i < 7; i++) {\n        // make the regex if we don't have it already\n        mom = createUTC([2000, 1]).day(i);\n        minp = this.weekdaysMin(mom, '');\n        shortp = this.weekdaysShort(mom, '');\n        longp = this.weekdays(mom, '');\n        minPieces.push(minp);\n        shortPieces.push(shortp);\n        longPieces.push(longp);\n        mixedPieces.push(minp);\n        mixedPieces.push(shortp);\n        mixedPieces.push(longp);\n    }\n    // Sorting makes sure if one weekday (or abbr) is a prefix of another it\n    // will match the longer piece.\n    minPieces.sort(cmpLenRev);\n    shortPieces.sort(cmpLenRev);\n    longPieces.sort(cmpLenRev);\n    mixedPieces.sort(cmpLenRev);\n    for (i = 0; i < 7; i++) {\n        shortPieces[i] = regexEscape(shortPieces[i]);\n        longPieces[i] = regexEscape(longPieces[i]);\n        mixedPieces[i] = regexEscape(mixedPieces[i]);\n    }\n\n    this._weekdaysRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');\n    this._weekdaysShortRegex = this._weekdaysRegex;\n    this._weekdaysMinRegex = this._weekdaysRegex;\n\n    this._weekdaysStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');\n    this._weekdaysShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');\n    this._weekdaysMinStrictRegex = new RegExp('^(' + minPieces.join('|') + ')', 'i');\n}\n\n// FORMATTING\n\nfunction hFormat() {\n    return this.hours() % 12 || 12;\n}\n\nfunction kFormat() {\n    return this.hours() || 24;\n}\n\naddFormatToken('H', ['HH', 2], 0, 'hour');\naddFormatToken('h', ['hh', 2], 0, hFormat);\naddFormatToken('k', ['kk', 2], 0, kFormat);\n\naddFormatToken('hmm', 0, 0, function () {\n    return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2);\n});\n\naddFormatToken('hmmss', 0, 0, function () {\n    return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2) +\n        zeroFill(this.seconds(), 2);\n});\n\naddFormatToken('Hmm', 0, 0, function () {\n    return '' + this.hours() + zeroFill(this.minutes(), 2);\n});\n\naddFormatToken('Hmmss', 0, 0, function () {\n    return '' + this.hours() + zeroFill(this.minutes(), 2) +\n        zeroFill(this.seconds(), 2);\n});\n\nfunction meridiem (token, lowercase) {\n    addFormatToken(token, 0, 0, function () {\n        return this.localeData().meridiem(this.hours(), this.minutes(), lowercase);\n    });\n}\n\nmeridiem('a', true);\nmeridiem('A', false);\n\n// ALIASES\n\naddUnitAlias('hour', 'h');\n\n// PRIORITY\naddUnitPriority('hour', 13);\n\n// PARSING\n\nfunction matchMeridiem (isStrict, locale) {\n    return locale._meridiemParse;\n}\n\naddRegexToken('a',  matchMeridiem);\naddRegexToken('A',  matchMeridiem);\naddRegexToken('H',  match1to2);\naddRegexToken('h',  match1to2);\naddRegexToken('k',  match1to2);\naddRegexToken('HH', match1to2, match2);\naddRegexToken('hh', match1to2, match2);\naddRegexToken('kk', match1to2, match2);\n\naddRegexToken('hmm', match3to4);\naddRegexToken('hmmss', match5to6);\naddRegexToken('Hmm', match3to4);\naddRegexToken('Hmmss', match5to6);\n\naddParseToken(['H', 'HH'], HOUR);\naddParseToken(['k', 'kk'], function (input, array, config) {\n    var kInput = toInt(input);\n    array[HOUR] = kInput === 24 ? 0 : kInput;\n});\naddParseToken(['a', 'A'], function (input, array, config) {\n    config._isPm = config._locale.isPM(input);\n    config._meridiem = input;\n});\naddParseToken(['h', 'hh'], function (input, array, config) {\n    array[HOUR] = toInt(input);\n    getParsingFlags(config).bigHour = true;\n});\naddParseToken('hmm', function (input, array, config) {\n    var pos = input.length - 2;\n    array[HOUR] = toInt(input.substr(0, pos));\n    array[MINUTE] = toInt(input.substr(pos));\n    getParsingFlags(config).bigHour = true;\n});\naddParseToken('hmmss', function (input, array, config) {\n    var pos1 = input.length - 4;\n    var pos2 = input.length - 2;\n    array[HOUR] = toInt(input.substr(0, pos1));\n    array[MINUTE] = toInt(input.substr(pos1, 2));\n    array[SECOND] = toInt(input.substr(pos2));\n    getParsingFlags(config).bigHour = true;\n});\naddParseToken('Hmm', function (input, array, config) {\n    var pos = input.length - 2;\n    array[HOUR] = toInt(input.substr(0, pos));\n    array[MINUTE] = toInt(input.substr(pos));\n});\naddParseToken('Hmmss', function (input, array, config) {\n    var pos1 = input.length - 4;\n    var pos2 = input.length - 2;\n    array[HOUR] = toInt(input.substr(0, pos1));\n    array[MINUTE] = toInt(input.substr(pos1, 2));\n    array[SECOND] = toInt(input.substr(pos2));\n});\n\n// LOCALES\n\nfunction localeIsPM (input) {\n    // IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays\n    // Using charAt should be more compatible.\n    return ((input + '').toLowerCase().charAt(0) === 'p');\n}\n\nvar defaultLocaleMeridiemParse = /[ap]\\.?m?\\.?/i;\nfunction localeMeridiem (hours, minutes, isLower) {\n    if (hours > 11) {\n        return isLower ? 'pm' : 'PM';\n    } else {\n        return isLower ? 'am' : 'AM';\n    }\n}\n\n\n// MOMENTS\n\n// Setting the hour should keep the time, because the user explicitly\n// specified which hour he wants. So trying to maintain the same hour (in\n// a new timezone) makes sense. Adding/subtracting hours does not follow\n// this rule.\nvar getSetHour = makeGetSet('Hours', true);\n\n// months\n// week\n// weekdays\n// meridiem\nvar baseConfig = {\n    calendar: defaultCalendar,\n    longDateFormat: defaultLongDateFormat,\n    invalidDate: defaultInvalidDate,\n    ordinal: defaultOrdinal,\n    dayOfMonthOrdinalParse: defaultDayOfMonthOrdinalParse,\n    relativeTime: defaultRelativeTime,\n\n    months: defaultLocaleMonths,\n    monthsShort: defaultLocaleMonthsShort,\n\n    week: defaultLocaleWeek,\n\n    weekdays: defaultLocaleWeekdays,\n    weekdaysMin: defaultLocaleWeekdaysMin,\n    weekdaysShort: defaultLocaleWeekdaysShort,\n\n    meridiemParse: defaultLocaleMeridiemParse\n};\n\n// internal storage for locale config files\nvar locales = {};\nvar localeFamilies = {};\nvar globalLocale;\n\nfunction normalizeLocale(key) {\n    return key ? key.toLowerCase().replace('_', '-') : key;\n}\n\n// pick the locale from the array\n// try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each\n// substring from most specific to least, but move to the next array item if it's a more specific variant than the current root\nfunction chooseLocale(names) {\n    var i = 0, j, next, locale, split;\n\n    while (i < names.length) {\n        split = normalizeLocale(names[i]).split('-');\n        j = split.length;\n        next = normalizeLocale(names[i + 1]);\n        next = next ? next.split('-') : null;\n        while (j > 0) {\n            locale = loadLocale(split.slice(0, j).join('-'));\n            if (locale) {\n                return locale;\n            }\n            if (next && next.length >= j && compareArrays(split, next, true) >= j - 1) {\n                //the next array item is better than a shallower substring of this one\n                break;\n            }\n            j--;\n        }\n        i++;\n    }\n    return null;\n}\n\nfunction loadLocale(name) {\n    var oldLocale = null;\n    // TODO: Find a better way to register and load all the locales in Node\n    if (!locales[name] && (typeof module !== 'undefined') &&\n            module && module.exports) {\n        try {\n            oldLocale = globalLocale._abbr;\n            !(function webpackMissingModule() { var e = new Error(\"Cannot find module \\\"./locale\\\"\"); e.code = 'MODULE_NOT_FOUND'; throw e; }());\n            // because defineLocale currently also sets the global locale, we\n            // want to undo that for lazy loaded locales\n            getSetGlobalLocale(oldLocale);\n        } catch (e) { }\n    }\n    return locales[name];\n}\n\n// This function will load locale and then set the global locale.  If\n// no arguments are passed in, it will simply return the current global\n// locale key.\nfunction getSetGlobalLocale (key, values) {\n    var data;\n    if (key) {\n        if (isUndefined(values)) {\n            data = getLocale(key);\n        }\n        else {\n            data = defineLocale(key, values);\n        }\n\n        if (data) {\n            // moment.duration._locale = moment._locale = data;\n            globalLocale = data;\n        }\n    }\n\n    return globalLocale._abbr;\n}\n\nfunction defineLocale (name, config) {\n    if (config !== null) {\n        var parentConfig = baseConfig;\n        config.abbr = name;\n        if (locales[name] != null) {\n            deprecateSimple('defineLocaleOverride',\n                    'use moment.updateLocale(localeName, config) to change ' +\n                    'an existing locale. moment.defineLocale(localeName, ' +\n                    'config) should only be used for creating a new locale ' +\n                    'See http://momentjs.com/guides/#/warnings/define-locale/ for more info.');\n            parentConfig = locales[name]._config;\n        } else if (config.parentLocale != null) {\n            if (locales[config.parentLocale] != null) {\n                parentConfig = locales[config.parentLocale]._config;\n            } else {\n                if (!localeFamilies[config.parentLocale]) {\n                    localeFamilies[config.parentLocale] = [];\n                }\n                localeFamilies[config.parentLocale].push({\n                    name: name,\n                    config: config\n                });\n                return null;\n            }\n        }\n        locales[name] = new Locale(mergeConfigs(parentConfig, config));\n\n        if (localeFamilies[name]) {\n            localeFamilies[name].forEach(function (x) {\n                defineLocale(x.name, x.config);\n            });\n        }\n\n        // backwards compat for now: also set the locale\n        // make sure we set the locale AFTER all child locales have been\n        // created, so we won't end up with the child locale set.\n        getSetGlobalLocale(name);\n\n\n        return locales[name];\n    } else {\n        // useful for testing\n        delete locales[name];\n        return null;\n    }\n}\n\nfunction updateLocale(name, config) {\n    if (config != null) {\n        var locale, parentConfig = baseConfig;\n        // MERGE\n        if (locales[name] != null) {\n            parentConfig = locales[name]._config;\n        }\n        config = mergeConfigs(parentConfig, config);\n        locale = new Locale(config);\n        locale.parentLocale = locales[name];\n        locales[name] = locale;\n\n        // backwards compat for now: also set the locale\n        getSetGlobalLocale(name);\n    } else {\n        // pass null for config to unupdate, useful for tests\n        if (locales[name] != null) {\n            if (locales[name].parentLocale != null) {\n                locales[name] = locales[name].parentLocale;\n            } else if (locales[name] != null) {\n                delete locales[name];\n            }\n        }\n    }\n    return locales[name];\n}\n\n// returns locale data\nfunction getLocale (key) {\n    var locale;\n\n    if (key && key._locale && key._locale._abbr) {\n        key = key._locale._abbr;\n    }\n\n    if (!key) {\n        return globalLocale;\n    }\n\n    if (!isArray(key)) {\n        //short-circuit everything else\n        locale = loadLocale(key);\n        if (locale) {\n            return locale;\n        }\n        key = [key];\n    }\n\n    return chooseLocale(key);\n}\n\nfunction listLocales() {\n    return keys$1(locales);\n}\n\nfunction checkOverflow (m) {\n    var overflow;\n    var a = m._a;\n\n    if (a && getParsingFlags(m).overflow === -2) {\n        overflow =\n            a[MONTH]       < 0 || a[MONTH]       > 11  ? MONTH :\n            a[DATE]        < 1 || a[DATE]        > daysInMonth(a[YEAR], a[MONTH]) ? DATE :\n            a[HOUR]        < 0 || a[HOUR]        > 24 || (a[HOUR] === 24 && (a[MINUTE] !== 0 || a[SECOND] !== 0 || a[MILLISECOND] !== 0)) ? HOUR :\n            a[MINUTE]      < 0 || a[MINUTE]      > 59  ? MINUTE :\n            a[SECOND]      < 0 || a[SECOND]      > 59  ? SECOND :\n            a[MILLISECOND] < 0 || a[MILLISECOND] > 999 ? MILLISECOND :\n            -1;\n\n        if (getParsingFlags(m)._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) {\n            overflow = DATE;\n        }\n        if (getParsingFlags(m)._overflowWeeks && overflow === -1) {\n            overflow = WEEK;\n        }\n        if (getParsingFlags(m)._overflowWeekday && overflow === -1) {\n            overflow = WEEKDAY;\n        }\n\n        getParsingFlags(m).overflow = overflow;\n    }\n\n    return m;\n}\n\n// iso 8601 regex\n// 0000-00-00 0000-W00 or 0000-W00-0 + T + 00 or 00:00 or 00:00:00 or 00:00:00.000 + +00:00 or +0000 or +00)\nvar extendedIsoRegex = /^\\s*((?:[+-]\\d{6}|\\d{4})-(?:\\d\\d-\\d\\d|W\\d\\d-\\d|W\\d\\d|\\d\\d\\d|\\d\\d))(?:(T| )(\\d\\d(?::\\d\\d(?::\\d\\d(?:[.,]\\d+)?)?)?)([\\+\\-]\\d\\d(?::?\\d\\d)?|\\s*Z)?)?$/;\nvar basicIsoRegex = /^\\s*((?:[+-]\\d{6}|\\d{4})(?:\\d\\d\\d\\d|W\\d\\d\\d|W\\d\\d|\\d\\d\\d|\\d\\d))(?:(T| )(\\d\\d(?:\\d\\d(?:\\d\\d(?:[.,]\\d+)?)?)?)([\\+\\-]\\d\\d(?::?\\d\\d)?|\\s*Z)?)?$/;\n\nvar tzRegex = /Z|[+-]\\d\\d(?::?\\d\\d)?/;\n\nvar isoDates = [\n    ['YYYYYY-MM-DD', /[+-]\\d{6}-\\d\\d-\\d\\d/],\n    ['YYYY-MM-DD', /\\d{4}-\\d\\d-\\d\\d/],\n    ['GGGG-[W]WW-E', /\\d{4}-W\\d\\d-\\d/],\n    ['GGGG-[W]WW', /\\d{4}-W\\d\\d/, false],\n    ['YYYY-DDD', /\\d{4}-\\d{3}/],\n    ['YYYY-MM', /\\d{4}-\\d\\d/, false],\n    ['YYYYYYMMDD', /[+-]\\d{10}/],\n    ['YYYYMMDD', /\\d{8}/],\n    // YYYYMM is NOT allowed by the standard\n    ['GGGG[W]WWE', /\\d{4}W\\d{3}/],\n    ['GGGG[W]WW', /\\d{4}W\\d{2}/, false],\n    ['YYYYDDD', /\\d{7}/]\n];\n\n// iso time formats and regexes\nvar isoTimes = [\n    ['HH:mm:ss.SSSS', /\\d\\d:\\d\\d:\\d\\d\\.\\d+/],\n    ['HH:mm:ss,SSSS', /\\d\\d:\\d\\d:\\d\\d,\\d+/],\n    ['HH:mm:ss', /\\d\\d:\\d\\d:\\d\\d/],\n    ['HH:mm', /\\d\\d:\\d\\d/],\n    ['HHmmss.SSSS', /\\d\\d\\d\\d\\d\\d\\.\\d+/],\n    ['HHmmss,SSSS', /\\d\\d\\d\\d\\d\\d,\\d+/],\n    ['HHmmss', /\\d\\d\\d\\d\\d\\d/],\n    ['HHmm', /\\d\\d\\d\\d/],\n    ['HH', /\\d\\d/]\n];\n\nvar aspNetJsonRegex = /^\\/?Date\\((\\-?\\d+)/i;\n\n// date from iso format\nfunction configFromISO(config) {\n    var i, l,\n        string = config._i,\n        match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string),\n        allowTime, dateFormat, timeFormat, tzFormat;\n\n    if (match) {\n        getParsingFlags(config).iso = true;\n\n        for (i = 0, l = isoDates.length; i < l; i++) {\n            if (isoDates[i][1].exec(match[1])) {\n                dateFormat = isoDates[i][0];\n                allowTime = isoDates[i][2] !== false;\n                break;\n            }\n        }\n        if (dateFormat == null) {\n            config._isValid = false;\n            return;\n        }\n        if (match[3]) {\n            for (i = 0, l = isoTimes.length; i < l; i++) {\n                if (isoTimes[i][1].exec(match[3])) {\n                    // match[2] should be 'T' or space\n                    timeFormat = (match[2] || ' ') + isoTimes[i][0];\n                    break;\n                }\n            }\n            if (timeFormat == null) {\n                config._isValid = false;\n                return;\n            }\n        }\n        if (!allowTime && timeFormat != null) {\n            config._isValid = false;\n            return;\n        }\n        if (match[4]) {\n            if (tzRegex.exec(match[4])) {\n                tzFormat = 'Z';\n            } else {\n                config._isValid = false;\n                return;\n            }\n        }\n        config._f = dateFormat + (timeFormat || '') + (tzFormat || '');\n        configFromStringAndFormat(config);\n    } else {\n        config._isValid = false;\n    }\n}\n\n// RFC 2822 regex: For details see https://tools.ietf.org/html/rfc2822#section-3.3\nvar basicRfcRegex = /^((?:Mon|Tue|Wed|Thu|Fri|Sat|Sun),?\\s)?(\\d?\\d\\s(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\\s(?:\\d\\d)?\\d\\d\\s)(\\d\\d:\\d\\d)(\\:\\d\\d)?(\\s(?:UT|GMT|[ECMP][SD]T|[A-IK-Za-ik-z]|[+-]\\d{4}))$/;\n\n// date and time from ref 2822 format\nfunction configFromRFC2822(config) {\n    var string, match, dayFormat,\n        dateFormat, timeFormat, tzFormat;\n    var timezones = {\n        ' GMT': ' +0000',\n        ' EDT': ' -0400',\n        ' EST': ' -0500',\n        ' CDT': ' -0500',\n        ' CST': ' -0600',\n        ' MDT': ' -0600',\n        ' MST': ' -0700',\n        ' PDT': ' -0700',\n        ' PST': ' -0800'\n    };\n    var military = 'YXWVUTSRQPONZABCDEFGHIKLM';\n    var timezone, timezoneIndex;\n\n    string = config._i\n        .replace(/\\([^\\)]*\\)|[\\n\\t]/g, ' ') // Remove comments and folding whitespace\n        .replace(/(\\s\\s+)/g, ' ') // Replace multiple-spaces with a single space\n        .replace(/^\\s|\\s$/g, ''); // Remove leading and trailing spaces\n    match = basicRfcRegex.exec(string);\n\n    if (match) {\n        dayFormat = match[1] ? 'ddd' + ((match[1].length === 5) ? ', ' : ' ') : '';\n        dateFormat = 'D MMM ' + ((match[2].length > 10) ? 'YYYY ' : 'YY ');\n        timeFormat = 'HH:mm' + (match[4] ? ':ss' : '');\n\n        // TODO: Replace the vanilla JS Date object with an indepentent day-of-week check.\n        if (match[1]) { // day of week given\n            var momentDate = new Date(match[2]);\n            var momentDay = ['Sun','Mon','Tue','Wed','Thu','Fri','Sat'][momentDate.getDay()];\n\n            if (match[1].substr(0,3) !== momentDay) {\n                getParsingFlags(config).weekdayMismatch = true;\n                config._isValid = false;\n                return;\n            }\n        }\n\n        switch (match[5].length) {\n            case 2: // military\n                if (timezoneIndex === 0) {\n                    timezone = ' +0000';\n                } else {\n                    timezoneIndex = military.indexOf(match[5][1].toUpperCase()) - 12;\n                    timezone = ((timezoneIndex < 0) ? ' -' : ' +') +\n                        (('' + timezoneIndex).replace(/^-?/, '0')).match(/..$/)[0] + '00';\n                }\n                break;\n            case 4: // Zone\n                timezone = timezones[match[5]];\n                break;\n            default: // UT or +/-9999\n                timezone = timezones[' GMT'];\n        }\n        match[5] = timezone;\n        config._i = match.splice(1).join('');\n        tzFormat = ' ZZ';\n        config._f = dayFormat + dateFormat + timeFormat + tzFormat;\n        configFromStringAndFormat(config);\n        getParsingFlags(config).rfc2822 = true;\n    } else {\n        config._isValid = false;\n    }\n}\n\n// date from iso format or fallback\nfunction configFromString(config) {\n    var matched = aspNetJsonRegex.exec(config._i);\n\n    if (matched !== null) {\n        config._d = new Date(+matched[1]);\n        return;\n    }\n\n    configFromISO(config);\n    if (config._isValid === false) {\n        delete config._isValid;\n    } else {\n        return;\n    }\n\n    configFromRFC2822(config);\n    if (config._isValid === false) {\n        delete config._isValid;\n    } else {\n        return;\n    }\n\n    // Final attempt, use Input Fallback\n    hooks.createFromInputFallback(config);\n}\n\nhooks.createFromInputFallback = deprecate(\n    'value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), ' +\n    'which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are ' +\n    'discouraged and will be removed in an upcoming major release. Please refer to ' +\n    'http://momentjs.com/guides/#/warnings/js-date/ for more info.',\n    function (config) {\n        config._d = new Date(config._i + (config._useUTC ? ' UTC' : ''));\n    }\n);\n\n// Pick the first defined of two or three arguments.\nfunction defaults(a, b, c) {\n    if (a != null) {\n        return a;\n    }\n    if (b != null) {\n        return b;\n    }\n    return c;\n}\n\nfunction currentDateArray(config) {\n    // hooks is actually the exported moment object\n    var nowValue = new Date(hooks.now());\n    if (config._useUTC) {\n        return [nowValue.getUTCFullYear(), nowValue.getUTCMonth(), nowValue.getUTCDate()];\n    }\n    return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()];\n}\n\n// convert an array to a date.\n// the array should mirror the parameters below\n// note: all values past the year are optional and will default to the lowest possible value.\n// [year, month, day , hour, minute, second, millisecond]\nfunction configFromArray (config) {\n    var i, date, input = [], currentDate, yearToUse;\n\n    if (config._d) {\n        return;\n    }\n\n    currentDate = currentDateArray(config);\n\n    //compute day of the year from weeks and weekdays\n    if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {\n        dayOfYearFromWeekInfo(config);\n    }\n\n    //if the day of the year is set, figure out what it is\n    if (config._dayOfYear != null) {\n        yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);\n\n        if (config._dayOfYear > daysInYear(yearToUse) || config._dayOfYear === 0) {\n            getParsingFlags(config)._overflowDayOfYear = true;\n        }\n\n        date = createUTCDate(yearToUse, 0, config._dayOfYear);\n        config._a[MONTH] = date.getUTCMonth();\n        config._a[DATE] = date.getUTCDate();\n    }\n\n    // Default to current date.\n    // * if no year, month, day of month are given, default to today\n    // * if day of month is given, default month and year\n    // * if month is given, default only year\n    // * if year is given, don't default anything\n    for (i = 0; i < 3 && config._a[i] == null; ++i) {\n        config._a[i] = input[i] = currentDate[i];\n    }\n\n    // Zero out whatever was not defaulted, including time\n    for (; i < 7; i++) {\n        config._a[i] = input[i] = (config._a[i] == null) ? (i === 2 ? 1 : 0) : config._a[i];\n    }\n\n    // Check for 24:00:00.000\n    if (config._a[HOUR] === 24 &&\n            config._a[MINUTE] === 0 &&\n            config._a[SECOND] === 0 &&\n            config._a[MILLISECOND] === 0) {\n        config._nextDay = true;\n        config._a[HOUR] = 0;\n    }\n\n    config._d = (config._useUTC ? createUTCDate : createDate).apply(null, input);\n    // Apply timezone offset from input. The actual utcOffset can be changed\n    // with parseZone.\n    if (config._tzm != null) {\n        config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);\n    }\n\n    if (config._nextDay) {\n        config._a[HOUR] = 24;\n    }\n}\n\nfunction dayOfYearFromWeekInfo(config) {\n    var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow;\n\n    w = config._w;\n    if (w.GG != null || w.W != null || w.E != null) {\n        dow = 1;\n        doy = 4;\n\n        // TODO: We need to take the current isoWeekYear, but that depends on\n        // how we interpret now (local, utc, fixed offset). So create\n        // a now version of current config (take local/utc/offset flags, and\n        // create now).\n        weekYear = defaults(w.GG, config._a[YEAR], weekOfYear(createLocal(), 1, 4).year);\n        week = defaults(w.W, 1);\n        weekday = defaults(w.E, 1);\n        if (weekday < 1 || weekday > 7) {\n            weekdayOverflow = true;\n        }\n    } else {\n        dow = config._locale._week.dow;\n        doy = config._locale._week.doy;\n\n        var curWeek = weekOfYear(createLocal(), dow, doy);\n\n        weekYear = defaults(w.gg, config._a[YEAR], curWeek.year);\n\n        // Default to current week.\n        week = defaults(w.w, curWeek.week);\n\n        if (w.d != null) {\n            // weekday -- low day numbers are considered next week\n            weekday = w.d;\n            if (weekday < 0 || weekday > 6) {\n                weekdayOverflow = true;\n            }\n        } else if (w.e != null) {\n            // local weekday -- counting starts from begining of week\n            weekday = w.e + dow;\n            if (w.e < 0 || w.e > 6) {\n                weekdayOverflow = true;\n            }\n        } else {\n            // default to begining of week\n            weekday = dow;\n        }\n    }\n    if (week < 1 || week > weeksInYear(weekYear, dow, doy)) {\n        getParsingFlags(config)._overflowWeeks = true;\n    } else if (weekdayOverflow != null) {\n        getParsingFlags(config)._overflowWeekday = true;\n    } else {\n        temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy);\n        config._a[YEAR] = temp.year;\n        config._dayOfYear = temp.dayOfYear;\n    }\n}\n\n// constant that refers to the ISO standard\nhooks.ISO_8601 = function () {};\n\n// constant that refers to the RFC 2822 form\nhooks.RFC_2822 = function () {};\n\n// date from string and format string\nfunction configFromStringAndFormat(config) {\n    // TODO: Move this to another part of the creation flow to prevent circular deps\n    if (config._f === hooks.ISO_8601) {\n        configFromISO(config);\n        return;\n    }\n    if (config._f === hooks.RFC_2822) {\n        configFromRFC2822(config);\n        return;\n    }\n    config._a = [];\n    getParsingFlags(config).empty = true;\n\n    // This array is used to make a Date, either with `new Date` or `Date.UTC`\n    var string = '' + config._i,\n        i, parsedInput, tokens, token, skipped,\n        stringLength = string.length,\n        totalParsedInputLength = 0;\n\n    tokens = expandFormat(config._f, config._locale).match(formattingTokens) || [];\n\n    for (i = 0; i < tokens.length; i++) {\n        token = tokens[i];\n        parsedInput = (string.match(getParseRegexForToken(token, config)) || [])[0];\n        // console.log('token', token, 'parsedInput', parsedInput,\n        //         'regex', getParseRegexForToken(token, config));\n        if (parsedInput) {\n            skipped = string.substr(0, string.indexOf(parsedInput));\n            if (skipped.length > 0) {\n                getParsingFlags(config).unusedInput.push(skipped);\n            }\n            string = string.slice(string.indexOf(parsedInput) + parsedInput.length);\n            totalParsedInputLength += parsedInput.length;\n        }\n        // don't parse if it's not a known token\n        if (formatTokenFunctions[token]) {\n            if (parsedInput) {\n                getParsingFlags(config).empty = false;\n            }\n            else {\n                getParsingFlags(config).unusedTokens.push(token);\n            }\n            addTimeToArrayFromToken(token, parsedInput, config);\n        }\n        else if (config._strict && !parsedInput) {\n            getParsingFlags(config).unusedTokens.push(token);\n        }\n    }\n\n    // add remaining unparsed input length to the string\n    getParsingFlags(config).charsLeftOver = stringLength - totalParsedInputLength;\n    if (string.length > 0) {\n        getParsingFlags(config).unusedInput.push(string);\n    }\n\n    // clear _12h flag if hour is <= 12\n    if (config._a[HOUR] <= 12 &&\n        getParsingFlags(config).bigHour === true &&\n        config._a[HOUR] > 0) {\n        getParsingFlags(config).bigHour = undefined;\n    }\n\n    getParsingFlags(config).parsedDateParts = config._a.slice(0);\n    getParsingFlags(config).meridiem = config._meridiem;\n    // handle meridiem\n    config._a[HOUR] = meridiemFixWrap(config._locale, config._a[HOUR], config._meridiem);\n\n    configFromArray(config);\n    checkOverflow(config);\n}\n\n\nfunction meridiemFixWrap (locale, hour, meridiem) {\n    var isPm;\n\n    if (meridiem == null) {\n        // nothing to do\n        return hour;\n    }\n    if (locale.meridiemHour != null) {\n        return locale.meridiemHour(hour, meridiem);\n    } else if (locale.isPM != null) {\n        // Fallback\n        isPm = locale.isPM(meridiem);\n        if (isPm && hour < 12) {\n            hour += 12;\n        }\n        if (!isPm && hour === 12) {\n            hour = 0;\n        }\n        return hour;\n    } else {\n        // this is not supposed to happen\n        return hour;\n    }\n}\n\n// date from string and array of format strings\nfunction configFromStringAndArray(config) {\n    var tempConfig,\n        bestMoment,\n\n        scoreToBeat,\n        i,\n        currentScore;\n\n    if (config._f.length === 0) {\n        getParsingFlags(config).invalidFormat = true;\n        config._d = new Date(NaN);\n        return;\n    }\n\n    for (i = 0; i < config._f.length; i++) {\n        currentScore = 0;\n        tempConfig = copyConfig({}, config);\n        if (config._useUTC != null) {\n            tempConfig._useUTC = config._useUTC;\n        }\n        tempConfig._f = config._f[i];\n        configFromStringAndFormat(tempConfig);\n\n        if (!isValid(tempConfig)) {\n            continue;\n        }\n\n        // if there is any input that was not parsed add a penalty for that format\n        currentScore += getParsingFlags(tempConfig).charsLeftOver;\n\n        //or tokens\n        currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10;\n\n        getParsingFlags(tempConfig).score = currentScore;\n\n        if (scoreToBeat == null || currentScore < scoreToBeat) {\n            scoreToBeat = currentScore;\n            bestMoment = tempConfig;\n        }\n    }\n\n    extend(config, bestMoment || tempConfig);\n}\n\nfunction configFromObject(config) {\n    if (config._d) {\n        return;\n    }\n\n    var i = normalizeObjectUnits(config._i);\n    config._a = map([i.year, i.month, i.day || i.date, i.hour, i.minute, i.second, i.millisecond], function (obj) {\n        return obj && parseInt(obj, 10);\n    });\n\n    configFromArray(config);\n}\n\nfunction createFromConfig (config) {\n    var res = new Moment(checkOverflow(prepareConfig(config)));\n    if (res._nextDay) {\n        // Adding is smart enough around DST\n        res.add(1, 'd');\n        res._nextDay = undefined;\n    }\n\n    return res;\n}\n\nfunction prepareConfig (config) {\n    var input = config._i,\n        format = config._f;\n\n    config._locale = config._locale || getLocale(config._l);\n\n    if (input === null || (format === undefined && input === '')) {\n        return createInvalid({nullInput: true});\n    }\n\n    if (typeof input === 'string') {\n        config._i = input = config._locale.preparse(input);\n    }\n\n    if (isMoment(input)) {\n        return new Moment(checkOverflow(input));\n    } else if (isDate(input)) {\n        config._d = input;\n    } else if (isArray(format)) {\n        configFromStringAndArray(config);\n    } else if (format) {\n        configFromStringAndFormat(config);\n    }  else {\n        configFromInput(config);\n    }\n\n    if (!isValid(config)) {\n        config._d = null;\n    }\n\n    return config;\n}\n\nfunction configFromInput(config) {\n    var input = config._i;\n    if (isUndefined(input)) {\n        config._d = new Date(hooks.now());\n    } else if (isDate(input)) {\n        config._d = new Date(input.valueOf());\n    } else if (typeof input === 'string') {\n        configFromString(config);\n    } else if (isArray(input)) {\n        config._a = map(input.slice(0), function (obj) {\n            return parseInt(obj, 10);\n        });\n        configFromArray(config);\n    } else if (isObject(input)) {\n        configFromObject(config);\n    } else if (isNumber(input)) {\n        // from milliseconds\n        config._d = new Date(input);\n    } else {\n        hooks.createFromInputFallback(config);\n    }\n}\n\nfunction createLocalOrUTC (input, format, locale, strict, isUTC) {\n    var c = {};\n\n    if (locale === true || locale === false) {\n        strict = locale;\n        locale = undefined;\n    }\n\n    if ((isObject(input) && isObjectEmpty(input)) ||\n            (isArray(input) && input.length === 0)) {\n        input = undefined;\n    }\n    // object construction must be done this way.\n    // https://github.com/moment/moment/issues/1423\n    c._isAMomentObject = true;\n    c._useUTC = c._isUTC = isUTC;\n    c._l = locale;\n    c._i = input;\n    c._f = format;\n    c._strict = strict;\n\n    return createFromConfig(c);\n}\n\nfunction createLocal (input, format, locale, strict) {\n    return createLocalOrUTC(input, format, locale, strict, false);\n}\n\nvar prototypeMin = deprecate(\n    'moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/',\n    function () {\n        var other = createLocal.apply(null, arguments);\n        if (this.isValid() && other.isValid()) {\n            return other < this ? this : other;\n        } else {\n            return createInvalid();\n        }\n    }\n);\n\nvar prototypeMax = deprecate(\n    'moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/',\n    function () {\n        var other = createLocal.apply(null, arguments);\n        if (this.isValid() && other.isValid()) {\n            return other > this ? this : other;\n        } else {\n            return createInvalid();\n        }\n    }\n);\n\n// Pick a moment m from moments so that m[fn](other) is true for all\n// other. This relies on the function fn to be transitive.\n//\n// moments should either be an array of moment objects or an array, whose\n// first element is an array of moment objects.\nfunction pickBy(fn, moments) {\n    var res, i;\n    if (moments.length === 1 && isArray(moments[0])) {\n        moments = moments[0];\n    }\n    if (!moments.length) {\n        return createLocal();\n    }\n    res = moments[0];\n    for (i = 1; i < moments.length; ++i) {\n        if (!moments[i].isValid() || moments[i][fn](res)) {\n            res = moments[i];\n        }\n    }\n    return res;\n}\n\n// TODO: Use [].sort instead?\nfunction min () {\n    var args = [].slice.call(arguments, 0);\n\n    return pickBy('isBefore', args);\n}\n\nfunction max () {\n    var args = [].slice.call(arguments, 0);\n\n    return pickBy('isAfter', args);\n}\n\nvar now = function () {\n    return Date.now ? Date.now() : +(new Date());\n};\n\nvar ordering = ['year', 'quarter', 'month', 'week', 'day', 'hour', 'minute', 'second', 'millisecond'];\n\nfunction isDurationValid(m) {\n    for (var key in m) {\n        if (!(ordering.indexOf(key) !== -1 && (m[key] == null || !isNaN(m[key])))) {\n            return false;\n        }\n    }\n\n    var unitHasDecimal = false;\n    for (var i = 0; i < ordering.length; ++i) {\n        if (m[ordering[i]]) {\n            if (unitHasDecimal) {\n                return false; // only allow non-integers for smallest unit\n            }\n            if (parseFloat(m[ordering[i]]) !== toInt(m[ordering[i]])) {\n                unitHasDecimal = true;\n            }\n        }\n    }\n\n    return true;\n}\n\nfunction isValid$1() {\n    return this._isValid;\n}\n\nfunction createInvalid$1() {\n    return createDuration(NaN);\n}\n\nfunction Duration (duration) {\n    var normalizedInput = normalizeObjectUnits(duration),\n        years = normalizedInput.year || 0,\n        quarters = normalizedInput.quarter || 0,\n        months = normalizedInput.month || 0,\n        weeks = normalizedInput.week || 0,\n        days = normalizedInput.day || 0,\n        hours = normalizedInput.hour || 0,\n        minutes = normalizedInput.minute || 0,\n        seconds = normalizedInput.second || 0,\n        milliseconds = normalizedInput.millisecond || 0;\n\n    this._isValid = isDurationValid(normalizedInput);\n\n    // representation for dateAddRemove\n    this._milliseconds = +milliseconds +\n        seconds * 1e3 + // 1000\n        minutes * 6e4 + // 1000 * 60\n        hours * 1000 * 60 * 60; //using 1000 * 60 * 60 instead of 36e5 to avoid floating point rounding errors https://github.com/moment/moment/issues/2978\n    // Because of dateAddRemove treats 24 hours as different from a\n    // day when working around DST, we need to store them separately\n    this._days = +days +\n        weeks * 7;\n    // It is impossible translate months into days without knowing\n    // which months you are are talking about, so we have to store\n    // it separately.\n    this._months = +months +\n        quarters * 3 +\n        years * 12;\n\n    this._data = {};\n\n    this._locale = getLocale();\n\n    this._bubble();\n}\n\nfunction isDuration (obj) {\n    return obj instanceof Duration;\n}\n\nfunction absRound (number) {\n    if (number < 0) {\n        return Math.round(-1 * number) * -1;\n    } else {\n        return Math.round(number);\n    }\n}\n\n// FORMATTING\n\nfunction offset (token, separator) {\n    addFormatToken(token, 0, 0, function () {\n        var offset = this.utcOffset();\n        var sign = '+';\n        if (offset < 0) {\n            offset = -offset;\n            sign = '-';\n        }\n        return sign + zeroFill(~~(offset / 60), 2) + separator + zeroFill(~~(offset) % 60, 2);\n    });\n}\n\noffset('Z', ':');\noffset('ZZ', '');\n\n// PARSING\n\naddRegexToken('Z',  matchShortOffset);\naddRegexToken('ZZ', matchShortOffset);\naddParseToken(['Z', 'ZZ'], function (input, array, config) {\n    config._useUTC = true;\n    config._tzm = offsetFromString(matchShortOffset, input);\n});\n\n// HELPERS\n\n// timezone chunker\n// '+10:00' > ['10',  '00']\n// '-1530'  > ['-15', '30']\nvar chunkOffset = /([\\+\\-]|\\d\\d)/gi;\n\nfunction offsetFromString(matcher, string) {\n    var matches = (string || '').match(matcher);\n\n    if (matches === null) {\n        return null;\n    }\n\n    var chunk   = matches[matches.length - 1] || [];\n    var parts   = (chunk + '').match(chunkOffset) || ['-', 0, 0];\n    var minutes = +(parts[1] * 60) + toInt(parts[2]);\n\n    return minutes === 0 ?\n      0 :\n      parts[0] === '+' ? minutes : -minutes;\n}\n\n// Return a moment from input, that is local/utc/zone equivalent to model.\nfunction cloneWithOffset(input, model) {\n    var res, diff;\n    if (model._isUTC) {\n        res = model.clone();\n        diff = (isMoment(input) || isDate(input) ? input.valueOf() : createLocal(input).valueOf()) - res.valueOf();\n        // Use low-level api, because this fn is low-level api.\n        res._d.setTime(res._d.valueOf() + diff);\n        hooks.updateOffset(res, false);\n        return res;\n    } else {\n        return createLocal(input).local();\n    }\n}\n\nfunction getDateOffset (m) {\n    // On Firefox.24 Date#getTimezoneOffset returns a floating point.\n    // https://github.com/moment/moment/pull/1871\n    return -Math.round(m._d.getTimezoneOffset() / 15) * 15;\n}\n\n// HOOKS\n\n// This function will be called whenever a moment is mutated.\n// It is intended to keep the offset in sync with the timezone.\nhooks.updateOffset = function () {};\n\n// MOMENTS\n\n// keepLocalTime = true means only change the timezone, without\n// affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]-->\n// 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset\n// +0200, so we adjust the time as needed, to be valid.\n//\n// Keeping the time actually adds/subtracts (one hour)\n// from the actual represented time. That is why we call updateOffset\n// a second time. In case it wants us to change the offset again\n// _changeInProgress == true case, then we have to adjust, because\n// there is no such time in the given timezone.\nfunction getSetOffset (input, keepLocalTime, keepMinutes) {\n    var offset = this._offset || 0,\n        localAdjust;\n    if (!this.isValid()) {\n        return input != null ? this : NaN;\n    }\n    if (input != null) {\n        if (typeof input === 'string') {\n            input = offsetFromString(matchShortOffset, input);\n            if (input === null) {\n                return this;\n            }\n        } else if (Math.abs(input) < 16 && !keepMinutes) {\n            input = input * 60;\n        }\n        if (!this._isUTC && keepLocalTime) {\n            localAdjust = getDateOffset(this);\n        }\n        this._offset = input;\n        this._isUTC = true;\n        if (localAdjust != null) {\n            this.add(localAdjust, 'm');\n        }\n        if (offset !== input) {\n            if (!keepLocalTime || this._changeInProgress) {\n                addSubtract(this, createDuration(input - offset, 'm'), 1, false);\n            } else if (!this._changeInProgress) {\n                this._changeInProgress = true;\n                hooks.updateOffset(this, true);\n                this._changeInProgress = null;\n            }\n        }\n        return this;\n    } else {\n        return this._isUTC ? offset : getDateOffset(this);\n    }\n}\n\nfunction getSetZone (input, keepLocalTime) {\n    if (input != null) {\n        if (typeof input !== 'string') {\n            input = -input;\n        }\n\n        this.utcOffset(input, keepLocalTime);\n\n        return this;\n    } else {\n        return -this.utcOffset();\n    }\n}\n\nfunction setOffsetToUTC (keepLocalTime) {\n    return this.utcOffset(0, keepLocalTime);\n}\n\nfunction setOffsetToLocal (keepLocalTime) {\n    if (this._isUTC) {\n        this.utcOffset(0, keepLocalTime);\n        this._isUTC = false;\n\n        if (keepLocalTime) {\n            this.subtract(getDateOffset(this), 'm');\n        }\n    }\n    return this;\n}\n\nfunction setOffsetToParsedOffset () {\n    if (this._tzm != null) {\n        this.utcOffset(this._tzm, false, true);\n    } else if (typeof this._i === 'string') {\n        var tZone = offsetFromString(matchOffset, this._i);\n        if (tZone != null) {\n            this.utcOffset(tZone);\n        }\n        else {\n            this.utcOffset(0, true);\n        }\n    }\n    return this;\n}\n\nfunction hasAlignedHourOffset (input) {\n    if (!this.isValid()) {\n        return false;\n    }\n    input = input ? createLocal(input).utcOffset() : 0;\n\n    return (this.utcOffset() - input) % 60 === 0;\n}\n\nfunction isDaylightSavingTime () {\n    return (\n        this.utcOffset() > this.clone().month(0).utcOffset() ||\n        this.utcOffset() > this.clone().month(5).utcOffset()\n    );\n}\n\nfunction isDaylightSavingTimeShifted () {\n    if (!isUndefined(this._isDSTShifted)) {\n        return this._isDSTShifted;\n    }\n\n    var c = {};\n\n    copyConfig(c, this);\n    c = prepareConfig(c);\n\n    if (c._a) {\n        var other = c._isUTC ? createUTC(c._a) : createLocal(c._a);\n        this._isDSTShifted = this.isValid() &&\n            compareArrays(c._a, other.toArray()) > 0;\n    } else {\n        this._isDSTShifted = false;\n    }\n\n    return this._isDSTShifted;\n}\n\nfunction isLocal () {\n    return this.isValid() ? !this._isUTC : false;\n}\n\nfunction isUtcOffset () {\n    return this.isValid() ? this._isUTC : false;\n}\n\nfunction isUtc () {\n    return this.isValid() ? this._isUTC && this._offset === 0 : false;\n}\n\n// ASP.NET json date format regex\nvar aspNetRegex = /^(\\-)?(?:(\\d*)[. ])?(\\d+)\\:(\\d+)(?:\\:(\\d+)(\\.\\d*)?)?$/;\n\n// from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html\n// somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere\n// and further modified to allow for strings containing both week and day\nvar isoRegex = /^(-)?P(?:(-?[0-9,.]*)Y)?(?:(-?[0-9,.]*)M)?(?:(-?[0-9,.]*)W)?(?:(-?[0-9,.]*)D)?(?:T(?:(-?[0-9,.]*)H)?(?:(-?[0-9,.]*)M)?(?:(-?[0-9,.]*)S)?)?$/;\n\nfunction createDuration (input, key) {\n    var duration = input,\n        // matching against regexp is expensive, do it on demand\n        match = null,\n        sign,\n        ret,\n        diffRes;\n\n    if (isDuration(input)) {\n        duration = {\n            ms : input._milliseconds,\n            d  : input._days,\n            M  : input._months\n        };\n    } else if (isNumber(input)) {\n        duration = {};\n        if (key) {\n            duration[key] = input;\n        } else {\n            duration.milliseconds = input;\n        }\n    } else if (!!(match = aspNetRegex.exec(input))) {\n        sign = (match[1] === '-') ? -1 : 1;\n        duration = {\n            y  : 0,\n            d  : toInt(match[DATE])                         * sign,\n            h  : toInt(match[HOUR])                         * sign,\n            m  : toInt(match[MINUTE])                       * sign,\n            s  : toInt(match[SECOND])                       * sign,\n            ms : toInt(absRound(match[MILLISECOND] * 1000)) * sign // the millisecond decimal point is included in the match\n        };\n    } else if (!!(match = isoRegex.exec(input))) {\n        sign = (match[1] === '-') ? -1 : 1;\n        duration = {\n            y : parseIso(match[2], sign),\n            M : parseIso(match[3], sign),\n            w : parseIso(match[4], sign),\n            d : parseIso(match[5], sign),\n            h : parseIso(match[6], sign),\n            m : parseIso(match[7], sign),\n            s : parseIso(match[8], sign)\n        };\n    } else if (duration == null) {// checks for null or undefined\n        duration = {};\n    } else if (typeof duration === 'object' && ('from' in duration || 'to' in duration)) {\n        diffRes = momentsDifference(createLocal(duration.from), createLocal(duration.to));\n\n        duration = {};\n        duration.ms = diffRes.milliseconds;\n        duration.M = diffRes.months;\n    }\n\n    ret = new Duration(duration);\n\n    if (isDuration(input) && hasOwnProp(input, '_locale')) {\n        ret._locale = input._locale;\n    }\n\n    return ret;\n}\n\ncreateDuration.fn = Duration.prototype;\ncreateDuration.invalid = createInvalid$1;\n\nfunction parseIso (inp, sign) {\n    // We'd normally use ~~inp for this, but unfortunately it also\n    // converts floats to ints.\n    // inp may be undefined, so careful calling replace on it.\n    var res = inp && parseFloat(inp.replace(',', '.'));\n    // apply sign while we're at it\n    return (isNaN(res) ? 0 : res) * sign;\n}\n\nfunction positiveMomentsDifference(base, other) {\n    var res = {milliseconds: 0, months: 0};\n\n    res.months = other.month() - base.month() +\n        (other.year() - base.year()) * 12;\n    if (base.clone().add(res.months, 'M').isAfter(other)) {\n        --res.months;\n    }\n\n    res.milliseconds = +other - +(base.clone().add(res.months, 'M'));\n\n    return res;\n}\n\nfunction momentsDifference(base, other) {\n    var res;\n    if (!(base.isValid() && other.isValid())) {\n        return {milliseconds: 0, months: 0};\n    }\n\n    other = cloneWithOffset(other, base);\n    if (base.isBefore(other)) {\n        res = positiveMomentsDifference(base, other);\n    } else {\n        res = positiveMomentsDifference(other, base);\n        res.milliseconds = -res.milliseconds;\n        res.months = -res.months;\n    }\n\n    return res;\n}\n\n// TODO: remove 'name' arg after deprecation is removed\nfunction createAdder(direction, name) {\n    return function (val, period) {\n        var dur, tmp;\n        //invert the arguments, but complain about it\n        if (period !== null && !isNaN(+period)) {\n            deprecateSimple(name, 'moment().' + name  + '(period, number) is deprecated. Please use moment().' + name + '(number, period). ' +\n            'See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info.');\n            tmp = val; val = period; period = tmp;\n        }\n\n        val = typeof val === 'string' ? +val : val;\n        dur = createDuration(val, period);\n        addSubtract(this, dur, direction);\n        return this;\n    };\n}\n\nfunction addSubtract (mom, duration, isAdding, updateOffset) {\n    var milliseconds = duration._milliseconds,\n        days = absRound(duration._days),\n        months = absRound(duration._months);\n\n    if (!mom.isValid()) {\n        // No op\n        return;\n    }\n\n    updateOffset = updateOffset == null ? true : updateOffset;\n\n    if (milliseconds) {\n        mom._d.setTime(mom._d.valueOf() + milliseconds * isAdding);\n    }\n    if (days) {\n        set$1(mom, 'Date', get(mom, 'Date') + days * isAdding);\n    }\n    if (months) {\n        setMonth(mom, get(mom, 'Month') + months * isAdding);\n    }\n    if (updateOffset) {\n        hooks.updateOffset(mom, days || months);\n    }\n}\n\nvar add      = createAdder(1, 'add');\nvar subtract = createAdder(-1, 'subtract');\n\nfunction getCalendarFormat(myMoment, now) {\n    var diff = myMoment.diff(now, 'days', true);\n    return diff < -6 ? 'sameElse' :\n            diff < -1 ? 'lastWeek' :\n            diff < 0 ? 'lastDay' :\n            diff < 1 ? 'sameDay' :\n            diff < 2 ? 'nextDay' :\n            diff < 7 ? 'nextWeek' : 'sameElse';\n}\n\nfunction calendar$1 (time, formats) {\n    // We want to compare the start of today, vs this.\n    // Getting start-of-today depends on whether we're local/utc/offset or not.\n    var now = time || createLocal(),\n        sod = cloneWithOffset(now, this).startOf('day'),\n        format = hooks.calendarFormat(this, sod) || 'sameElse';\n\n    var output = formats && (isFunction(formats[format]) ? formats[format].call(this, now) : formats[format]);\n\n    return this.format(output || this.localeData().calendar(format, this, createLocal(now)));\n}\n\nfunction clone () {\n    return new Moment(this);\n}\n\nfunction isAfter (input, units) {\n    var localInput = isMoment(input) ? input : createLocal(input);\n    if (!(this.isValid() && localInput.isValid())) {\n        return false;\n    }\n    units = normalizeUnits(!isUndefined(units) ? units : 'millisecond');\n    if (units === 'millisecond') {\n        return this.valueOf() > localInput.valueOf();\n    } else {\n        return localInput.valueOf() < this.clone().startOf(units).valueOf();\n    }\n}\n\nfunction isBefore (input, units) {\n    var localInput = isMoment(input) ? input : createLocal(input);\n    if (!(this.isValid() && localInput.isValid())) {\n        return false;\n    }\n    units = normalizeUnits(!isUndefined(units) ? units : 'millisecond');\n    if (units === 'millisecond') {\n        return this.valueOf() < localInput.valueOf();\n    } else {\n        return this.clone().endOf(units).valueOf() < localInput.valueOf();\n    }\n}\n\nfunction isBetween (from, to, units, inclusivity) {\n    inclusivity = inclusivity || '()';\n    return (inclusivity[0] === '(' ? this.isAfter(from, units) : !this.isBefore(from, units)) &&\n        (inclusivity[1] === ')' ? this.isBefore(to, units) : !this.isAfter(to, units));\n}\n\nfunction isSame (input, units) {\n    var localInput = isMoment(input) ? input : createLocal(input),\n        inputMs;\n    if (!(this.isValid() && localInput.isValid())) {\n        return false;\n    }\n    units = normalizeUnits(units || 'millisecond');\n    if (units === 'millisecond') {\n        return this.valueOf() === localInput.valueOf();\n    } else {\n        inputMs = localInput.valueOf();\n        return this.clone().startOf(units).valueOf() <= inputMs && inputMs <= this.clone().endOf(units).valueOf();\n    }\n}\n\nfunction isSameOrAfter (input, units) {\n    return this.isSame(input, units) || this.isAfter(input,units);\n}\n\nfunction isSameOrBefore (input, units) {\n    return this.isSame(input, units) || this.isBefore(input,units);\n}\n\nfunction diff (input, units, asFloat) {\n    var that,\n        zoneDelta,\n        delta, output;\n\n    if (!this.isValid()) {\n        return NaN;\n    }\n\n    that = cloneWithOffset(input, this);\n\n    if (!that.isValid()) {\n        return NaN;\n    }\n\n    zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4;\n\n    units = normalizeUnits(units);\n\n    if (units === 'year' || units === 'month' || units === 'quarter') {\n        output = monthDiff(this, that);\n        if (units === 'quarter') {\n            output = output / 3;\n        } else if (units === 'year') {\n            output = output / 12;\n        }\n    } else {\n        delta = this - that;\n        output = units === 'second' ? delta / 1e3 : // 1000\n            units === 'minute' ? delta / 6e4 : // 1000 * 60\n            units === 'hour' ? delta / 36e5 : // 1000 * 60 * 60\n            units === 'day' ? (delta - zoneDelta) / 864e5 : // 1000 * 60 * 60 * 24, negate dst\n            units === 'week' ? (delta - zoneDelta) / 6048e5 : // 1000 * 60 * 60 * 24 * 7, negate dst\n            delta;\n    }\n    return asFloat ? output : absFloor(output);\n}\n\nfunction monthDiff (a, b) {\n    // difference in months\n    var wholeMonthDiff = ((b.year() - a.year()) * 12) + (b.month() - a.month()),\n        // b is in (anchor - 1 month, anchor + 1 month)\n        anchor = a.clone().add(wholeMonthDiff, 'months'),\n        anchor2, adjust;\n\n    if (b - anchor < 0) {\n        anchor2 = a.clone().add(wholeMonthDiff - 1, 'months');\n        // linear across the month\n        adjust = (b - anchor) / (anchor - anchor2);\n    } else {\n        anchor2 = a.clone().add(wholeMonthDiff + 1, 'months');\n        // linear across the month\n        adjust = (b - anchor) / (anchor2 - anchor);\n    }\n\n    //check for negative zero, return zero if negative zero\n    return -(wholeMonthDiff + adjust) || 0;\n}\n\nhooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ';\nhooks.defaultFormatUtc = 'YYYY-MM-DDTHH:mm:ss[Z]';\n\nfunction toString () {\n    return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');\n}\n\nfunction toISOString() {\n    if (!this.isValid()) {\n        return null;\n    }\n    var m = this.clone().utc();\n    if (m.year() < 0 || m.year() > 9999) {\n        return formatMoment(m, 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]');\n    }\n    if (isFunction(Date.prototype.toISOString)) {\n        // native implementation is ~50x faster, use it when we can\n        return this.toDate().toISOString();\n    }\n    return formatMoment(m, 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]');\n}\n\n/**\n * Return a human readable representation of a moment that can\n * also be evaluated to get a new moment which is the same\n *\n * @link https://nodejs.org/dist/latest/docs/api/util.html#util_custom_inspect_function_on_objects\n */\nfunction inspect () {\n    if (!this.isValid()) {\n        return 'moment.invalid(/* ' + this._i + ' */)';\n    }\n    var func = 'moment';\n    var zone = '';\n    if (!this.isLocal()) {\n        func = this.utcOffset() === 0 ? 'moment.utc' : 'moment.parseZone';\n        zone = 'Z';\n    }\n    var prefix = '[' + func + '(\"]';\n    var year = (0 <= this.year() && this.year() <= 9999) ? 'YYYY' : 'YYYYYY';\n    var datetime = '-MM-DD[T]HH:mm:ss.SSS';\n    var suffix = zone + '[\")]';\n\n    return this.format(prefix + year + datetime + suffix);\n}\n\nfunction format (inputString) {\n    if (!inputString) {\n        inputString = this.isUtc() ? hooks.defaultFormatUtc : hooks.defaultFormat;\n    }\n    var output = formatMoment(this, inputString);\n    return this.localeData().postformat(output);\n}\n\nfunction from (time, withoutSuffix) {\n    if (this.isValid() &&\n            ((isMoment(time) && time.isValid()) ||\n             createLocal(time).isValid())) {\n        return createDuration({to: this, from: time}).locale(this.locale()).humanize(!withoutSuffix);\n    } else {\n        return this.localeData().invalidDate();\n    }\n}\n\nfunction fromNow (withoutSuffix) {\n    return this.from(createLocal(), withoutSuffix);\n}\n\nfunction to (time, withoutSuffix) {\n    if (this.isValid() &&\n            ((isMoment(time) && time.isValid()) ||\n             createLocal(time).isValid())) {\n        return createDuration({from: this, to: time}).locale(this.locale()).humanize(!withoutSuffix);\n    } else {\n        return this.localeData().invalidDate();\n    }\n}\n\nfunction toNow (withoutSuffix) {\n    return this.to(createLocal(), withoutSuffix);\n}\n\n// If passed a locale key, it will set the locale for this\n// instance.  Otherwise, it will return the locale configuration\n// variables for this instance.\nfunction locale (key) {\n    var newLocaleData;\n\n    if (key === undefined) {\n        return this._locale._abbr;\n    } else {\n        newLocaleData = getLocale(key);\n        if (newLocaleData != null) {\n            this._locale = newLocaleData;\n        }\n        return this;\n    }\n}\n\nvar lang = deprecate(\n    'moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.',\n    function (key) {\n        if (key === undefined) {\n            return this.localeData();\n        } else {\n            return this.locale(key);\n        }\n    }\n);\n\nfunction localeData () {\n    return this._locale;\n}\n\nfunction startOf (units) {\n    units = normalizeUnits(units);\n    // the following switch intentionally omits break keywords\n    // to utilize falling through the cases.\n    switch (units) {\n        case 'year':\n            this.month(0);\n            /* falls through */\n        case 'quarter':\n        case 'month':\n            this.date(1);\n            /* falls through */\n        case 'week':\n        case 'isoWeek':\n        case 'day':\n        case 'date':\n            this.hours(0);\n            /* falls through */\n        case 'hour':\n            this.minutes(0);\n            /* falls through */\n        case 'minute':\n            this.seconds(0);\n            /* falls through */\n        case 'second':\n            this.milliseconds(0);\n    }\n\n    // weeks are a special case\n    if (units === 'week') {\n        this.weekday(0);\n    }\n    if (units === 'isoWeek') {\n        this.isoWeekday(1);\n    }\n\n    // quarters are also special\n    if (units === 'quarter') {\n        this.month(Math.floor(this.month() / 3) * 3);\n    }\n\n    return this;\n}\n\nfunction endOf (units) {\n    units = normalizeUnits(units);\n    if (units === undefined || units === 'millisecond') {\n        return this;\n    }\n\n    // 'date' is an alias for 'day', so it should be considered as such.\n    if (units === 'date') {\n        units = 'day';\n    }\n\n    return this.startOf(units).add(1, (units === 'isoWeek' ? 'week' : units)).subtract(1, 'ms');\n}\n\nfunction valueOf () {\n    return this._d.valueOf() - ((this._offset || 0) * 60000);\n}\n\nfunction unix () {\n    return Math.floor(this.valueOf() / 1000);\n}\n\nfunction toDate () {\n    return new Date(this.valueOf());\n}\n\nfunction toArray () {\n    var m = this;\n    return [m.year(), m.month(), m.date(), m.hour(), m.minute(), m.second(), m.millisecond()];\n}\n\nfunction toObject () {\n    var m = this;\n    return {\n        years: m.year(),\n        months: m.month(),\n        date: m.date(),\n        hours: m.hours(),\n        minutes: m.minutes(),\n        seconds: m.seconds(),\n        milliseconds: m.milliseconds()\n    };\n}\n\nfunction toJSON () {\n    // new Date(NaN).toJSON() === null\n    return this.isValid() ? this.toISOString() : null;\n}\n\nfunction isValid$2 () {\n    return isValid(this);\n}\n\nfunction parsingFlags () {\n    return extend({}, getParsingFlags(this));\n}\n\nfunction invalidAt () {\n    return getParsingFlags(this).overflow;\n}\n\nfunction creationData() {\n    return {\n        input: this._i,\n        format: this._f,\n        locale: this._locale,\n        isUTC: this._isUTC,\n        strict: this._strict\n    };\n}\n\n// FORMATTING\n\naddFormatToken(0, ['gg', 2], 0, function () {\n    return this.weekYear() % 100;\n});\n\naddFormatToken(0, ['GG', 2], 0, function () {\n    return this.isoWeekYear() % 100;\n});\n\nfunction addWeekYearFormatToken (token, getter) {\n    addFormatToken(0, [token, token.length], 0, getter);\n}\n\naddWeekYearFormatToken('gggg',     'weekYear');\naddWeekYearFormatToken('ggggg',    'weekYear');\naddWeekYearFormatToken('GGGG',  'isoWeekYear');\naddWeekYearFormatToken('GGGGG', 'isoWeekYear');\n\n// ALIASES\n\naddUnitAlias('weekYear', 'gg');\naddUnitAlias('isoWeekYear', 'GG');\n\n// PRIORITY\n\naddUnitPriority('weekYear', 1);\naddUnitPriority('isoWeekYear', 1);\n\n\n// PARSING\n\naddRegexToken('G',      matchSigned);\naddRegexToken('g',      matchSigned);\naddRegexToken('GG',     match1to2, match2);\naddRegexToken('gg',     match1to2, match2);\naddRegexToken('GGGG',   match1to4, match4);\naddRegexToken('gggg',   match1to4, match4);\naddRegexToken('GGGGG',  match1to6, match6);\naddRegexToken('ggggg',  match1to6, match6);\n\naddWeekParseToken(['gggg', 'ggggg', 'GGGG', 'GGGGG'], function (input, week, config, token) {\n    week[token.substr(0, 2)] = toInt(input);\n});\n\naddWeekParseToken(['gg', 'GG'], function (input, week, config, token) {\n    week[token] = hooks.parseTwoDigitYear(input);\n});\n\n// MOMENTS\n\nfunction getSetWeekYear (input) {\n    return getSetWeekYearHelper.call(this,\n            input,\n            this.week(),\n            this.weekday(),\n            this.localeData()._week.dow,\n            this.localeData()._week.doy);\n}\n\nfunction getSetISOWeekYear (input) {\n    return getSetWeekYearHelper.call(this,\n            input, this.isoWeek(), this.isoWeekday(), 1, 4);\n}\n\nfunction getISOWeeksInYear () {\n    return weeksInYear(this.year(), 1, 4);\n}\n\nfunction getWeeksInYear () {\n    var weekInfo = this.localeData()._week;\n    return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy);\n}\n\nfunction getSetWeekYearHelper(input, week, weekday, dow, doy) {\n    var weeksTarget;\n    if (input == null) {\n        return weekOfYear(this, dow, doy).year;\n    } else {\n        weeksTarget = weeksInYear(input, dow, doy);\n        if (week > weeksTarget) {\n            week = weeksTarget;\n        }\n        return setWeekAll.call(this, input, week, weekday, dow, doy);\n    }\n}\n\nfunction setWeekAll(weekYear, week, weekday, dow, doy) {\n    var dayOfYearData = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy),\n        date = createUTCDate(dayOfYearData.year, 0, dayOfYearData.dayOfYear);\n\n    this.year(date.getUTCFullYear());\n    this.month(date.getUTCMonth());\n    this.date(date.getUTCDate());\n    return this;\n}\n\n// FORMATTING\n\naddFormatToken('Q', 0, 'Qo', 'quarter');\n\n// ALIASES\n\naddUnitAlias('quarter', 'Q');\n\n// PRIORITY\n\naddUnitPriority('quarter', 7);\n\n// PARSING\n\naddRegexToken('Q', match1);\naddParseToken('Q', function (input, array) {\n    array[MONTH] = (toInt(input) - 1) * 3;\n});\n\n// MOMENTS\n\nfunction getSetQuarter (input) {\n    return input == null ? Math.ceil((this.month() + 1) / 3) : this.month((input - 1) * 3 + this.month() % 3);\n}\n\n// FORMATTING\n\naddFormatToken('D', ['DD', 2], 'Do', 'date');\n\n// ALIASES\n\naddUnitAlias('date', 'D');\n\n// PRIOROITY\naddUnitPriority('date', 9);\n\n// PARSING\n\naddRegexToken('D',  match1to2);\naddRegexToken('DD', match1to2, match2);\naddRegexToken('Do', function (isStrict, locale) {\n    // TODO: Remove \"ordinalParse\" fallback in next major release.\n    return isStrict ?\n      (locale._dayOfMonthOrdinalParse || locale._ordinalParse) :\n      locale._dayOfMonthOrdinalParseLenient;\n});\n\naddParseToken(['D', 'DD'], DATE);\naddParseToken('Do', function (input, array) {\n    array[DATE] = toInt(input.match(match1to2)[0], 10);\n});\n\n// MOMENTS\n\nvar getSetDayOfMonth = makeGetSet('Date', true);\n\n// FORMATTING\n\naddFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear');\n\n// ALIASES\n\naddUnitAlias('dayOfYear', 'DDD');\n\n// PRIORITY\naddUnitPriority('dayOfYear', 4);\n\n// PARSING\n\naddRegexToken('DDD',  match1to3);\naddRegexToken('DDDD', match3);\naddParseToken(['DDD', 'DDDD'], function (input, array, config) {\n    config._dayOfYear = toInt(input);\n});\n\n// HELPERS\n\n// MOMENTS\n\nfunction getSetDayOfYear (input) {\n    var dayOfYear = Math.round((this.clone().startOf('day') - this.clone().startOf('year')) / 864e5) + 1;\n    return input == null ? dayOfYear : this.add((input - dayOfYear), 'd');\n}\n\n// FORMATTING\n\naddFormatToken('m', ['mm', 2], 0, 'minute');\n\n// ALIASES\n\naddUnitAlias('minute', 'm');\n\n// PRIORITY\n\naddUnitPriority('minute', 14);\n\n// PARSING\n\naddRegexToken('m',  match1to2);\naddRegexToken('mm', match1to2, match2);\naddParseToken(['m', 'mm'], MINUTE);\n\n// MOMENTS\n\nvar getSetMinute = makeGetSet('Minutes', false);\n\n// FORMATTING\n\naddFormatToken('s', ['ss', 2], 0, 'second');\n\n// ALIASES\n\naddUnitAlias('second', 's');\n\n// PRIORITY\n\naddUnitPriority('second', 15);\n\n// PARSING\n\naddRegexToken('s',  match1to2);\naddRegexToken('ss', match1to2, match2);\naddParseToken(['s', 'ss'], SECOND);\n\n// MOMENTS\n\nvar getSetSecond = makeGetSet('Seconds', false);\n\n// FORMATTING\n\naddFormatToken('S', 0, 0, function () {\n    return ~~(this.millisecond() / 100);\n});\n\naddFormatToken(0, ['SS', 2], 0, function () {\n    return ~~(this.millisecond() / 10);\n});\n\naddFormatToken(0, ['SSS', 3], 0, 'millisecond');\naddFormatToken(0, ['SSSS', 4], 0, function () {\n    return this.millisecond() * 10;\n});\naddFormatToken(0, ['SSSSS', 5], 0, function () {\n    return this.millisecond() * 100;\n});\naddFormatToken(0, ['SSSSSS', 6], 0, function () {\n    return this.millisecond() * 1000;\n});\naddFormatToken(0, ['SSSSSSS', 7], 0, function () {\n    return this.millisecond() * 10000;\n});\naddFormatToken(0, ['SSSSSSSS', 8], 0, function () {\n    return this.millisecond() * 100000;\n});\naddFormatToken(0, ['SSSSSSSSS', 9], 0, function () {\n    return this.millisecond() * 1000000;\n});\n\n\n// ALIASES\n\naddUnitAlias('millisecond', 'ms');\n\n// PRIORITY\n\naddUnitPriority('millisecond', 16);\n\n// PARSING\n\naddRegexToken('S',    match1to3, match1);\naddRegexToken('SS',   match1to3, match2);\naddRegexToken('SSS',  match1to3, match3);\n\nvar token;\nfor (token = 'SSSS'; token.length <= 9; token += 'S') {\n    addRegexToken(token, matchUnsigned);\n}\n\nfunction parseMs(input, array) {\n    array[MILLISECOND] = toInt(('0.' + input) * 1000);\n}\n\nfor (token = 'S'; token.length <= 9; token += 'S') {\n    addParseToken(token, parseMs);\n}\n// MOMENTS\n\nvar getSetMillisecond = makeGetSet('Milliseconds', false);\n\n// FORMATTING\n\naddFormatToken('z',  0, 0, 'zoneAbbr');\naddFormatToken('zz', 0, 0, 'zoneName');\n\n// MOMENTS\n\nfunction getZoneAbbr () {\n    return this._isUTC ? 'UTC' : '';\n}\n\nfunction getZoneName () {\n    return this._isUTC ? 'Coordinated Universal Time' : '';\n}\n\nvar proto = Moment.prototype;\n\nproto.add               = add;\nproto.calendar          = calendar$1;\nproto.clone             = clone;\nproto.diff              = diff;\nproto.endOf             = endOf;\nproto.format            = format;\nproto.from              = from;\nproto.fromNow           = fromNow;\nproto.to                = to;\nproto.toNow             = toNow;\nproto.get               = stringGet;\nproto.invalidAt         = invalidAt;\nproto.isAfter           = isAfter;\nproto.isBefore          = isBefore;\nproto.isBetween         = isBetween;\nproto.isSame            = isSame;\nproto.isSameOrAfter     = isSameOrAfter;\nproto.isSameOrBefore    = isSameOrBefore;\nproto.isValid           = isValid$2;\nproto.lang              = lang;\nproto.locale            = locale;\nproto.localeData        = localeData;\nproto.max               = prototypeMax;\nproto.min               = prototypeMin;\nproto.parsingFlags      = parsingFlags;\nproto.set               = stringSet;\nproto.startOf           = startOf;\nproto.subtract          = subtract;\nproto.toArray           = toArray;\nproto.toObject          = toObject;\nproto.toDate            = toDate;\nproto.toISOString       = toISOString;\nproto.inspect           = inspect;\nproto.toJSON            = toJSON;\nproto.toString          = toString;\nproto.unix              = unix;\nproto.valueOf           = valueOf;\nproto.creationData      = creationData;\n\n// Year\nproto.year       = getSetYear;\nproto.isLeapYear = getIsLeapYear;\n\n// Week Year\nproto.weekYear    = getSetWeekYear;\nproto.isoWeekYear = getSetISOWeekYear;\n\n// Quarter\nproto.quarter = proto.quarters = getSetQuarter;\n\n// Month\nproto.month       = getSetMonth;\nproto.daysInMonth = getDaysInMonth;\n\n// Week\nproto.week           = proto.weeks        = getSetWeek;\nproto.isoWeek        = proto.isoWeeks     = getSetISOWeek;\nproto.weeksInYear    = getWeeksInYear;\nproto.isoWeeksInYear = getISOWeeksInYear;\n\n// Day\nproto.date       = getSetDayOfMonth;\nproto.day        = proto.days             = getSetDayOfWeek;\nproto.weekday    = getSetLocaleDayOfWeek;\nproto.isoWeekday = getSetISODayOfWeek;\nproto.dayOfYear  = getSetDayOfYear;\n\n// Hour\nproto.hour = proto.hours = getSetHour;\n\n// Minute\nproto.minute = proto.minutes = getSetMinute;\n\n// Second\nproto.second = proto.seconds = getSetSecond;\n\n// Millisecond\nproto.millisecond = proto.milliseconds = getSetMillisecond;\n\n// Offset\nproto.utcOffset            = getSetOffset;\nproto.utc                  = setOffsetToUTC;\nproto.local                = setOffsetToLocal;\nproto.parseZone            = setOffsetToParsedOffset;\nproto.hasAlignedHourOffset = hasAlignedHourOffset;\nproto.isDST                = isDaylightSavingTime;\nproto.isLocal              = isLocal;\nproto.isUtcOffset          = isUtcOffset;\nproto.isUtc                = isUtc;\nproto.isUTC                = isUtc;\n\n// Timezone\nproto.zoneAbbr = getZoneAbbr;\nproto.zoneName = getZoneName;\n\n// Deprecations\nproto.dates  = deprecate('dates accessor is deprecated. Use date instead.', getSetDayOfMonth);\nproto.months = deprecate('months accessor is deprecated. Use month instead', getSetMonth);\nproto.years  = deprecate('years accessor is deprecated. Use year instead', getSetYear);\nproto.zone   = deprecate('moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/', getSetZone);\nproto.isDSTShifted = deprecate('isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information', isDaylightSavingTimeShifted);\n\nfunction createUnix (input) {\n    return createLocal(input * 1000);\n}\n\nfunction createInZone () {\n    return createLocal.apply(null, arguments).parseZone();\n}\n\nfunction preParsePostFormat (string) {\n    return string;\n}\n\nvar proto$1 = Locale.prototype;\n\nproto$1.calendar        = calendar;\nproto$1.longDateFormat  = longDateFormat;\nproto$1.invalidDate     = invalidDate;\nproto$1.ordinal         = ordinal;\nproto$1.preparse        = preParsePostFormat;\nproto$1.postformat      = preParsePostFormat;\nproto$1.relativeTime    = relativeTime;\nproto$1.pastFuture      = pastFuture;\nproto$1.set             = set;\n\n// Month\nproto$1.months            =        localeMonths;\nproto$1.monthsShort       =        localeMonthsShort;\nproto$1.monthsParse       =        localeMonthsParse;\nproto$1.monthsRegex       = monthsRegex;\nproto$1.monthsShortRegex  = monthsShortRegex;\n\n// Week\nproto$1.week = localeWeek;\nproto$1.firstDayOfYear = localeFirstDayOfYear;\nproto$1.firstDayOfWeek = localeFirstDayOfWeek;\n\n// Day of Week\nproto$1.weekdays       =        localeWeekdays;\nproto$1.weekdaysMin    =        localeWeekdaysMin;\nproto$1.weekdaysShort  =        localeWeekdaysShort;\nproto$1.weekdaysParse  =        localeWeekdaysParse;\n\nproto$1.weekdaysRegex       =        weekdaysRegex;\nproto$1.weekdaysShortRegex  =        weekdaysShortRegex;\nproto$1.weekdaysMinRegex    =        weekdaysMinRegex;\n\n// Hours\nproto$1.isPM = localeIsPM;\nproto$1.meridiem = localeMeridiem;\n\nfunction get$1 (format, index, field, setter) {\n    var locale = getLocale();\n    var utc = createUTC().set(setter, index);\n    return locale[field](utc, format);\n}\n\nfunction listMonthsImpl (format, index, field) {\n    if (isNumber(format)) {\n        index = format;\n        format = undefined;\n    }\n\n    format = format || '';\n\n    if (index != null) {\n        return get$1(format, index, field, 'month');\n    }\n\n    var i;\n    var out = [];\n    for (i = 0; i < 12; i++) {\n        out[i] = get$1(format, i, field, 'month');\n    }\n    return out;\n}\n\n// ()\n// (5)\n// (fmt, 5)\n// (fmt)\n// (true)\n// (true, 5)\n// (true, fmt, 5)\n// (true, fmt)\nfunction listWeekdaysImpl (localeSorted, format, index, field) {\n    if (typeof localeSorted === 'boolean') {\n        if (isNumber(format)) {\n            index = format;\n            format = undefined;\n        }\n\n        format = format || '';\n    } else {\n        format = localeSorted;\n        index = format;\n        localeSorted = false;\n\n        if (isNumber(format)) {\n            index = format;\n            format = undefined;\n        }\n\n        format = format || '';\n    }\n\n    var locale = getLocale(),\n        shift = localeSorted ? locale._week.dow : 0;\n\n    if (index != null) {\n        return get$1(format, (index + shift) % 7, field, 'day');\n    }\n\n    var i;\n    var out = [];\n    for (i = 0; i < 7; i++) {\n        out[i] = get$1(format, (i + shift) % 7, field, 'day');\n    }\n    return out;\n}\n\nfunction listMonths (format, index) {\n    return listMonthsImpl(format, index, 'months');\n}\n\nfunction listMonthsShort (format, index) {\n    return listMonthsImpl(format, index, 'monthsShort');\n}\n\nfunction listWeekdays (localeSorted, format, index) {\n    return listWeekdaysImpl(localeSorted, format, index, 'weekdays');\n}\n\nfunction listWeekdaysShort (localeSorted, format, index) {\n    return listWeekdaysImpl(localeSorted, format, index, 'weekdaysShort');\n}\n\nfunction listWeekdaysMin (localeSorted, format, index) {\n    return listWeekdaysImpl(localeSorted, format, index, 'weekdaysMin');\n}\n\ngetSetGlobalLocale('en', {\n    dayOfMonthOrdinalParse: /\\d{1,2}(th|st|nd|rd)/,\n    ordinal : function (number) {\n        var b = number % 10,\n            output = (toInt(number % 100 / 10) === 1) ? 'th' :\n            (b === 1) ? 'st' :\n            (b === 2) ? 'nd' :\n            (b === 3) ? 'rd' : 'th';\n        return number + output;\n    }\n});\n\n// Side effect imports\nhooks.lang = deprecate('moment.lang is deprecated. Use moment.locale instead.', getSetGlobalLocale);\nhooks.langData = deprecate('moment.langData is deprecated. Use moment.localeData instead.', getLocale);\n\nvar mathAbs = Math.abs;\n\nfunction abs () {\n    var data           = this._data;\n\n    this._milliseconds = mathAbs(this._milliseconds);\n    this._days         = mathAbs(this._days);\n    this._months       = mathAbs(this._months);\n\n    data.milliseconds  = mathAbs(data.milliseconds);\n    data.seconds       = mathAbs(data.seconds);\n    data.minutes       = mathAbs(data.minutes);\n    data.hours         = mathAbs(data.hours);\n    data.months        = mathAbs(data.months);\n    data.years         = mathAbs(data.years);\n\n    return this;\n}\n\nfunction addSubtract$1 (duration, input, value, direction) {\n    var other = createDuration(input, value);\n\n    duration._milliseconds += direction * other._milliseconds;\n    duration._days         += direction * other._days;\n    duration._months       += direction * other._months;\n\n    return duration._bubble();\n}\n\n// supports only 2.0-style add(1, 's') or add(duration)\nfunction add$1 (input, value) {\n    return addSubtract$1(this, input, value, 1);\n}\n\n// supports only 2.0-style subtract(1, 's') or subtract(duration)\nfunction subtract$1 (input, value) {\n    return addSubtract$1(this, input, value, -1);\n}\n\nfunction absCeil (number) {\n    if (number < 0) {\n        return Math.floor(number);\n    } else {\n        return Math.ceil(number);\n    }\n}\n\nfunction bubble () {\n    var milliseconds = this._milliseconds;\n    var days         = this._days;\n    var months       = this._months;\n    var data         = this._data;\n    var seconds, minutes, hours, years, monthsFromDays;\n\n    // if we have a mix of positive and negative values, bubble down first\n    // check: https://github.com/moment/moment/issues/2166\n    if (!((milliseconds >= 0 && days >= 0 && months >= 0) ||\n            (milliseconds <= 0 && days <= 0 && months <= 0))) {\n        milliseconds += absCeil(monthsToDays(months) + days) * 864e5;\n        days = 0;\n        months = 0;\n    }\n\n    // The following code bubbles up values, see the tests for\n    // examples of what that means.\n    data.milliseconds = milliseconds % 1000;\n\n    seconds           = absFloor(milliseconds / 1000);\n    data.seconds      = seconds % 60;\n\n    minutes           = absFloor(seconds / 60);\n    data.minutes      = minutes % 60;\n\n    hours             = absFloor(minutes / 60);\n    data.hours        = hours % 24;\n\n    days += absFloor(hours / 24);\n\n    // convert days to months\n    monthsFromDays = absFloor(daysToMonths(days));\n    months += monthsFromDays;\n    days -= absCeil(monthsToDays(monthsFromDays));\n\n    // 12 months -> 1 year\n    years = absFloor(months / 12);\n    months %= 12;\n\n    data.days   = days;\n    data.months = months;\n    data.years  = years;\n\n    return this;\n}\n\nfunction daysToMonths (days) {\n    // 400 years have 146097 days (taking into account leap year rules)\n    // 400 years have 12 months === 4800\n    return days * 4800 / 146097;\n}\n\nfunction monthsToDays (months) {\n    // the reverse of daysToMonths\n    return months * 146097 / 4800;\n}\n\nfunction as (units) {\n    if (!this.isValid()) {\n        return NaN;\n    }\n    var days;\n    var months;\n    var milliseconds = this._milliseconds;\n\n    units = normalizeUnits(units);\n\n    if (units === 'month' || units === 'year') {\n        days   = this._days   + milliseconds / 864e5;\n        months = this._months + daysToMonths(days);\n        return units === 'month' ? months : months / 12;\n    } else {\n        // handle milliseconds separately because of floating point math errors (issue #1867)\n        days = this._days + Math.round(monthsToDays(this._months));\n        switch (units) {\n            case 'week'   : return days / 7     + milliseconds / 6048e5;\n            case 'day'    : return days         + milliseconds / 864e5;\n            case 'hour'   : return days * 24    + milliseconds / 36e5;\n            case 'minute' : return days * 1440  + milliseconds / 6e4;\n            case 'second' : return days * 86400 + milliseconds / 1000;\n            // Math.floor prevents floating point math errors here\n            case 'millisecond': return Math.floor(days * 864e5) + milliseconds;\n            default: throw new Error('Unknown unit ' + units);\n        }\n    }\n}\n\n// TODO: Use this.as('ms')?\nfunction valueOf$1 () {\n    if (!this.isValid()) {\n        return NaN;\n    }\n    return (\n        this._milliseconds +\n        this._days * 864e5 +\n        (this._months % 12) * 2592e6 +\n        toInt(this._months / 12) * 31536e6\n    );\n}\n\nfunction makeAs (alias) {\n    return function () {\n        return this.as(alias);\n    };\n}\n\nvar asMilliseconds = makeAs('ms');\nvar asSeconds      = makeAs('s');\nvar asMinutes      = makeAs('m');\nvar asHours        = makeAs('h');\nvar asDays         = makeAs('d');\nvar asWeeks        = makeAs('w');\nvar asMonths       = makeAs('M');\nvar asYears        = makeAs('y');\n\nfunction get$2 (units) {\n    units = normalizeUnits(units);\n    return this.isValid() ? this[units + 's']() : NaN;\n}\n\nfunction makeGetter(name) {\n    return function () {\n        return this.isValid() ? this._data[name] : NaN;\n    };\n}\n\nvar milliseconds = makeGetter('milliseconds');\nvar seconds      = makeGetter('seconds');\nvar minutes      = makeGetter('minutes');\nvar hours        = makeGetter('hours');\nvar days         = makeGetter('days');\nvar months       = makeGetter('months');\nvar years        = makeGetter('years');\n\nfunction weeks () {\n    return absFloor(this.days() / 7);\n}\n\nvar round = Math.round;\nvar thresholds = {\n    ss: 44,         // a few seconds to seconds\n    s : 45,         // seconds to minute\n    m : 45,         // minutes to hour\n    h : 22,         // hours to day\n    d : 26,         // days to month\n    M : 11          // months to year\n};\n\n// helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize\nfunction substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) {\n    return locale.relativeTime(number || 1, !!withoutSuffix, string, isFuture);\n}\n\nfunction relativeTime$1 (posNegDuration, withoutSuffix, locale) {\n    var duration = createDuration(posNegDuration).abs();\n    var seconds  = round(duration.as('s'));\n    var minutes  = round(duration.as('m'));\n    var hours    = round(duration.as('h'));\n    var days     = round(duration.as('d'));\n    var months   = round(duration.as('M'));\n    var years    = round(duration.as('y'));\n\n    var a = seconds <= thresholds.ss && ['s', seconds]  ||\n            seconds < thresholds.s   && ['ss', seconds] ||\n            minutes <= 1             && ['m']           ||\n            minutes < thresholds.m   && ['mm', minutes] ||\n            hours   <= 1             && ['h']           ||\n            hours   < thresholds.h   && ['hh', hours]   ||\n            days    <= 1             && ['d']           ||\n            days    < thresholds.d   && ['dd', days]    ||\n            months  <= 1             && ['M']           ||\n            months  < thresholds.M   && ['MM', months]  ||\n            years   <= 1             && ['y']           || ['yy', years];\n\n    a[2] = withoutSuffix;\n    a[3] = +posNegDuration > 0;\n    a[4] = locale;\n    return substituteTimeAgo.apply(null, a);\n}\n\n// This function allows you to set the rounding function for relative time strings\nfunction getSetRelativeTimeRounding (roundingFunction) {\n    if (roundingFunction === undefined) {\n        return round;\n    }\n    if (typeof(roundingFunction) === 'function') {\n        round = roundingFunction;\n        return true;\n    }\n    return false;\n}\n\n// This function allows you to set a threshold for relative time strings\nfunction getSetRelativeTimeThreshold (threshold, limit) {\n    if (thresholds[threshold] === undefined) {\n        return false;\n    }\n    if (limit === undefined) {\n        return thresholds[threshold];\n    }\n    thresholds[threshold] = limit;\n    if (threshold === 's') {\n        thresholds.ss = limit - 1;\n    }\n    return true;\n}\n\nfunction humanize (withSuffix) {\n    if (!this.isValid()) {\n        return this.localeData().invalidDate();\n    }\n\n    var locale = this.localeData();\n    var output = relativeTime$1(this, !withSuffix, locale);\n\n    if (withSuffix) {\n        output = locale.pastFuture(+this, output);\n    }\n\n    return locale.postformat(output);\n}\n\nvar abs$1 = Math.abs;\n\nfunction toISOString$1() {\n    // for ISO strings we do not use the normal bubbling rules:\n    //  * milliseconds bubble up until they become hours\n    //  * days do not bubble at all\n    //  * months bubble up until they become years\n    // This is because there is no context-free conversion between hours and days\n    // (think of clock changes)\n    // and also not between days and months (28-31 days per month)\n    if (!this.isValid()) {\n        return this.localeData().invalidDate();\n    }\n\n    var seconds = abs$1(this._milliseconds) / 1000;\n    var days         = abs$1(this._days);\n    var months       = abs$1(this._months);\n    var minutes, hours, years;\n\n    // 3600 seconds -> 60 minutes -> 1 hour\n    minutes           = absFloor(seconds / 60);\n    hours             = absFloor(minutes / 60);\n    seconds %= 60;\n    minutes %= 60;\n\n    // 12 months -> 1 year\n    years  = absFloor(months / 12);\n    months %= 12;\n\n\n    // inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js\n    var Y = years;\n    var M = months;\n    var D = days;\n    var h = hours;\n    var m = minutes;\n    var s = seconds;\n    var total = this.asSeconds();\n\n    if (!total) {\n        // this is the same as C#'s (Noda) and python (isodate)...\n        // but not other JS (goog.date)\n        return 'P0D';\n    }\n\n    return (total < 0 ? '-' : '') +\n        'P' +\n        (Y ? Y + 'Y' : '') +\n        (M ? M + 'M' : '') +\n        (D ? D + 'D' : '') +\n        ((h || m || s) ? 'T' : '') +\n        (h ? h + 'H' : '') +\n        (m ? m + 'M' : '') +\n        (s ? s + 'S' : '');\n}\n\nvar proto$2 = Duration.prototype;\n\nproto$2.isValid        = isValid$1;\nproto$2.abs            = abs;\nproto$2.add            = add$1;\nproto$2.subtract       = subtract$1;\nproto$2.as             = as;\nproto$2.asMilliseconds = asMilliseconds;\nproto$2.asSeconds      = asSeconds;\nproto$2.asMinutes      = asMinutes;\nproto$2.asHours        = asHours;\nproto$2.asDays         = asDays;\nproto$2.asWeeks        = asWeeks;\nproto$2.asMonths       = asMonths;\nproto$2.asYears        = asYears;\nproto$2.valueOf        = valueOf$1;\nproto$2._bubble        = bubble;\nproto$2.get            = get$2;\nproto$2.milliseconds   = milliseconds;\nproto$2.seconds        = seconds;\nproto$2.minutes        = minutes;\nproto$2.hours          = hours;\nproto$2.days           = days;\nproto$2.weeks          = weeks;\nproto$2.months         = months;\nproto$2.years          = years;\nproto$2.humanize       = humanize;\nproto$2.toISOString    = toISOString$1;\nproto$2.toString       = toISOString$1;\nproto$2.toJSON         = toISOString$1;\nproto$2.locale         = locale;\nproto$2.localeData     = localeData;\n\n// Deprecations\nproto$2.toIsoString = deprecate('toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)', toISOString$1);\nproto$2.lang = lang;\n\n// Side effect imports\n\n// FORMATTING\n\naddFormatToken('X', 0, 0, 'unix');\naddFormatToken('x', 0, 0, 'valueOf');\n\n// PARSING\n\naddRegexToken('x', matchSigned);\naddRegexToken('X', matchTimestamp);\naddParseToken('X', function (input, array, config) {\n    config._d = new Date(parseFloat(input, 10) * 1000);\n});\naddParseToken('x', function (input, array, config) {\n    config._d = new Date(toInt(input));\n});\n\n// Side effect imports\n\n\nhooks.version = '2.18.1';\n\nsetHookCallback(createLocal);\n\nhooks.fn                    = proto;\nhooks.min                   = min;\nhooks.max                   = max;\nhooks.now                   = now;\nhooks.utc                   = createUTC;\nhooks.unix                  = createUnix;\nhooks.months                = listMonths;\nhooks.isDate                = isDate;\nhooks.locale                = getSetGlobalLocale;\nhooks.invalid               = createInvalid;\nhooks.duration              = createDuration;\nhooks.isMoment              = isMoment;\nhooks.weekdays              = listWeekdays;\nhooks.parseZone             = createInZone;\nhooks.localeData            = getLocale;\nhooks.isDuration            = isDuration;\nhooks.monthsShort           = listMonthsShort;\nhooks.weekdaysMin           = listWeekdaysMin;\nhooks.defineLocale          = defineLocale;\nhooks.updateLocale          = updateLocale;\nhooks.locales               = listLocales;\nhooks.weekdaysShort         = listWeekdaysShort;\nhooks.normalizeUnits        = normalizeUnits;\nhooks.relativeTimeRounding = getSetRelativeTimeRounding;\nhooks.relativeTimeThreshold = getSetRelativeTimeThreshold;\nhooks.calendarFormat        = getCalendarFormat;\nhooks.prototype             = proto;\n\nreturn hooks;\n\n})));\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(31)(module)))\n\n/***/ }),\n/* 31 */\n/***/ (function(module, exports) {\n\nmodule.exports = function(module) {\r\n\tif(!module.webpackPolyfill) {\r\n\t\tmodule.deprecate = function() {};\r\n\t\tmodule.paths = [];\r\n\t\t// module.parent = undefined by default\r\n\t\tif(!module.children) module.children = [];\r\n\t\tObject.defineProperty(module, \"loaded\", {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function() {\r\n\t\t\t\treturn module.l;\r\n\t\t\t}\r\n\t\t});\r\n\t\tObject.defineProperty(module, \"id\", {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function() {\r\n\t\t\t\treturn module.i;\r\n\t\t\t}\r\n\t\t});\r\n\t\tmodule.webpackPolyfill = 1;\r\n\t}\r\n\treturn module;\r\n};\r\n\n\n/***/ })\n/******/ ]);\n\n\n// WEBPACK FOOTER //\n// dist/theme.min.js"," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// identity function for calling harmony imports with the correct context\n \t__webpack_require__.i = function(value) { return value; };\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, {\n \t\t\t\tconfigurable: false,\n \t\t\t\tenumerable: true,\n \t\t\t\tget: getter\n \t\t\t});\n \t\t}\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 28);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap 7c2777c3addcce4ae91a","/*!\n * jQuery JavaScript Library v1.12.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:17Z\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 deletedIds = [];\n\nvar document = window.document;\n\nvar slice = deletedIds.slice;\n\nvar concat = deletedIds.concat;\n\nvar push = deletedIds.push;\n\nvar indexOf = deletedIds.indexOf;\n\nvar class2type = {};\n\nvar toString = class2type.toString;\n\nvar hasOwn = class2type.hasOwnProperty;\n\nvar support = {};\n\n\n\nvar\n\tversion = \"1.12.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, IE<9\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: deletedIds.sort,\n\tsplice: deletedIds.splice\n};\n\njQuery.extend = jQuery.fn.extend = function() {\n\tvar src, copyIsArray, copy, name, options, 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\t// See test/unit/core.js for details concerning isFunction.\n\t// Since version 1.3, DOM methods and functions like alert\n\t// aren't supported. They return false on IE (#2968).\n\tisFunction: function( obj ) {\n\t\treturn jQuery.type( obj ) === \"function\";\n\t},\n\n\tisArray: Array.isArray || function( obj ) {\n\t\treturn jQuery.type( obj ) === \"array\";\n\t},\n\n\tisWindow: function( obj ) {\n\t\t/* jshint eqeqeq: false */\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\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\tisPlainObject: function( obj ) {\n\t\tvar key;\n\n\t\t// Must be an Object.\n\t\t// Because of IE, we also have to check the presence of the constructor property.\n\t\t// Make sure that DOM nodes and window objects don't pass through, as well\n\t\tif ( !obj || jQuery.type( obj ) !== \"object\" || obj.nodeType || jQuery.isWindow( obj ) ) {\n\t\t\treturn false;\n\t\t}\n\n\t\ttry {\n\n\t\t\t// Not own constructor property must be Object\n\t\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\t\treturn false;\n\t\t\t}\n\t\t} catch ( e ) {\n\n\t\t\t// IE8,9 Will throw exceptions on certain host objects #9897\n\t\t\treturn false;\n\t\t}\n\n\t\t// Support: IE<9\n\t\t// Handle iteration over inherited properties before own properties.\n\t\tif ( !support.ownFirst ) {\n\t\t\tfor ( key in obj ) {\n\t\t\t\treturn hasOwn.call( obj, key );\n\t\t\t}\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\ttype: function( obj ) {\n\t\tif ( obj == null ) {\n\t\t\treturn obj + \"\";\n\t\t}\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// Workarounds based on findings by Jim Driscoll\n\t// http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context\n\tglobalEval: function( data ) {\n\t\tif ( data && jQuery.trim( data ) ) {\n\n\t\t\t// We use execScript on Internet Explorer\n\t\t\t// We use an anonymous function so that context is window\n\t\t\t// rather than jQuery in Firefox\n\t\t\t( window.execScript || function( data ) {\n\t\t\t\twindow[ \"eval\" ].call( window, data ); // jscs:ignore requireDotNotation\n\t\t\t} )( data );\n\t\t}\n\t},\n\n\t// Convert dashed to camelCase; used by the css and data modules\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, IE<9\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\tvar len;\n\n\t\tif ( arr ) {\n\t\t\tif ( indexOf ) {\n\t\t\t\treturn indexOf.call( arr, elem, i );\n\t\t\t}\n\n\t\t\tlen = arr.length;\n\t\t\ti = i ? i < 0 ? Math.max( 0, len + i ) : i : 0;\n\n\t\t\tfor ( ; i < len; i++ ) {\n\n\t\t\t\t// Skip accessing in sparse arrays\n\t\t\t\tif ( i in arr && arr[ i ] === elem ) {\n\t\t\t\t\treturn i;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn -1;\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\twhile ( j < len ) {\n\t\t\tfirst[ i++ ] = second[ j++ ];\n\t\t}\n\n\t\t// Support: IE<9\n\t\t// Workaround casting of .length to NaN on otherwise arraylike objects (e.g., NodeLists)\n\t\tif ( len !== len ) {\n\t\t\twhile ( second[ j ] !== undefined ) {\n\t\t\t\tfirst[ i++ ] = second[ j++ ];\n\t\t\t}\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 args, proxy, tmp;\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: function() {\n\t\treturn +( new Date() );\n\t},\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 ] = deletedIds[ 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 ( jQuery.inArray( elem, qualifier ) > -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\tret = [],\n\t\t\tself = this,\n\t\t\tlen = self.length;\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// 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.charAt( 0 ) === \"<\" &&\n\t\t\t\tselector.charAt( 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// 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// Check parentNode to catch when Blackberry 4.6 returns\n\t\t\t\t\t// nodes that are no longer in the document #6963\n\t\t\t\t\tif ( elem && elem.parentNode ) {\n\n\t\t\t\t\t\t// Handle the case where IE and Opera return items\n\t\t\t\t\t\t// by name instead of ID\n\t\t\t\t\t\tif ( elem.id !== match[ 2 ] ) {\n\t\t\t\t\t\t\treturn rootjQuery.find( selector );\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Otherwise, we 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 typeof 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 i,\n\t\t\ttargets = jQuery( target, this ),\n\t\t\tlen = targets.length;\n\n\t\treturn this.filter( function() {\n\t\t\tfor ( i = 0; i < len; 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\n\t// the matched set of elements\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 jQuery.inArray( this[ 0 ], jQuery( elem ) );\n\t\t}\n\n\t\t// Locate the position of the desired element\n\t\treturn jQuery.inArray(\n\n\t\t\t// If it receives a jQuery object, the first element is used\n\t\t\telem.jquery ? elem[ 0 ] : elem, this );\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\tdo {\n\t\tcur = cur[ dir ];\n\t} while ( cur && cur.nodeType !== 1 );\n\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 jQuery.nodeName( elem, \"iframe\" ) ?\n\t\t\telem.contentDocument || elem.contentWindow.document :\n\t\t\tjQuery.merge( [], elem.childNodes );\n\t}\n}, function( name, fn ) {\n\tjQuery.fn[ name ] = function( until, selector ) {\n\t\tvar ret = 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\tret = jQuery.filter( selector, ret );\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\tret = jQuery.uniqueSort( ret );\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\tret = ret.reverse();\n\t\t\t}\n\t\t}\n\n\t\treturn this.pushStack( ret );\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 = true;\n\t\t\t\tif ( !memory ) {\n\t\t\t\t\tself.disable();\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\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 * Clean-up method for dom ready events\n */\nfunction detach() {\n\tif ( document.addEventListener ) {\n\t\tdocument.removeEventListener( \"DOMContentLoaded\", completed );\n\t\twindow.removeEventListener( \"load\", completed );\n\n\t} else {\n\t\tdocument.detachEvent( \"onreadystatechange\", completed );\n\t\twindow.detachEvent( \"onload\", completed );\n\t}\n}\n\n/**\n * The ready event handler and self cleanup method\n */\nfunction completed() {\n\n\t// readyState === \"complete\" is good enough for us to call the dom ready in oldIE\n\tif ( document.addEventListener ||\n\t\twindow.event.type === \"load\" ||\n\t\tdocument.readyState === \"complete\" ) {\n\n\t\tdetach();\n\t\tjQuery.ready();\n\t}\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: IE6-10\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// Standards-based browsers support DOMContentLoaded\n\t\t} else if ( document.addEventListener ) {\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\n\t\t// If IE event model is used\n\t\t} else {\n\n\t\t\t// Ensure firing before onload, maybe late but safe also for iframes\n\t\t\tdocument.attachEvent( \"onreadystatechange\", completed );\n\n\t\t\t// A fallback to window.onload, that will always work\n\t\t\twindow.attachEvent( \"onload\", completed );\n\n\t\t\t// If IE and not a frame\n\t\t\t// continually check to see if the document is ready\n\t\t\tvar top = false;\n\n\t\t\ttry {\n\t\t\t\ttop = window.frameElement == null && document.documentElement;\n\t\t\t} catch ( e ) {}\n\n\t\t\tif ( top && top.doScroll ) {\n\t\t\t\t( function doScrollCheck() {\n\t\t\t\t\tif ( !jQuery.isReady ) {\n\n\t\t\t\t\t\ttry {\n\n\t\t\t\t\t\t\t// Use the trick by Diego Perini\n\t\t\t\t\t\t\t// http://javascript.nwbox.com/IEContentLoaded/\n\t\t\t\t\t\t\ttop.doScroll( \"left\" );\n\t\t\t\t\t\t} catch ( e ) {\n\t\t\t\t\t\t\treturn window.setTimeout( doScrollCheck, 50 );\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// detach all dom ready events\n\t\t\t\t\t\tdetach();\n\n\t\t\t\t\t\t// and execute any waiting functions\n\t\t\t\t\t\tjQuery.ready();\n\t\t\t\t\t}\n\t\t\t\t} )();\n\t\t\t}\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// Support: IE<9\n// Iteration over object's inherited properties before its own\nvar i;\nfor ( i in jQuery( support ) ) {\n\tbreak;\n}\nsupport.ownFirst = i === \"0\";\n\n// Note: most support tests are defined in their respective modules.\n// false until the test is run\nsupport.inlineBlockNeedsLayout = false;\n\n// Execute ASAP in case we need to set body.style.zoom\njQuery( function() {\n\n\t// Minified: var a,b,c,d\n\tvar val, div, body, container;\n\n\tbody = document.getElementsByTagName( \"body\" )[ 0 ];\n\tif ( !body || !body.style ) {\n\n\t\t// Return for frameset docs that don't have a body\n\t\treturn;\n\t}\n\n\t// Setup\n\tdiv = document.createElement( \"div\" );\n\tcontainer = document.createElement( \"div\" );\n\tcontainer.style.cssText = \"position:absolute;border:0;width:0;height:0;top:0;left:-9999px\";\n\tbody.appendChild( container ).appendChild( div );\n\n\tif ( typeof div.style.zoom !== \"undefined\" ) {\n\n\t\t// Support: IE<8\n\t\t// Check if natively block-level elements act like inline-block\n\t\t// elements when setting their display to 'inline' and giving\n\t\t// them layout\n\t\tdiv.style.cssText = \"display:inline;margin:0;border:0;padding:1px;width:1px;zoom:1\";\n\n\t\tsupport.inlineBlockNeedsLayout = val = div.offsetWidth === 3;\n\t\tif ( val ) {\n\n\t\t\t// Prevent IE 6 from affecting layout for positioned elements #11048\n\t\t\t// Prevent IE from shrinking the body in IE 7 mode #12869\n\t\t\t// Support: IE<8\n\t\t\tbody.style.zoom = 1;\n\t\t}\n\t}\n\n\tbody.removeChild( container );\n} );\n\n\n( function() {\n\tvar div = document.createElement( \"div\" );\n\n\t// Support: IE<9\n\tsupport.deleteExpando = true;\n\ttry {\n\t\tdelete div.test;\n\t} catch ( e ) {\n\t\tsupport.deleteExpando = false;\n\t}\n\n\t// Null elements to avoid leaks in IE.\n\tdiv = null;\n} )();\nvar acceptData = function( elem ) {\n\tvar noData = jQuery.noData[ ( elem.nodeName + \" \" ).toLowerCase() ],\n\t\tnodeType = +elem.nodeType || 1;\n\n\t// Do not set data on non-element DOM nodes because it will not be cleared (#8335).\n\treturn nodeType !== 1 && nodeType !== 9 ?\n\t\tfalse :\n\n\t\t// Nodes accept data unless otherwise specified; rejection can be conditional\n\t\t!noData || noData !== true && elem.getAttribute( \"classid\" ) === noData;\n};\n\n\n\n\nvar rbrace = /^(?:\\{[\\w\\W]*\\}|\\[[\\w\\W]*\\])$/,\n\trmultiDash = /([A-Z])/g;\n\nfunction dataAttr( elem, key, data ) {\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\n\t\tvar name = \"data-\" + key.replace( rmultiDash, \"-$1\" ).toLowerCase();\n\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\tjQuery.data( elem, key, data );\n\n\t\t} else {\n\t\t\tdata = undefined;\n\t\t}\n\t}\n\n\treturn data;\n}\n\n// checks a cache object for emptiness\nfunction isEmptyDataObject( obj ) {\n\tvar name;\n\tfor ( name in obj ) {\n\n\t\t// if the public data object is empty, the private is still empty\n\t\tif ( name === \"data\" && jQuery.isEmptyObject( obj[ name ] ) ) {\n\t\t\tcontinue;\n\t\t}\n\t\tif ( name !== \"toJSON\" ) {\n\t\t\treturn false;\n\t\t}\n\t}\n\n\treturn true;\n}\n\nfunction internalData( elem, name, data, pvt /* Internal Use Only */ ) {\n\tif ( !acceptData( elem ) ) {\n\t\treturn;\n\t}\n\n\tvar ret, thisCache,\n\t\tinternalKey = jQuery.expando,\n\n\t\t// We have to handle DOM nodes and JS objects differently because IE6-7\n\t\t// can't GC object references properly across the DOM-JS boundary\n\t\tisNode = elem.nodeType,\n\n\t\t// Only DOM nodes need the global jQuery cache; JS object data is\n\t\t// attached directly to the object so GC can occur automatically\n\t\tcache = isNode ? jQuery.cache : elem,\n\n\t\t// Only defining an ID for JS objects if its cache already exists allows\n\t\t// the code to shortcut on the same path as a DOM node with no cache\n\t\tid = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey;\n\n\t// Avoid doing any more work than we need to when trying to get data on an\n\t// object that has no data at all\n\tif ( ( !id || !cache[ id ] || ( !pvt && !cache[ id ].data ) ) &&\n\t\tdata === undefined && typeof name === \"string\" ) {\n\t\treturn;\n\t}\n\n\tif ( !id ) {\n\n\t\t// Only DOM nodes need a new unique ID for each element since their data\n\t\t// ends up in the global cache\n\t\tif ( isNode ) {\n\t\t\tid = elem[ internalKey ] = deletedIds.pop() || jQuery.guid++;\n\t\t} else {\n\t\t\tid = internalKey;\n\t\t}\n\t}\n\n\tif ( !cache[ id ] ) {\n\n\t\t// Avoid exposing jQuery metadata on plain JS objects when the object\n\t\t// is serialized using JSON.stringify\n\t\tcache[ id ] = isNode ? {} : { toJSON: jQuery.noop };\n\t}\n\n\t// An object can be passed to jQuery.data instead of a key/value pair; this gets\n\t// shallow copied over onto the existing cache\n\tif ( typeof name === \"object\" || typeof name === \"function\" ) {\n\t\tif ( pvt ) {\n\t\t\tcache[ id ] = jQuery.extend( cache[ id ], name );\n\t\t} else {\n\t\t\tcache[ id ].data = jQuery.extend( cache[ id ].data, name );\n\t\t}\n\t}\n\n\tthisCache = cache[ id ];\n\n\t// jQuery data() is stored in a separate object inside the object's internal data\n\t// cache in order to avoid key collisions between internal data and user-defined\n\t// data.\n\tif ( !pvt ) {\n\t\tif ( !thisCache.data ) {\n\t\t\tthisCache.data = {};\n\t\t}\n\n\t\tthisCache = thisCache.data;\n\t}\n\n\tif ( data !== undefined ) {\n\t\tthisCache[ jQuery.camelCase( name ) ] = data;\n\t}\n\n\t// Check for both converted-to-camel and non-converted data property names\n\t// If a data property was specified\n\tif ( typeof name === \"string\" ) {\n\n\t\t// First Try to find as-is property data\n\t\tret = thisCache[ name ];\n\n\t\t// Test for null|undefined property data\n\t\tif ( ret == null ) {\n\n\t\t\t// Try to find the camelCased property\n\t\t\tret = thisCache[ jQuery.camelCase( name ) ];\n\t\t}\n\t} else {\n\t\tret = thisCache;\n\t}\n\n\treturn ret;\n}\n\nfunction internalRemoveData( elem, name, pvt ) {\n\tif ( !acceptData( elem ) ) {\n\t\treturn;\n\t}\n\n\tvar thisCache, i,\n\t\tisNode = elem.nodeType,\n\n\t\t// See jQuery.data for more information\n\t\tcache = isNode ? jQuery.cache : elem,\n\t\tid = isNode ? elem[ jQuery.expando ] : jQuery.expando;\n\n\t// If there is already no cache entry for this object, there is no\n\t// purpose in continuing\n\tif ( !cache[ id ] ) {\n\t\treturn;\n\t}\n\n\tif ( name ) {\n\n\t\tthisCache = pvt ? cache[ id ] : cache[ id ].data;\n\n\t\tif ( thisCache ) {\n\n\t\t\t// Support array or space separated string names for data keys\n\t\t\tif ( !jQuery.isArray( name ) ) {\n\n\t\t\t\t// try the string as a key before any manipulation\n\t\t\t\tif ( name in thisCache ) {\n\t\t\t\t\tname = [ name ];\n\t\t\t\t} else {\n\n\t\t\t\t\t// split the camel cased version by spaces unless a key with the spaces exists\n\t\t\t\t\tname = jQuery.camelCase( name );\n\t\t\t\t\tif ( name in thisCache ) {\n\t\t\t\t\t\tname = [ name ];\n\t\t\t\t\t} else {\n\t\t\t\t\t\tname = name.split( \" \" );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else {\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 = name.concat( jQuery.map( name, jQuery.camelCase ) );\n\t\t\t}\n\n\t\t\ti = name.length;\n\t\t\twhile ( i-- ) {\n\t\t\t\tdelete thisCache[ name[ i ] ];\n\t\t\t}\n\n\t\t\t// If there is no data left in the cache, we want to continue\n\t\t\t// and let the cache object itself get destroyed\n\t\t\tif ( pvt ? !isEmptyDataObject( thisCache ) : !jQuery.isEmptyObject( thisCache ) ) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t}\n\t}\n\n\t// See jQuery.data for more information\n\tif ( !pvt ) {\n\t\tdelete cache[ id ].data;\n\n\t\t// Don't destroy the parent cache unless the internal data object\n\t\t// had been the only thing left in it\n\t\tif ( !isEmptyDataObject( cache[ id ] ) ) {\n\t\t\treturn;\n\t\t}\n\t}\n\n\t// Destroy the cache\n\tif ( isNode ) {\n\t\tjQuery.cleanData( [ elem ], true );\n\n\t// Use delete when supported for expandos or `cache` is not a window per isWindow (#10080)\n\t/* jshint eqeqeq: false */\n\t} else if ( support.deleteExpando || cache != cache.window ) {\n\t\t/* jshint eqeqeq: true */\n\t\tdelete cache[ id ];\n\n\t// When all else fails, undefined\n\t} else {\n\t\tcache[ id ] = undefined;\n\t}\n}\n\njQuery.extend( {\n\tcache: {},\n\n\t// The following elements (space-suffixed to avoid Object.prototype collisions)\n\t// throw uncatchable exceptions if you attempt to set expando properties\n\tnoData: {\n\t\t\"applet \": true,\n\t\t\"embed \": true,\n\n\t\t// ...but Flash objects (which have this classid) *can* handle expandos\n\t\t\"object \": \"clsid:D27CDB6E-AE6D-11cf-96B8-444553540000\"\n\t},\n\n\thasData: function( elem ) {\n\t\telem = elem.nodeType ? jQuery.cache[ elem[ jQuery.expando ] ] : elem[ jQuery.expando ];\n\t\treturn !!elem && !isEmptyDataObject( elem );\n\t},\n\n\tdata: function( elem, name, data ) {\n\t\treturn internalData( elem, name, data );\n\t},\n\n\tremoveData: function( elem, name ) {\n\t\treturn internalRemoveData( elem, name );\n\t},\n\n\t// For internal use only.\n\t_data: function( elem, name, data ) {\n\t\treturn internalData( elem, name, data, true );\n\t},\n\n\t_removeData: function( elem, name ) {\n\t\treturn internalRemoveData( elem, name, true );\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// Special expections of .data basically thwart jQuery.access,\n\t\t// so implement the relevant behavior ourselves\n\n\t\t// Gets all values\n\t\tif ( key === undefined ) {\n\t\t\tif ( this.length ) {\n\t\t\t\tdata = jQuery.data( elem );\n\n\t\t\t\tif ( elem.nodeType === 1 && !jQuery._data( elem, \"parsedAttrs\" ) ) {\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\tjQuery._data( elem, \"parsedAttrs\", 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\tjQuery.data( this, key );\n\t\t\t} );\n\t\t}\n\n\t\treturn arguments.length > 1 ?\n\n\t\t\t// Sets one value\n\t\t\tthis.each( function() {\n\t\t\t\tjQuery.data( this, key, value );\n\t\t\t} ) :\n\n\t\t\t// Gets one value\n\t\t\t// Try to fetch any internally stored data first\n\t\t\telem ? dataAttr( elem, key, jQuery.data( elem, key ) ) : undefined;\n\t},\n\n\tremoveData: function( key ) {\n\t\treturn this.each( function() {\n\t\t\tjQuery.removeData( 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 = jQuery._data( 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 = jQuery._data( 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 intended for public consumption - generates a queueHooks object,\n\t// or returns the current one\n\t_queueHooks: function( elem, type ) {\n\t\tvar key = type + \"queueHooks\";\n\t\treturn jQuery._data( elem, key ) || jQuery._data( elem, key, {\n\t\t\tempty: jQuery.Callbacks( \"once memory\" ).add( function() {\n\t\t\t\tjQuery._removeData( elem, type + \"queue\" );\n\t\t\t\tjQuery._removeData( elem, 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 = jQuery._data( 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} );\n\n\n( function() {\n\tvar shrinkWrapBlocksVal;\n\n\tsupport.shrinkWrapBlocks = function() {\n\t\tif ( shrinkWrapBlocksVal != null ) {\n\t\t\treturn shrinkWrapBlocksVal;\n\t\t}\n\n\t\t// Will be changed later if needed.\n\t\tshrinkWrapBlocksVal = false;\n\n\t\t// Minified: var b,c,d\n\t\tvar div, body, container;\n\n\t\tbody = document.getElementsByTagName( \"body\" )[ 0 ];\n\t\tif ( !body || !body.style ) {\n\n\t\t\t// Test fired too early or in an unsupported environment, exit.\n\t\t\treturn;\n\t\t}\n\n\t\t// Setup\n\t\tdiv = document.createElement( \"div\" );\n\t\tcontainer = document.createElement( \"div\" );\n\t\tcontainer.style.cssText = \"position:absolute;border:0;width:0;height:0;top:0;left:-9999px\";\n\t\tbody.appendChild( container ).appendChild( div );\n\n\t\t// Support: IE6\n\t\t// Check if elements with layout shrink-wrap their children\n\t\tif ( typeof div.style.zoom !== \"undefined\" ) {\n\n\t\t\t// Reset CSS: box-sizing; display; margin; border\n\t\t\tdiv.style.cssText =\n\n\t\t\t\t// Support: Firefox<29, Android 2.3\n\t\t\t\t// Vendor-prefix box-sizing\n\t\t\t\t\"-webkit-box-sizing:content-box;-moz-box-sizing:content-box;\" +\n\t\t\t\t\"box-sizing:content-box;display:block;margin:0;border:0;\" +\n\t\t\t\t\"padding:1px;width:1px;zoom:1\";\n\t\t\tdiv.appendChild( document.createElement( \"div\" ) ).style.width = \"5px\";\n\t\t\tshrinkWrapBlocksVal = div.offsetWidth !== 3;\n\t\t}\n\n\t\tbody.removeChild( container );\n\n\t\treturn shrinkWrapBlocksVal;\n\t};\n\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}\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\tlength = 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 < length; i++ ) {\n\t\t\t\tfn(\n\t\t\t\t\telems[ i ],\n\t\t\t\t\tkey,\n\t\t\t\t\traw ? value : value.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\tlength ? fn( elems[ 0 ], key ) : emptyGet;\n};\nvar rcheckableType = ( /^(?:checkbox|radio)$/i );\n\nvar rtagName = ( /<([\\w:-]+)/ );\n\nvar rscriptType = ( /^$|\\/(?:java|ecma)script/i );\n\nvar rleadingWhitespace = ( /^\\s+/ );\n\nvar nodeNames = \"abbr|article|aside|audio|bdi|canvas|data|datalist|\" +\n\t\t\"details|dialog|figcaption|figure|footer|header|hgroup|main|\" +\n\t\t\"mark|meter|nav|output|picture|progress|section|summary|template|time|video\";\n\n\n\nfunction createSafeFragment( document ) {\n\tvar list = nodeNames.split( \"|\" ),\n\t\tsafeFrag = document.createDocumentFragment();\n\n\tif ( safeFrag.createElement ) {\n\t\twhile ( list.length ) {\n\t\t\tsafeFrag.createElement(\n\t\t\t\tlist.pop()\n\t\t\t);\n\t\t}\n\t}\n\treturn safeFrag;\n}\n\n\n( function() {\n\tvar div = document.createElement( \"div\" ),\n\t\tfragment = document.createDocumentFragment(),\n\t\tinput = document.createElement( \"input\" );\n\n\t// Setup\n\tdiv.innerHTML = \"  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>\";\n\n\t// IE strips leading whitespace when .innerHTML is used\n\tsupport.leadingWhitespace = div.firstChild.nodeType === 3;\n\n\t// Make sure that tbody elements aren't automatically inserted\n\t// IE will insert them into empty tables\n\tsupport.tbody = !div.getElementsByTagName( \"tbody\" ).length;\n\n\t// Make sure that link elements get serialized correctly by innerHTML\n\t// This requires a wrapper element in IE\n\tsupport.htmlSerialize = !!div.getElementsByTagName( \"link\" ).length;\n\n\t// Makes sure cloning an html5 element does not cause problems\n\t// Where outerHTML is undefined, this still works\n\tsupport.html5Clone =\n\t\tdocument.createElement( \"nav\" ).cloneNode( true ).outerHTML !== \"<:nav></:nav>\";\n\n\t// Check if a disconnected checkbox will retain its checked\n\t// value of true after appended to the DOM (IE6/7)\n\tinput.type = \"checkbox\";\n\tinput.checked = true;\n\tfragment.appendChild( input );\n\tsupport.appendChecked = input.checked;\n\n\t// Make sure textarea (and checkbox) defaultValue is properly cloned\n\t// Support: IE6-IE11+\n\tdiv.innerHTML = \"<textarea>x</textarea>\";\n\tsupport.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;\n\n\t// #11217 - WebKit loses check when the name is after the checked attribute\n\tfragment.appendChild( div );\n\n\t// Support: Windows Web Apps (WWA)\n\t// `name` and `type` must use .setAttribute for WWA (#14901)\n\tinput = document.createElement( \"input\" );\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, iOS 5.1, Android 4.x, Android 2.3\n\t// old WebKit doesn't clone checked state correctly in fragments\n\tsupport.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;\n\n\t// Support: IE<9\n\t// Cloned elements keep attachEvent handlers, we use addEventListener on IE9+\n\tsupport.noCloneEvent = !!div.addEventListener;\n\n\t// Support: IE<9\n\t// Since attributes and properties are the same in IE,\n\t// cleanData must set properties to undefined rather than use removeAttribute\n\tdiv[ jQuery.expando ] = 1;\n\tsupport.attributes = !div.getAttribute( jQuery.expando );\n} )();\n\n\n// We have to close these tags to support XHTML (#13200)\nvar wrapMap = {\n\toption: [ 1, \"<select multiple='multiple'>\", \"</select>\" ],\n\tlegend: [ 1, \"<fieldset>\", \"</fieldset>\" ],\n\tarea: [ 1, \"<map>\", \"</map>\" ],\n\n\t// Support: IE8\n\tparam: [ 1, \"<object>\", \"</object>\" ],\n\tthead: [ 1, \"<table>\", \"</table>\" ],\n\ttr: [ 2, \"<table><tbody>\", \"</tbody></table>\" ],\n\tcol: [ 2, \"<table><tbody></tbody><colgroup>\", \"</colgroup></table>\" ],\n\ttd: [ 3, \"<table><tbody><tr>\", \"</tr></tbody></table>\" ],\n\n\t// IE6-8 can't serialize link, script, style, or any html5 (NoScope) tags,\n\t// unless wrapped in a div with non-breaking characters in front of it.\n\t_default: support.htmlSerialize ? [ 0, \"\", \"\" ] : [ 1, \"X<div>\", \"</div>\" ]\n};\n\n// Support: IE8-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\tvar elems, elem,\n\t\ti = 0,\n\t\tfound = 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\tundefined;\n\n\tif ( !found ) {\n\t\tfor ( found = [], elems = context.childNodes || context;\n\t\t\t( elem = elems[ i ] ) != null;\n\t\t\ti++\n\t\t) {\n\t\t\tif ( !tag || jQuery.nodeName( elem, tag ) ) {\n\t\t\t\tfound.push( elem );\n\t\t\t} else {\n\t\t\t\tjQuery.merge( found, getAll( elem, tag ) );\n\t\t\t}\n\t\t}\n\t}\n\n\treturn tag === undefined || tag && jQuery.nodeName( context, tag ) ?\n\t\tjQuery.merge( [ context ], found ) :\n\t\tfound;\n}\n\n\n// Mark scripts as having already been evaluated\nfunction setGlobalEval( elems, refElements ) {\n\tvar elem,\n\t\ti = 0;\n\tfor ( ; ( elem = elems[ i ] ) != null; i++ ) {\n\t\tjQuery._data(\n\t\t\telem,\n\t\t\t\"globalEval\",\n\t\t\t!refElements || jQuery._data( refElements[ i ], \"globalEval\" )\n\t\t);\n\t}\n}\n\n\nvar rhtml = /<|&#?\\w+;/,\n\trtbody = /<tbody/i;\n\nfunction fixDefaultChecked( elem ) {\n\tif ( rcheckableType.test( elem.type ) ) {\n\t\telem.defaultChecked = elem.checked;\n\t}\n}\n\nfunction buildFragment( elems, context, scripts, selection, ignored ) {\n\tvar j, elem, contains,\n\t\ttmp, tag, tbody, wrap,\n\t\tl = elems.length,\n\n\t\t// Ensure a safe fragment\n\t\tsafe = createSafeFragment( context ),\n\n\t\tnodes = [],\n\t\ti = 0;\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\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 || safe.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\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// Manually add leading whitespace removed by IE\n\t\t\t\tif ( !support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {\n\t\t\t\t\tnodes.push( context.createTextNode( rleadingWhitespace.exec( elem )[ 0 ] ) );\n\t\t\t\t}\n\n\t\t\t\t// Remove IE's autoinserted <tbody> from table fragments\n\t\t\t\tif ( !support.tbody ) {\n\n\t\t\t\t\t// String was a <table>, *may* have spurious <tbody>\n\t\t\t\t\telem = tag === \"table\" && !rtbody.test( elem ) ?\n\t\t\t\t\t\ttmp.firstChild :\n\n\t\t\t\t\t\t// String was a bare <thead> or <tfoot>\n\t\t\t\t\t\twrap[ 1 ] === \"<table>\" && !rtbody.test( elem ) ?\n\t\t\t\t\t\t\ttmp :\n\t\t\t\t\t\t\t0;\n\n\t\t\t\t\tj = elem && elem.childNodes.length;\n\t\t\t\t\twhile ( j-- ) {\n\t\t\t\t\t\tif ( jQuery.nodeName( ( tbody = elem.childNodes[ j ] ), \"tbody\" ) &&\n\t\t\t\t\t\t\t!tbody.childNodes.length ) {\n\n\t\t\t\t\t\t\telem.removeChild( tbody );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tjQuery.merge( nodes, tmp.childNodes );\n\n\t\t\t\t// Fix #12392 for WebKit and IE > 9\n\t\t\t\ttmp.textContent = \"\";\n\n\t\t\t\t// Fix #12392 for oldIE\n\t\t\t\twhile ( tmp.firstChild ) {\n\t\t\t\t\ttmp.removeChild( tmp.firstChild );\n\t\t\t\t}\n\n\t\t\t\t// Remember the top-level container for proper cleanup\n\t\t\t\ttmp = safe.lastChild;\n\t\t\t}\n\t\t}\n\t}\n\n\t// Fix #11356: Clear elements from fragment\n\tif ( tmp ) {\n\t\tsafe.removeChild( tmp );\n\t}\n\n\t// Reset defaultChecked for any radios and checkboxes\n\t// about to be appended to the DOM in IE 6/7 (#8060)\n\tif ( !support.appendChecked ) {\n\t\tjQuery.grep( getAll( nodes, \"input\" ), fixDefaultChecked );\n\t}\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\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( safe.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\ttmp = null;\n\n\treturn safe;\n}\n\n\n( function() {\n\tvar i, eventName,\n\t\tdiv = document.createElement( \"div\" );\n\n\t// Support: IE<9 (lack submit/change bubble), Firefox (lack focus(in | out) events)\n\tfor ( i in { submit: true, change: true, focusin: true } ) {\n\t\teventName = \"on\" + i;\n\n\t\tif ( !( support[ i ] = eventName in window ) ) {\n\n\t\t\t// Beware of CSP restrictions (https://developer.mozilla.org/en/Security/CSP)\n\t\t\tdiv.setAttribute( eventName, \"t\" );\n\t\t\tsupport[ i ] = div.attributes[ eventName ].expando === false;\n\t\t}\n\t}\n\n\t// Null elements to avoid leaks in IE.\n\tdiv = null;\n} )();\n\n\nvar rformElems = /^(?:input|select|textarea)$/i,\n\trkeyEvent = /^key/,\n\trmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/,\n\trfocusMorph = /^(?:focusinfocus|focusoutblur)$/,\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\t\tvar tmp, events, t, handleObjIn,\n\t\t\tspecial, eventHandle, handleObj,\n\t\t\thandlers, type, namespaces, origType,\n\t\t\telemData = jQuery._data( 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\" &&\n\t\t\t\t\t( !e || jQuery.event.triggered !== e.type ) ?\n\t\t\t\t\tjQuery.event.dispatch.apply( eventHandle.elem, arguments ) :\n\t\t\t\t\tundefined;\n\t\t\t};\n\n\t\t\t// Add elem as a property of the handle fn to prevent a memory leak\n\t\t\t// with IE non-native events\n\t\t\teventHandle.elem = elem;\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/attachEvent 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\t// Bind the global event handler to the element\n\t\t\t\t\tif ( elem.addEventListener ) {\n\t\t\t\t\t\telem.addEventListener( type, eventHandle, false );\n\n\t\t\t\t\t} else if ( elem.attachEvent ) {\n\t\t\t\t\t\telem.attachEvent( \"on\" + 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\t// Nullify elem to prevent memory leaks in IE\n\t\telem = null;\n\t},\n\n\t// Detach an event or set of events from an element\n\tremove: function( elem, types, handler, selector, mappedTypes ) {\n\t\tvar j, handleObj, tmp,\n\t\t\torigCount, t, events,\n\t\t\tspecial, handlers, type,\n\t\t\tnamespaces, origType,\n\t\t\telemData = jQuery.hasData( elem ) && jQuery._data( 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 the expando if it's no longer used\n\t\tif ( jQuery.isEmptyObject( events ) ) {\n\t\t\tdelete elemData.handle;\n\n\t\t\t// removeData also checks for emptiness and clears the expando if empty\n\t\t\t// so use it instead of delete\n\t\t\tjQuery._removeData( elem, \"events\" );\n\t\t}\n\t},\n\n\ttrigger: function( event, data, elem, onlyHandlers ) {\n\t\tvar handle, ontype, cur,\n\t\t\tbubbleType, special, tmp, i,\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 = ( jQuery._data( cur, \"events\" ) || {} )[ event.type ] &&\n\t\t\t\tjQuery._data( cur, \"handle\" );\n\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 (\n\t\t\t\t( !special._default ||\n\t\t\t\t special._default.apply( eventPath.pop(), data ) === false\n\t\t\t\t) && acceptData( elem )\n\t\t\t) {\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// Can't use an .isFunction() check here because IE6/7 fails that test.\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 && 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\ttry {\n\t\t\t\t\t\telem[ type ]();\n\t\t\t\t\t} catch ( e ) {\n\n\t\t\t\t\t\t// IE<9 dies on focus/blur to hidden element (#1486,#12518)\n\t\t\t\t\t\t// only reproducible on winXP IE8 native, not IE9 in IE8 mode\n\t\t\t\t\t}\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\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 = ( jQuery._data( 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\t/* jshint eqeqeq: false */\n\t\t\tfor ( ; cur != this; cur = cur.parentNode || this ) {\n\t\t\t\t/* jshint eqeqeq: true */\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\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: IE<9\n\t\t// Fix target property (#1925)\n\t\tif ( !event.target ) {\n\t\t\tevent.target = originalEvent.srcElement || document;\n\t\t}\n\n\t\t// Support: Safari 6-8+\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\t// Support: IE<9\n\t\t// For mouse/key events, metaKey==false if it's undefined (#3368, #11328)\n\t\tevent.metaKey = !!event.metaKey;\n\n\t\treturn fixHook.filter ? fixHook.filter( event, originalEvent ) : event;\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 fromElement offsetX offsetY \" +\n\t\t\t\"pageX pageY screenX screenY toElement\" ).split( \" \" ),\n\t\tfilter: function( event, original ) {\n\t\t\tvar body, eventDoc, doc,\n\t\t\t\tbutton = original.button,\n\t\t\t\tfromElement = original.fromElement;\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 relatedTarget, if necessary\n\t\t\tif ( !event.relatedTarget && fromElement ) {\n\t\t\t\tevent.relatedTarget = fromElement === event.target ?\n\t\t\t\t\toriginal.toElement :\n\t\t\t\t\tfromElement;\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\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\ttry {\n\t\t\t\t\t\tthis.focus();\n\t\t\t\t\t\treturn false;\n\t\t\t\t\t} catch ( e ) {\n\n\t\t\t\t\t\t// Support: IE<9\n\t\t\t\t\t\t// If we error on focus to hidden element (#1486, #12518),\n\t\t\t\t\t\t// let .trigger() run the handlers\n\t\t\t\t\t}\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 ( jQuery.nodeName( this, \"input\" ) && this.type === \"checkbox\" && this.click ) {\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\t// Piggyback on a donor event to simulate a different one\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\n\t\t\t\t// Previously, `originalEvent: {}` was set here, so stopPropagation call\n\t\t\t\t// would not be triggered on donor event, since in our own\n\t\t\t\t// jQuery.event.stopPropagation function we had a check for existence of\n\t\t\t\t// originalEvent.stopPropagation method, so, consequently it would be a noop.\n\t\t\t\t//\n\t\t\t\t// Guard for simulated events was moved to jQuery.event.stopPropagation function\n\t\t\t\t// since `originalEvent` should point to the original event for the\n\t\t\t\t// constancy with other events and for more focused logic\n\t\t\t}\n\t\t);\n\n\t\tjQuery.event.trigger( e, null, elem );\n\n\t\tif ( e.isDefaultPrevented() ) {\n\t\t\tevent.preventDefault();\n\t\t}\n\t}\n};\n\njQuery.removeEvent = document.removeEventListener ?\n\tfunction( elem, type, handle ) {\n\n\t\t// This \"if\" is needed for plain objects\n\t\tif ( elem.removeEventListener ) {\n\t\t\telem.removeEventListener( type, handle );\n\t\t}\n\t} :\n\tfunction( elem, type, handle ) {\n\t\tvar name = \"on\" + type;\n\n\t\tif ( elem.detachEvent ) {\n\n\t\t\t// #8545, #7054, preventing memory leaks for custom events in IE6-8\n\t\t\t// detachEvent needed property on element, by name of that event,\n\t\t\t// to properly expose it to GC\n\t\t\tif ( typeof elem[ name ] === \"undefined\" ) {\n\t\t\t\telem[ name ] = null;\n\t\t\t}\n\n\t\t\telem.detachEvent( name, handle );\n\t\t}\n\t};\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: IE < 9, 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\n\tpreventDefault: function() {\n\t\tvar e = this.originalEvent;\n\n\t\tthis.isDefaultPrevented = returnTrue;\n\t\tif ( !e ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// If preventDefault exists, run it on the original event\n\t\tif ( e.preventDefault ) {\n\t\t\te.preventDefault();\n\n\t\t// Support: IE\n\t\t// Otherwise set the returnValue property of the original event to false\n\t\t} else {\n\t\t\te.returnValue = false;\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\treturn;\n\t\t}\n\n\t\t// If stopPropagation exists, run it on the original event\n\t\tif ( e.stopPropagation ) {\n\t\t\te.stopPropagation();\n\t\t}\n\n\t\t// Support: IE\n\t\t// Set the cancelBubble property of the original event to true\n\t\te.cancelBubble = true;\n\t},\n\tstopImmediatePropagation: function() {\n\t\tvar e = this.originalEvent;\n\n\t\tthis.isImmediatePropagationStopped = returnTrue;\n\n\t\tif ( e && e.stopImmediatePropagation ) {\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\n// IE submit delegation\nif ( !support.submit ) {\n\n\tjQuery.event.special.submit = {\n\t\tsetup: function() {\n\n\t\t\t// Only need this for delegated form submit events\n\t\t\tif ( jQuery.nodeName( this, \"form\" ) ) {\n\t\t\t\treturn false;\n\t\t\t}\n\n\t\t\t// Lazy-add a submit handler when a descendant form may potentially be submitted\n\t\t\tjQuery.event.add( this, \"click._submit keypress._submit\", function( e ) {\n\n\t\t\t\t// Node name check avoids a VML-related crash in IE (#9807)\n\t\t\t\tvar elem = e.target,\n\t\t\t\t\tform = jQuery.nodeName( elem, \"input\" ) || jQuery.nodeName( elem, \"button\" ) ?\n\n\t\t\t\t\t\t// Support: IE <=8\n\t\t\t\t\t\t// We use jQuery.prop instead of elem.form\n\t\t\t\t\t\t// to allow fixing the IE8 delegated submit issue (gh-2332)\n\t\t\t\t\t\t// by 3rd party polyfills/workarounds.\n\t\t\t\t\t\tjQuery.prop( elem, \"form\" ) :\n\t\t\t\t\t\tundefined;\n\n\t\t\t\tif ( form && !jQuery._data( form, \"submit\" ) ) {\n\t\t\t\t\tjQuery.event.add( form, \"submit._submit\", function( event ) {\n\t\t\t\t\t\tevent._submitBubble = true;\n\t\t\t\t\t} );\n\t\t\t\t\tjQuery._data( form, \"submit\", true );\n\t\t\t\t}\n\t\t\t} );\n\n\t\t\t// return undefined since we don't need an event listener\n\t\t},\n\n\t\tpostDispatch: function( event ) {\n\n\t\t\t// If form was submitted by the user, bubble the event up the tree\n\t\t\tif ( event._submitBubble ) {\n\t\t\t\tdelete event._submitBubble;\n\t\t\t\tif ( this.parentNode && !event.isTrigger ) {\n\t\t\t\t\tjQuery.event.simulate( \"submit\", this.parentNode, event );\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\n\t\tteardown: function() {\n\n\t\t\t// Only need this for delegated form submit events\n\t\t\tif ( jQuery.nodeName( this, \"form\" ) ) {\n\t\t\t\treturn false;\n\t\t\t}\n\n\t\t\t// Remove delegated handlers; cleanData eventually reaps submit handlers attached above\n\t\t\tjQuery.event.remove( this, \"._submit\" );\n\t\t}\n\t};\n}\n\n// IE change delegation and checkbox/radio fix\nif ( !support.change ) {\n\n\tjQuery.event.special.change = {\n\n\t\tsetup: function() {\n\n\t\t\tif ( rformElems.test( this.nodeName ) ) {\n\n\t\t\t\t// IE doesn't fire change on a check/radio until blur; trigger it on click\n\t\t\t\t// after a propertychange. Eat the blur-change in special.change.handle.\n\t\t\t\t// This still fires onchange a second time for check/radio after blur.\n\t\t\t\tif ( this.type === \"checkbox\" || this.type === \"radio\" ) {\n\t\t\t\t\tjQuery.event.add( this, \"propertychange._change\", function( event ) {\n\t\t\t\t\t\tif ( event.originalEvent.propertyName === \"checked\" ) {\n\t\t\t\t\t\t\tthis._justChanged = true;\n\t\t\t\t\t\t}\n\t\t\t\t\t} );\n\t\t\t\t\tjQuery.event.add( this, \"click._change\", function( event ) {\n\t\t\t\t\t\tif ( this._justChanged && !event.isTrigger ) {\n\t\t\t\t\t\t\tthis._justChanged = false;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Allow triggered, simulated change events (#11500)\n\t\t\t\t\t\tjQuery.event.simulate( \"change\", this, event );\n\t\t\t\t\t} );\n\t\t\t\t}\n\t\t\t\treturn false;\n\t\t\t}\n\n\t\t\t// Delegated event; lazy-add a change handler on descendant inputs\n\t\t\tjQuery.event.add( this, \"beforeactivate._change\", function( e ) {\n\t\t\t\tvar elem = e.target;\n\n\t\t\t\tif ( rformElems.test( elem.nodeName ) && !jQuery._data( elem, \"change\" ) ) {\n\t\t\t\t\tjQuery.event.add( elem, \"change._change\", function( event ) {\n\t\t\t\t\t\tif ( this.parentNode && !event.isSimulated && !event.isTrigger ) {\n\t\t\t\t\t\t\tjQuery.event.simulate( \"change\", this.parentNode, event );\n\t\t\t\t\t\t}\n\t\t\t\t\t} );\n\t\t\t\t\tjQuery._data( elem, \"change\", true );\n\t\t\t\t}\n\t\t\t} );\n\t\t},\n\n\t\thandle: function( event ) {\n\t\t\tvar elem = event.target;\n\n\t\t\t// Swallow native change events from checkbox/radio, we already triggered them above\n\t\t\tif ( this !== elem || event.isSimulated || event.isTrigger ||\n\t\t\t\t( elem.type !== \"radio\" && elem.type !== \"checkbox\" ) ) {\n\n\t\t\t\treturn event.handleObj.handler.apply( this, arguments );\n\t\t\t}\n\t\t},\n\n\t\tteardown: function() {\n\t\t\tjQuery.event.remove( this, \"._change\" );\n\n\t\t\treturn !rformElems.test( this.nodeName );\n\t\t}\n\t};\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 = jQuery._data( 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\tjQuery._data( 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 = jQuery._data( 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\tjQuery._removeData( doc, fix );\n\t\t\t\t} else {\n\t\t\t\t\tjQuery._data( doc, fix, attaches );\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\t} );\n}\n\njQuery.fn.extend( {\n\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\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\nvar rinlinejQuery = / jQuery\\d+=\"(?:null|\\d+)\"/g,\n\trnoshimcache = new RegExp( \"<(?:\" + nodeNames + \")[\\\\s/>]\", \"i\" ),\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\tsafeFragment = createSafeFragment( document ),\n\tfragmentDiv = safeFragment.appendChild( document.createElement( \"div\" ) );\n\n// Support: IE<8\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 = ( jQuery.find.attr( elem, \"type\" ) !== null ) + \"/\" + elem.type;\n\treturn elem;\n}\nfunction restoreScript( elem ) {\n\tvar match = rscriptTypeMasked.exec( elem.type );\n\tif ( match ) {\n\t\telem.type = match[ 1 ];\n\t} else {\n\t\telem.removeAttribute( \"type\" );\n\t}\n\treturn elem;\n}\n\nfunction cloneCopyEvent( src, dest ) {\n\tif ( dest.nodeType !== 1 || !jQuery.hasData( src ) ) {\n\t\treturn;\n\t}\n\n\tvar type, i, l,\n\t\toldData = jQuery._data( src ),\n\t\tcurData = jQuery._data( dest, oldData ),\n\t\tevents = oldData.events;\n\n\tif ( events ) {\n\t\tdelete curData.handle;\n\t\tcurData.events = {};\n\n\t\tfor ( type in events ) {\n\t\t\tfor ( i = 0, l = events[ type ].length; i < l; i++ ) {\n\t\t\t\tjQuery.event.add( dest, type, events[ type ][ i ] );\n\t\t\t}\n\t\t}\n\t}\n\n\t// make the cloned public data object a copy from the original\n\tif ( curData.data ) {\n\t\tcurData.data = jQuery.extend( {}, curData.data );\n\t}\n}\n\nfunction fixCloneNodeIssues( src, dest ) {\n\tvar nodeName, e, data;\n\n\t// We do not need to do anything for non-Elements\n\tif ( dest.nodeType !== 1 ) {\n\t\treturn;\n\t}\n\n\tnodeName = dest.nodeName.toLowerCase();\n\n\t// IE6-8 copies events bound via attachEvent when using cloneNode.\n\tif ( !support.noCloneEvent && dest[ jQuery.expando ] ) {\n\t\tdata = jQuery._data( dest );\n\n\t\tfor ( e in data.events ) {\n\t\t\tjQuery.removeEvent( dest, e, data.handle );\n\t\t}\n\n\t\t// Event data gets referenced instead of copied if the expando gets copied too\n\t\tdest.removeAttribute( jQuery.expando );\n\t}\n\n\t// IE blanks contents when cloning scripts, and tries to evaluate newly-set text\n\tif ( nodeName === \"script\" && dest.text !== src.text ) {\n\t\tdisableScript( dest ).text = src.text;\n\t\trestoreScript( dest );\n\n\t// IE6-10 improperly clones children of object elements using classid.\n\t// IE10 throws NoModificationAllowedError if parent is null, #12132.\n\t} else if ( nodeName === \"object\" ) {\n\t\tif ( dest.parentNode ) {\n\t\t\tdest.outerHTML = src.outerHTML;\n\t\t}\n\n\t\t// This path appears unavoidable for IE9. When cloning an object\n\t\t// element in IE9, the outerHTML strategy above is not sufficient.\n\t\t// If the src has innerHTML and the destination does not,\n\t\t// copy the src.innerHTML into the dest.innerHTML. #10324\n\t\tif ( support.html5Clone && ( src.innerHTML && !jQuery.trim( dest.innerHTML ) ) ) {\n\t\t\tdest.innerHTML = src.innerHTML;\n\t\t}\n\n\t} else if ( nodeName === \"input\" && rcheckableType.test( src.type ) ) {\n\n\t\t// IE6-8 fails to persist the checked state of a cloned checkbox\n\t\t// or radio button. Worse, IE6-7 fail to give the cloned element\n\t\t// a checked appearance if the defaultChecked value isn't also set\n\n\t\tdest.defaultChecked = dest.checked = src.checked;\n\n\t\t// IE6-7 get confused and end up setting the value of a cloned\n\t\t// checkbox/radio button to an empty string instead of \"on\"\n\t\tif ( dest.value !== src.value ) {\n\t\t\tdest.value = src.value;\n\t\t}\n\n\t// IE6-8 fails to return the selected option to the default selected\n\t// state when cloning options\n\t} else if ( nodeName === \"option\" ) {\n\t\tdest.defaultSelected = dest.selected = src.defaultSelected;\n\n\t// IE6-8 fails to set the defaultValue to the correct value when\n\t// cloning other types of input fields\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 first, node, hasScripts,\n\t\tscripts, doc, fragment,\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!jQuery._data( 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(\n\t\t\t\t\t\t\t\t( node.text || node.textContent || node.innerHTML || \"\" )\n\t\t\t\t\t\t\t\t\t.replace( rcleanScript, \"\" )\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\n\t\t\t// Fix #11809: Avoid leaking memory\n\t\t\tfragment = first = null;\n\t\t}\n\t}\n\n\treturn collection;\n}\n\nfunction remove( elem, selector, keepData ) {\n\tvar node,\n\t\telems = selector ? jQuery.filter( selector, elem ) : elem,\n\t\ti = 0;\n\n\tfor ( ; ( node = elems[ i ] ) != null; i++ ) {\n\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 destElements, node, clone, i, srcElements,\n\t\t\tinPage = jQuery.contains( elem.ownerDocument, elem );\n\n\t\tif ( support.html5Clone || jQuery.isXMLDoc( elem ) ||\n\t\t\t!rnoshimcache.test( \"<\" + elem.nodeName + \">\" ) ) {\n\n\t\t\tclone = elem.cloneNode( true );\n\n\t\t// IE<=8 does not properly clone detached, unknown element nodes\n\t\t} else {\n\t\t\tfragmentDiv.innerHTML = elem.outerHTML;\n\t\t\tfragmentDiv.removeChild( clone = fragmentDiv.firstChild );\n\t\t}\n\n\t\tif ( ( !support.noCloneEvent || !support.noCloneChecked ) &&\n\t\t\t\t( elem.nodeType === 1 || elem.nodeType === 11 ) && !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\t// Fix all IE cloning issues\n\t\t\tfor ( i = 0; ( node = srcElements[ i ] ) != null; ++i ) {\n\n\t\t\t\t// Ensure that the destination node is not null; Fixes #9587\n\t\t\t\tif ( destElements[ i ] ) {\n\t\t\t\t\tfixCloneNodeIssues( node, destElements[ i ] );\n\t\t\t\t}\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; ( node = srcElements[ i ] ) != null; i++ ) {\n\t\t\t\t\tcloneCopyEvent( node, 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\tdestElements = srcElements = node = null;\n\n\t\t// Return the cloned set\n\t\treturn clone;\n\t},\n\n\tcleanData: function( elems, /* internal */ forceAcceptData ) {\n\t\tvar elem, type, id, data,\n\t\t\ti = 0,\n\t\t\tinternalKey = jQuery.expando,\n\t\t\tcache = jQuery.cache,\n\t\t\tattributes = support.attributes,\n\t\t\tspecial = jQuery.event.special;\n\n\t\tfor ( ; ( elem = elems[ i ] ) != null; i++ ) {\n\t\t\tif ( forceAcceptData || acceptData( elem ) ) {\n\n\t\t\t\tid = elem[ internalKey ];\n\t\t\t\tdata = id && cache[ id ];\n\n\t\t\t\tif ( data ) {\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// Remove cache only if it was not already removed by jQuery.event.remove\n\t\t\t\t\tif ( cache[ id ] ) {\n\n\t\t\t\t\t\tdelete cache[ id ];\n\n\t\t\t\t\t\t// Support: IE<9\n\t\t\t\t\t\t// IE does not allow us to delete expando properties from nodes\n\t\t\t\t\t\t// IE creates expando attributes along with the property\n\t\t\t\t\t\t// IE does not have a removeAttribute function on Document nodes\n\t\t\t\t\t\tif ( !attributes && typeof elem.removeAttribute !== \"undefined\" ) {\n\t\t\t\t\t\t\telem.removeAttribute( internalKey );\n\n\t\t\t\t\t\t// Webkit & Blink performance suffers when deleting properties\n\t\t\t\t\t\t// from DOM nodes, so set to undefined instead\n\t\t\t\t\t\t// https://code.google.com/p/chromium/issues/detail?id=378607\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\telem[ internalKey ] = undefined;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tdeletedIds.push( id );\n\t\t\t\t\t}\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().append(\n\t\t\t\t\t( this[ 0 ] && this[ 0 ].ownerDocument || document ).createTextNode( value )\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\n\t\t\t// Remove element nodes and prevent memory leaks\n\t\t\tif ( elem.nodeType === 1 ) {\n\t\t\t\tjQuery.cleanData( getAll( elem, false ) );\n\t\t\t}\n\n\t\t\t// Remove any remaining nodes\n\t\t\twhile ( elem.firstChild ) {\n\t\t\t\telem.removeChild( elem.firstChild );\n\t\t\t}\n\n\t\t\t// If this is a select, ensure that it displays empty (#12336)\n\t\t\t// Support: IE<9\n\t\t\tif ( elem.options && jQuery.nodeName( elem, \"select\" ) ) {\n\t\t\t\telem.options.length = 0;\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 ) {\n\t\t\t\treturn elem.nodeType === 1 ?\n\t\t\t\t\telem.innerHTML.replace( rinlinejQuery, \"\" ) :\n\t\t\t\t\tundefined;\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( support.htmlSerialize || !rnoshimcache.test( value )  ) &&\n\t\t\t\t( support.leadingWhitespace || !rleadingWhitespace.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\n\t\t\t\t\t\t// Remove element nodes and prevent memory leaks\n\t\t\t\t\t\telem = this[ i ] || {};\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\ti = 0,\n\t\t\tret = [],\n\t\t\tinsert = jQuery( selector ),\n\t\t\tlast = insert.length - 1;\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// Modern browsers can apply jQuery collections as arrays, but oldIE needs a .get()\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 ].contentWindow || iframe[ 0 ].contentDocument ).document;\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 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, pixelMarginRightVal, boxSizingReliableVal,\n\t\treliableHiddenOffsetsVal, reliableMarginRightVal, 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\tdiv.style.cssText = \"float:left;opacity:.5\";\n\n\t// Support: IE<9\n\t// Make sure that element opacity exists (as opposed to filter)\n\tsupport.opacity = div.style.opacity === \"0.5\";\n\n\t// Verify style float existence\n\t// (IE uses styleFloat instead of cssFloat)\n\tsupport.cssFloat = !!div.style.cssFloat;\n\n\tdiv.style.backgroundClip = \"content-box\";\n\tdiv.cloneNode( true ).style.backgroundClip = \"\";\n\tsupport.clearCloneStyle = div.style.backgroundClip === \"content-box\";\n\n\tcontainer = document.createElement( \"div\" );\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\tdiv.innerHTML = \"\";\n\tcontainer.appendChild( div );\n\n\t// Support: Firefox<29, Android 2.3\n\t// Vendor-prefix box-sizing\n\tsupport.boxSizing = div.style.boxSizing === \"\" || div.style.MozBoxSizing === \"\" ||\n\t\tdiv.style.WebkitBoxSizing === \"\";\n\n\tjQuery.extend( support, {\n\t\treliableHiddenOffsets: function() {\n\t\t\tif ( pixelPositionVal == null ) {\n\t\t\t\tcomputeStyleTests();\n\t\t\t}\n\t\t\treturn reliableHiddenOffsetsVal;\n\t\t},\n\n\t\tboxSizingReliable: function() {\n\n\t\t\t// We're checking for pixelPositionVal here instead of boxSizingReliableVal\n\t\t\t// since that compresses better and they're computed together anyway.\n\t\t\tif ( pixelPositionVal == null ) {\n\t\t\t\tcomputeStyleTests();\n\t\t\t}\n\t\t\treturn boxSizingReliableVal;\n\t\t},\n\n\t\tpixelMarginRight: function() {\n\n\t\t\t// Support: Android 4.0-4.3\n\t\t\tif ( pixelPositionVal == null ) {\n\t\t\t\tcomputeStyleTests();\n\t\t\t}\n\t\t\treturn pixelMarginRightVal;\n\t\t},\n\n\t\tpixelPosition: function() {\n\t\t\tif ( pixelPositionVal == null ) {\n\t\t\t\tcomputeStyleTests();\n\t\t\t}\n\t\t\treturn pixelPositionVal;\n\t\t},\n\n\t\treliableMarginRight: function() {\n\n\t\t\t// Support: Android 2.3\n\t\t\tif ( pixelPositionVal == null ) {\n\t\t\t\tcomputeStyleTests();\n\t\t\t}\n\t\t\treturn reliableMarginRightVal;\n\t\t},\n\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 ( pixelPositionVal == null ) {\n\t\t\t\tcomputeStyleTests();\n\t\t\t}\n\t\t\treturn reliableMarginLeftVal;\n\t\t}\n\t} );\n\n\tfunction computeStyleTests() {\n\t\tvar contents, divStyle,\n\t\t\tdocumentElement = document.documentElement;\n\n\t\t// Setup\n\t\tdocumentElement.appendChild( container );\n\n\t\tdiv.style.cssText =\n\n\t\t\t// Support: Android 2.3\n\t\t\t// Vendor-prefix box-sizing\n\t\t\t\"-webkit-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\n\t\t// Support: IE<9\n\t\t// Assume reasonable values in the absence of getComputedStyle\n\t\tpixelPositionVal = boxSizingReliableVal = reliableMarginLeftVal = false;\n\t\tpixelMarginRightVal = reliableMarginRightVal = true;\n\n\t\t// Check for getComputedStyle so that this code is not run in IE<9.\n\t\tif ( window.getComputedStyle ) {\n\t\t\tdivStyle = window.getComputedStyle( div );\n\t\t\tpixelPositionVal = ( divStyle || {} ).top !== \"1%\";\n\t\t\treliableMarginLeftVal = ( divStyle || {} ).marginLeft === \"2px\";\n\t\t\tboxSizingReliableVal = ( divStyle || { width: \"4px\" } ).width === \"4px\";\n\n\t\t\t// Support: Android 4.0 - 4.3 only\n\t\t\t// Some styles come back with percentage values, even though they shouldn't\n\t\t\tdiv.style.marginRight = \"50%\";\n\t\t\tpixelMarginRightVal = ( divStyle || { marginRight: \"4px\" } ).marginRight === \"4px\";\n\n\t\t\t// Support: Android 2.3 only\n\t\t\t// 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\tcontents = div.appendChild( document.createElement( \"div\" ) );\n\n\t\t\t// Reset CSS: box-sizing; display; margin; border; padding\n\t\t\tcontents.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;-moz-box-sizing:content-box;\" +\n\t\t\t\t\"box-sizing:content-box;display:block;margin:0;border:0;padding:0\";\n\t\t\tcontents.style.marginRight = contents.style.width = \"0\";\n\t\t\tdiv.style.width = \"1px\";\n\n\t\t\treliableMarginRightVal =\n\t\t\t\t!parseFloat( ( window.getComputedStyle( contents ) || {} ).marginRight );\n\n\t\t\tdiv.removeChild( contents );\n\t\t}\n\n\t\t// Support: IE6-8\n\t\t// First check that getClientRects works as expected\n\t\t// Check if table cells still have offsetWidth/Height when they are set\n\t\t// to display:none and there are still other visible table cells in a\n\t\t// table row; if so, offsetWidth/Height are not reliable for use when\n\t\t// determining if an element has been hidden directly using\n\t\t// display:none (it is still safe to use offsets if a parent element is\n\t\t// hidden; don safety goggles and see bug #4512 for more information).\n\t\tdiv.style.display = \"none\";\n\t\treliableHiddenOffsetsVal = div.getClientRects().length === 0;\n\t\tif ( reliableHiddenOffsetsVal ) {\n\t\t\tdiv.style.display = \"\";\n\t\t\tdiv.innerHTML = \"<table><tr><td></td><td>t</td></tr></table>\";\n\t\t\tdiv.childNodes[ 0 ].style.borderCollapse = \"separate\";\n\t\t\tcontents = div.getElementsByTagName( \"td\" );\n\t\t\tcontents[ 0 ].style.cssText = \"margin:0;border:0;padding:0;display:none\";\n\t\t\treliableHiddenOffsetsVal = contents[ 0 ].offsetHeight === 0;\n\t\t\tif ( reliableHiddenOffsetsVal ) {\n\t\t\t\tcontents[ 0 ].style.display = \"\";\n\t\t\t\tcontents[ 1 ].style.display = \"none\";\n\t\t\t\treliableHiddenOffsetsVal = contents[ 0 ].offsetHeight === 0;\n\t\t\t}\n\t\t}\n\n\t\t// Teardown\n\t\tdocumentElement.removeChild( container );\n\t}\n\n} )();\n\n\nvar getStyles, curCSS,\n\trposition = /^(top|right|bottom|left)$/;\n\nif ( window.getComputedStyle ) {\n\tgetStyles = 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\n\tcurCSS = function( elem, name, computed ) {\n\t\tvar width, minWidth, maxWidth, ret,\n\t\t\tstyle = elem.style;\n\n\t\tcomputed = computed || getStyles( elem );\n\n\t\t// getPropertyValue is only needed for .css('filter') in IE9, see #12537\n\t\tret = computed ? computed.getPropertyValue( name ) || computed[ name ] : undefined;\n\n\t\t// Support: Opera 12.1x only\n\t\t// Fall back to style even without computed\n\t\t// computed is undefined for elems on document fragments\n\t\tif ( ( ret === \"\" || ret === undefined ) && !jQuery.contains( elem.ownerDocument, elem ) ) {\n\t\t\tret = jQuery.style( elem, name );\n\t\t}\n\n\t\tif ( computed ) {\n\n\t\t\t// A tribute to the \"awesome hack by Dean Edwards\"\n\t\t\t// Chrome < 17 and Safari 5.0 uses \"computed value\"\n\t\t\t// instead of \"used value\" for margin-right\n\t\t\t// Safari 5.1.7 (at least) returns percentage for a larger set of values,\n\t\t\t// but width seems to be reliably pixels\n\t\t\t// this is against the CSSOM draft spec:\n\t\t\t// http://dev.w3.org/csswg/cssom/#resolved-values\n\t\t\tif ( !support.pixelMarginRight() && rnumnonpx.test( ret ) && rmargin.test( name ) ) {\n\n\t\t\t\t// Remember the original values\n\t\t\t\twidth = style.width;\n\t\t\t\tminWidth = style.minWidth;\n\t\t\t\tmaxWidth = style.maxWidth;\n\n\t\t\t\t// Put in the new values to get a computed value out\n\t\t\t\tstyle.minWidth = style.maxWidth = style.width = ret;\n\t\t\t\tret = computed.width;\n\n\t\t\t\t// Revert the changed values\n\t\t\t\tstyle.width = width;\n\t\t\t\tstyle.minWidth = minWidth;\n\t\t\t\tstyle.maxWidth = maxWidth;\n\t\t\t}\n\t\t}\n\n\t\t// Support: IE\n\t\t// IE returns zIndex value as an integer.\n\t\treturn ret === undefined ?\n\t\t\tret :\n\t\t\tret + \"\";\n\t};\n} else if ( documentElement.currentStyle ) {\n\tgetStyles = function( elem ) {\n\t\treturn elem.currentStyle;\n\t};\n\n\tcurCSS = function( elem, name, computed ) {\n\t\tvar left, rs, rsLeft, ret,\n\t\t\tstyle = elem.style;\n\n\t\tcomputed = computed || getStyles( elem );\n\t\tret = computed ? computed[ name ] : undefined;\n\n\t\t// Avoid setting ret to empty string here\n\t\t// so we don't default to auto\n\t\tif ( ret == null && style && style[ name ] ) {\n\t\t\tret = style[ name ];\n\t\t}\n\n\t\t// From the awesome hack by Dean Edwards\n\t\t// http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291\n\n\t\t// If we're not dealing with a regular pixel number\n\t\t// but a number that has a weird ending, we need to convert it to pixels\n\t\t// but not position css attributes, as those are\n\t\t// proportional to the parent element instead\n\t\t// and we can't measure the parent instead because it\n\t\t// might trigger a \"stacking dolls\" problem\n\t\tif ( rnumnonpx.test( ret ) && !rposition.test( name ) ) {\n\n\t\t\t// Remember the original values\n\t\t\tleft = style.left;\n\t\t\trs = elem.runtimeStyle;\n\t\t\trsLeft = rs && rs.left;\n\n\t\t\t// Put in the new values to get a computed value out\n\t\t\tif ( rsLeft ) {\n\t\t\t\trs.left = elem.currentStyle.left;\n\t\t\t}\n\t\t\tstyle.left = name === \"fontSize\" ? \"1em\" : ret;\n\t\t\tret = style.pixelLeft + \"px\";\n\n\t\t\t// Revert the changed values\n\t\t\tstyle.left = left;\n\t\t\tif ( rsLeft ) {\n\t\t\t\trs.left = rsLeft;\n\t\t\t}\n\t\t}\n\n\t\t// Support: IE\n\t\t// IE returns zIndex value as an integer.\n\t\treturn ret === undefined ?\n\t\t\tret :\n\t\t\tret + \"\" || \"auto\";\n\t};\n}\n\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\tralpha = /alpha\\([^)]*\\)/i,\n\tropacity = /opacity\\s*=\\s*([^)]*)/i,\n\n\t// swappable if display is none or starts with table except\n\t// \"table\", \"table-cell\", or \"table-caption\"\n\t// see here for display values:\n\t// https://developer.mozilla.org/en-US/docs/CSS/display\n\trdisplayswap = /^(none|table(?!-c[ea]).+)/,\n\trnumsplit = new RegExp( \"^(\" + pnum + \")(.*)$\", \"i\" ),\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\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.charAt( 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 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 ] = jQuery._data( 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 ] =\n\t\t\t\t\tjQuery._data( elem, \"olddisplay\", defaultDisplay( elem.nodeName ) );\n\t\t\t}\n\t\t} else {\n\t\t\thidden = isHidden( elem );\n\n\t\t\tif ( display && display !== \"none\" || !hidden ) {\n\t\t\t\tjQuery._data(\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\nfunction setPositiveNumber( elem, value, subtract ) {\n\tvar matches = rnumsplit.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[ 1 ] - ( subtract || 0 ) ) + ( matches[ 2 ] || \"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 = support.boxSizing &&\n\t\t\tjQuery.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// we need the 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\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\n\t\t// normalize float css property\n\t\t\"float\": support.cssFloat ? \"cssFloat\" : \"styleFloat\"\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\n\t\t// followed by the 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. See: #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// Fixes #8908, it can be done more correctly by specifing setters in cssHooks,\n\t\t\t// but it would mean to define eight\n\t\t\t// (for every problematic property) identical functions\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\t// Support: IE\n\t\t\t\t// Swallow errors from 'invalid' CSS values (#5509)\n\t\t\t\ttry {\n\t\t\t\t\tstyle[ name ] = value;\n\t\t\t\t} catch ( e ) {}\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 num, val, 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// gets hook for the prefixed version\n\t\t// followed by the unprefixed version\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// Return, converting to number 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// however, it must have a current display style that would benefit from this\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 styles = extra && getStyles( elem );\n\t\t\treturn setPositiveNumber( elem, value, extra ?\n\t\t\t\taugmentWidthOrHeight(\n\t\t\t\t\telem,\n\t\t\t\t\tname,\n\t\t\t\t\textra,\n\t\t\t\t\tsupport.boxSizing &&\n\t\t\t\t\t\tjQuery.css( elem, \"boxSizing\", false, styles ) === \"border-box\",\n\t\t\t\t\tstyles\n\t\t\t\t) : 0\n\t\t\t);\n\t\t}\n\t};\n} );\n\nif ( !support.opacity ) {\n\tjQuery.cssHooks.opacity = {\n\t\tget: function( elem, computed ) {\n\n\t\t\t// IE uses filters for opacity\n\t\t\treturn ropacity.test( ( computed && elem.currentStyle ?\n\t\t\t\telem.currentStyle.filter :\n\t\t\t\telem.style.filter ) || \"\" ) ?\n\t\t\t\t\t( 0.01 * parseFloat( RegExp.$1 ) ) + \"\" :\n\t\t\t\t\tcomputed ? \"1\" : \"\";\n\t\t},\n\n\t\tset: function( elem, value ) {\n\t\t\tvar style = elem.style,\n\t\t\t\tcurrentStyle = elem.currentStyle,\n\t\t\t\topacity = jQuery.isNumeric( value ) ? \"alpha(opacity=\" + value * 100 + \")\" : \"\",\n\t\t\t\tfilter = currentStyle && currentStyle.filter || style.filter || \"\";\n\n\t\t\t// IE has trouble with opacity if it does not have layout\n\t\t\t// Force it by setting the zoom level\n\t\t\tstyle.zoom = 1;\n\n\t\t\t// if setting opacity to 1, and no other filters exist -\n\t\t\t// attempt to remove filter attribute #6652\n\t\t\t// if value === \"\", then remove inline opacity #12685\n\t\t\tif ( ( value >= 1 || value === \"\" ) &&\n\t\t\t\t\tjQuery.trim( filter.replace( ralpha, \"\" ) ) === \"\" &&\n\t\t\t\t\tstyle.removeAttribute ) {\n\n\t\t\t\t// Setting style.filter to null, \"\" & \" \" still leave \"filter:\" in the cssText\n\t\t\t\t// if \"filter:\" is present at all, clearType is disabled, we want to avoid this\n\t\t\t\t// style.removeAttribute is IE Only, but so apparently is this code path...\n\t\t\t\tstyle.removeAttribute( \"filter\" );\n\n\t\t\t\t// if there is no filter style applied in a css rule\n\t\t\t\t// or unset inline opacity, we are done\n\t\t\t\tif ( value === \"\" || currentStyle && !currentStyle.filter ) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// otherwise, set new filter values\n\t\t\tstyle.filter = ralpha.test( filter ) ?\n\t\t\t\tfilter.replace( ralpha, opacity ) :\n\t\t\t\tfilter + \" \" + opacity;\n\t\t}\n\t};\n}\n\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\njQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft,\n\tfunction( elem, computed ) {\n\t\tif ( computed ) {\n\t\t\treturn (\n\t\t\t\tparseFloat( curCSS( elem, \"marginLeft\" ) ) ||\n\n\t\t\t\t// Support: IE<=11+\n\t\t\t\t// Running getBoundingClientRect on a disconnected node in IE throws an error\n\t\t\t\t// Support: IE8 only\n\t\t\t\t// getClientRects() errors on disconnected elems\n\t\t\t\t( jQuery.contains( elem.ownerDocument, elem ) ?\n\t\t\t\t\telem.getBoundingClientRect().left -\n\t\t\t\t\t\tswap( elem, { marginLeft: 0 }, function() {\n\t\t\t\t\t\t\treturn elem.getBoundingClientRect().left;\n\t\t\t\t\t\t} ) :\n\t\t\t\t\t0\n\t\t\t\t)\n\t\t\t) + \"px\";\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// so, 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 - use cssHook if its there - use .style if its\n\t\t\t// 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: IE <=9\n// Panic based approach to setting things on disconnected nodes\n\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\tattrs = { height: type },\n\t\ti = 0;\n\n\t// if we include width, step value is 1 to do all cssExpand values,\n\t// if we don't include width, 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 = jQuery._data( 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// doing this makes sure that the complete handler will be called\n\t\t\t// 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 IE does 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\tjQuery._data( elem, \"olddisplay\" ) || defaultDisplay( elem.nodeName ) : display;\n\n\t\tif ( checkDisplay === \"inline\" && jQuery.css( elem, \"float\" ) === \"none\" ) {\n\n\t\t\t// inline-level elements accept inline-block;\n\t\t\t// block-level elements need to be inline with layout\n\t\t\tif ( !support.inlineBlockNeedsLayout || defaultDisplay( elem.nodeName ) === \"inline\" ) {\n\t\t\t\tstyle.display = \"inline-block\";\n\t\t\t} else {\n\t\t\t\tstyle.zoom = 1;\n\t\t\t}\n\t\t}\n\t}\n\n\tif ( opts.overflow ) {\n\t\tstyle.overflow = \"hidden\";\n\t\tif ( !support.shrinkWrapBlocks() ) {\n\t\t\tanim.always( function() {\n\t\t\t\tstyle.overflow = opts.overflow[ 0 ];\n\t\t\t\tstyle.overflowX = opts.overflow[ 1 ];\n\t\t\t\tstyle.overflowY = opts.overflow[ 2 ];\n\t\t\t} );\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 = jQuery._data( 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\t\t\tjQuery._removeData( 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 wont overwrite keys already present.\n\t\t\t// also - reusing 'index' from above 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\n\t\t\t\t// 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\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\" ? opt.duration :\n\t\topt.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 || jQuery._data( 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 = jQuery._data( 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 will dequeue\n\t\t\t// 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 = jQuery._data( 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\ttimers = jQuery.timers,\n\t\ti = 0;\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;\n\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\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 a,\n\t\tinput = document.createElement( \"input\" ),\n\t\tdiv = document.createElement( \"div\" ),\n\t\tselect = document.createElement( \"select\" ),\n\t\topt = select.appendChild( document.createElement( \"option\" ) );\n\n\t// Setup\n\tdiv = document.createElement( \"div\" );\n\tdiv.setAttribute( \"className\", \"t\" );\n\tdiv.innerHTML = \"  <link/><table></table><a href='/a'>a</a><input type='checkbox'/>\";\n\ta = div.getElementsByTagName( \"a\" )[ 0 ];\n\n\t// Support: Windows Web Apps (WWA)\n\t// `type` must use .setAttribute for WWA (#14901)\n\tinput.setAttribute( \"type\", \"checkbox\" );\n\tdiv.appendChild( input );\n\n\ta = div.getElementsByTagName( \"a\" )[ 0 ];\n\n\t// First batch of tests.\n\ta.style.cssText = \"top:1px\";\n\n\t// Test setAttribute on camelCase class.\n\t// If it works, we need attrFixes when doing get/setAttribute (ie6/7)\n\tsupport.getSetAttribute = div.className !== \"t\";\n\n\t// Get the style information from getAttribute\n\t// (IE uses .cssText instead)\n\tsupport.style = /top/.test( a.getAttribute( \"style\" ) );\n\n\t// Make sure that URLs aren't manipulated\n\t// (IE normalizes it by default)\n\tsupport.hrefNormalized = a.getAttribute( \"href\" ) === \"/a\";\n\n\t// Check the default checkbox/radio value (\"\" on WebKit; \"on\" elsewhere)\n\tsupport.checkOn = !!input.value;\n\n\t// Make sure that a selected-by-default option has a working selected property.\n\t// (WebKit defaults to false instead of true, IE too, if it's in an optgroup)\n\tsupport.optSelected = opt.selected;\n\n\t// Tests for enctype support on a form (#6743)\n\tsupport.enctype = !!document.createElement( \"form\" ).enctype;\n\n\t// Make sure that the options inside disabled selects aren't marked as disabled\n\t// (WebKit marks them as disabled)\n\tselect.disabled = true;\n\tsupport.optDisabled = !opt.disabled;\n\n\t// Support: IE8 only\n\t// Check if we can trust getAttribute(\"value\")\n\tinput = document.createElement( \"input\" );\n\tinput.setAttribute( \"value\", \"\" );\n\tsupport.input = input.getAttribute( \"value\" ) === \"\";\n\n\t// Check if an input maintains its value after becoming a radio\n\tinput.value = \"t\";\n\tinput.setAttribute( \"type\", \"radio\" );\n\tsupport.radioValue = input.value === \"t\";\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 (\n\t\t\t\t\thooks &&\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\t\t\t} else if ( typeof val === \"number\" ) {\n\t\t\t\tval += \"\";\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\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// oldIE 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 :\n\t\t\t\t\t\t\t\toption.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\n\t\t\t\t\tif ( jQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1 ) {\n\n\t\t\t\t\t\t// Support: IE6\n\t\t\t\t\t\t// When new option element is added to select box we need to\n\t\t\t\t\t\t// force reflow of newly added node in order to workaround delay\n\t\t\t\t\t\t// of initialization properties\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\toption.selected = optionSet = true;\n\n\t\t\t\t\t\t} catch ( _ ) {\n\n\t\t\t\t\t\t\t// Will be executed only in IE6\n\t\t\t\t\t\t\toption.scrollHeight;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t} else {\n\t\t\t\t\t\toption.selected = false;\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\n\t\t\t\treturn options;\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\nvar nodeHook, boolHook,\n\tattrHandle = jQuery.expr.attrHandle,\n\truseDefault = /^(?:checked|selected)$/i,\n\tgetSetAttribute = support.getSetAttribute,\n\tgetSetInput = support.input;\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 : nodeHook );\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\n\t\t\t\t\t// Setting the type on a radio button after the value resets the value in IE8-9\n\t\t\t\t\t// Reset value to default in case type is set after value during creation\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\tif ( getSetInput && getSetAttribute || !ruseDefault.test( name ) ) {\n\t\t\t\t\t\telem[ propName ] = false;\n\n\t\t\t\t\t// Support: IE<9\n\t\t\t\t\t// Also clear defaultChecked/defaultSelected (if appropriate)\n\t\t\t\t\t} else {\n\t\t\t\t\t\telem[ jQuery.camelCase( \"default-\" + name ) ] =\n\t\t\t\t\t\t\telem[ propName ] = false;\n\t\t\t\t\t}\n\n\t\t\t\t// See #9699 for explanation of this approach (setting first, then removal)\n\t\t\t\t} else {\n\t\t\t\t\tjQuery.attr( elem, name, \"\" );\n\t\t\t\t}\n\n\t\t\t\telem.removeAttribute( getSetAttribute ? name : propName );\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 if ( getSetInput && getSetAttribute || !ruseDefault.test( name ) ) {\n\n\t\t\t// IE<8 needs the *property* name\n\t\t\telem.setAttribute( !getSetAttribute && jQuery.propFix[ name ] || name, name );\n\n\t\t} else {\n\n\t\t\t// Support: IE<9\n\t\t\t// Use defaultChecked and defaultSelected for oldIE\n\t\t\telem[ jQuery.camelCase( \"default-\" + name ) ] = elem[ name ] = true;\n\t\t}\n\t\treturn name;\n\t}\n};\n\njQuery.each( jQuery.expr.match.bool.source.match( /\\w+/g ), function( i, name ) {\n\tvar getter = attrHandle[ name ] || jQuery.find.attr;\n\n\tif ( getSetInput && getSetAttribute || !ruseDefault.test( name ) ) {\n\t\tattrHandle[ name ] = function( elem, name, isXML ) {\n\t\t\tvar ret, handle;\n\t\t\tif ( !isXML ) {\n\n\t\t\t\t// Avoid an infinite loop by temporarily removing this function from the getter\n\t\t\t\thandle = attrHandle[ name ];\n\t\t\t\tattrHandle[ name ] = ret;\n\t\t\t\tret = getter( elem, name, isXML ) != null ?\n\t\t\t\t\tname.toLowerCase() :\n\t\t\t\t\tnull;\n\t\t\t\tattrHandle[ name ] = handle;\n\t\t\t}\n\t\t\treturn ret;\n\t\t};\n\t} else {\n\t\tattrHandle[ name ] = function( elem, name, isXML ) {\n\t\t\tif ( !isXML ) {\n\t\t\t\treturn elem[ jQuery.camelCase( \"default-\" + name ) ] ?\n\t\t\t\t\tname.toLowerCase() :\n\t\t\t\t\tnull;\n\t\t\t}\n\t\t};\n\t}\n} );\n\n// fix oldIE attroperties\nif ( !getSetInput || !getSetAttribute ) {\n\tjQuery.attrHooks.value = {\n\t\tset: function( elem, value, name ) {\n\t\t\tif ( jQuery.nodeName( elem, \"input\" ) ) {\n\n\t\t\t\t// Does not return so that setAttribute is also used\n\t\t\t\telem.defaultValue = value;\n\t\t\t} else {\n\n\t\t\t\t// Use nodeHook if defined (#1954); otherwise setAttribute is fine\n\t\t\t\treturn nodeHook && nodeHook.set( elem, value, name );\n\t\t\t}\n\t\t}\n\t};\n}\n\n// IE6/7 do not support getting/setting some attributes with get/setAttribute\nif ( !getSetAttribute ) {\n\n\t// Use this for any attribute in IE6/7\n\t// This fixes almost every IE6/7 issue\n\tnodeHook = {\n\t\tset: function( elem, value, name ) {\n\n\t\t\t// Set the existing or create a new attribute node\n\t\t\tvar ret = elem.getAttributeNode( name );\n\t\t\tif ( !ret ) {\n\t\t\t\telem.setAttributeNode(\n\t\t\t\t\t( ret = elem.ownerDocument.createAttribute( name ) )\n\t\t\t\t);\n\t\t\t}\n\n\t\t\tret.value = value += \"\";\n\n\t\t\t// Break association with cloned elements by also using setAttribute (#9646)\n\t\t\tif ( name === \"value\" || value === elem.getAttribute( name ) ) {\n\t\t\t\treturn value;\n\t\t\t}\n\t\t}\n\t};\n\n\t// Some attributes are constructed with empty-string values when not defined\n\tattrHandle.id = attrHandle.name = attrHandle.coords =\n\t\tfunction( elem, name, isXML ) {\n\t\t\tvar ret;\n\t\t\tif ( !isXML ) {\n\t\t\t\treturn ( ret = elem.getAttributeNode( name ) ) && ret.value !== \"\" ?\n\t\t\t\t\tret.value :\n\t\t\t\t\tnull;\n\t\t\t}\n\t\t};\n\n\t// Fixing value retrieval on a button requires this module\n\tjQuery.valHooks.button = {\n\t\tget: function( elem, name ) {\n\t\t\tvar ret = elem.getAttributeNode( name );\n\t\t\tif ( ret && ret.specified ) {\n\t\t\t\treturn ret.value;\n\t\t\t}\n\t\t},\n\t\tset: nodeHook.set\n\t};\n\n\t// Set contenteditable to false on removals(#10429)\n\t// Setting to empty string throws an error as an invalid value\n\tjQuery.attrHooks.contenteditable = {\n\t\tset: function( elem, value, name ) {\n\t\t\tnodeHook.set( elem, value === \"\" ? false : value, name );\n\t\t}\n\t};\n\n\t// Set width and height to auto instead of 0 on empty string( Bug #8150 )\n\t// This is for removals\n\tjQuery.each( [ \"width\", \"height\" ], function( i, name ) {\n\t\tjQuery.attrHooks[ name ] = {\n\t\t\tset: function( elem, value ) {\n\t\t\t\tif ( value === \"\" ) {\n\t\t\t\t\telem.setAttribute( name, \"auto\" );\n\t\t\t\t\treturn value;\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\t} );\n}\n\nif ( !support.style ) {\n\tjQuery.attrHooks.style = {\n\t\tget: function( elem ) {\n\n\t\t\t// Return undefined in the case of empty string\n\t\t\t// Note: IE uppercases css property names, but if we were to .toLowerCase()\n\t\t\t// .cssText, that would destroy case sensitivity in URL's, like in \"background\"\n\t\t\treturn elem.style.cssText || undefined;\n\t\t},\n\t\tset: function( elem, value ) {\n\t\t\treturn ( elem.style.cssText = value + \"\" );\n\t\t}\n\t};\n}\n\n\n\n\nvar rfocusable = /^(?:input|select|textarea|button|object)$/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\tname = jQuery.propFix[ name ] || name;\n\t\treturn this.each( function() {\n\n\t\t\t// try/catch handles cases where IE balks (such as removing a property on window)\n\t\t\ttry {\n\t\t\t\tthis[ name ] = undefined;\n\t\t\t\tdelete this[ name ];\n\t\t\t} catch ( e ) {}\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// Some attributes require a special call on IE\n// http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx\nif ( !support.hrefNormalized ) {\n\n\t// href/src property should get the full normalized URL (#10299/#12915)\n\tjQuery.each( [ \"href\", \"src\" ], function( i, name ) {\n\t\tjQuery.propHooks[ name ] = {\n\t\t\tget: function( elem ) {\n\t\t\t\treturn elem.getAttribute( name, 4 );\n\t\t\t}\n\t\t};\n\t} );\n}\n\n// Support: Safari, IE9+\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\n\t\t\tif ( parent ) {\n\t\t\t\tparent.selectedIndex;\n\n\t\t\t\t// Make sure that it also works with optgroups, see #5701\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\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// IE6/7 call enctype encoding\nif ( !support.enctype ) {\n\tjQuery.propFix.enctype = \"encoding\";\n}\n\n\n\n\nvar rclass = /[\\t\\r\\n\\f]/g;\n\nfunction getClass( elem ) {\n\treturn jQuery.attr( elem, \"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\tjQuery.attr( elem, \"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\tjQuery.attr( elem, \"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\tjQuery._data( 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\tjQuery.attr( this, \"class\",\n\t\t\t\t\tclassName || value === false ?\n\t\t\t\t\t\"\" :\n\t\t\t\t\tjQuery._data( this, \"__className__\" ) || \"\"\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\n// Return jQuery for attributes-only inclusion\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\nvar location = window.location;\n\nvar nonce = jQuery.now();\n\nvar rquery = ( /\\?/ );\n\n\n\nvar rvalidtokens = /(,)|(\\[|{)|(}|])|\"(?:[^\"\\\\\\r\\n]|\\\\[\"\\\\\\/bfnrt]|\\\\u[\\da-fA-F]{4})*\"\\s*:?|true|false|null|-?(?!0\\d)\\d+(?:\\.\\d+|)(?:[eE][+-]?\\d+|)/g;\n\njQuery.parseJSON = function( data ) {\n\n\t// Attempt to parse using the native JSON parser first\n\tif ( window.JSON && window.JSON.parse ) {\n\n\t\t// Support: Android 2.3\n\t\t// Workaround failure to string-cast null input\n\t\treturn window.JSON.parse( data + \"\" );\n\t}\n\n\tvar requireNonComma,\n\t\tdepth = null,\n\t\tstr = jQuery.trim( data + \"\" );\n\n\t// Guard against invalid (and possibly dangerous) input by ensuring that nothing remains\n\t// after removing valid tokens\n\treturn str && !jQuery.trim( str.replace( rvalidtokens, function( token, comma, open, close ) {\n\n\t\t// Force termination if we see a misplaced comma\n\t\tif ( requireNonComma && comma ) {\n\t\t\tdepth = 0;\n\t\t}\n\n\t\t// Perform no more replacements after returning to outermost depth\n\t\tif ( depth === 0 ) {\n\t\t\treturn token;\n\t\t}\n\n\t\t// Commas must not follow \"[\", \"{\", or \",\"\n\t\trequireNonComma = open || comma;\n\n\t\t// Determine new depth\n\t\t// array/object open (\"[\" or \"{\"): depth += true - false (increment)\n\t\t// array/object close (\"]\" or \"}\"): depth += false - true (decrement)\n\t\t// other cases (\",\" or primitive): depth += true - true (numeric cast)\n\t\tdepth += !close - !open;\n\n\t\t// Remove this token\n\t\treturn \"\";\n\t} ) ) ?\n\t\t( Function( \"return \" + str ) )() :\n\t\tjQuery.error( \"Invalid JSON: \" + data );\n};\n\n\n// Cross-browser xml parsing\njQuery.parseXML = function( data ) {\n\tvar xml, tmp;\n\tif ( !data || typeof data !== \"string\" ) {\n\t\treturn null;\n\t}\n\ttry {\n\t\tif ( window.DOMParser ) { // Standard\n\t\t\ttmp = new window.DOMParser();\n\t\t\txml = tmp.parseFromString( data, \"text/xml\" );\n\t\t} else { // IE\n\t\t\txml = new window.ActiveXObject( \"Microsoft.XMLDOM\" );\n\t\t\txml.async = \"false\";\n\t\t\txml.loadXML( data );\n\t\t}\n\t} catch ( e ) {\n\t\txml = undefined;\n\t}\n\tif ( !xml || !xml.documentElement || 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\n\t// IE leaves an \\r character at EOL\n\trheaders = /^(.*?):[ \\t]*([^\\r\\n]*)\\r?$/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\trurl = /^([\\w.+-]+:)(?:\\/\\/(?:[^\\/?#]*@|)([^\\/?#:]*)(?::(\\d+)|)|)/,\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// Document location\n\tajaxLocation = location.href,\n\n\t// Segment location into parts\n\tajaxLocParts = rurl.exec( ajaxLocation.toLowerCase() ) || [];\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.charAt( 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 deep, key,\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\tvar firstDataType, ct, finalDataType, type,\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\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\" ] ) { // jscs:ignore requireDotNotation\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: ajaxLocation,\n\t\ttype: \"GET\",\n\t\tisLocal: rlocalProtocol.test( ajaxLocParts[ 1 ] ),\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\n\n\t\t\t// Cross-domain detection vars\n\t\t\tparts,\n\n\t\t\t// Loop variable\n\t\t\ti,\n\n\t\t\t// URL without anti-cache param\n\t\t\tcacheURL,\n\n\t\t\t// Response headers as string\n\t\t\tresponseHeadersString,\n\n\t\t\t// timeout handle\n\t\t\ttimeoutTimer,\n\n\t\t\t// To know if global events are to be dispatched\n\t\t\tfireGlobals,\n\n\t\t\ttransport,\n\n\t\t\t// Response headers\n\t\t\tresponseHeaders,\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 (#5866: IE7 issue with protocol-less urls)\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 || ajaxLocation ) + \"\" )\n\t\t\t.replace( rhash, \"\" )\n\t\t\t.replace( rprotocol, ajaxLocParts[ 1 ] + \"//\" );\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 we have a protocol:host:port mismatch\n\t\tif ( s.crossDomain == null ) {\n\t\t\tparts = rurl.exec( s.url.toLowerCase() );\n\t\t\ts.crossDomain = !!( parts &&\n\t\t\t\t( parts[ 1 ] !== ajaxLocParts[ 1 ] || parts[ 2 ] !== ajaxLocParts[ 2 ] ||\n\t\t\t\t\t( parts[ 3 ] || ( parts[ 1 ] === \"http:\" ? \"80\" : \"443\" ) ) !==\n\t\t\t\t\t\t( ajaxLocParts[ 3 ] || ( ajaxLocParts[ 1 ] === \"http:\" ? \"80\" : \"443\" ) ) )\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// We extract error from statusText\n\t\t\t\t// then normalize statusText and status 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\tcache: true,\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\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\tvar wrap = 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.firstChild && elem.firstChild.nodeType === 1 ) {\n\t\t\t\t\telem = elem.firstChild;\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\nfunction getDisplay( elem ) {\n\treturn elem.style && elem.style.display || jQuery.css( elem, \"display\" );\n}\n\nfunction filterHidden( elem ) {\n\n\t// Disconnected elements are considered hidden\n\tif ( !jQuery.contains( elem.ownerDocument || document, elem ) ) {\n\t\treturn true;\n\t}\n\twhile ( elem && elem.nodeType === 1 ) {\n\t\tif ( getDisplay( elem ) === \"none\" || elem.type === \"hidden\" ) {\n\t\t\treturn true;\n\t\t}\n\t\telem = elem.parentNode;\n\t}\n\treturn false;\n}\n\njQuery.expr.filters.hidden = function( elem ) {\n\n\t// Support: Opera <= 12.12\n\t// Opera reports offsetWidths and offsetHeights less than zero on some elements\n\treturn support.reliableHiddenOffsets() ?\n\t\t( elem.offsetWidth <= 0 && elem.offsetHeight <= 0 &&\n\t\t\t!elem.getClientRects().length ) :\n\t\t\tfilterHidden( elem );\n};\n\njQuery.expr.filters.visible = function( elem ) {\n\treturn !jQuery.expr.filters.hidden( elem );\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\n// Create the request object\n// (This is still attached to ajaxSettings for backward compatibility)\njQuery.ajaxSettings.xhr = window.ActiveXObject !== undefined ?\n\n\t// Support: IE6-IE8\n\tfunction() {\n\n\t\t// XHR cannot access local files, always use ActiveX for that case\n\t\tif ( this.isLocal ) {\n\t\t\treturn createActiveXHR();\n\t\t}\n\n\t\t// Support: IE 9-11\n\t\t// IE seems to error on cross-domain PATCH requests when ActiveX XHR\n\t\t// is used. In IE 9+ always use the native XHR.\n\t\t// Note: this condition won't catch Edge as it doesn't define\n\t\t// document.documentMode but it also doesn't support ActiveX so it won't\n\t\t// reach this code.\n\t\tif ( document.documentMode > 8 ) {\n\t\t\treturn createStandardXHR();\n\t\t}\n\n\t\t// Support: IE<9\n\t\t// oldIE XHR does not support non-RFC2616 methods (#13240)\n\t\t// See http://msdn.microsoft.com/en-us/library/ie/ms536648(v=vs.85).aspx\n\t\t// and http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9\n\t\t// Although this check for six methods instead of eight\n\t\t// since IE also does not support \"trace\" and \"connect\"\n\t\treturn /^(get|post|head|put|delete|options)$/i.test( this.type ) &&\n\t\t\tcreateStandardXHR() || createActiveXHR();\n\t} :\n\n\t// For all other browsers, use the standard XMLHttpRequest object\n\tcreateStandardXHR;\n\nvar xhrId = 0,\n\txhrCallbacks = {},\n\txhrSupported = jQuery.ajaxSettings.xhr();\n\n// Support: IE<10\n// Open requests must be manually aborted on unload (#5280)\n// See https://support.microsoft.com/kb/2856746 for more info\nif ( window.attachEvent ) {\n\twindow.attachEvent( \"onunload\", function() {\n\t\tfor ( var key in xhrCallbacks ) {\n\t\t\txhrCallbacks[ key ]( undefined, true );\n\t\t}\n\t} );\n}\n\n// Determine support properties\nsupport.cors = !!xhrSupported && ( \"withCredentials\" in xhrSupported );\nxhrSupported = support.ajax = !!xhrSupported;\n\n// Create transport if the browser can provide an xhr\nif ( xhrSupported ) {\n\n\tjQuery.ajaxTransport( function( options ) {\n\n\t\t// Cross domain only allowed if supported through XMLHttpRequest\n\t\tif ( !options.crossDomain || support.cors ) {\n\n\t\t\tvar callback;\n\n\t\t\treturn {\n\t\t\t\tsend: function( headers, complete ) {\n\t\t\t\t\tvar i,\n\t\t\t\t\t\txhr = options.xhr(),\n\t\t\t\t\t\tid = ++xhrId;\n\n\t\t\t\t\t// Open the socket\n\t\t\t\t\txhr.open(\n\t\t\t\t\t\toptions.type,\n\t\t\t\t\t\toptions.url,\n\t\t\t\t\t\toptions.async,\n\t\t\t\t\t\toptions.username,\n\t\t\t\t\t\toptions.password\n\t\t\t\t\t);\n\n\t\t\t\t\t// Apply custom fields if provided\n\t\t\t\t\tif ( options.xhrFields ) {\n\t\t\t\t\t\tfor ( i in options.xhrFields ) {\n\t\t\t\t\t\t\txhr[ i ] = options.xhrFields[ i ];\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Override mime type if needed\n\t\t\t\t\tif ( options.mimeType && xhr.overrideMimeType ) {\n\t\t\t\t\t\txhr.overrideMimeType( options.mimeType );\n\t\t\t\t\t}\n\n\t\t\t\t\t// X-Requested-With header\n\t\t\t\t\t// For cross-domain requests, seeing as conditions for a preflight are\n\t\t\t\t\t// akin to a jigsaw puzzle, we simply never set it to be sure.\n\t\t\t\t\t// (it can always be set on a per-request basis or even using ajaxSetup)\n\t\t\t\t\t// For same-domain requests, won't change header if already provided.\n\t\t\t\t\tif ( !options.crossDomain && !headers[ \"X-Requested-With\" ] ) {\n\t\t\t\t\t\theaders[ \"X-Requested-With\" ] = \"XMLHttpRequest\";\n\t\t\t\t\t}\n\n\t\t\t\t\t// Set headers\n\t\t\t\t\tfor ( i in headers ) {\n\n\t\t\t\t\t\t// Support: IE<9\n\t\t\t\t\t\t// IE's ActiveXObject throws a 'Type Mismatch' exception when setting\n\t\t\t\t\t\t// request header to a null-value.\n\t\t\t\t\t\t//\n\t\t\t\t\t\t// To keep consistent with other XHR implementations, cast the value\n\t\t\t\t\t\t// to string and ignore `undefined`.\n\t\t\t\t\t\tif ( headers[ i ] !== undefined ) {\n\t\t\t\t\t\t\txhr.setRequestHeader( i, headers[ i ] + \"\" );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Do send the request\n\t\t\t\t\t// This may raise an exception which is actually\n\t\t\t\t\t// handled in jQuery.ajax (so no try/catch here)\n\t\t\t\t\txhr.send( ( options.hasContent && options.data ) || null );\n\n\t\t\t\t\t// Listener\n\t\t\t\t\tcallback = function( _, isAbort ) {\n\t\t\t\t\t\tvar status, statusText, responses;\n\n\t\t\t\t\t\t// Was never called and is aborted or complete\n\t\t\t\t\t\tif ( callback && ( isAbort || xhr.readyState === 4 ) ) {\n\n\t\t\t\t\t\t\t// Clean up\n\t\t\t\t\t\t\tdelete xhrCallbacks[ id ];\n\t\t\t\t\t\t\tcallback = undefined;\n\t\t\t\t\t\t\txhr.onreadystatechange = jQuery.noop;\n\n\t\t\t\t\t\t\t// Abort manually if needed\n\t\t\t\t\t\t\tif ( isAbort ) {\n\t\t\t\t\t\t\t\tif ( xhr.readyState !== 4 ) {\n\t\t\t\t\t\t\t\t\txhr.abort();\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\tresponses = {};\n\t\t\t\t\t\t\t\tstatus = xhr.status;\n\n\t\t\t\t\t\t\t\t// Support: IE<10\n\t\t\t\t\t\t\t\t// Accessing binary-data responseText throws an exception\n\t\t\t\t\t\t\t\t// (#11426)\n\t\t\t\t\t\t\t\tif ( typeof xhr.responseText === \"string\" ) {\n\t\t\t\t\t\t\t\t\tresponses.text = xhr.responseText;\n\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t// Firefox throws an exception when accessing\n\t\t\t\t\t\t\t\t// statusText for faulty cross-domain requests\n\t\t\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\t\t\tstatusText = xhr.statusText;\n\t\t\t\t\t\t\t\t} catch ( e ) {\n\n\t\t\t\t\t\t\t\t\t// We normalize with Webkit giving an empty statusText\n\t\t\t\t\t\t\t\t\tstatusText = \"\";\n\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t// Filter status for non standard behaviors\n\n\t\t\t\t\t\t\t\t// If the request is local and we have data: assume a success\n\t\t\t\t\t\t\t\t// (success with no data won't get notified, that's the best we\n\t\t\t\t\t\t\t\t// can do given current implementations)\n\t\t\t\t\t\t\t\tif ( !status && options.isLocal && !options.crossDomain ) {\n\t\t\t\t\t\t\t\t\tstatus = responses.text ? 200 : 404;\n\n\t\t\t\t\t\t\t\t// IE - #1450: sometimes returns 1223 when it should be 204\n\t\t\t\t\t\t\t\t} else if ( status === 1223 ) {\n\t\t\t\t\t\t\t\t\tstatus = 204;\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// Call complete if needed\n\t\t\t\t\t\tif ( responses ) {\n\t\t\t\t\t\t\tcomplete( status, statusText, responses, xhr.getAllResponseHeaders() );\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\n\t\t\t\t\t// Do send the request\n\t\t\t\t\t// `xhr.send` may raise an exception, but it will be\n\t\t\t\t\t// handled in jQuery.ajax (so no try/catch here)\n\t\t\t\t\tif ( !options.async ) {\n\n\t\t\t\t\t\t// If we're in sync mode we fire the callback\n\t\t\t\t\t\tcallback();\n\t\t\t\t\t} else if ( xhr.readyState === 4 ) {\n\n\t\t\t\t\t\t// (IE6 & IE7) if it's in cache and has been\n\t\t\t\t\t\t// retrieved directly we need to fire the callback\n\t\t\t\t\t\twindow.setTimeout( callback );\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\t// Register the callback, but delay it in case `xhr.send` throws\n\t\t\t\t\t\t// Add to the list of active xhr callbacks\n\t\t\t\t\t\txhr.onreadystatechange = xhrCallbacks[ id ] = callback;\n\t\t\t\t\t}\n\t\t\t\t},\n\n\t\t\t\tabort: function() {\n\t\t\t\t\tif ( callback ) {\n\t\t\t\t\t\tcallback( undefined, true );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t};\n\t\t}\n\t} );\n}\n\n// Functions to create xhrs\nfunction createStandardXHR() {\n\ttry {\n\t\treturn new window.XMLHttpRequest();\n\t} catch ( e ) {}\n}\n\nfunction createActiveXHR() {\n\ttry {\n\t\treturn new window.ActiveXObject( \"Microsoft.XMLHTTP\" );\n\t} catch ( e ) {}\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 global\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\ts.global = false;\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\n\t\tvar script,\n\t\t\thead = document.head || jQuery( \"head\" )[ 0 ] || document.documentElement;\n\n\t\treturn {\n\n\t\t\tsend: function( _, callback ) {\n\n\t\t\t\tscript = document.createElement( \"script\" );\n\n\t\t\t\tscript.async = true;\n\n\t\t\t\tif ( s.scriptCharset ) {\n\t\t\t\t\tscript.charset = s.scriptCharset;\n\t\t\t\t}\n\n\t\t\t\tscript.src = s.url;\n\n\t\t\t\t// Attach handlers for all browsers\n\t\t\t\tscript.onload = script.onreadystatechange = function( _, isAbort ) {\n\n\t\t\t\t\tif ( isAbort || !script.readyState || /loaded|complete/.test( script.readyState ) ) {\n\n\t\t\t\t\t\t// Handle memory leak in IE\n\t\t\t\t\t\tscript.onload = script.onreadystatechange = null;\n\n\t\t\t\t\t\t// Remove the script\n\t\t\t\t\t\tif ( script.parentNode ) {\n\t\t\t\t\t\t\tscript.parentNode.removeChild( script );\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Dereference the script\n\t\t\t\t\t\tscript = null;\n\n\t\t\t\t\t\t// Callback if not abort\n\t\t\t\t\t\tif ( !isAbort ) {\n\t\t\t\t\t\t\tcallback( 200, \"success\" );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t};\n\n\t\t\t\t// Circumvent IE6 bugs with base elements (#2709 and #4378) by prepending\n\t\t\t\t// Use native DOM manipulation to avoid our domManip AJAX trickery\n\t\t\t\thead.insertBefore( script, head.firstChild );\n\t\t\t},\n\n\t\t\tabort: function() {\n\t\t\t\tif ( script ) {\n\t\t\t\t\tscript.onload( undefined, true );\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// data: 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, url.length ) );\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/**\n * Gets a window from an element\n */\nfunction getWindow( elem ) {\n\treturn jQuery.isWindow( elem ) ?\n\t\telem :\n\t\telem.nodeType === 9 ?\n\t\t\telem.defaultView || elem.parentWindow :\n\t\t\tfalse;\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\tjQuery.inArray( \"auto\", [ curCSSTop, curCSSLeft ] ) > -1;\n\n\t\t// need to be able to calculate position if either top or left\n\t\t// 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\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\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\tbox = { top: 0, left: 0 },\n\t\t\telem = this[ 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\t// If we don't have gBCR, just use 0,0 rather than error\n\t\t// BlackBerry 5, iOS 3 (original iPhone)\n\t\tif ( typeof elem.getBoundingClientRect !== \"undefined\" ) {\n\t\t\tbox = elem.getBoundingClientRect();\n\t\t}\n\t\twin = getWindow( doc );\n\t\treturn {\n\t\t\ttop: box.top  + ( win.pageYOffset || docElem.scrollTop )  - ( docElem.clientTop  || 0 ),\n\t\t\tleft: box.left + ( win.pageXOffset || docElem.scrollLeft ) - ( docElem.clientLeft || 0 )\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\tparentOffset = { top: 0, left: 0 },\n\t\t\telem = this[ 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// we assume that getBoundingClientRect is available when computed position is fixed\n\t\t\toffset = elem.getBoundingClientRect();\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\t// note: when an element has margin: auto the offsetLeft and marginLeft\n\t\t// are the same in Safari causing offset.left to incorrectly be 0\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\toffsetParent: function() {\n\t\treturn this.map( function() {\n\t\t\tvar offsetParent = this.offsetParent;\n\n\t\t\twhile ( offsetParent && ( !jQuery.nodeName( offsetParent, \"html\" ) &&\n\t\t\t\tjQuery.css( offsetParent, \"position\" ) === \"static\" ) ) {\n\t\t\t\toffsetParent = offsetParent.offsetParent;\n\t\t\t}\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 = /Y/.test( 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 ? ( prop in win ) ? win[ prop ] :\n\t\t\t\t\twin.document.documentElement[ method ] :\n\t\t\t\t\telem[ 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 : jQuery( win ).scrollLeft(),\n\t\t\t\t\ttop ? val : jQuery( win ).scrollTop()\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, null );\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// getComputedStyle returns percent when specified for top/left/bottom/right\n// rather than make the css module depend on the offset module, we 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\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\t// unfortunately, this causes bug #3838 in IE6/8 only,\n\t\t\t\t\t// but there is currently no good, small way to fix it.\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} );\n\n// The number of elements contained in the matched element set\njQuery.fn.size = function() {\n\treturn this.length;\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\n// AMD (#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\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/jquery/dist/jquery.js\n// module id = 0\n// module chunks = 0","import $ from 'jquery';\n\nconst breakpoint = 1024;\n\nfunction Viewport() {\n  this.change = $.proxy(this.change, this);\n  this.mobileState = this.getCurrentState();\n  this.ticking = false;\n  this.addListeners();\n}\n\nViewport.prototype = {\n  setCurrentState(state) {\n    this.mobileState = state;\n  },\n  getCurrentState() {\n    return window.innerWidth < breakpoint;\n  },\n  update() {\n    this.ticking = false;\n    const currentState = this.getCurrentState();\n    const previousState = this.mobileState;\n\n    // Announce screen has changed\n    if (this.changeCallbacks) {\n      this.changeCallbacks.fire();\n    }\n\n    // Check to see if the view state has changed\n    if (currentState !== previousState) {\n      this.setCurrentState(currentState);\n\n      // Announce screen has changed to mobile mode\n      if (this.mobileCallbacks && this.mobileState) {\n        this.mobileCallbacks.fire();\n      }\n\n      // Announce screen has changed to desktop mode\n      if (this.desktopCallbacks && !this.mobileState) {\n        this.desktopCallbacks.fire();\n      }\n    }\n  },\n  change() {\n    this.requestTick();\n  },\n  requestTick() {\n    if (!this.ticking) {\n      requestAnimationFrame(this.update.bind(this));\n      this.ticking = true;\n    }\n  },\n  onMobileChange(callback) {\n    if (!this.mobileCallbacks) {\n      this.mobileCallbacks = $.Callbacks('memory');\n    }\n    this.mobileCallbacks.add(callback);\n    return this;\n  },\n  onDesktopChange(callback) {\n    if (!this.desktopCallbacks) {\n      this.desktopCallbacks = $.Callbacks('memory');\n    }\n    this.desktopCallbacks.add(callback);\n    return this;\n  },\n  onChange(callback) {\n    if (!this.changeCallbacks) {\n      this.changeCallbacks = $.Callbacks('memory');\n    }\n    this.changeCallbacks.add(callback);\n    return this;\n  },\n  addListeners() {\n    $(window).on('resize orientationchange', this.change);\n  },\n};\n\nexport default new Viewport();\n\n\n\n// WEBPACK FOOTER //\n// ./Viewport.js","import $ from 'jquery';\n\nfunction Change() {\n  this.change = $.proxy(this.change, this);\n  this.ticking = false;\n  this.listen();\n}\n\nChange.prototype = {\n  update() {\n    this.ticking = false;\n    if (this.callbacks) {\n      this.callbacks.fire();\n    }\n  },\n  change() {\n    this.request();\n  },\n  request() {\n    if (!this.ticking) {\n      requestAnimationFrame(this.update.bind(this));\n      this.ticking = true;\n    }\n  },\n  onChange(callback) {\n    if (!this.callbacks) {\n      this.callbacks = $.Callbacks('memory');\n    }\n    this.callbacks.add(callback);\n    return this;\n  },\n  listen() {\n    $(window).on('scroll resize orientationchange', this.change);\n  },\n};\n\nexport default new Change();\n\n\n\n// WEBPACK FOOTER //\n// ./Change.js","/*** IMPORTS FROM imports-loader ***/\nvar jQuery = require(\"jquery\");\nvar $ = require(\"jquery\");\n(function() {\n\n/*\n * jQuery doTimeout: Like setTimeout, but better! - v1.0 - 3/3/2010\n * http://benalman.com/projects/jquery-dotimeout-plugin/\n * \n * Copyright (c) 2010 \"Cowboy\" Ben Alman\n * Dual licensed under the MIT and GPL licenses.\n * http://benalman.com/about/license/\n */\n(function($){var a={},c=\"doTimeout\",d=Array.prototype.slice;$[c]=function(){return b.apply(window,[0].concat(d.call(arguments)))};$.fn[c]=function(){var f=d.call(arguments),e=b.apply(this,[c+f[0]].concat(f));return typeof f[0]===\"number\"||typeof f[1]===\"number\"?this:e};function b(l){var m=this,h,k={},g=l?$.fn:$,n=arguments,i=4,f=n[1],j=n[2],p=n[3];if(typeof f!==\"string\"){i--;f=l=0;j=n[1];p=n[2]}if(l){h=m.eq(0);h.data(l,k=h.data(l)||{})}else{if(f){k=a[f]||(a[f]={})}}k.id&&clearTimeout(k.id);delete k.id;function e(){if(l){h.removeData(l)}else{if(f){delete a[f]}}}function o(){k.id=setTimeout(function(){k.fn()},j)}if(p){k.fn=function(q){if(typeof p===\"string\"){p=g[p]}p.apply(m,d.call(n,i))===true&&!q?o():e()};o()}else{if(k.fn){j===undefined?e():k.fn(j===false);return true}else{e()}}}})(jQuery);\n\n}.call(window));\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../vendor/dotimeout/jquery.ba-dotimeout.min.js\n// module id = 3\n// module chunks = 0","/*\n     _ _      _       _\n ___| (_) ___| | __  (_)___\n/ __| | |/ __| |/ /  | / __|\n\\__ \\ | | (__|   < _ | \\__ \\\n|___/_|_|\\___|_|\\_(_)/ |___/\n                   |__/\n\n Version: 1.6.0\n  Author: Ken Wheeler\n Website: http://kenwheeler.github.io\n    Docs: http://kenwheeler.github.io/slick\n    Repo: http://github.com/kenwheeler/slick\n  Issues: http://github.com/kenwheeler/slick/issues\n\n */\n/* global window, document, define, jQuery, setInterval, clearInterval */\n(function(factory) {\n    'use strict';\n    if (typeof define === 'function' && define.amd) {\n        define(['jquery'], factory);\n    } else if (typeof exports !== 'undefined') {\n        module.exports = factory(require('jquery'));\n    } else {\n        factory(jQuery);\n    }\n\n}(function($) {\n    'use strict';\n    var Slick = window.Slick || {};\n\n    Slick = (function() {\n\n        var instanceUid = 0;\n\n        function Slick(element, settings) {\n\n            var _ = this, dataSettings;\n\n            _.defaults = {\n                accessibility: true,\n                adaptiveHeight: false,\n                appendArrows: $(element),\n                appendDots: $(element),\n                arrows: true,\n                asNavFor: null,\n                prevArrow: '<button type=\"button\" data-role=\"none\" class=\"slick-prev\" aria-label=\"Previous\" tabindex=\"0\" role=\"button\">Previous</button>',\n                nextArrow: '<button type=\"button\" data-role=\"none\" class=\"slick-next\" aria-label=\"Next\" tabindex=\"0\" role=\"button\">Next</button>',\n                autoplay: false,\n                autoplaySpeed: 3000,\n                centerMode: false,\n                centerPadding: '50px',\n                cssEase: 'ease',\n                customPaging: function(slider, i) {\n                    return $('<button type=\"button\" data-role=\"none\" role=\"button\" tabindex=\"0\" />').text(i + 1);\n                },\n                dots: false,\n                dotsClass: 'slick-dots',\n                draggable: true,\n                easing: 'linear',\n                edgeFriction: 0.35,\n                fade: false,\n                focusOnSelect: false,\n                infinite: true,\n                initialSlide: 0,\n                lazyLoad: 'ondemand',\n                mobileFirst: false,\n                pauseOnHover: true,\n                pauseOnFocus: true,\n                pauseOnDotsHover: false,\n                respondTo: 'window',\n                responsive: null,\n                rows: 1,\n                rtl: false,\n                slide: '',\n                slidesPerRow: 1,\n                slidesToShow: 1,\n                slidesToScroll: 1,\n                speed: 500,\n                swipe: true,\n                swipeToSlide: false,\n                touchMove: true,\n                touchThreshold: 5,\n                useCSS: true,\n                useTransform: true,\n                variableWidth: false,\n                vertical: false,\n                verticalSwiping: false,\n                waitForAnimate: true,\n                zIndex: 1000\n            };\n\n            _.initials = {\n                animating: false,\n                dragging: false,\n                autoPlayTimer: null,\n                currentDirection: 0,\n                currentLeft: null,\n                currentSlide: 0,\n                direction: 1,\n                $dots: null,\n                listWidth: null,\n                listHeight: null,\n                loadIndex: 0,\n                $nextArrow: null,\n                $prevArrow: null,\n                slideCount: null,\n                slideWidth: null,\n                $slideTrack: null,\n                $slides: null,\n                sliding: false,\n                slideOffset: 0,\n                swipeLeft: null,\n                $list: null,\n                touchObject: {},\n                transformsEnabled: false,\n                unslicked: false\n            };\n\n            $.extend(_, _.initials);\n\n            _.activeBreakpoint = null;\n            _.animType = null;\n            _.animProp = null;\n            _.breakpoints = [];\n            _.breakpointSettings = [];\n            _.cssTransitions = false;\n            _.focussed = false;\n            _.interrupted = false;\n            _.hidden = 'hidden';\n            _.paused = true;\n            _.positionProp = null;\n            _.respondTo = null;\n            _.rowCount = 1;\n            _.shouldClick = true;\n            _.$slider = $(element);\n            _.$slidesCache = null;\n            _.transformType = null;\n            _.transitionType = null;\n            _.visibilityChange = 'visibilitychange';\n            _.windowWidth = 0;\n            _.windowTimer = null;\n\n            dataSettings = $(element).data('slick') || {};\n\n            _.options = $.extend({}, _.defaults, settings, dataSettings);\n\n            _.currentSlide = _.options.initialSlide;\n\n            _.originalSettings = _.options;\n\n            if (typeof document.mozHidden !== 'undefined') {\n                _.hidden = 'mozHidden';\n                _.visibilityChange = 'mozvisibilitychange';\n            } else if (typeof document.webkitHidden !== 'undefined') {\n                _.hidden = 'webkitHidden';\n                _.visibilityChange = 'webkitvisibilitychange';\n            }\n\n            _.autoPlay = $.proxy(_.autoPlay, _);\n            _.autoPlayClear = $.proxy(_.autoPlayClear, _);\n            _.autoPlayIterator = $.proxy(_.autoPlayIterator, _);\n            _.changeSlide = $.proxy(_.changeSlide, _);\n            _.clickHandler = $.proxy(_.clickHandler, _);\n            _.selectHandler = $.proxy(_.selectHandler, _);\n            _.setPosition = $.proxy(_.setPosition, _);\n            _.swipeHandler = $.proxy(_.swipeHandler, _);\n            _.dragHandler = $.proxy(_.dragHandler, _);\n            _.keyHandler = $.proxy(_.keyHandler, _);\n\n            _.instanceUid = instanceUid++;\n\n            // A simple way to check for HTML strings\n            // Strict HTML recognition (must start with <)\n            // Extracted from jQuery v1.11 source\n            _.htmlExpr = /^(?:\\s*(<[\\w\\W]+>)[^>]*)$/;\n\n\n            _.registerBreakpoints();\n            _.init(true);\n\n        }\n\n        return Slick;\n\n    }());\n\n    Slick.prototype.activateADA = function() {\n        var _ = this;\n\n        _.$slideTrack.find('.slick-active').attr({\n            'aria-hidden': 'false'\n        }).find('a, input, button, select').attr({\n            'tabindex': '0'\n        });\n\n    };\n\n    Slick.prototype.addSlide = Slick.prototype.slickAdd = function(markup, index, addBefore) {\n\n        var _ = this;\n\n        if (typeof(index) === 'boolean') {\n            addBefore = index;\n            index = null;\n        } else if (index < 0 || (index >= _.slideCount)) {\n            return false;\n        }\n\n        _.unload();\n\n        if (typeof(index) === 'number') {\n            if (index === 0 && _.$slides.length === 0) {\n                $(markup).appendTo(_.$slideTrack);\n            } else if (addBefore) {\n                $(markup).insertBefore(_.$slides.eq(index));\n            } else {\n                $(markup).insertAfter(_.$slides.eq(index));\n            }\n        } else {\n            if (addBefore === true) {\n                $(markup).prependTo(_.$slideTrack);\n            } else {\n                $(markup).appendTo(_.$slideTrack);\n            }\n        }\n\n        _.$slides = _.$slideTrack.children(this.options.slide);\n\n        _.$slideTrack.children(this.options.slide).detach();\n\n        _.$slideTrack.append(_.$slides);\n\n        _.$slides.each(function(index, element) {\n            $(element).attr('data-slick-index', index);\n        });\n\n        _.$slidesCache = _.$slides;\n\n        _.reinit();\n\n    };\n\n    Slick.prototype.animateHeight = function() {\n        var _ = this;\n        if (_.options.slidesToShow === 1 && _.options.adaptiveHeight === true && _.options.vertical === false) {\n            var targetHeight = _.$slides.eq(_.currentSlide).outerHeight(true);\n            _.$list.animate({\n                height: targetHeight\n            }, _.options.speed);\n        }\n    };\n\n    Slick.prototype.animateSlide = function(targetLeft, callback) {\n\n        var animProps = {},\n            _ = this;\n\n        _.animateHeight();\n\n        if (_.options.rtl === true && _.options.vertical === false) {\n            targetLeft = -targetLeft;\n        }\n        if (_.transformsEnabled === false) {\n            if (_.options.vertical === false) {\n                _.$slideTrack.animate({\n                    left: targetLeft\n                }, _.options.speed, _.options.easing, callback);\n            } else {\n                _.$slideTrack.animate({\n                    top: targetLeft\n                }, _.options.speed, _.options.easing, callback);\n            }\n\n        } else {\n\n            if (_.cssTransitions === false) {\n                if (_.options.rtl === true) {\n                    _.currentLeft = -(_.currentLeft);\n                }\n                $({\n                    animStart: _.currentLeft\n                }).animate({\n                    animStart: targetLeft\n                }, {\n                    duration: _.options.speed,\n                    easing: _.options.easing,\n                    step: function(now) {\n                        now = Math.ceil(now);\n                        if (_.options.vertical === false) {\n                            animProps[_.animType] = 'translate(' +\n                                now + 'px, 0px)';\n                            _.$slideTrack.css(animProps);\n                        } else {\n                            animProps[_.animType] = 'translate(0px,' +\n                                now + 'px)';\n                            _.$slideTrack.css(animProps);\n                        }\n                    },\n                    complete: function() {\n                        if (callback) {\n                            callback.call();\n                        }\n                    }\n                });\n\n            } else {\n\n                _.applyTransition();\n                targetLeft = Math.ceil(targetLeft);\n\n                if (_.options.vertical === false) {\n                    animProps[_.animType] = 'translate3d(' + targetLeft + 'px, 0px, 0px)';\n                } else {\n                    animProps[_.animType] = 'translate3d(0px,' + targetLeft + 'px, 0px)';\n                }\n                _.$slideTrack.css(animProps);\n\n                if (callback) {\n                    setTimeout(function() {\n\n                        _.disableTransition();\n\n                        callback.call();\n                    }, _.options.speed);\n                }\n\n            }\n\n        }\n\n    };\n\n    Slick.prototype.getNavTarget = function() {\n\n        var _ = this,\n            asNavFor = _.options.asNavFor;\n\n        if ( asNavFor && asNavFor !== null ) {\n            asNavFor = $(asNavFor).not(_.$slider);\n        }\n\n        return asNavFor;\n\n    };\n\n    Slick.prototype.asNavFor = function(index) {\n\n        var _ = this,\n            asNavFor = _.getNavTarget();\n\n        if ( asNavFor !== null && typeof asNavFor === 'object' ) {\n            asNavFor.each(function() {\n                var target = $(this).slick('getSlick');\n                if(!target.unslicked) {\n                    target.slideHandler(index, true);\n                }\n            });\n        }\n\n    };\n\n    Slick.prototype.applyTransition = function(slide) {\n\n        var _ = this,\n            transition = {};\n\n        if (_.options.fade === false) {\n            transition[_.transitionType] = _.transformType + ' ' + _.options.speed + 'ms ' + _.options.cssEase;\n        } else {\n            transition[_.transitionType] = 'opacity ' + _.options.speed + 'ms ' + _.options.cssEase;\n        }\n\n        if (_.options.fade === false) {\n            _.$slideTrack.css(transition);\n        } else {\n            _.$slides.eq(slide).css(transition);\n        }\n\n    };\n\n    Slick.prototype.autoPlay = function() {\n\n        var _ = this;\n\n        _.autoPlayClear();\n\n        if ( _.slideCount > _.options.slidesToShow ) {\n            _.autoPlayTimer = setInterval( _.autoPlayIterator, _.options.autoplaySpeed );\n        }\n\n    };\n\n    Slick.prototype.autoPlayClear = function() {\n\n        var _ = this;\n\n        if (_.autoPlayTimer) {\n            clearInterval(_.autoPlayTimer);\n        }\n\n    };\n\n    Slick.prototype.autoPlayIterator = function() {\n\n        var _ = this,\n            slideTo = _.currentSlide + _.options.slidesToScroll;\n\n        if ( !_.paused && !_.interrupted && !_.focussed ) {\n\n            if ( _.options.infinite === false ) {\n\n                if ( _.direction === 1 && ( _.currentSlide + 1 ) === ( _.slideCount - 1 )) {\n                    _.direction = 0;\n                }\n\n                else if ( _.direction === 0 ) {\n\n                    slideTo = _.currentSlide - _.options.slidesToScroll;\n\n                    if ( _.currentSlide - 1 === 0 ) {\n                        _.direction = 1;\n                    }\n\n                }\n\n            }\n\n            _.slideHandler( slideTo );\n\n        }\n\n    };\n\n    Slick.prototype.buildArrows = function() {\n\n        var _ = this;\n\n        if (_.options.arrows === true ) {\n\n            _.$prevArrow = $(_.options.prevArrow).addClass('slick-arrow');\n            _.$nextArrow = $(_.options.nextArrow).addClass('slick-arrow');\n\n            if( _.slideCount > _.options.slidesToShow ) {\n\n                _.$prevArrow.removeClass('slick-hidden').removeAttr('aria-hidden tabindex');\n                _.$nextArrow.removeClass('slick-hidden').removeAttr('aria-hidden tabindex');\n\n                if (_.htmlExpr.test(_.options.prevArrow)) {\n                    _.$prevArrow.prependTo(_.options.appendArrows);\n                }\n\n                if (_.htmlExpr.test(_.options.nextArrow)) {\n                    _.$nextArrow.appendTo(_.options.appendArrows);\n                }\n\n                if (_.options.infinite !== true) {\n                    _.$prevArrow\n                        .addClass('slick-disabled')\n                        .attr('aria-disabled', 'true');\n                }\n\n            } else {\n\n                _.$prevArrow.add( _.$nextArrow )\n\n                    .addClass('slick-hidden')\n                    .attr({\n                        'aria-disabled': 'true',\n                        'tabindex': '-1'\n                    });\n\n            }\n\n        }\n\n    };\n\n    Slick.prototype.buildDots = function() {\n\n        var _ = this,\n            i, dot;\n\n        if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {\n\n            _.$slider.addClass('slick-dotted');\n\n            dot = $('<ul />').addClass(_.options.dotsClass);\n\n            for (i = 0; i <= _.getDotCount(); i += 1) {\n                dot.append($('<li />').append(_.options.customPaging.call(this, _, i)));\n            }\n\n            _.$dots = dot.appendTo(_.options.appendDots);\n\n            _.$dots.find('li').first().addClass('slick-active').attr('aria-hidden', 'false');\n\n        }\n\n    };\n\n    Slick.prototype.buildOut = function() {\n\n        var _ = this;\n\n        _.$slides =\n            _.$slider\n                .children( _.options.slide + ':not(.slick-cloned)')\n                .addClass('slick-slide');\n\n        _.slideCount = _.$slides.length;\n\n        _.$slides.each(function(index, element) {\n            $(element)\n                .attr('data-slick-index', index)\n                .data('originalStyling', $(element).attr('style') || '');\n        });\n\n        _.$slider.addClass('slick-slider');\n\n        _.$slideTrack = (_.slideCount === 0) ?\n            $('<div class=\"slick-track\"/>').appendTo(_.$slider) :\n            _.$slides.wrapAll('<div class=\"slick-track\"/>').parent();\n\n        _.$list = _.$slideTrack.wrap(\n            '<div aria-live=\"polite\" class=\"slick-list\"/>').parent();\n        _.$slideTrack.css('opacity', 0);\n\n        if (_.options.centerMode === true || _.options.swipeToSlide === true) {\n            _.options.slidesToScroll = 1;\n        }\n\n        $('img[data-lazy]', _.$slider).not('[src]').addClass('slick-loading');\n\n        _.setupInfinite();\n\n        _.buildArrows();\n\n        _.buildDots();\n\n        _.updateDots();\n\n\n        _.setSlideClasses(typeof _.currentSlide === 'number' ? _.currentSlide : 0);\n\n        if (_.options.draggable === true) {\n            _.$list.addClass('draggable');\n        }\n\n    };\n\n    Slick.prototype.buildRows = function() {\n\n        var _ = this, a, b, c, newSlides, numOfSlides, originalSlides,slidesPerSection;\n\n        newSlides = document.createDocumentFragment();\n        originalSlides = _.$slider.children();\n\n        if(_.options.rows > 1) {\n\n            slidesPerSection = _.options.slidesPerRow * _.options.rows;\n            numOfSlides = Math.ceil(\n                originalSlides.length / slidesPerSection\n            );\n\n            for(a = 0; a < numOfSlides; a++){\n                var slide = document.createElement('div');\n                for(b = 0; b < _.options.rows; b++) {\n                    var row = document.createElement('div');\n                    for(c = 0; c < _.options.slidesPerRow; c++) {\n                        var target = (a * slidesPerSection + ((b * _.options.slidesPerRow) + c));\n                        if (originalSlides.get(target)) {\n                            row.appendChild(originalSlides.get(target));\n                        }\n                    }\n                    slide.appendChild(row);\n                }\n                newSlides.appendChild(slide);\n            }\n\n            _.$slider.empty().append(newSlides);\n            _.$slider.children().children().children()\n                .css({\n                    'width':(100 / _.options.slidesPerRow) + '%',\n                    'display': 'inline-block'\n                });\n\n        }\n\n    };\n\n    Slick.prototype.checkResponsive = function(initial, forceUpdate) {\n\n        var _ = this,\n            breakpoint, targetBreakpoint, respondToWidth, triggerBreakpoint = false;\n        var sliderWidth = _.$slider.width();\n        var windowWidth = window.innerWidth || $(window).width();\n\n        if (_.respondTo === 'window') {\n            respondToWidth = windowWidth;\n        } else if (_.respondTo === 'slider') {\n            respondToWidth = sliderWidth;\n        } else if (_.respondTo === 'min') {\n            respondToWidth = Math.min(windowWidth, sliderWidth);\n        }\n\n        if ( _.options.responsive &&\n            _.options.responsive.length &&\n            _.options.responsive !== null) {\n\n            targetBreakpoint = null;\n\n            for (breakpoint in _.breakpoints) {\n                if (_.breakpoints.hasOwnProperty(breakpoint)) {\n                    if (_.originalSettings.mobileFirst === false) {\n                        if (respondToWidth < _.breakpoints[breakpoint]) {\n                            targetBreakpoint = _.breakpoints[breakpoint];\n                        }\n                    } else {\n                        if (respondToWidth > _.breakpoints[breakpoint]) {\n                            targetBreakpoint = _.breakpoints[breakpoint];\n                        }\n                    }\n                }\n            }\n\n            if (targetBreakpoint !== null) {\n                if (_.activeBreakpoint !== null) {\n                    if (targetBreakpoint !== _.activeBreakpoint || forceUpdate) {\n                        _.activeBreakpoint =\n                            targetBreakpoint;\n                        if (_.breakpointSettings[targetBreakpoint] === 'unslick') {\n                            _.unslick(targetBreakpoint);\n                        } else {\n                            _.options = $.extend({}, _.originalSettings,\n                                _.breakpointSettings[\n                                    targetBreakpoint]);\n                            if (initial === true) {\n                                _.currentSlide = _.options.initialSlide;\n                            }\n                            _.refresh(initial);\n                        }\n                        triggerBreakpoint = targetBreakpoint;\n                    }\n                } else {\n                    _.activeBreakpoint = targetBreakpoint;\n                    if (_.breakpointSettings[targetBreakpoint] === 'unslick') {\n                        _.unslick(targetBreakpoint);\n                    } else {\n                        _.options = $.extend({}, _.originalSettings,\n                            _.breakpointSettings[\n                                targetBreakpoint]);\n                        if (initial === true) {\n                            _.currentSlide = _.options.initialSlide;\n                        }\n                        _.refresh(initial);\n                    }\n                    triggerBreakpoint = targetBreakpoint;\n                }\n            } else {\n                if (_.activeBreakpoint !== null) {\n                    _.activeBreakpoint = null;\n                    _.options = _.originalSettings;\n                    if (initial === true) {\n                        _.currentSlide = _.options.initialSlide;\n                    }\n                    _.refresh(initial);\n                    triggerBreakpoint = targetBreakpoint;\n                }\n            }\n\n            // only trigger breakpoints during an actual break. not on initialize.\n            if( !initial && triggerBreakpoint !== false ) {\n                _.$slider.trigger('breakpoint', [_, triggerBreakpoint]);\n            }\n        }\n\n    };\n\n    Slick.prototype.changeSlide = function(event, dontAnimate) {\n\n        var _ = this,\n            $target = $(event.currentTarget),\n            indexOffset, slideOffset, unevenOffset;\n\n        // If target is a link, prevent default action.\n        if($target.is('a')) {\n            event.preventDefault();\n        }\n\n        // If target is not the <li> element (ie: a child), find the <li>.\n        if(!$target.is('li')) {\n            $target = $target.closest('li');\n        }\n\n        unevenOffset = (_.slideCount % _.options.slidesToScroll !== 0);\n        indexOffset = unevenOffset ? 0 : (_.slideCount - _.currentSlide) % _.options.slidesToScroll;\n\n        switch (event.data.message) {\n\n            case 'previous':\n                slideOffset = indexOffset === 0 ? _.options.slidesToScroll : _.options.slidesToShow - indexOffset;\n                if (_.slideCount > _.options.slidesToShow) {\n                    _.slideHandler(_.currentSlide - slideOffset, false, dontAnimate);\n                }\n                break;\n\n            case 'next':\n                slideOffset = indexOffset === 0 ? _.options.slidesToScroll : indexOffset;\n                if (_.slideCount > _.options.slidesToShow) {\n                    _.slideHandler(_.currentSlide + slideOffset, false, dontAnimate);\n                }\n                break;\n\n            case 'index':\n                var index = event.data.index === 0 ? 0 :\n                    event.data.index || $target.index() * _.options.slidesToScroll;\n\n                _.slideHandler(_.checkNavigable(index), false, dontAnimate);\n                $target.children().trigger('focus');\n                break;\n\n            default:\n                return;\n        }\n\n    };\n\n    Slick.prototype.checkNavigable = function(index) {\n\n        var _ = this,\n            navigables, prevNavigable;\n\n        navigables = _.getNavigableIndexes();\n        prevNavigable = 0;\n        if (index > navigables[navigables.length - 1]) {\n            index = navigables[navigables.length - 1];\n        } else {\n            for (var n in navigables) {\n                if (index < navigables[n]) {\n                    index = prevNavigable;\n                    break;\n                }\n                prevNavigable = navigables[n];\n            }\n        }\n\n        return index;\n    };\n\n    Slick.prototype.cleanUpEvents = function() {\n\n        var _ = this;\n\n        if (_.options.dots && _.$dots !== null) {\n\n            $('li', _.$dots)\n                .off('click.slick', _.changeSlide)\n                .off('mouseenter.slick', $.proxy(_.interrupt, _, true))\n                .off('mouseleave.slick', $.proxy(_.interrupt, _, false));\n\n        }\n\n        _.$slider.off('focus.slick blur.slick');\n\n        if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {\n            _.$prevArrow && _.$prevArrow.off('click.slick', _.changeSlide);\n            _.$nextArrow && _.$nextArrow.off('click.slick', _.changeSlide);\n        }\n\n        _.$list.off('touchstart.slick mousedown.slick', _.swipeHandler);\n        _.$list.off('touchmove.slick mousemove.slick', _.swipeHandler);\n        _.$list.off('touchend.slick mouseup.slick', _.swipeHandler);\n        _.$list.off('touchcancel.slick mouseleave.slick', _.swipeHandler);\n\n        _.$list.off('click.slick', _.clickHandler);\n\n        $(document).off(_.visibilityChange, _.visibility);\n\n        _.cleanUpSlideEvents();\n\n        if (_.options.accessibility === true) {\n            _.$list.off('keydown.slick', _.keyHandler);\n        }\n\n        if (_.options.focusOnSelect === true) {\n            $(_.$slideTrack).children().off('click.slick', _.selectHandler);\n        }\n\n        $(window).off('orientationchange.slick.slick-' + _.instanceUid, _.orientationChange);\n\n        $(window).off('resize.slick.slick-' + _.instanceUid, _.resize);\n\n        $('[draggable!=true]', _.$slideTrack).off('dragstart', _.preventDefault);\n\n        $(window).off('load.slick.slick-' + _.instanceUid, _.setPosition);\n        $(document).off('ready.slick.slick-' + _.instanceUid, _.setPosition);\n\n    };\n\n    Slick.prototype.cleanUpSlideEvents = function() {\n\n        var _ = this;\n\n        _.$list.off('mouseenter.slick', $.proxy(_.interrupt, _, true));\n        _.$list.off('mouseleave.slick', $.proxy(_.interrupt, _, false));\n\n    };\n\n    Slick.prototype.cleanUpRows = function() {\n\n        var _ = this, originalSlides;\n\n        if(_.options.rows > 1) {\n            originalSlides = _.$slides.children().children();\n            originalSlides.removeAttr('style');\n            _.$slider.empty().append(originalSlides);\n        }\n\n    };\n\n    Slick.prototype.clickHandler = function(event) {\n\n        var _ = this;\n\n        if (_.shouldClick === false) {\n            event.stopImmediatePropagation();\n            event.stopPropagation();\n            event.preventDefault();\n        }\n\n    };\n\n    Slick.prototype.destroy = function(refresh) {\n\n        var _ = this;\n\n        _.autoPlayClear();\n\n        _.touchObject = {};\n\n        _.cleanUpEvents();\n\n        $('.slick-cloned', _.$slider).detach();\n\n        if (_.$dots) {\n            _.$dots.remove();\n        }\n\n\n        if ( _.$prevArrow && _.$prevArrow.length ) {\n\n            _.$prevArrow\n                .removeClass('slick-disabled slick-arrow slick-hidden')\n                .removeAttr('aria-hidden aria-disabled tabindex')\n                .css('display','');\n\n            if ( _.htmlExpr.test( _.options.prevArrow )) {\n                _.$prevArrow.remove();\n            }\n        }\n\n        if ( _.$nextArrow && _.$nextArrow.length ) {\n\n            _.$nextArrow\n                .removeClass('slick-disabled slick-arrow slick-hidden')\n                .removeAttr('aria-hidden aria-disabled tabindex')\n                .css('display','');\n\n            if ( _.htmlExpr.test( _.options.nextArrow )) {\n                _.$nextArrow.remove();\n            }\n\n        }\n\n\n        if (_.$slides) {\n\n            _.$slides\n                .removeClass('slick-slide slick-active slick-center slick-visible slick-current')\n                .removeAttr('aria-hidden')\n                .removeAttr('data-slick-index')\n                .each(function(){\n                    $(this).attr('style', $(this).data('originalStyling'));\n                });\n\n            _.$slideTrack.children(this.options.slide).detach();\n\n            _.$slideTrack.detach();\n\n            _.$list.detach();\n\n            _.$slider.append(_.$slides);\n        }\n\n        _.cleanUpRows();\n\n        _.$slider.removeClass('slick-slider');\n        _.$slider.removeClass('slick-initialized');\n        _.$slider.removeClass('slick-dotted');\n\n        _.unslicked = true;\n\n        if(!refresh) {\n            _.$slider.trigger('destroy', [_]);\n        }\n\n    };\n\n    Slick.prototype.disableTransition = function(slide) {\n\n        var _ = this,\n            transition = {};\n\n        transition[_.transitionType] = '';\n\n        if (_.options.fade === false) {\n            _.$slideTrack.css(transition);\n        } else {\n            _.$slides.eq(slide).css(transition);\n        }\n\n    };\n\n    Slick.prototype.fadeSlide = function(slideIndex, callback) {\n\n        var _ = this;\n\n        if (_.cssTransitions === false) {\n\n            _.$slides.eq(slideIndex).css({\n                zIndex: _.options.zIndex\n            });\n\n            _.$slides.eq(slideIndex).animate({\n                opacity: 1\n            }, _.options.speed, _.options.easing, callback);\n\n        } else {\n\n            _.applyTransition(slideIndex);\n\n            _.$slides.eq(slideIndex).css({\n                opacity: 1,\n                zIndex: _.options.zIndex\n            });\n\n            if (callback) {\n                setTimeout(function() {\n\n                    _.disableTransition(slideIndex);\n\n                    callback.call();\n                }, _.options.speed);\n            }\n\n        }\n\n    };\n\n    Slick.prototype.fadeSlideOut = function(slideIndex) {\n\n        var _ = this;\n\n        if (_.cssTransitions === false) {\n\n            _.$slides.eq(slideIndex).animate({\n                opacity: 0,\n                zIndex: _.options.zIndex - 2\n            }, _.options.speed, _.options.easing);\n\n        } else {\n\n            _.applyTransition(slideIndex);\n\n            _.$slides.eq(slideIndex).css({\n                opacity: 0,\n                zIndex: _.options.zIndex - 2\n            });\n\n        }\n\n    };\n\n    Slick.prototype.filterSlides = Slick.prototype.slickFilter = function(filter) {\n\n        var _ = this;\n\n        if (filter !== null) {\n\n            _.$slidesCache = _.$slides;\n\n            _.unload();\n\n            _.$slideTrack.children(this.options.slide).detach();\n\n            _.$slidesCache.filter(filter).appendTo(_.$slideTrack);\n\n            _.reinit();\n\n        }\n\n    };\n\n    Slick.prototype.focusHandler = function() {\n\n        var _ = this;\n\n        _.$slider\n            .off('focus.slick blur.slick')\n            .on('focus.slick blur.slick',\n                '*:not(.slick-arrow)', function(event) {\n\n            event.stopImmediatePropagation();\n            var $sf = $(this);\n\n            setTimeout(function() {\n\n                if( _.options.pauseOnFocus ) {\n                    _.focussed = $sf.is(':focus');\n                    _.autoPlay();\n                }\n\n            }, 0);\n\n        });\n    };\n\n    Slick.prototype.getCurrent = Slick.prototype.slickCurrentSlide = function() {\n\n        var _ = this;\n        return _.currentSlide;\n\n    };\n\n    Slick.prototype.getDotCount = function() {\n\n        var _ = this;\n\n        var breakPoint = 0;\n        var counter = 0;\n        var pagerQty = 0;\n\n        if (_.options.infinite === true) {\n            while (breakPoint < _.slideCount) {\n                ++pagerQty;\n                breakPoint = counter + _.options.slidesToScroll;\n                counter += _.options.slidesToScroll <= _.options.slidesToShow ? _.options.slidesToScroll : _.options.slidesToShow;\n            }\n        } else if (_.options.centerMode === true) {\n            pagerQty = _.slideCount;\n        } else if(!_.options.asNavFor) {\n            pagerQty = 1 + Math.ceil((_.slideCount - _.options.slidesToShow) / _.options.slidesToScroll);\n        }else {\n            while (breakPoint < _.slideCount) {\n                ++pagerQty;\n                breakPoint = counter + _.options.slidesToScroll;\n                counter += _.options.slidesToScroll <= _.options.slidesToShow ? _.options.slidesToScroll : _.options.slidesToShow;\n            }\n        }\n\n        return pagerQty - 1;\n\n    };\n\n    Slick.prototype.getLeft = function(slideIndex) {\n\n        var _ = this,\n            targetLeft,\n            verticalHeight,\n            verticalOffset = 0,\n            targetSlide;\n\n        _.slideOffset = 0;\n        verticalHeight = _.$slides.first().outerHeight(true);\n\n        if (_.options.infinite === true) {\n            if (_.slideCount > _.options.slidesToShow) {\n                _.slideOffset = (_.slideWidth * _.options.slidesToShow) * -1;\n                verticalOffset = (verticalHeight * _.options.slidesToShow) * -1;\n            }\n            if (_.slideCount % _.options.slidesToScroll !== 0) {\n                if (slideIndex + _.options.slidesToScroll > _.slideCount && _.slideCount > _.options.slidesToShow) {\n                    if (slideIndex > _.slideCount) {\n                        _.slideOffset = ((_.options.slidesToShow - (slideIndex - _.slideCount)) * _.slideWidth) * -1;\n                        verticalOffset = ((_.options.slidesToShow - (slideIndex - _.slideCount)) * verticalHeight) * -1;\n                    } else {\n                        _.slideOffset = ((_.slideCount % _.options.slidesToScroll) * _.slideWidth) * -1;\n                        verticalOffset = ((_.slideCount % _.options.slidesToScroll) * verticalHeight) * -1;\n                    }\n                }\n            }\n        } else {\n            if (slideIndex + _.options.slidesToShow > _.slideCount) {\n                _.slideOffset = ((slideIndex + _.options.slidesToShow) - _.slideCount) * _.slideWidth;\n                verticalOffset = ((slideIndex + _.options.slidesToShow) - _.slideCount) * verticalHeight;\n            }\n        }\n\n        if (_.slideCount <= _.options.slidesToShow) {\n            _.slideOffset = 0;\n            verticalOffset = 0;\n        }\n\n        if (_.options.centerMode === true && _.options.infinite === true) {\n            _.slideOffset += _.slideWidth * Math.floor(_.options.slidesToShow / 2) - _.slideWidth;\n        } else if (_.options.centerMode === true) {\n            _.slideOffset = 0;\n            _.slideOffset += _.slideWidth * Math.floor(_.options.slidesToShow / 2);\n        }\n\n        if (_.options.vertical === false) {\n            targetLeft = ((slideIndex * _.slideWidth) * -1) + _.slideOffset;\n        } else {\n            targetLeft = ((slideIndex * verticalHeight) * -1) + verticalOffset;\n        }\n\n        if (_.options.variableWidth === true) {\n\n            if (_.slideCount <= _.options.slidesToShow || _.options.infinite === false) {\n                targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex);\n            } else {\n                targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex + _.options.slidesToShow);\n            }\n\n            if (_.options.rtl === true) {\n                if (targetSlide[0]) {\n                    targetLeft = (_.$slideTrack.width() - targetSlide[0].offsetLeft - targetSlide.width()) * -1;\n                } else {\n                    targetLeft =  0;\n                }\n            } else {\n                targetLeft = targetSlide[0] ? targetSlide[0].offsetLeft * -1 : 0;\n            }\n\n            if (_.options.centerMode === true) {\n                if (_.slideCount <= _.options.slidesToShow || _.options.infinite === false) {\n                    targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex);\n                } else {\n                    targetSlide = _.$slideTrack.children('.slick-slide').eq(slideIndex + _.options.slidesToShow + 1);\n                }\n\n                if (_.options.rtl === true) {\n                    if (targetSlide[0]) {\n                        targetLeft = (_.$slideTrack.width() - targetSlide[0].offsetLeft - targetSlide.width()) * -1;\n                    } else {\n                        targetLeft =  0;\n                    }\n                } else {\n                    targetLeft = targetSlide[0] ? targetSlide[0].offsetLeft * -1 : 0;\n                }\n\n                targetLeft += (_.$list.width() - targetSlide.outerWidth()) / 2;\n            }\n        }\n\n        return targetLeft;\n\n    };\n\n    Slick.prototype.getOption = Slick.prototype.slickGetOption = function(option) {\n\n        var _ = this;\n\n        return _.options[option];\n\n    };\n\n    Slick.prototype.getNavigableIndexes = function() {\n\n        var _ = this,\n            breakPoint = 0,\n            counter = 0,\n            indexes = [],\n            max;\n\n        if (_.options.infinite === false) {\n            max = _.slideCount;\n        } else {\n            breakPoint = _.options.slidesToScroll * -1;\n            counter = _.options.slidesToScroll * -1;\n            max = _.slideCount * 2;\n        }\n\n        while (breakPoint < max) {\n            indexes.push(breakPoint);\n            breakPoint = counter + _.options.slidesToScroll;\n            counter += _.options.slidesToScroll <= _.options.slidesToShow ? _.options.slidesToScroll : _.options.slidesToShow;\n        }\n\n        return indexes;\n\n    };\n\n    Slick.prototype.getSlick = function() {\n\n        return this;\n\n    };\n\n    Slick.prototype.getSlideCount = function() {\n\n        var _ = this,\n            slidesTraversed, swipedSlide, centerOffset;\n\n        centerOffset = _.options.centerMode === true ? _.slideWidth * Math.floor(_.options.slidesToShow / 2) : 0;\n\n        if (_.options.swipeToSlide === true) {\n            _.$slideTrack.find('.slick-slide').each(function(index, slide) {\n                if (slide.offsetLeft - centerOffset + ($(slide).outerWidth() / 2) > (_.swipeLeft * -1)) {\n                    swipedSlide = slide;\n                    return false;\n                }\n            });\n\n            slidesTraversed = Math.abs($(swipedSlide).attr('data-slick-index') - _.currentSlide) || 1;\n\n            return slidesTraversed;\n\n        } else {\n            return _.options.slidesToScroll;\n        }\n\n    };\n\n    Slick.prototype.goTo = Slick.prototype.slickGoTo = function(slide, dontAnimate) {\n\n        var _ = this;\n\n        _.changeSlide({\n            data: {\n                message: 'index',\n                index: parseInt(slide)\n            }\n        }, dontAnimate);\n\n    };\n\n    Slick.prototype.init = function(creation) {\n\n        var _ = this;\n\n        if (!$(_.$slider).hasClass('slick-initialized')) {\n\n            $(_.$slider).addClass('slick-initialized');\n\n            _.buildRows();\n            _.buildOut();\n            _.setProps();\n            _.startLoad();\n            _.loadSlider();\n            _.initializeEvents();\n            _.updateArrows();\n            _.updateDots();\n            _.checkResponsive(true);\n            _.focusHandler();\n\n        }\n\n        if (creation) {\n            _.$slider.trigger('init', [_]);\n        }\n\n        if (_.options.accessibility === true) {\n            _.initADA();\n        }\n\n        if ( _.options.autoplay ) {\n\n            _.paused = false;\n            _.autoPlay();\n\n        }\n\n    };\n\n    Slick.prototype.initADA = function() {\n        var _ = this;\n        _.$slides.add(_.$slideTrack.find('.slick-cloned')).attr({\n            'aria-hidden': 'true',\n            'tabindex': '-1'\n        }).find('a, input, button, select').attr({\n            'tabindex': '-1'\n        });\n\n        _.$slideTrack.attr('role', 'listbox');\n\n        _.$slides.not(_.$slideTrack.find('.slick-cloned')).each(function(i) {\n            $(this).attr({\n                'role': 'option',\n                'aria-describedby': 'slick-slide' + _.instanceUid + i + ''\n            });\n        });\n\n        if (_.$dots !== null) {\n            _.$dots.attr('role', 'tablist').find('li').each(function(i) {\n                $(this).attr({\n                    'role': 'presentation',\n                    'aria-selected': 'false',\n                    'aria-controls': 'navigation' + _.instanceUid + i + '',\n                    'id': 'slick-slide' + _.instanceUid + i + ''\n                });\n            })\n                .first().attr('aria-selected', 'true').end()\n                .find('button').attr('role', 'button').end()\n                .closest('div').attr('role', 'toolbar');\n        }\n        _.activateADA();\n\n    };\n\n    Slick.prototype.initArrowEvents = function() {\n\n        var _ = this;\n\n        if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {\n            _.$prevArrow\n               .off('click.slick')\n               .on('click.slick', {\n                    message: 'previous'\n               }, _.changeSlide);\n            _.$nextArrow\n               .off('click.slick')\n               .on('click.slick', {\n                    message: 'next'\n               }, _.changeSlide);\n        }\n\n    };\n\n    Slick.prototype.initDotEvents = function() {\n\n        var _ = this;\n\n        if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {\n            $('li', _.$dots).on('click.slick', {\n                message: 'index'\n            }, _.changeSlide);\n        }\n\n        if ( _.options.dots === true && _.options.pauseOnDotsHover === true ) {\n\n            $('li', _.$dots)\n                .on('mouseenter.slick', $.proxy(_.interrupt, _, true))\n                .on('mouseleave.slick', $.proxy(_.interrupt, _, false));\n\n        }\n\n    };\n\n    Slick.prototype.initSlideEvents = function() {\n\n        var _ = this;\n\n        if ( _.options.pauseOnHover ) {\n\n            _.$list.on('mouseenter.slick', $.proxy(_.interrupt, _, true));\n            _.$list.on('mouseleave.slick', $.proxy(_.interrupt, _, false));\n\n        }\n\n    };\n\n    Slick.prototype.initializeEvents = function() {\n\n        var _ = this;\n\n        _.initArrowEvents();\n\n        _.initDotEvents();\n        _.initSlideEvents();\n\n        _.$list.on('touchstart.slick mousedown.slick', {\n            action: 'start'\n        }, _.swipeHandler);\n        _.$list.on('touchmove.slick mousemove.slick', {\n            action: 'move'\n        }, _.swipeHandler);\n        _.$list.on('touchend.slick mouseup.slick', {\n            action: 'end'\n        }, _.swipeHandler);\n        _.$list.on('touchcancel.slick mouseleave.slick', {\n            action: 'end'\n        }, _.swipeHandler);\n\n        _.$list.on('click.slick', _.clickHandler);\n\n        $(document).on(_.visibilityChange, $.proxy(_.visibility, _));\n\n        if (_.options.accessibility === true) {\n            _.$list.on('keydown.slick', _.keyHandler);\n        }\n\n        if (_.options.focusOnSelect === true) {\n            $(_.$slideTrack).children().on('click.slick', _.selectHandler);\n        }\n\n        $(window).on('orientationchange.slick.slick-' + _.instanceUid, $.proxy(_.orientationChange, _));\n\n        $(window).on('resize.slick.slick-' + _.instanceUid, $.proxy(_.resize, _));\n\n        $('[draggable!=true]', _.$slideTrack).on('dragstart', _.preventDefault);\n\n        $(window).on('load.slick.slick-' + _.instanceUid, _.setPosition);\n        $(document).on('ready.slick.slick-' + _.instanceUid, _.setPosition);\n\n    };\n\n    Slick.prototype.initUI = function() {\n\n        var _ = this;\n\n        if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {\n\n            _.$prevArrow.show();\n            _.$nextArrow.show();\n\n        }\n\n        if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {\n\n            _.$dots.show();\n\n        }\n\n    };\n\n    Slick.prototype.keyHandler = function(event) {\n\n        var _ = this;\n         //Dont slide if the cursor is inside the form fields and arrow keys are pressed\n        if(!event.target.tagName.match('TEXTAREA|INPUT|SELECT')) {\n            if (event.keyCode === 37 && _.options.accessibility === true) {\n                _.changeSlide({\n                    data: {\n                        message: _.options.rtl === true ? 'next' :  'previous'\n                    }\n                });\n            } else if (event.keyCode === 39 && _.options.accessibility === true) {\n                _.changeSlide({\n                    data: {\n                        message: _.options.rtl === true ? 'previous' : 'next'\n                    }\n                });\n            }\n        }\n\n    };\n\n    Slick.prototype.lazyLoad = function() {\n\n        var _ = this,\n            loadRange, cloneRange, rangeStart, rangeEnd;\n\n        function loadImages(imagesScope) {\n\n            $('img[data-lazy]', imagesScope).each(function() {\n\n                var image = $(this),\n                    imageSource = $(this).attr('data-lazy'),\n                    imageToLoad = document.createElement('img');\n\n                imageToLoad.onload = function() {\n\n                    image\n                        .animate({ opacity: 0 }, 100, function() {\n                            image\n                                .attr('src', imageSource)\n                                .animate({ opacity: 1 }, 200, function() {\n                                    image\n                                        .removeAttr('data-lazy')\n                                        .removeClass('slick-loading');\n                                });\n                            _.$slider.trigger('lazyLoaded', [_, image, imageSource]);\n                        });\n\n                };\n\n                imageToLoad.onerror = function() {\n\n                    image\n                        .removeAttr( 'data-lazy' )\n                        .removeClass( 'slick-loading' )\n                        .addClass( 'slick-lazyload-error' );\n\n                    _.$slider.trigger('lazyLoadError', [ _, image, imageSource ]);\n\n                };\n\n                imageToLoad.src = imageSource;\n\n            });\n\n        }\n\n        if (_.options.centerMode === true) {\n            if (_.options.infinite === true) {\n                rangeStart = _.currentSlide + (_.options.slidesToShow / 2 + 1);\n                rangeEnd = rangeStart + _.options.slidesToShow + 2;\n            } else {\n                rangeStart = Math.max(0, _.currentSlide - (_.options.slidesToShow / 2 + 1));\n                rangeEnd = 2 + (_.options.slidesToShow / 2 + 1) + _.currentSlide;\n            }\n        } else {\n            rangeStart = _.options.infinite ? _.options.slidesToShow + _.currentSlide : _.currentSlide;\n            rangeEnd = Math.ceil(rangeStart + _.options.slidesToShow);\n            if (_.options.fade === true) {\n                if (rangeStart > 0) rangeStart--;\n                if (rangeEnd <= _.slideCount) rangeEnd++;\n            }\n        }\n\n        loadRange = _.$slider.find('.slick-slide').slice(rangeStart, rangeEnd);\n        loadImages(loadRange);\n\n        if (_.slideCount <= _.options.slidesToShow) {\n            cloneRange = _.$slider.find('.slick-slide');\n            loadImages(cloneRange);\n        } else\n        if (_.currentSlide >= _.slideCount - _.options.slidesToShow) {\n            cloneRange = _.$slider.find('.slick-cloned').slice(0, _.options.slidesToShow);\n            loadImages(cloneRange);\n        } else if (_.currentSlide === 0) {\n            cloneRange = _.$slider.find('.slick-cloned').slice(_.options.slidesToShow * -1);\n            loadImages(cloneRange);\n        }\n\n    };\n\n    Slick.prototype.loadSlider = function() {\n\n        var _ = this;\n\n        _.setPosition();\n\n        _.$slideTrack.css({\n            opacity: 1\n        });\n\n        _.$slider.removeClass('slick-loading');\n\n        _.initUI();\n\n        if (_.options.lazyLoad === 'progressive') {\n            _.progressiveLazyLoad();\n        }\n\n    };\n\n    Slick.prototype.next = Slick.prototype.slickNext = function() {\n\n        var _ = this;\n\n        _.changeSlide({\n            data: {\n                message: 'next'\n            }\n        });\n\n    };\n\n    Slick.prototype.orientationChange = function() {\n\n        var _ = this;\n\n        _.checkResponsive();\n        _.setPosition();\n\n    };\n\n    Slick.prototype.pause = Slick.prototype.slickPause = function() {\n\n        var _ = this;\n\n        _.autoPlayClear();\n        _.paused = true;\n\n    };\n\n    Slick.prototype.play = Slick.prototype.slickPlay = function() {\n\n        var _ = this;\n\n        _.autoPlay();\n        _.options.autoplay = true;\n        _.paused = false;\n        _.focussed = false;\n        _.interrupted = false;\n\n    };\n\n    Slick.prototype.postSlide = function(index) {\n\n        var _ = this;\n\n        if( !_.unslicked ) {\n\n            _.$slider.trigger('afterChange', [_, index]);\n\n            _.animating = false;\n\n            _.setPosition();\n\n            _.swipeLeft = null;\n\n            if ( _.options.autoplay ) {\n                _.autoPlay();\n            }\n\n            if (_.options.accessibility === true) {\n                _.initADA();\n            }\n\n        }\n\n    };\n\n    Slick.prototype.prev = Slick.prototype.slickPrev = function() {\n\n        var _ = this;\n\n        _.changeSlide({\n            data: {\n                message: 'previous'\n            }\n        });\n\n    };\n\n    Slick.prototype.preventDefault = function(event) {\n\n        event.preventDefault();\n\n    };\n\n    Slick.prototype.progressiveLazyLoad = function( tryCount ) {\n\n        tryCount = tryCount || 1;\n\n        var _ = this,\n            $imgsToLoad = $( 'img[data-lazy]', _.$slider ),\n            image,\n            imageSource,\n            imageToLoad;\n\n        if ( $imgsToLoad.length ) {\n\n            image = $imgsToLoad.first();\n            imageSource = image.attr('data-lazy');\n            imageToLoad = document.createElement('img');\n\n            imageToLoad.onload = function() {\n\n                image\n                    .attr( 'src', imageSource )\n                    .removeAttr('data-lazy')\n                    .removeClass('slick-loading');\n\n                if ( _.options.adaptiveHeight === true ) {\n                    _.setPosition();\n                }\n\n                _.$slider.trigger('lazyLoaded', [ _, image, imageSource ]);\n                _.progressiveLazyLoad();\n\n            };\n\n            imageToLoad.onerror = function() {\n\n                if ( tryCount < 3 ) {\n\n                    /**\n                     * try to load the image 3 times,\n                     * leave a slight delay so we don't get\n                     * servers blocking the request.\n                     */\n                    setTimeout( function() {\n                        _.progressiveLazyLoad( tryCount + 1 );\n                    }, 500 );\n\n                } else {\n\n                    image\n                        .removeAttr( 'data-lazy' )\n                        .removeClass( 'slick-loading' )\n                        .addClass( 'slick-lazyload-error' );\n\n                    _.$slider.trigger('lazyLoadError', [ _, image, imageSource ]);\n\n                    _.progressiveLazyLoad();\n\n                }\n\n            };\n\n            imageToLoad.src = imageSource;\n\n        } else {\n\n            _.$slider.trigger('allImagesLoaded', [ _ ]);\n\n        }\n\n    };\n\n    Slick.prototype.refresh = function( initializing ) {\n\n        var _ = this, currentSlide, lastVisibleIndex;\n\n        lastVisibleIndex = _.slideCount - _.options.slidesToShow;\n\n        // in non-infinite sliders, we don't want to go past the\n        // last visible index.\n        if( !_.options.infinite && ( _.currentSlide > lastVisibleIndex )) {\n            _.currentSlide = lastVisibleIndex;\n        }\n\n        // if less slides than to show, go to start.\n        if ( _.slideCount <= _.options.slidesToShow ) {\n            _.currentSlide = 0;\n\n        }\n\n        currentSlide = _.currentSlide;\n\n        _.destroy(true);\n\n        $.extend(_, _.initials, { currentSlide: currentSlide });\n\n        _.init();\n\n        if( !initializing ) {\n\n            _.changeSlide({\n                data: {\n                    message: 'index',\n                    index: currentSlide\n                }\n            }, false);\n\n        }\n\n    };\n\n    Slick.prototype.registerBreakpoints = function() {\n\n        var _ = this, breakpoint, currentBreakpoint, l,\n            responsiveSettings = _.options.responsive || null;\n\n        if ( $.type(responsiveSettings) === 'array' && responsiveSettings.length ) {\n\n            _.respondTo = _.options.respondTo || 'window';\n\n            for ( breakpoint in responsiveSettings ) {\n\n                l = _.breakpoints.length-1;\n                currentBreakpoint = responsiveSettings[breakpoint].breakpoint;\n\n                if (responsiveSettings.hasOwnProperty(breakpoint)) {\n\n                    // loop through the breakpoints and cut out any existing\n                    // ones with the same breakpoint number, we don't want dupes.\n                    while( l >= 0 ) {\n                        if( _.breakpoints[l] && _.breakpoints[l] === currentBreakpoint ) {\n                            _.breakpoints.splice(l,1);\n                        }\n                        l--;\n                    }\n\n                    _.breakpoints.push(currentBreakpoint);\n                    _.breakpointSettings[currentBreakpoint] = responsiveSettings[breakpoint].settings;\n\n                }\n\n            }\n\n            _.breakpoints.sort(function(a, b) {\n                return ( _.options.mobileFirst ) ? a-b : b-a;\n            });\n\n        }\n\n    };\n\n    Slick.prototype.reinit = function() {\n\n        var _ = this;\n\n        _.$slides =\n            _.$slideTrack\n                .children(_.options.slide)\n                .addClass('slick-slide');\n\n        _.slideCount = _.$slides.length;\n\n        if (_.currentSlide >= _.slideCount && _.currentSlide !== 0) {\n            _.currentSlide = _.currentSlide - _.options.slidesToScroll;\n        }\n\n        if (_.slideCount <= _.options.slidesToShow) {\n            _.currentSlide = 0;\n        }\n\n        _.registerBreakpoints();\n\n        _.setProps();\n        _.setupInfinite();\n        _.buildArrows();\n        _.updateArrows();\n        _.initArrowEvents();\n        _.buildDots();\n        _.updateDots();\n        _.initDotEvents();\n        _.cleanUpSlideEvents();\n        _.initSlideEvents();\n\n        _.checkResponsive(false, true);\n\n        if (_.options.focusOnSelect === true) {\n            $(_.$slideTrack).children().on('click.slick', _.selectHandler);\n        }\n\n        _.setSlideClasses(typeof _.currentSlide === 'number' ? _.currentSlide : 0);\n\n        _.setPosition();\n        _.focusHandler();\n\n        _.paused = !_.options.autoplay;\n        _.autoPlay();\n\n        _.$slider.trigger('reInit', [_]);\n\n    };\n\n    Slick.prototype.resize = function() {\n\n        var _ = this;\n\n        if ($(window).width() !== _.windowWidth) {\n            clearTimeout(_.windowDelay);\n            _.windowDelay = window.setTimeout(function() {\n                _.windowWidth = $(window).width();\n                _.checkResponsive();\n                if( !_.unslicked ) { _.setPosition(); }\n            }, 50);\n        }\n    };\n\n    Slick.prototype.removeSlide = Slick.prototype.slickRemove = function(index, removeBefore, removeAll) {\n\n        var _ = this;\n\n        if (typeof(index) === 'boolean') {\n            removeBefore = index;\n            index = removeBefore === true ? 0 : _.slideCount - 1;\n        } else {\n            index = removeBefore === true ? --index : index;\n        }\n\n        if (_.slideCount < 1 || index < 0 || index > _.slideCount - 1) {\n            return false;\n        }\n\n        _.unload();\n\n        if (removeAll === true) {\n            _.$slideTrack.children().remove();\n        } else {\n            _.$slideTrack.children(this.options.slide).eq(index).remove();\n        }\n\n        _.$slides = _.$slideTrack.children(this.options.slide);\n\n        _.$slideTrack.children(this.options.slide).detach();\n\n        _.$slideTrack.append(_.$slides);\n\n        _.$slidesCache = _.$slides;\n\n        _.reinit();\n\n    };\n\n    Slick.prototype.setCSS = function(position) {\n\n        var _ = this,\n            positionProps = {},\n            x, y;\n\n        if (_.options.rtl === true) {\n            position = -position;\n        }\n        x = _.positionProp == 'left' ? Math.ceil(position) + 'px' : '0px';\n        y = _.positionProp == 'top' ? Math.ceil(position) + 'px' : '0px';\n\n        positionProps[_.positionProp] = position;\n\n        if (_.transformsEnabled === false) {\n            _.$slideTrack.css(positionProps);\n        } else {\n            positionProps = {};\n            if (_.cssTransitions === false) {\n                positionProps[_.animType] = 'translate(' + x + ', ' + y + ')';\n                _.$slideTrack.css(positionProps);\n            } else {\n                positionProps[_.animType] = 'translate3d(' + x + ', ' + y + ', 0px)';\n                _.$slideTrack.css(positionProps);\n            }\n        }\n\n    };\n\n    Slick.prototype.setDimensions = function() {\n\n        var _ = this;\n\n        if (_.options.vertical === false) {\n            if (_.options.centerMode === true) {\n                _.$list.css({\n                    padding: ('0px ' + _.options.centerPadding)\n                });\n            }\n        } else {\n            _.$list.height(_.$slides.first().outerHeight(true) * _.options.slidesToShow);\n            if (_.options.centerMode === true) {\n                _.$list.css({\n                    padding: (_.options.centerPadding + ' 0px')\n                });\n            }\n        }\n\n        _.listWidth = _.$list.width();\n        _.listHeight = _.$list.height();\n\n\n        if (_.options.vertical === false && _.options.variableWidth === false) {\n            _.slideWidth = Math.ceil(_.listWidth / _.options.slidesToShow);\n            _.$slideTrack.width(Math.ceil((_.slideWidth * _.$slideTrack.children('.slick-slide').length)));\n\n        } else if (_.options.variableWidth === true) {\n            _.$slideTrack.width(5000 * _.slideCount);\n        } else {\n            _.slideWidth = Math.ceil(_.listWidth);\n            _.$slideTrack.height(Math.ceil((_.$slides.first().outerHeight(true) * _.$slideTrack.children('.slick-slide').length)));\n        }\n\n        var offset = _.$slides.first().outerWidth(true) - _.$slides.first().width();\n        if (_.options.variableWidth === false) _.$slideTrack.children('.slick-slide').width(_.slideWidth - offset);\n\n    };\n\n    Slick.prototype.setFade = function() {\n\n        var _ = this,\n            targetLeft;\n\n        _.$slides.each(function(index, element) {\n            targetLeft = (_.slideWidth * index) * -1;\n            if (_.options.rtl === true) {\n                $(element).css({\n                    position: 'relative',\n                    right: targetLeft,\n                    top: 0,\n                    zIndex: _.options.zIndex - 2,\n                    opacity: 0\n                });\n            } else {\n                $(element).css({\n                    position: 'relative',\n                    left: targetLeft,\n                    top: 0,\n                    zIndex: _.options.zIndex - 2,\n                    opacity: 0\n                });\n            }\n        });\n\n        _.$slides.eq(_.currentSlide).css({\n            zIndex: _.options.zIndex - 1,\n            opacity: 1\n        });\n\n    };\n\n    Slick.prototype.setHeight = function() {\n\n        var _ = this;\n\n        if (_.options.slidesToShow === 1 && _.options.adaptiveHeight === true && _.options.vertical === false) {\n            var targetHeight = _.$slides.eq(_.currentSlide).outerHeight(true);\n            _.$list.css('height', targetHeight);\n        }\n\n    };\n\n    Slick.prototype.setOption =\n    Slick.prototype.slickSetOption = function() {\n\n        /**\n         * accepts arguments in format of:\n         *\n         *  - for changing a single option's value:\n         *     .slick(\"setOption\", option, value, refresh )\n         *\n         *  - for changing a set of responsive options:\n         *     .slick(\"setOption\", 'responsive', [{}, ...], refresh )\n         *\n         *  - for updating multiple values at once (not responsive)\n         *     .slick(\"setOption\", { 'option': value, ... }, refresh )\n         */\n\n        var _ = this, l, item, option, value, refresh = false, type;\n\n        if( $.type( arguments[0] ) === 'object' ) {\n\n            option =  arguments[0];\n            refresh = arguments[1];\n            type = 'multiple';\n\n        } else if ( $.type( arguments[0] ) === 'string' ) {\n\n            option =  arguments[0];\n            value = arguments[1];\n            refresh = arguments[2];\n\n            if ( arguments[0] === 'responsive' && $.type( arguments[1] ) === 'array' ) {\n\n                type = 'responsive';\n\n            } else if ( typeof arguments[1] !== 'undefined' ) {\n\n                type = 'single';\n\n            }\n\n        }\n\n        if ( type === 'single' ) {\n\n            _.options[option] = value;\n\n\n        } else if ( type === 'multiple' ) {\n\n            $.each( option , function( opt, val ) {\n\n                _.options[opt] = val;\n\n            });\n\n\n        } else if ( type === 'responsive' ) {\n\n            for ( item in value ) {\n\n                if( $.type( _.options.responsive ) !== 'array' ) {\n\n                    _.options.responsive = [ value[item] ];\n\n                } else {\n\n                    l = _.options.responsive.length-1;\n\n                    // loop through the responsive object and splice out duplicates.\n                    while( l >= 0 ) {\n\n                        if( _.options.responsive[l].breakpoint === value[item].breakpoint ) {\n\n                            _.options.responsive.splice(l,1);\n\n                        }\n\n                        l--;\n\n                    }\n\n                    _.options.responsive.push( value[item] );\n\n                }\n\n            }\n\n        }\n\n        if ( refresh ) {\n\n            _.unload();\n            _.reinit();\n\n        }\n\n    };\n\n    Slick.prototype.setPosition = function() {\n\n        var _ = this;\n\n        _.setDimensions();\n\n        _.setHeight();\n\n        if (_.options.fade === false) {\n            _.setCSS(_.getLeft(_.currentSlide));\n        } else {\n            _.setFade();\n        }\n\n        _.$slider.trigger('setPosition', [_]);\n\n    };\n\n    Slick.prototype.setProps = function() {\n\n        var _ = this,\n            bodyStyle = document.body.style;\n\n        _.positionProp = _.options.vertical === true ? 'top' : 'left';\n\n        if (_.positionProp === 'top') {\n            _.$slider.addClass('slick-vertical');\n        } else {\n            _.$slider.removeClass('slick-vertical');\n        }\n\n        if (bodyStyle.WebkitTransition !== undefined ||\n            bodyStyle.MozTransition !== undefined ||\n            bodyStyle.msTransition !== undefined) {\n            if (_.options.useCSS === true) {\n                _.cssTransitions = true;\n            }\n        }\n\n        if ( _.options.fade ) {\n            if ( typeof _.options.zIndex === 'number' ) {\n                if( _.options.zIndex < 3 ) {\n                    _.options.zIndex = 3;\n                }\n            } else {\n                _.options.zIndex = _.defaults.zIndex;\n            }\n        }\n\n        if (bodyStyle.OTransform !== undefined) {\n            _.animType = 'OTransform';\n            _.transformType = '-o-transform';\n            _.transitionType = 'OTransition';\n            if (bodyStyle.perspectiveProperty === undefined && bodyStyle.webkitPerspective === undefined) _.animType = false;\n        }\n        if (bodyStyle.MozTransform !== undefined) {\n            _.animType = 'MozTransform';\n            _.transformType = '-moz-transform';\n            _.transitionType = 'MozTransition';\n            if (bodyStyle.perspectiveProperty === undefined && bodyStyle.MozPerspective === undefined) _.animType = false;\n        }\n        if (bodyStyle.webkitTransform !== undefined) {\n            _.animType = 'webkitTransform';\n            _.transformType = '-webkit-transform';\n            _.transitionType = 'webkitTransition';\n            if (bodyStyle.perspectiveProperty === undefined && bodyStyle.webkitPerspective === undefined) _.animType = false;\n        }\n        if (bodyStyle.msTransform !== undefined) {\n            _.animType = 'msTransform';\n            _.transformType = '-ms-transform';\n            _.transitionType = 'msTransition';\n            if (bodyStyle.msTransform === undefined) _.animType = false;\n        }\n        if (bodyStyle.transform !== undefined && _.animType !== false) {\n            _.animType = 'transform';\n            _.transformType = 'transform';\n            _.transitionType = 'transition';\n        }\n        _.transformsEnabled = _.options.useTransform && (_.animType !== null && _.animType !== false);\n    };\n\n\n    Slick.prototype.setSlideClasses = function(index) {\n\n        var _ = this,\n            centerOffset, allSlides, indexOffset, remainder;\n\n        allSlides = _.$slider\n            .find('.slick-slide')\n            .removeClass('slick-active slick-center slick-current')\n            .attr('aria-hidden', 'true');\n\n        _.$slides\n            .eq(index)\n            .addClass('slick-current');\n\n        if (_.options.centerMode === true) {\n\n            centerOffset = Math.floor(_.options.slidesToShow / 2);\n\n            if (_.options.infinite === true) {\n\n                if (index >= centerOffset && index <= (_.slideCount - 1) - centerOffset) {\n\n                    _.$slides\n                        .slice(index - centerOffset, index + centerOffset + 1)\n                        .addClass('slick-active')\n                        .attr('aria-hidden', 'false');\n\n                } else {\n\n                    indexOffset = _.options.slidesToShow + index;\n                    allSlides\n                        .slice(indexOffset - centerOffset + 1, indexOffset + centerOffset + 2)\n                        .addClass('slick-active')\n                        .attr('aria-hidden', 'false');\n\n                }\n\n                if (index === 0) {\n\n                    allSlides\n                        .eq(allSlides.length - 1 - _.options.slidesToShow)\n                        .addClass('slick-center');\n\n                } else if (index === _.slideCount - 1) {\n\n                    allSlides\n                        .eq(_.options.slidesToShow)\n                        .addClass('slick-center');\n\n                }\n\n            }\n\n            _.$slides\n                .eq(index)\n                .addClass('slick-center');\n\n        } else {\n\n            if (index >= 0 && index <= (_.slideCount - _.options.slidesToShow)) {\n\n                _.$slides\n                    .slice(index, index + _.options.slidesToShow)\n                    .addClass('slick-active')\n                    .attr('aria-hidden', 'false');\n\n            } else if (allSlides.length <= _.options.slidesToShow) {\n\n                allSlides\n                    .addClass('slick-active')\n                    .attr('aria-hidden', 'false');\n\n            } else {\n\n                remainder = _.slideCount % _.options.slidesToShow;\n                indexOffset = _.options.infinite === true ? _.options.slidesToShow + index : index;\n\n                if (_.options.slidesToShow == _.options.slidesToScroll && (_.slideCount - index) < _.options.slidesToShow) {\n\n                    allSlides\n                        .slice(indexOffset - (_.options.slidesToShow - remainder), indexOffset + remainder)\n                        .addClass('slick-active')\n                        .attr('aria-hidden', 'false');\n\n                } else {\n\n                    allSlides\n                        .slice(indexOffset, indexOffset + _.options.slidesToShow)\n                        .addClass('slick-active')\n                        .attr('aria-hidden', 'false');\n\n                }\n\n            }\n\n        }\n\n        if (_.options.lazyLoad === 'ondemand') {\n            _.lazyLoad();\n        }\n\n    };\n\n    Slick.prototype.setupInfinite = function() {\n\n        var _ = this,\n            i, slideIndex, infiniteCount;\n\n        if (_.options.fade === true) {\n            _.options.centerMode = false;\n        }\n\n        if (_.options.infinite === true && _.options.fade === false) {\n\n            slideIndex = null;\n\n            if (_.slideCount > _.options.slidesToShow) {\n\n                if (_.options.centerMode === true) {\n                    infiniteCount = _.options.slidesToShow + 1;\n                } else {\n                    infiniteCount = _.options.slidesToShow;\n                }\n\n                for (i = _.slideCount; i > (_.slideCount -\n                        infiniteCount); i -= 1) {\n                    slideIndex = i - 1;\n                    $(_.$slides[slideIndex]).clone(true).attr('id', '')\n                        .attr('data-slick-index', slideIndex - _.slideCount)\n                        .prependTo(_.$slideTrack).addClass('slick-cloned');\n                }\n                for (i = 0; i < infiniteCount; i += 1) {\n                    slideIndex = i;\n                    $(_.$slides[slideIndex]).clone(true).attr('id', '')\n                        .attr('data-slick-index', slideIndex + _.slideCount)\n                        .appendTo(_.$slideTrack).addClass('slick-cloned');\n                }\n                _.$slideTrack.find('.slick-cloned').find('[id]').each(function() {\n                    $(this).attr('id', '');\n                });\n\n            }\n\n        }\n\n    };\n\n    Slick.prototype.interrupt = function( toggle ) {\n\n        var _ = this;\n\n        if( !toggle ) {\n            _.autoPlay();\n        }\n        _.interrupted = toggle;\n\n    };\n\n    Slick.prototype.selectHandler = function(event) {\n\n        var _ = this;\n\n        var targetElement =\n            $(event.target).is('.slick-slide') ?\n                $(event.target) :\n                $(event.target).parents('.slick-slide');\n\n        var index = parseInt(targetElement.attr('data-slick-index'));\n\n        if (!index) index = 0;\n\n        if (_.slideCount <= _.options.slidesToShow) {\n\n            _.setSlideClasses(index);\n            _.asNavFor(index);\n            return;\n\n        }\n\n        _.slideHandler(index);\n\n    };\n\n    Slick.prototype.slideHandler = function(index, sync, dontAnimate) {\n\n        var targetSlide, animSlide, oldSlide, slideLeft, targetLeft = null,\n            _ = this, navTarget;\n\n        sync = sync || false;\n\n        if (_.animating === true && _.options.waitForAnimate === true) {\n            return;\n        }\n\n        if (_.options.fade === true && _.currentSlide === index) {\n            return;\n        }\n\n        if (_.slideCount <= _.options.slidesToShow) {\n            return;\n        }\n\n        if (sync === false) {\n            _.asNavFor(index);\n        }\n\n        targetSlide = index;\n        targetLeft = _.getLeft(targetSlide);\n        slideLeft = _.getLeft(_.currentSlide);\n\n        _.currentLeft = _.swipeLeft === null ? slideLeft : _.swipeLeft;\n\n        if (_.options.infinite === false && _.options.centerMode === false && (index < 0 || index > _.getDotCount() * _.options.slidesToScroll)) {\n            if (_.options.fade === false) {\n                targetSlide = _.currentSlide;\n                if (dontAnimate !== true) {\n                    _.animateSlide(slideLeft, function() {\n                        _.postSlide(targetSlide);\n                    });\n                } else {\n                    _.postSlide(targetSlide);\n                }\n            }\n            return;\n        } else if (_.options.infinite === false && _.options.centerMode === true && (index < 0 || index > (_.slideCount - _.options.slidesToScroll))) {\n            if (_.options.fade === false) {\n                targetSlide = _.currentSlide;\n                if (dontAnimate !== true) {\n                    _.animateSlide(slideLeft, function() {\n                        _.postSlide(targetSlide);\n                    });\n                } else {\n                    _.postSlide(targetSlide);\n                }\n            }\n            return;\n        }\n\n        if ( _.options.autoplay ) {\n            clearInterval(_.autoPlayTimer);\n        }\n\n        if (targetSlide < 0) {\n            if (_.slideCount % _.options.slidesToScroll !== 0) {\n                animSlide = _.slideCount - (_.slideCount % _.options.slidesToScroll);\n            } else {\n                animSlide = _.slideCount + targetSlide;\n            }\n        } else if (targetSlide >= _.slideCount) {\n            if (_.slideCount % _.options.slidesToScroll !== 0) {\n                animSlide = 0;\n            } else {\n                animSlide = targetSlide - _.slideCount;\n            }\n        } else {\n            animSlide = targetSlide;\n        }\n\n        _.animating = true;\n\n        _.$slider.trigger('beforeChange', [_, _.currentSlide, animSlide]);\n\n        oldSlide = _.currentSlide;\n        _.currentSlide = animSlide;\n\n        _.setSlideClasses(_.currentSlide);\n\n        if ( _.options.asNavFor ) {\n\n            navTarget = _.getNavTarget();\n            navTarget = navTarget.slick('getSlick');\n\n            if ( navTarget.slideCount <= navTarget.options.slidesToShow ) {\n                navTarget.setSlideClasses(_.currentSlide);\n            }\n\n        }\n\n        _.updateDots();\n        _.updateArrows();\n\n        if (_.options.fade === true) {\n            if (dontAnimate !== true) {\n\n                _.fadeSlideOut(oldSlide);\n\n                _.fadeSlide(animSlide, function() {\n                    _.postSlide(animSlide);\n                });\n\n            } else {\n                _.postSlide(animSlide);\n            }\n            _.animateHeight();\n            return;\n        }\n\n        if (dontAnimate !== true) {\n            _.animateSlide(targetLeft, function() {\n                _.postSlide(animSlide);\n            });\n        } else {\n            _.postSlide(animSlide);\n        }\n\n    };\n\n    Slick.prototype.startLoad = function() {\n\n        var _ = this;\n\n        if (_.options.arrows === true && _.slideCount > _.options.slidesToShow) {\n\n            _.$prevArrow.hide();\n            _.$nextArrow.hide();\n\n        }\n\n        if (_.options.dots === true && _.slideCount > _.options.slidesToShow) {\n\n            _.$dots.hide();\n\n        }\n\n        _.$slider.addClass('slick-loading');\n\n    };\n\n    Slick.prototype.swipeDirection = function() {\n\n        var xDist, yDist, r, swipeAngle, _ = this;\n\n        xDist = _.touchObject.startX - _.touchObject.curX;\n        yDist = _.touchObject.startY - _.touchObject.curY;\n        r = Math.atan2(yDist, xDist);\n\n        swipeAngle = Math.round(r * 180 / Math.PI);\n        if (swipeAngle < 0) {\n            swipeAngle = 360 - Math.abs(swipeAngle);\n        }\n\n        if ((swipeAngle <= 45) && (swipeAngle >= 0)) {\n            return (_.options.rtl === false ? 'left' : 'right');\n        }\n        if ((swipeAngle <= 360) && (swipeAngle >= 315)) {\n            return (_.options.rtl === false ? 'left' : 'right');\n        }\n        if ((swipeAngle >= 135) && (swipeAngle <= 225)) {\n            return (_.options.rtl === false ? 'right' : 'left');\n        }\n        if (_.options.verticalSwiping === true) {\n            if ((swipeAngle >= 35) && (swipeAngle <= 135)) {\n                return 'down';\n            } else {\n                return 'up';\n            }\n        }\n\n        return 'vertical';\n\n    };\n\n    Slick.prototype.swipeEnd = function(event) {\n\n        var _ = this,\n            slideCount,\n            direction;\n\n        _.dragging = false;\n        _.interrupted = false;\n        _.shouldClick = ( _.touchObject.swipeLength > 10 ) ? false : true;\n\n        if ( _.touchObject.curX === undefined ) {\n            return false;\n        }\n\n        if ( _.touchObject.edgeHit === true ) {\n            _.$slider.trigger('edge', [_, _.swipeDirection() ]);\n        }\n\n        if ( _.touchObject.swipeLength >= _.touchObject.minSwipe ) {\n\n            direction = _.swipeDirection();\n\n            switch ( direction ) {\n\n                case 'left':\n                case 'down':\n\n                    slideCount =\n                        _.options.swipeToSlide ?\n                            _.checkNavigable( _.currentSlide + _.getSlideCount() ) :\n                            _.currentSlide + _.getSlideCount();\n\n                    _.currentDirection = 0;\n\n                    break;\n\n                case 'right':\n                case 'up':\n\n                    slideCount =\n                        _.options.swipeToSlide ?\n                            _.checkNavigable( _.currentSlide - _.getSlideCount() ) :\n                            _.currentSlide - _.getSlideCount();\n\n                    _.currentDirection = 1;\n\n                    break;\n\n                default:\n\n\n            }\n\n            if( direction != 'vertical' ) {\n\n                _.slideHandler( slideCount );\n                _.touchObject = {};\n                _.$slider.trigger('swipe', [_, direction ]);\n\n            }\n\n        } else {\n\n            if ( _.touchObject.startX !== _.touchObject.curX ) {\n\n                _.slideHandler( _.currentSlide );\n                _.touchObject = {};\n\n            }\n\n        }\n\n    };\n\n    Slick.prototype.swipeHandler = function(event) {\n\n        var _ = this;\n\n        if ((_.options.swipe === false) || ('ontouchend' in document && _.options.swipe === false)) {\n            return;\n        } else if (_.options.draggable === false && event.type.indexOf('mouse') !== -1) {\n            return;\n        }\n\n        _.touchObject.fingerCount = event.originalEvent && event.originalEvent.touches !== undefined ?\n            event.originalEvent.touches.length : 1;\n\n        _.touchObject.minSwipe = _.listWidth / _.options\n            .touchThreshold;\n\n        if (_.options.verticalSwiping === true) {\n            _.touchObject.minSwipe = _.listHeight / _.options\n                .touchThreshold;\n        }\n\n        switch (event.data.action) {\n\n            case 'start':\n                _.swipeStart(event);\n                break;\n\n            case 'move':\n                _.swipeMove(event);\n                break;\n\n            case 'end':\n                _.swipeEnd(event);\n                break;\n\n        }\n\n    };\n\n    Slick.prototype.swipeMove = function(event) {\n\n        var _ = this,\n            edgeWasHit = false,\n            curLeft, swipeDirection, swipeLength, positionOffset, touches;\n\n        touches = event.originalEvent !== undefined ? event.originalEvent.touches : null;\n\n        if (!_.dragging || touches && touches.length !== 1) {\n            return false;\n        }\n\n        curLeft = _.getLeft(_.currentSlide);\n\n        _.touchObject.curX = touches !== undefined ? touches[0].pageX : event.clientX;\n        _.touchObject.curY = touches !== undefined ? touches[0].pageY : event.clientY;\n\n        _.touchObject.swipeLength = Math.round(Math.sqrt(\n            Math.pow(_.touchObject.curX - _.touchObject.startX, 2)));\n\n        if (_.options.verticalSwiping === true) {\n            _.touchObject.swipeLength = Math.round(Math.sqrt(\n                Math.pow(_.touchObject.curY - _.touchObject.startY, 2)));\n        }\n\n        swipeDirection = _.swipeDirection();\n\n        if (swipeDirection === 'vertical') {\n            return;\n        }\n\n        if (event.originalEvent !== undefined && _.touchObject.swipeLength > 4) {\n            event.preventDefault();\n        }\n\n        positionOffset = (_.options.rtl === false ? 1 : -1) * (_.touchObject.curX > _.touchObject.startX ? 1 : -1);\n        if (_.options.verticalSwiping === true) {\n            positionOffset = _.touchObject.curY > _.touchObject.startY ? 1 : -1;\n        }\n\n\n        swipeLength = _.touchObject.swipeLength;\n\n        _.touchObject.edgeHit = false;\n\n        if (_.options.infinite === false) {\n            if ((_.currentSlide === 0 && swipeDirection === 'right') || (_.currentSlide >= _.getDotCount() && swipeDirection === 'left')) {\n                swipeLength = _.touchObject.swipeLength * _.options.edgeFriction;\n                _.touchObject.edgeHit = true;\n            }\n        }\n\n        if (_.options.vertical === false) {\n            _.swipeLeft = curLeft + swipeLength * positionOffset;\n        } else {\n            _.swipeLeft = curLeft + (swipeLength * (_.$list.height() / _.listWidth)) * positionOffset;\n        }\n        if (_.options.verticalSwiping === true) {\n            _.swipeLeft = curLeft + swipeLength * positionOffset;\n        }\n\n        if (_.options.fade === true || _.options.touchMove === false) {\n            return false;\n        }\n\n        if (_.animating === true) {\n            _.swipeLeft = null;\n            return false;\n        }\n\n        _.setCSS(_.swipeLeft);\n\n    };\n\n    Slick.prototype.swipeStart = function(event) {\n\n        var _ = this,\n            touches;\n\n        _.interrupted = true;\n\n        if (_.touchObject.fingerCount !== 1 || _.slideCount <= _.options.slidesToShow) {\n            _.touchObject = {};\n            return false;\n        }\n\n        if (event.originalEvent !== undefined && event.originalEvent.touches !== undefined) {\n            touches = event.originalEvent.touches[0];\n        }\n\n        _.touchObject.startX = _.touchObject.curX = touches !== undefined ? touches.pageX : event.clientX;\n        _.touchObject.startY = _.touchObject.curY = touches !== undefined ? touches.pageY : event.clientY;\n\n        _.dragging = true;\n\n    };\n\n    Slick.prototype.unfilterSlides = Slick.prototype.slickUnfilter = function() {\n\n        var _ = this;\n\n        if (_.$slidesCache !== null) {\n\n            _.unload();\n\n            _.$slideTrack.children(this.options.slide).detach();\n\n            _.$slidesCache.appendTo(_.$slideTrack);\n\n            _.reinit();\n\n        }\n\n    };\n\n    Slick.prototype.unload = function() {\n\n        var _ = this;\n\n        $('.slick-cloned', _.$slider).remove();\n\n        if (_.$dots) {\n            _.$dots.remove();\n        }\n\n        if (_.$prevArrow && _.htmlExpr.test(_.options.prevArrow)) {\n            _.$prevArrow.remove();\n        }\n\n        if (_.$nextArrow && _.htmlExpr.test(_.options.nextArrow)) {\n            _.$nextArrow.remove();\n        }\n\n        _.$slides\n            .removeClass('slick-slide slick-active slick-visible slick-current')\n            .attr('aria-hidden', 'true')\n            .css('width', '');\n\n    };\n\n    Slick.prototype.unslick = function(fromBreakpoint) {\n\n        var _ = this;\n        _.$slider.trigger('unslick', [_, fromBreakpoint]);\n        _.destroy();\n\n    };\n\n    Slick.prototype.updateArrows = function() {\n\n        var _ = this,\n            centerOffset;\n\n        centerOffset = Math.floor(_.options.slidesToShow / 2);\n\n        if ( _.options.arrows === true &&\n            _.slideCount > _.options.slidesToShow &&\n            !_.options.infinite ) {\n\n            _.$prevArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');\n            _.$nextArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');\n\n            if (_.currentSlide === 0) {\n\n                _.$prevArrow.addClass('slick-disabled').attr('aria-disabled', 'true');\n                _.$nextArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');\n\n            } else if (_.currentSlide >= _.slideCount - _.options.slidesToShow && _.options.centerMode === false) {\n\n                _.$nextArrow.addClass('slick-disabled').attr('aria-disabled', 'true');\n                _.$prevArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');\n\n            } else if (_.currentSlide >= _.slideCount - 1 && _.options.centerMode === true) {\n\n                _.$nextArrow.addClass('slick-disabled').attr('aria-disabled', 'true');\n                _.$prevArrow.removeClass('slick-disabled').attr('aria-disabled', 'false');\n\n            }\n\n        }\n\n    };\n\n    Slick.prototype.updateDots = function() {\n\n        var _ = this;\n\n        if (_.$dots !== null) {\n\n            _.$dots\n                .find('li')\n                .removeClass('slick-active')\n                .attr('aria-hidden', 'true');\n\n            _.$dots\n                .find('li')\n                .eq(Math.floor(_.currentSlide / _.options.slidesToScroll))\n                .addClass('slick-active')\n                .attr('aria-hidden', 'false');\n\n        }\n\n    };\n\n    Slick.prototype.visibility = function() {\n\n        var _ = this;\n\n        if ( _.options.autoplay ) {\n\n            if ( document[_.hidden] ) {\n\n                _.interrupted = true;\n\n            } else {\n\n                _.interrupted = false;\n\n            }\n\n        }\n\n    };\n\n    $.fn.slick = function() {\n        var _ = this,\n            opt = arguments[0],\n            args = Array.prototype.slice.call(arguments, 1),\n            l = _.length,\n            i,\n            ret;\n        for (i = 0; i < l; i++) {\n            if (typeof opt == 'object' || typeof opt == 'undefined')\n                _[i].slick = new Slick(_[i], opt);\n            else\n                ret = _[i].slick[opt].apply(_[i].slick, args);\n            if (typeof ret != 'undefined') return ret;\n        }\n        return _;\n    };\n\n}));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/slick-carousel/slick/slick.js\n// module id = 4\n// module chunks = 0","import $ from 'jquery';\n\nconst selector = '.field-image.c1 img';\n\nexport default class BackgroundImage {\n  constructor(element) {\n    this.$element = $(element);\n    const src = this.$element.find(selector).attr('src');\n    if (src) {\n      this.$element.css('background-image', `url(${src})`);\n    }\n    this.$element.addClass('ready');\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./BackgroundImage.js","import $ from 'jquery';\nimport moment from 'moment';\n\nconst defaults = {\n  // local storage key used to save the currently applied filter\n  storageKey: 'currentCalendarFilter',\n\n  // Button text displayed as the pagination to the next page of events\n  paginationLabel: 'Load More Events',\n\n  // Mobile only drop down label that houses the filtering options\n  filtersLabel: 'Filter by...',\n\n  // Force the filters to be automatically determined by the post types present in the feed.\n  filterByPostTypes: false,\n\n  // A simple indicator to determine the build out of filters\n  useFilters: false,\n\n  // Used to pass in an object of filters which use key value pairs.\n  // {Object}\n  //   @key: Name that will appear as the filter button text\n  //   @value: ID of post type or navigation term\n  filters: false,\n};\n\n// These filters are used if the filterByPostTypes is enabled. Present post\n// types are then added to this object, then the filters are made from those.\nconst defaultFilters = {\n  All: 2,\n};\n\nfunction CalendarFeed(element, options) {\n  this.$element = $(element);\n  this.settings = { ...defaults, ...options };\n  this.filters = this.getFilters();\n  this.init();\n}\n\nCalendarFeed.prototype = {\n  init() {\n    this.buildCalendar();\n    if (this.settings.useFilters) {\n      this.createFilters();\n    }\n  },\n  buildCalendar() {\n    const $posts = this.$element.find('.node');\n    const group = '<div class=\"group\"></div>';\n    let currentYear = null;\n    let currentMonth = '';\n    let $group;\n\n    // Manage the types of calendar filters being created\n    $posts.each((i, post) => {\n      const $post = $(post);\n      const dates = ['start', 'end'];\n      const oDates = {};\n\n      // Parse the start/end timestamps using the moment.js framework\n      $.each(dates, (j, type) => {\n        const datetime = $post.find(`time.${type}`).attr('datetime');\n        const date = moment(datetime);\n        oDates[type] = {\n          month: date.format('MMMM'),\n          mon: date.format('MMM'),\n          day: date.format('D'),\n          dow: date.format('ddd'),\n          year: date.format('YYYY'),\n        };\n      });\n\n      // Add the post into a month grouping\n      if (oDates.start.month.length && currentMonth !== oDates.start.month) {\n        currentMonth = oDates.start.month;\n        $group = $(group);\n        $group.addClass(oDates.start.month.toLowerCase());\n        $group.append(`<h3 class=\"group-title\">${oDates.start.month}</h3>`);\n        $post.before($group);\n\n        // Set year labels followed by the associated months of that year\n        if (oDates.start.year && oDates.start.year > currentYear) {\n          const $year = $(`<span class=\"group-year\">${oDates.start.year}</span>`);\n          $group.before($year);\n          currentYear = oDates.start.year;\n        }\n      }\n\n      // Dynamically create the date tile for the event display\n      const $tile = $post.find('.event-date-tile');\n      const markup = data => `<span class=\"day-of-week\">${data.dow}</span><span class=\"month\">${data.mon}</span><span class=\"day\">${data.day}</span>`;\n      $tile.find('time.start').html(markup(oDates.start));\n\n      // Handle date ranges\n      if ($tile.is('.range')) {\n        const isSameMonth = oDates.start.month === oDates.end.month;\n        const isSameDay = oDates.start.day === oDates.end.day;\n        const isSameYear = oDates.start.year === oDates.end.year;\n\n        // This identifies an event which begins and ends at different times on the same day\n        if (isSameMonth && isSameDay && isSameYear) {\n          $post.addClass('day-event');\n        }\n\n        // This identifies an event which spans multiple days within the same month\n        if (isSameMonth && !isSameDay && isSameYear) {\n          $post.addClass('multiple-day-event');\n          $tile.find('time.start .day').text(`${oDates.start.day}-${oDates.end.day}`);\n        }\n\n        // This identifies an event which spans multiple months or maybe a year(s)\n        if (!isSameMonth || !isSameYear) {\n          $post.addClass('multiple-month-event');\n          $tile.find('time.end').html(markup(oDates.end));\n        }\n      }\n\n      // Add the grouped posts to the display\n      $post.appendTo($group);\n    });\n\n    // Alter the text of the next pager button\n    $('.pager-next a', this.$element).text(this.settings.paginationLabel);\n\n    // Add a helper class\n    this.$element.addClass('ready');\n  },\n  filterHandler(event) {\n    event.preventDefault();\n    $(this).next('.filters').toggleClass('expanded');\n  },\n  getFilters() {\n    // If custom filters where passed, use them, if not use the defaults.\n    let data = this.settings.filters ? this.settings.filters : defaultFilters;\n    // If the filter by post types flag is set, force that filtering option.\n    if (this.settings.filterByPostTypes) {\n      data = defaultFilters;\n    }\n    return data;\n  },\n  createFilters() {\n    const $element = this.$element;\n    const $posts = $element.find('.node');\n    let $filters = $('<div class=\"filters\"></div>');\n    const filter = '<div class=\"filter\"></div>';\n    let types = [];\n    let ids = [];\n\n    // Create the proposed filters\n    $.each(this.filters, (type, id) => {\n      types.push(type);\n      ids.push(id);\n    });\n\n    // Using the proposed filters, generate relevant filters of those types\n    // that are actually present or use the semi default, filter by post type.\n    const data = this.settings.filterByPostTypes\n      ? this.getDefaultData(types, ids)\n      : this.getCustomizedData(types, ids)\n    ;\n\n    // Using the provided date, rebuild the arrays using relevant data.\n    types = data.types;\n    ids = data.ids;\n\n    // Get the latest selected filter.\n    let currentFilter = sessionStorage.getItem(this.settings.storageKey) || ids[0];\n\n    // See if a hash was passed, if so let's filter by that instead later on.\n    let hash = window.location.hash;\n    if (hash.length > 1) {\n      hash = hash.substr(1); // Remove the hash symbol #\n      hash = decodeURIComponent(hash); // Normalize the filter passed\n    }\n\n    // Create filters\n    $.each(types, (i, type) => {\n      const $filter = $(filter);\n      // Use the type key to identify the associated filter id\n      const id = ids[i];\n\n      // Check to see if this filter is being forced to be filtered by using\n      // a url hash.\n      if (hash.length && hash.toLowerCase() === type.toLowerCase()) {\n        currentFilter = id;\n      }\n\n      // Add the type to the filter\n      $filter.text(type);\n\n      // Add a class name to theme the filter\n      $filter.addClass(`show-${ids[i]}`);\n\n      // Add the newly created filter\n      $filters.append($filter);\n\n      // Add a click handler\n      $filter.on('click', () => {\n        // Default to all posts in calendar feed\n        let $show = $posts;\n\n        // Filter what posts to display if not all option\n        if (type !== 'All') {\n          $show = $posts.filter(\n            (j, element) => $.inArray(type, $(element).data('types')) !== -1,\n          );\n        }\n\n        // Manage the active filter styling\n        $filters.not(this).removeClass('active');\n        $(this).addClass('active');\n\n        // hide all events that aren't of this type\n        $posts.not($show).stop(true, true).animate({\n          opacity: 'hide',\n          height: 'hide',\n        }, 300).removeClass('show');\n\n        // show all events that are of this type\n        $show.stop(true, true).animate({\n          opacity: 'show',\n          height: 'show',\n        }, 300).addClass('show');\n\n        // Set the current filter into session storage\n        sessionStorage.setItem(this.settings.storageKey, id);\n        currentFilter = id;\n\n        // Check to see if the event group is empty\n        $element.find('.group').each((j, element) => {\n          const $shown = $('.node.show', element);\n          const result = $shown.length ? 'show' : 'hide';\n\n          // Add a helper class for the use with the year function below\n          if ($shown.length) {\n            $(element).addClass('show');\n          } else {\n            $(element).removeClass('show');\n          }\n\n          // Manages the visibility of the group\n          $(element).stop(true, true).animate({\n            opacity: result,\n            height: result,\n          }, 300);\n        });\n\n        // Check to see if the group year should display or not\n        $element.find('.group-year').each((j, element) => {\n          const $shown = $(element).nextUntil('.group-year').filter('.show');\n          const result = $shown.length ? 'show' : 'hide';\n          $(element).stop(true, true).animate({\n            opacity: result,\n            height: result,\n          }, 300);\n        });\n      });\n    });\n\n    // Add a drop down controller for mobile\n    const $ctrl = $(`<h3 class=\"ctrl\">${this.settings.filtersLabel}</h3>`);\n    $ctrl.on('click', this.filterHandler);\n\n    // Add the drop down controller for mobile display\n    $element.find('.view-header').append($ctrl, $filters);\n\n    // Make this an jquery array of filters reference rather than a container\n    // reference.\n    $filters = $filters.find('.filter');\n\n    // Simulate a click event for the last or default calendar filter\n    $filters.filter(`.show-${currentFilter}`).trigger('click');\n  },\n  getDefaultData(_types, _ids) {\n    const $element = this.$element;\n    const $posts = $element.find('.node');\n\n    const types = _types;\n    const ids = _ids;\n\n    // Dynamically create the filter types and identify the posts that belong\n    // to each one.\n    $posts.each((i, post) => {\n      const $post = $(post);\n\n      // Extract the post type\n      let type = $('.post-type', post).text();\n\n      // If the post type is the generic Event, set the label to All instead.\n      if (type === 'Event') {\n        type = 'All';\n      }\n\n      let id = 0;\n      const classes = $post.attr('class');\n      const regex = /\\w?pt([0-9]+)/;\n\n      // Make filters by types found if were using the default filters\n      if (regex.test(classes)) {\n        id = regex.exec(classes)[1];\n      }\n\n      // Make filters by post type\n      if ($.inArray(type, types) === -1) {\n        types.push(type);\n        ids.push(id);\n      }\n\n      // Add a data types to identify this when a filter is clicked\n      $post.data('types', [type]);\n    });\n\n    return {\n      types,\n      ids,\n    };\n  },\n  getCustomizedData(_types, _ids) {\n    const $element = this.$element;\n    const $posts = $element.find('.node');\n    const types = [];\n    const ids = [];\n\n    // Keep track of the types and ids that have been identified within this content.\n    const indexes = [];\n\n    // Dynamically create the filter types and identify the posts that belong\n    // to each one.\n    $posts.each((i, post) => {\n      const $post = $(post);\n      const classes = $post.attr('class');\n      const regex = /\\w?[wp]t([0-9]+)/g; // Filter could be either wt or pt.\n      const aTypes = [];\n\n      // Add the post type by default\n      aTypes.push($('.post-type', post).text());\n\n      // If the post type is the generic Event, set the label to All instead.\n      if (aTypes[0] === 'Event') {\n        aTypes[0] = 'All';\n      }\n\n      // Iterates through all matches made to see what this post should be\n      // filtered by from the filters assigned\n      let aResults;\n      // eslint-disable-next-line no-cond-assign\n      while ((aResults = regex.exec(classes)) !== null) {\n        const result = parseInt(aResults[1], 10);\n        if ($.inArray(result, _ids) !== -1) {\n          const index = _ids.indexOf(result);\n          // Check to see if index has already been added, if not, add it.\n          if ($.inArray(index, indexes) === -1) {\n            indexes.push(index);\n          }\n          // Add this type to the post since it's been found\n          aTypes.push(_types[index]);\n        }\n      }\n\n      // Add a data id to identify this type when the filter is clicked\n      $post.data('types', aTypes);\n    });\n\n    // Create new types and ids of the relevant types found using the\n    // supplied custom filters\n    $.each(indexes.sort(), (i, index) => {\n      types.push(_types[index]);\n      ids.push(_ids[index]);\n    });\n\n    return {\n      types,\n      ids,\n    };\n  },\n};\n\nexport default CalendarFeed;\n\n\n\n// WEBPACK FOOTER //\n// ./CalendarFeed.js","import $ from 'jquery';\n\nconst key = 'has_seen_alert_';\n\nexport default class DistrictAlert {\n  constructor(element) {\n    this.$element = $(element);\n    this.$instance = this.getAlert();\n    this.click = this.click.bind(this);\n    if (this.$instance.length && this.areWeThere) {\n      this.storageKey = this.createKey();\n      if (!this.getVariable()) {\n        this.listen();\n        this.show();\n      }\n    }\n  }\n\n  getAlert() {\n    return this.$element.find('.node');\n  }\n\n  createKey() {\n    const id = this.$instance.attr('id');\n    return key + /(\\d+)/.exec(id)[0];\n  }\n\n  getVariable() {\n    return sessionStorage.getItem(this.storageKey) || false;\n  }\n\n  setVariable() {\n    sessionStorage.setItem(this.storageKey, true);\n  }\n\n  click(event) {\n    this.setVariable();\n    event.stopPropagation();\n\n    if ($(event.target).is('.block, .node-links')) {\n      event.preventDefault();\n      this.hide();\n    }\n  }\n\n  hide() {\n    this.$element.removeClass('show');\n  }\n\n  show() {\n    this.$element.addClass('show');\n  }\n\n  listen() {\n    this.$element.on('click', this.click);\n  }\n\n  get areWeThere() {\n    const url = this.$element.find('.link-read-more a').attr('href');\n    const currentURL = document.location.pathname;\n    return url !== currentURL;\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./DistrictAlert.js","/* global Drupal */\nimport $ from 'jquery';\n\nlet behaviors;\nlet documentIsReady = false;\n\n/**\n * Allows a Drupal behavior to be added from an AMD-style module. The behavior\n * will be executed when:\n * - As soon as the DOM is ready, if the DOM is not ready when the behavior is\n *   added, just like a regular Drupal behavior.\n * - Immediately upon adding, if the DOM is ready (which may happen since\n *   AMD-style modules are loaded asynchronously).\n * - When Drupal.attachBehaviors is executed.\n */\nDrupal.behavior = function addDrupalBehavior(fn) {\n  if (!behaviors) {\n    behaviors = $.Callbacks();\n    documentIsReady = false;\n\n    $(document).ready(() => {\n      documentIsReady = true;\n      // eslint-disable-next-line no-console\n      console.log('Executing behaviors that were added before DOM was ready');\n      behaviors.fire(document);\n\n      // Now that we know the document is ready, add ourselves to Drupal's\n      // behavior handling.\n      window.Drupal.behaviors.DrupalAMD = function DrupalAMD(context) {\n        // eslint-disable-next-line no-console\n        console.log('Executing behaviors in response to Drupal.attachBehaviors');\n        behaviors.fire(context);\n      };\n    });\n  }\n\n  // Note: we can't use the 'memory' option of jQuery.Callbacks, because we\n  // need control over the argument.\n  if (documentIsReady) {\n    // eslint-disable-next-line no-console\n    console.log('Executing behavior immediately, DOM is already ready');\n    fn(document);\n  }\n\n  behaviors.add(fn);\n  return this;\n};\n\nexport default Drupal;\n\n\n\n// WEBPACK FOOTER //\n// ./Drupal.js","import $ from 'jquery';\n\nconst defaults = {\n  events: 'click',\n  className: 'expanded',\n  trigger: '.node-header a',\n};\n\nexport default class Expanded {\n  constructor(element, options) {\n    this.$element = $(element);\n    this.settings = { ...defaults, ...options };\n    this.update = this.update.bind(this);\n    this.listen();\n  }\n\n  listen() {\n    this.$element.find(this.settings.trigger).bind(this.settings.events, this.update);\n  }\n\n  update(event) {\n    event.preventDefault(); // prevent native behavior\n    const state = this.$element.hasClass(this.settings.className) ? 'remove' : 'add';\n    this.$element[`${state}Class`](this.settings.className);\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./Expanded.js","import $ from 'jquery';\n\nfunction FixNavigation(element) {\n  this.element = element;\n  this.process();\n  this.ready();\n}\n\nFixNavigation.prototype = {\n  process() {\n    $('.menuparent, .expanded, .collapsed', this.element).each((i, item) => {\n      // handles the parent term (if hidden)\n      const $parent = $(item).children('a');\n      if (!$parent.length || $parent.is('.hidden')) {\n        $(item).remove();\n      }\n\n      // handles the term to see if it only parents orphans.\n      const $children = $('> ul > li', item);\n      if (!$parent.is('.hidden') && $children.length) {\n        const $orphans = $children.children('a.hidden');\n        $orphans.parent().remove();\n        if ($orphans.length === $children.length) {\n          $(item).removeClass('expanded menuparent collapsed');\n          $(item).children('ul').remove();\n        }\n      }\n    });\n  },\n  ready() {\n    $(this.element).addClass('ready');\n  },\n};\n\nexport default FixNavigation;\n\n\n\n// WEBPACK FOOTER //\n// ./FixNavigation.js","import $ from 'jquery';\nimport 'slick-carousel';\n\nconst defaults = {\n  speed: 500,\n  fade: true,\n  slide: '.field-image, a',\n  autoplay: true,\n  autoplaySpeed: 4000,\n  dots: true,\n  arrows: true,\n  slidesToShow: 1,\n  slidesToScroll: 1,\n  responsive: [\n    {\n      breakpoint: 690,\n      settings: {\n        arrows: false,\n      },\n    },\n  ],\n};\n\n/**\n * Gallery Constructor\n */\nfunction Gallery(element, options) {\n  this.element = element;\n  this.$element = $(element);\n  this.settings = $.extend(true, defaults, options);\n  this.$gallery = this.build();\n  this.ready();\n}\n\nGallery.prototype = {\n  build() {\n    return this.$element.slick(this.settings);\n  },\n  ready() {\n    this.$element.addClass('ready');\n  },\n};\n\nexport default Gallery;\n\n\n\n// WEBPACK FOOTER //\n// ./Gallery.js","import Headroom from 'headroom.js';\n\n// Headroom settings\nconst settings = {\n  // vertical offset in px before element is first unpinned\n  offset: 105, // @header-height value @see dtheme/less/variables.less\n  // scroll tolerance in px before state changes\n  tolerance: 5, // or {down: 0, up: 0},\n  // css classes to apply\n  classes: {\n    // when element is initialised\n    initial: 'headroom',\n    // when scrolling up\n    pinned: 'locked',\n    // when scrolling down\n    unpinned: 'unlocked',\n    // when above offset\n    top: 'top',\n    // when below offset\n    notTop: 'not-top',\n    // when at bottom of scoll area\n    bottom: 'bottom',\n    // when not at bottom of scroll area\n    notBottom: 'not-bottom',\n  },\n  // callback when pinned, `this` is headroom object\n  onPin() {},\n  // callback when unpinned, `this` is headroom object\n  onUnpin() {},\n  // callback when above offset, `this` is headroom object\n  onTop() {},\n  // callback when below offset, `this` is headroom object\n  onNotTop() {},\n  // callback at bottom of page, `this` is headroom object\n  onBottom() {},\n  // callback when moving away from bottom of page, `this` is headroom object\n  onNotBottom() {},\n};\n\nexport default function Header(element) {\n  // Create a new Headroom instance\n  const headroom = new Headroom(element, settings);\n  // Initialize this Headroom instance\n  headroom.init();\n  // Return back the new instance\n  return headroom;\n}\n\n\n\n// WEBPACK FOOTER //\n// ./Header.js","import $ from 'jquery';\nimport Viewport from './Viewport';\nimport '../vendor/dotimeout/jquery.ba-dotimeout.min';\n\nconst defaults = {\n  hoverInit: 250,\n  hoverDelay: 250,\n  selector: 'li.menuparent',\n};\n\nfunction Menu(element, options) {\n  this.element = element;\n  this.$element = $(element);\n  this.settings = { ...defaults, ...options };\n  this.$menus = this.getMenus();\n  this.over = $.proxy(this.over, this);\n  this.out = $.proxy(this.out, this);\n  this.listen();\n}\n\nMenu.prototype = {\n  getMenus() {\n    return this.$element.find(this.settings.selector);\n  },\n  over(event) {\n    const $target = $(event.currentTarget);\n    if (!Viewport.mobileState) {\n      $target.doTimeout('hide');\n      $target.doTimeout('show', this.settings.hoverInit, () => {\n        $target.addClass('show');\n      });\n    }\n  },\n  out(event) {\n    const $target = $(event.currentTarget);\n    if (!Viewport.mobileState) {\n      $target.doTimeout('show');\n      $target.doTimeout('hide', this.settings.hoverDelay, () => {\n        $target.removeClass('show');\n      });\n    }\n  },\n  listen() {\n    this.$menus.removeClass('show')\n      .on('mouseover', this.over)\n      .on('mouseout', this.out)\n      .on('focusin', this.over)\n      .on('focusout', this.out);\n  },\n};\n\nexport default Menu;\n\n\n\n// WEBPACK FOOTER //\n// ./Menu.js","import $ from 'jquery';\nimport Viewport from './Viewport';\n\nfunction MobileMenu(element) {\n  this.element = element;\n  this.$roots = this.getRootMenus();\n  this.onClick = $.proxy(this.onClick, this);\n  this.displayActiveMenus();\n  this.listen();\n}\n\nMobileMenu.prototype = {\n  getRootMenus() {\n    return $('a.depth-1', this.element);\n  },\n  onClick(event) {\n    const shouldExpand = $(event.target).is('.menu-link');\n    if (Viewport.mobileState && shouldExpand) {\n      $(event.currentTarget).toggleClass('expand');\n      event.preventDefault();\n    }\n  },\n  displayActiveMenus() {\n    $('.active-trail a.depth-1:not(.active)', this.element).addClass('expand');\n  },\n  listen() {\n    this.$roots.on('click', this.onClick);\n  },\n};\n\nexport default MobileMenu;\n\n\n\n// WEBPACK FOOTER //\n// ./MobileMenu.js","import $ from 'jquery';\n\nconst key = 'has_seen_alert_';\n\nfunction Notification(element) {\n  this.$element = $(element);\n  this.click = $.proxy(this.click, this);\n  this.$instance = this.getPost();\n  // Exit if a notifcation post is not found.\n  if (!this.$instance.length) return;\n  // Proceed ->\n  this.storageKey = this.createKey();\n  if (!this.getVariable() && this.$instance.length) {\n    this.listen();\n    this.show();\n  } else {\n    this.hide();\n  }\n}\n\nNotification.prototype = {\n  getPost() {\n    return this.$element.find('.node');\n  },\n  createKey() {\n    const id = this.$instance.attr('id');\n    return key + /(\\d+)/.exec(id)[0];\n  },\n  getVariable() {\n    return sessionStorage.getItem(this.storageKey) || false;\n  },\n  setVariable() {\n    sessionStorage.setItem(this.storageKey, true);\n  },\n  click(event) {\n    this.setVariable();\n    event.stopPropagation();\n    if ($(event.target).is('.block, .block-inner')) {\n      event.preventDefault();\n      this.hide();\n    }\n  },\n  hide() {\n    this.$element.removeClass('show').addClass('hide');\n  },\n  show() {\n    this.$element.addClass('show');\n  },\n  listen() {\n    this.$element.on('click', this.click);\n  },\n};\n\nexport default Notification;\n\n\n\n// WEBPACK FOOTER //\n// ./Notification.js","import $ from 'jquery';\nimport Change from './Change';\n\nconst defaults = {\n  speed: 0.35,\n};\n\nfunction Parallax(element, options) {\n  this.$element = $(element);\n  this.settings = { ...defaults, ...options };\n  this.register();\n  this.update();\n}\n\nParallax.prototype = {\n  register() {\n    Change.onChange(this.update.bind(this));\n  },\n  update() {\n    const offset = window.pageYOffset * this.settings.speed;\n    this.$element.css('transform', `translate3d(0, ${offset}px, 0)`);\n  },\n};\n\nexport default Parallax;\n\n\n\n// WEBPACK FOOTER //\n// ./Parallax.js","import $ from 'jquery';\n\nexport default class Placholder {\n  constructor(element) {\n    const $label = $('label', element);\n    const $input = $('input, textarea', element);\n    if ($label.length && $input.length) {\n      const placeholder = $label.text().replace(':', '');\n      $input.attr('placeholder', placeholder);\n    }\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./Placeholder.js","import $ from 'jquery';\n\nconst key = 'has_seen_popup_';\n\nexport default class DistrictAlert {\n  constructor(element) {\n    this.$element = $(element);\n    this.$instance = this.getAlert();\n    this.click = this.click.bind(this);\n    if (this.$instance.length && this.areWeThere) {\n      this.storageKey = this.createKey();\n      if (!this.getVariable()) {\n        this.listen();\n        this.show();\n      }\n    }\n  }\n\n  getAlert() {\n    return this.$element.find('.node');\n  }\n\n  createKey() {\n    const id = this.$instance.attr('id');\n    return key + /(\\d+)/.exec(id)[0];\n  }\n\n  getVariable() {\n    return sessionStorage.getItem(this.storageKey) || false;\n  }\n\n  setVariable() {\n    sessionStorage.setItem(this.storageKey, true);\n  }\n\n  click(event) {\n    this.setVariable();\n    event.stopPropagation();\n\n    if ($(event.target).is('.block, .node-links')) {\n      event.preventDefault();\n      this.hide();\n    }\n  }\n\n  hide() {\n    this.$element.removeClass('show');\n  }\n\n  show() {\n    this.$element.addClass('show');\n  }\n\n  listen() {\n    this.$element.on('click', this.click);\n  }\n\n  get areWeThere() {\n    const url = this.$element.find('.link-read-more a').attr('href');\n    const currentURL = document.location.pathname;\n    return url !== currentURL;\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./PopupAlert.js","import $ from 'jquery';\nimport Change from './Change';\n\nfunction Footer(element, $footprint) {\n  this.$element = $(element);\n  this.$footprint = $footprint;\n  this.register();\n  this.update();\n  this.ready();\n}\n\nFooter.prototype = {\n  register() {\n    Change.onChange(this.update.bind(this));\n  },\n  update() {\n    this.$footprint.height(this.$element.outerHeight());\n  },\n  ready() {\n    this.$element.addClass('ready');\n  },\n};\n\nexport default Footer;\n\n\n\n// WEBPACK FOOTER //\n// ./SmartFooter.js","import $ from 'jquery';\n\nconst defaults = {\n  fade: true,\n  speed: 500,\n  dots: true,\n  arrows: false,\n  responsive: [\n    {\n      breakpoint: 768,\n      settings: {\n        fade: false,\n        speed: 200,\n      },\n    },\n  ],\n};\n\nexport default class StoriesSlider {\n  constructor(element, options) {\n    this.$element = $(element);\n    this.settings = { ...defaults, ...options };\n    this.slider = this.createSlider();\n    this.ready();\n  }\n\n  createSlider() {\n    return this.$element.find('.view-content').slick(this.settings);\n  }\n\n  ready() {\n    this.$element.addClass('ready');\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./StoriesSlider.js","import $ from 'jquery';\n\nfunction Stripper(element) {\n  this.$element = $(element);\n  this.strip();\n}\n\nStripper.prototype = {\n  strip() {\n    this.$element.children().unwrap();\n  },\n};\n\nexport default Stripper;\n\n\n\n// WEBPACK FOOTER //\n// ./Strip.js","import $ from 'jquery';\nimport Viewport from './Viewport';\n\nfunction TermNavigation(element) {\n  this.element = element;\n  this.$element = $(element);\n  this.$menus = this.getMenus();\n  this.onHeaderClick = $.proxy(this.onHeaderClick, this);\n  this.setCurrentState();\n  this.addPatties();\n  this.listen();\n  this.ready();\n}\n\nTermNavigation.prototype = {\n  getMenus() {\n    const $menus = this.$element.find('.block-content .expanded');\n    const $filteredMenus = $menus.has('li a');\n    $menus.removeClass('expanded');\n    $filteredMenus.addClass('expanded');\n    return $filteredMenus;\n  },\n  onHeaderClick(event) {\n    if (Viewport.mobileState) {\n      this.$element.toggleClass('expanded');\n      event.preventDefault();\n    }\n  },\n  onMenuClick(event) {\n    const clickedActivator = $(event.target).is('.menu-link');\n    if (clickedActivator) {\n      $(this).parent().toggleClass('expanded collapsed');\n      event.preventDefault();\n    }\n  },\n  addPatties() {\n    const patties = '<span class=\"patty\"></span><span class=\"patty\"></span><span class=\"patty\"></span>';\n    this.$element.find('.block-title a').prepend(patties);\n  },\n  setCurrentState() {\n    // set all to collapsed other than the active items\n    this.$menus.not('.active-trail').toggleClass('expanded collapsed');\n  },\n  listen() {\n    // Add a click handler to control each submenu's visibility\n    this.$menus.find(' > a').bind('click', this.onMenuClick);\n    // Add a click handler to control the mobile dropdown menu\n    this.$element.find('.block-title a').bind('click', this.onHeaderClick);\n  },\n  ready() {\n    this.$element.addClass('ready');\n  },\n};\n\nexport default TermNavigation;\n\n\n\n// WEBPACK FOOTER //\n// ./TermNavigation.js","import $ from 'jquery';\nimport '../vendor/dotimeout/jquery.ba-dotimeout.min';\n\nconst defaults = {\n  delay: 400,\n  selectors: {\n    menu: '.menu-icon',\n    search: '.search-icon',\n    text: '#edit-box-text',\n    input: '#edit-keywords',\n  },\n};\n\nfunction Toolbar(element, context, options) {\n  this.element = element;\n  this.$element = $(element);\n  this.settings = $.extend(true, defaults, options);\n  this.$body = this.getBody(context);\n  this.$menuBtn = this.getBtn('menu');\n  this.$searchBtn = this.getBtn('search');\n  this.$searchBox = this.getBox(context);\n  this.searchText = this.getText(context);\n  this.menuHandler = $.proxy(this.menuHandler, this);\n  this.searchHandler = $.proxy(this.searchHandler, this);\n  this.resetSearchInput = $.proxy(this.resetSearchInput, this);\n  this.listen();\n}\n\nToolbar.prototype = {\n  getBody(context) {\n    return $(document.body, context);\n  },\n  getBtn(type) {\n    return $(this.settings.selectors[type], this.element);\n  },\n  getText(context) {\n    const $searchText = $(this.settings.selectors.text, context);\n    // clear out the value since we don't want it displayed\n    const searchText = $searchText.val();\n    $searchText.val('');\n    return searchText;\n  },\n  getBox(context) {\n    const $input = $(this.settings.selectors.input, context);\n    $input.val('');\n    return $input;\n  },\n  menuHandler() {\n    const active = this.$body.is('.menu-active');\n    this.$body.filter('.search-active').removeClass('search-active');\n    if (active) {\n      this.$body.removeClass('menu-active');\n    } else {\n      this.$body.addClass('menu-active');\n    }\n  },\n  searchHandler() {\n    const active = this.$body.is('.search-active');\n    this.$body.filter('.menu-active').removeClass('menu-active');\n    if (active) {\n      this.$body.removeClass('search-active');\n      // Cancel any search input timeouts that may be running.\n      this.$searchBox.doTimeout('focus');\n      this.$searchBox.doTimeout('typing');\n    } else {\n      this.$body.addClass('search-active');\n      this.$searchBox.attr('placeholder', '');\n      // Focus the search box after a small delay.\n      this.$searchBox.doTimeout('focus', 750, () => {\n        this.typeOutPlaceholderText();\n      });\n    }\n  },\n  typeOutPlaceholderText() {\n    let i = 0;\n    if (!this.$searchBox.val().length) {\n      this.$searchBox.doTimeout('typing', 60, () => {\n        if (i <= this.searchText.length) {\n          this.$searchBox.attr('placeholder', this.searchText.substr(0, i)).focus();\n          i += 1;\n          return true;\n        }\n\n        return false;\n      });\n    }\n  },\n  resetSearchInput() {\n    // This is a workaround to overcome the default dd-search.js search\n    // input scripted behaviors.\n    if (this.searchText === this.$searchBox.val()) {\n      this.$searchBox.val('');\n    }\n  },\n  listen() {\n    this.$menuBtn.bind('click', this.menuHandler);\n    this.$searchBtn.bind('click', this.searchHandler);\n\n    // Listening so that we can override previously set scripted behaviors.\n    this.$searchBox.bind('blur focus', this.resetSearchInput);\n  },\n};\n\nexport default Toolbar;\n\n\n\n// WEBPACK FOOTER //\n// ./Toolbar.js","import $ from 'jquery';\nimport Viewport from './Viewport';\n\nconst SELECTOR = '.google-translate';\nconst GOOGLE_TRANSLATE = '.goog-te-gadget';\n\nclass Translate {\n  constructor(element) {\n    this.google = null;\n    this.$element = $(element);\n    this.change = this.change.bind(this);\n    this.translateElement = this.translateElement.bind(this);\n    this.$desktop = this.getDesktopPlacement();\n    this.$mobile = this.getMobilePlacement();\n    this.load();\n  }\n\n  getMobilePlacement() {\n    return this.$element.find(`.header-bottom ${SELECTOR}`);\n  }\n\n  getDesktopPlacement() {\n    return this.$element.find(`.header-top ${SELECTOR}`);\n  }\n\n  load() {\n    // Load Google Translate framework.\n    const script = document.createElement('script');\n    script.async = true;\n    script.type = 'text/javascript';\n    script.src = '//translate.google.com/translate_a/element.js?cb=googleTranslateInit';\n    const head = document.getElementsByTagName('head')[0];\n    head.appendChild(script);\n\n    // Add window callback function to signal when the framework is ready.\n    window.googleTranslateInit = () => {\n      this.google = window.google;\n      this.translateElement();\n      this.listen();\n    };\n  }\n\n  translateElement() {\n    return new this.google.translate.TranslateElement(this.settings, 'google-translate');\n  }\n\n  listen() {\n    Viewport.onChange(this.change);\n    Viewport.requestTick();\n  }\n\n  change() {\n    const $gt = this.$element.find(GOOGLE_TRANSLATE);\n    const mode = Viewport.mobileState ? this.$mobile : this.$desktop;\n    mode.append($gt);\n  }\n\n  get settings() {\n    return {\n      pageLanguage: 'en',\n      layout: this.google.translate.TranslateElement.FloatPosition.BOTTOM_RIGHT,\n    };\n  }\n}\n\nexport default Translate;\n\n\n\n// WEBPACK FOOTER //\n// ./Translate.js","import $ from 'jquery';\nimport 'slick-carousel';\n\nconst GET_TWEETS_URL = '/dd_twitter_feed/get_tweets';\n\nconst requestData = {\n  cache: true,\n  dataType: 'html',\n};\n\nconst slickSettings = {\n  speed: 200,\n  dots: true,\n  arrows: false,\n  slidesToShow: 3,\n  slidesToScroll: 1,\n  responsive: [\n    {\n      breakpoint: 1024,\n      settings: {\n        slidesToShow: 2,\n        slidesToScroll: 1,\n        variableWidth: true,\n      },\n    },\n    {\n      breakpoint: 768,\n      settings: {\n        slidesToShow: 1,\n        slidesToScroll: 1,\n        adaptiveHeight: true,\n      },\n    },\n  ],\n};\n\nclass TwitterFeed {\n  constructor(element) {\n    this.$element = $(element);\n    this.success = this.success.bind(this);\n    this.complete = this.complete.bind(this);\n    this.request = this.sendRequest();\n  }\n\n  sendRequest() {\n    return $.ajax(GET_TWEETS_URL, requestData)\n      .success(this.success)\n      .complete(this.complete)\n    ;\n  }\n\n  success(data) {\n    const $tweets = this.$element.find('.tweets');\n    $tweets.html(data);\n    $tweets.slick(slickSettings);\n  }\n\n  complete() {\n    this.$element.addClass('ready');\n  }\n}\n\nexport default TwitterFeed;\n\n\n\n// WEBPACK FOOTER //\n// ./TwitterFeed.js","import $ from 'jquery';\n\nconst defaults = {\n  showVideoAtThisBreakpoint: 720,\n  playBtn: '<button class=\"slick-play slick-btn\" type=\"button\" aria-label=\"Play\">Play</button>',\n  pauseBtn: '<button class=\"slick-pause slick-btn\" type=\"button\" aria-label=\"Pause\">Pause</button>',\n};\n\nfunction Video(element, options) {\n  this.element = element;\n  this.$element = $(element);\n  this.settings = { ...defaults, ...options };\n  this.video = null;\n  this.playing = false;\n  this.playPause = this.playPause.bind(this);\n  this.$playBtn = this.addPlayBtn();\n  this.$pauseBtn = this.addPauseBtn();\n  this.$bgVideo = this.getVideo();\n  this.$destination = this.getDestination();\n  this.init();\n}\n\nVideo.prototype = {\n  init() {\n    // if the background element or image isn't found, quit.\n    if (!this.$bgVideo.length || !this.$destination) return;\n    // show if applicable\n    if ($(window).width() >= this.settings.showVideoAtThisBreakpoint && !this.isMobileDevice()) {\n      this.addVideo();\n    }\n  },\n  isMobileDevice() {\n    return /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);\n  },\n  getVideo() {\n    return this.$element.find('.background-video');\n  },\n  getDestination() {\n    return this.$element.find('.field-image.c1 img');\n  },\n  addPlayBtn() {\n    return $(this.settings.playBtn);\n  },\n  addPauseBtn() {\n    return $(this.settings.pauseBtn);\n  },\n  addVideo() {\n    const $source = this.$bgVideo.find('.video');\n    const $check = $source.data('src');\n    let sources;\n    if (typeof $check !== 'undefined') {\n      sources = $source.data('src').replace(/\\s/g, '').split(',');\n    }\n    const $video = $('<video autoplay loop muted></video>');\n\n    // Assign the video element so we can use it.\n    this.video = $video[0];\n\n    $.each(sources, (i, src) => {\n      const type = src.substring(src.lastIndexOf('.') + 1);\n      $video.append(`<source src=\"${src}\" type=\"video/${type}\">`);\n    });\n\n    this.$destination.replaceWith($video);\n\n    // Fired when the browser has finished loading the metadata for the video\n    // and all attributes have been populated.\n    $video.bind('loadeddata', () => {\n      this.$element.addClass('ready');\n      this.addControls();\n    });\n\n    // Fired when the video starts playing, for the first time, after being paused\n    // or when restarting.\n    $video.bind('playing', () => {\n      this.playing = true;\n      this.setCurrentState();\n    });\n\n    // Add a helper class to possibly style this block differently if a video is present.\n    this.$element.addClass('has-background-video');\n\n    // Delete temp markup\n    this.$bgVideo.remove();\n  },\n  addControls() {\n    // Add play and pause the controls and finally add the controls container\n    this.$element.append(this.$playBtn, this.$pauseBtn);\n\n    // Add click handlers to each button to control autoplay functionality\n    this.$playBtn.on('click', this.playPause);\n    this.$pauseBtn.on('click', this.playPause);\n  },\n  playPause() {\n    if (this.playing) {\n      this.video.pause();\n      this.playing = false;\n    } else {\n      this.video.play();\n      this.playing = true;\n    }\n    this.setCurrentState();\n  },\n  setPlayState() {\n    this.$playBtn.attr('aria-hidden', 'false');\n    this.$pauseBtn.attr('aria-hidden', 'true');\n  },\n  setPauseState() {\n    this.$playBtn.attr('aria-hidden', 'true');\n    this.$pauseBtn.attr('aria-hidden', 'false');\n  },\n  setCurrentState() {\n    if (this.playing) {\n      this.setPauseState();\n    } else {\n      this.setPlayState();\n    }\n  },\n};\n\nexport default Video;\n\n\n\n// WEBPACK FOOTER //\n// ./Video.js","// Define a module that works with CommonJS (Node/Babel) and AMD (RequireJS).\n(function(factory) {\n  if (typeof define === 'function' && define.amd) {\n    define(['jquery'], factory);\n  } else {\n    module.exports = factory(require('jquery'));\n  }\n})(function($) {\n  'use strict';\n\n  var defaults = {\n    photoGalleryPID: 107,\n    behaviors: {\n      relatedLinks: true,\n      itemAppearsIn: true,\n      fullNodeRelatedLinks: true,\n      bundledReferringContent: true,\n      lexiconGlossary: true,\n      subtermOverviews: true,\n      nodeMeta: true,\n      imageCaptions: true,\n      slideshowIcons: true,\n      expandingDates: true\n    }\n  };\n\n  var DDTemplates = function(context, options) {\n    this.context = context;\n    this._defaults = defaults;\n    this.isNodeView = this.isNode(context);\n    this.settings = $.extend(true, defaults, options);\n    this.init();\n  };\n\n  DDTemplates.prototype = {\n    init: function() {\n      var context = this.context;\n      var view = this.isNodeView ? 'node' : 'term';\n      // Global behaviors\n      this.defineApplicableBehaviors('global', context);\n      // Current view behaviors only\n      this.defineApplicableBehaviors(view, context);\n    },\n    /**\n     * Simple check to see if the current body element contains the node class.\n     */\n    isNode: function(context) {\n      return $(document.body, context).is('.n, .section-node');\n    },\n    /**\n     * A way to enable only behaviors the theme requires.\n     */\n    addEnabledBehavior: function(behavior) {\n      var enabled = this.settings.behaviors[behavior];\n      if (enabled) {\n        this[behavior](this.context);\n      }\n      return true;\n    },\n    /**\n     * Segregates behaviors by different types of common views. If they're\n     * enabled, define them in this module.\n     */\n    defineApplicableBehaviors: function(view) {\n      var self = this;\n      var behaviors = {\n        node: [\n          'itemAppearsIn',\n          'fullNodeRelatedLinks',\n          'bundledReferringContent'\n        ],\n        term: [\n          'lexiconGlossary',\n          'subtermOverviews'\n        ],\n        global: [\n          'nodeMeta',\n          'relatedLinks',\n          'imageCaptions',\n          'slideshowIcons',\n          'expandingDates'\n        ]\n      };\n\n      // Cycle through each behavior and only add it if it's enabled\n      $.each(behaviors[view], function(i, behavior) {\n        self.addEnabledBehavior(behavior);\n      });\n\n      return true;\n    },\n    /**\n     * Helper class for theming related links sitewide.\n     * @status DEPRECATED\n     */\n    relatedLinks: function() {},\n    /**\n     * Helper class for theming the appearing navigation block\n     */\n    itemAppearsIn: function(context) {\n      var $appearingNav = $('.appearing-nav', context);\n      var $links = $appearingNav.find('ul.links li');\n      if (!$links.length) {\n        $appearingNav.addClass('placeholder-block');\n      }\n    },\n    /**\n     * Sets the block to show if one or more links are found\n     */\n    fullNodeRelatedLinks: function(context) {\n      var $nodeFields = $('#block-digitaldcore-node_fields',context);\n      var $relatedLinks = $nodeFields.find('.node-links');\n      var numLinks = $relatedLinks.find('.link-related, .link-file').length;\n\n      if (!numLinks) {\n        $relatedLinks.addClass('placeholder-block');\n      }\n    },\n    /**\n     * Hides the blocks if no content is present.\n     */\n    bundledReferringContent: function(context) {\n      var $blocks = $('#block-digitaldcore-node_referring, #block-digitaldcore-node_bundled', context);\n      $blocks.each(function() {\n        var $block = $(this);\n        var $nodes = $block.find('.node-teaser');\n        if (!$nodes.length) {\n          $block.addClass('placeholder-block');\n        }\n      });\n    },\n    /**\n     * Finds the real last meta item and identifies node of visible meta info\n     */\n    nodeMeta: function(context) {\n      var $nodes = $('.node', context);\n      $nodes.each(function() {\n        // Create a meta object\n        var $node = $(this);\n        var $meta = $node.find('.node-upper-meta');\n        var $items = $meta.find('.meta-item');\n\n        // Clean up last classname\n        $items.removeClass('last');\n\n        // Get all visible meta items\n        var $visible = $items.map(function() {\n          return $(this).css('display') !== 'none' ? this : null;\n        });\n\n        // Correctly identify last meta item and label node with the has-meta flag\n        if ($visible.length) {\n          $node.addClass('has-meta');\n          $visible.filter(':last').addClass('last new-dd-templates-functionality');\n        }\n      });\n    },\n    /**\n     * If there is more than two event dates, functionality is added to show and\n     * hide all events within one container.\n     *\n     * Helps cleans up the look of meta data.\n     *\n     * @note:\n     *   This is only enabled for blocks with the 'posts' classname and all\n     *   full post views\n     */\n    expandingDates: function(context) {\n      $('.posts .node, .node-full', context).each(function(i, node) {\n        var $meta = $('.node-meta, .node-upper-meta', node);\n        $meta.each(function(i, meta) {\n          var $meta = $(meta);\n          var $dates = $('.event-date', node);\n          if ($dates.length > 2) {\n            // Create and add functionality to display all other dates\n            var $link = $('<a class=\"meta-item all-dates-link\" href=\"#\">Show all dates</a>');\n            $link.bind('click', function(event) {\n              event.preventDefault();\n              $meta.toggleClass('show-all-dates');\n              $(this).text(\n                $meta.is('.show-all-dates')\n                  ? 'Hide all dates'\n                  : 'Show all dates'\n              );\n            });\n            $link.insertBefore($dates.eq(0));\n\n            // Move all other dates\n            var $container = $('<div class=\"all-dates\"></div>');\n            $dates.appendTo($container);\n            $meta.append($container);\n          }\n        });\n      });\n    },\n    /**\n     * Field image caption control\n     */\n    imageCaptions: function(context) {\n      // Identifies an image that should have a caption added\n      $('.field-image img[title]', context).each(function() {\n        var $image = $(this);\n        var caption = $image.attr('title');\n        // Continue processing this title isn't an empty string\n        if (caption.length) {\n          var $field = $image.parents('.field-image');\n          var $link = $field.find('a');\n          // delete the existing caption if it exists\n          $field.find('.caption').remove();\n          // Add a helper class for theming\n          $field.addClass('has-caption');\n          // Add the caption to the link\n          $link.append('<span class=\"caption\">' + caption + '</span>');\n          // Sets the container link a maximum width so the caption doesn't expand\n          // bigger than the image width\n          //var imgWidth = $image.attr('width');\n          //if (imgWidth && imgWidth > 0) {\n          //  $link.css('max-width', imgWidth + 'px');\n          //}\n        }\n      });\n    },\n    /**\n     * Adds markup to slideshow teasers to show an icon overlay\n     */\n    slideshowIcons: function(context) {\n      var $slideshowNodes = $('.pt' + this.settings.photoGalleryPID + '.node-teaser', context);\n      // cycle through each node instance\n      $slideshowNodes.each(function() {\n        var $images = $(this).find('.field-image');\n        // cycle through each field image instance\n        $images.each(function() {\n          var $img = $(this).find('img');\n          // add a button helper classname\n          $(this).find('a').addClass('slideshow-btn');\n          // prepend the icon overlay\n          $img.before('<i class=\"slideshow-icon\"></i>');\n        });\n      });\n\n    },\n    /**\n     * Adds the has more class to subterm overviews to properly control node-link display\n     */\n    subtermOverviews: function(context) {\n      $('.subterm-overview .node-teaser', context).removeClass('no-more').addClass('has-more');\n    },\n    /**\n     * Helper function to theme the category letters and seperate the sections\n     */\n    lexiconGlossary: function(context) {\n      $('#glossary', context).find('.lexicon-list > a').each(function() {\n        var letter = $(this).attr('id').replace('letter_', '');\n        $(this).html(letter.toUpperCase());\n      });\n    }\n  };\n\n  return DDTemplates;\n\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/dd-templates/js/ddTemplates.js\n// module id = 27\n// module chunks = 0","// Absolute imports\nimport $ from 'jquery';\nimport DDTemplates from 'dd-templates';\n// Relative imports\nimport Menu from './Menu';\nimport Drupal from './Drupal';\nimport Header from './Header';\nimport Gallery from './Gallery';\nimport Toolbar from './Toolbar';\nimport MobileMenu from './MobileMenu';\nimport SmartFooter from './SmartFooter';\nimport CalendarFeed from './CalendarFeed';\nimport FixNavigation from './FixNavigation';\nimport TermNavigation from './TermNavigation';\n// Relative theme specific imports\nimport Strip from './Strip';\nimport Notification from './Notification';\nimport DistrictAlert from './DistrictAlert';\nimport PopupAlert from './PopupAlert';\nimport BackgroundImage from './BackgroundImage';\nimport Placeholder from './Placeholder';\nimport Parallax from './Parallax';\nimport Expanded from './Expanded';\nimport TwitterFeed from './TwitterFeed';\nimport StoriesSlider from './StoriesSlider';\nimport Translate from './Translate';\nimport Video from './Video';\n\n// Add the theme behaviors\n\nDrupal.behavior((context) => {\n  // Helpers\n\n  const $body = $(document.body, context);\n\n  // DD Template Behaviors\n\n  // eslint-disable-next-line no-new\n  new DDTemplates(context);\n\n  // Fix our damn menus from displaying orphaned children\n\n  $('.primary-navigation, .term-nav', context).each((i, element) => {\n    if (!element.FixNavigation) {\n      element.FixNavigation = new FixNavigation(element);\n    }\n  });\n\n  // Get bundled content from URL\n  const postUrl = $('.hero.banner .node-header a', context).attr('href');\n  $.get(postUrl, (data) => {\n    const elements = $(data);\n    const bundledContent = $('.bundled-posts article', elements);\n    bundledContent.each((i, element) => {\n      $('.bundled-wrapper').append(element);\n    });\n\n    // Add a wrapper around bundled content items that contains a URL to the node\n    $('.hero.banner .node-inner', context).each((i, element) => {\n      $('.bundled-wrapper .links', element).each((j, item) => {\n        const wrapper = $(item).parent().parent().parent();\n        const newLink = document.createElement('a');\n        $(newLink).addClass('wrapped-link');\n        $(newLink).attr('href', $(item).find('.link-read-more a').attr('href'));\n        wrapper.wrap(newLink);\n      });\n    });\n  });\n\n  // Add wrapper for bundled content\n  $('.hero.banner .views-row .node-inner', context).each((i, element) => {\n    const d = document.createElement('div');\n    $(d).addClass('bundled-wrapper');\n    $(d).appendTo(element);\n  });\n\n  // Move .node-image to another parent\n  $('.hero.banner .node-image', context).each((i, element) => {\n    $('.hero.banner article').append(element);\n  });\n\n  $('.hero.banner .node-inner', context).each((i, element) => {\n    const elements = $(element).find('.node-upper-meta, .node-header, .node-content, .node-links');\n    const newElement = document.createElement('div');\n    $(newElement).addClass('content-inner');\n    $(elements).each((j, item) => {\n      newElement.append(item);\n    });\n    element.append(newElement);\n  });\n\n  // Main/Primary Site Navigation\n  $('#block-nice_menus-3', context).each((i, element) => {\n    if (!element.menu && !element.mobileMenu) {\n      element.menu = new Menu(element);\n      element.mobileMenu = new MobileMenu(element);\n    }\n  });\n\n  // Notifications\n\n  $('#block-views_blocks-term-block_1-4', context).each((i, element) => {\n    if (!element.Notification) {\n      element.Notification = new Notification(element);\n    }\n  });\n\n  // District Alerts\n\n  $('#block-views_blocks-term-block_1-11', context).each((i, element) => {\n    if (!element.DistrictAlert) {\n      element.DistrictAlert = new DistrictAlert(element);\n    }\n  });\n\n  // Popup Alert\n\n  $('.popup-alert', context).each((i, element) => {\n    if (!element.PopupAlert) {\n      element.PopupAlert = new PopupAlert(element);\n    }\n  });\n\n  // Resource Slidemenus\n\n  $('.slidemenu.block .views-row', context).each((i, element) => {\n    if (!element.Expanded) {\n      element.Expanded = new Expanded(element);\n    }\n  });\n\n  // Twitter Feed\n\n  $('.twitter-feed', context).each((i, element) => {\n    if (!element.TwitterFeed) {\n      element.TwitterFeed = new TwitterFeed(element);\n    }\n  });\n\n  // Stories Slider\n\n  $('#block-views_blocks-term-block_1-8', context).each((i, element) => {\n    if (!element.StoriesSlider) {\n      element.StoriesSlider = new StoriesSlider(element);\n    }\n  });\n\n  // Controls the states of the menu and search states\n\n  $('.site-toolbar', context).each((i, element) => {\n    if (!element.toolbar) {\n      element.toolbar = new Toolbar(element);\n    }\n  });\n\n  // Controls the page overlay display\n\n  $('.overlay', context).bind('click', () => {\n    $body.removeClass('menu-active search-active');\n  });\n\n  // Hero and Term Banner Parallax Backgrounds\n\n  $('.banner.block .field-image a', context).each((i, element) => {\n    if (!element.Parallax) {\n      element.Parallax = new Parallax(element);\n      $body.addClass('has-banner');\n    }\n  });\n\n  // Hero Banner Video Backgrounds\n\n  $('#block-views_blocks-term-block_1-6', context).each((i, element) => {\n    if (!element.Video) {\n      element.Video = new Video(element);\n    }\n  });\n\n  // Pod Background Images\n\n  $('.pods.block .node, .home-pods.block .node', context).each((i, element) => {\n    if (!element.BackgroundImage) {\n      element.BackgroundImage = new BackgroundImage(element);\n    }\n  });\n\n  // Add placeholder text to all text and textarea components.\n\n  $('.node-webform .type-textfield, .node-webform .type-textarea', context).each((i, element) => {\n    if (!element.Placeholder) {\n      element.Placeholder = new Placeholder(element);\n    }\n  });\n\n  // Fixed Header using Headroom.js\n\n  $('.headroom', context).each((i, element) => {\n    if (!element.headroom) {\n      element.headroom = new Header(element);\n    }\n  });\n\n  // Smart Footer\n\n  $('.page-footer', context).each((i, footer) => {\n    const $footprint = $('.footprint', context);\n    if (!footer.smartFooter && $footprint.length) {\n      footer.smartFooter = new SmartFooter(footer, $footprint);\n    }\n  });\n\n  // Term Navigation\n\n  $('.term-nav', context).each((i, element) => {\n    if (!element.termNavigation) {\n      element.termNavigation = new TermNavigation(element);\n    }\n  });\n\n  // Photo Galleries\n\n  $('.node-content .photo-gallery, .photo-gallery .node-image, .photo-gallery .node-upper-image', context).each((i, element) => {\n    if (!element.gallery) {\n      element.gallery = new Gallery(element);\n    }\n  });\n\n  // Calendar of Events View\n\n  $('.calendar-feed', context).each((i, element) => {\n    if (!element.calendarFeed) {\n      element.calendarFeed = new CalendarFeed(element);\n    }\n  });\n\n  // Strip various header links\n\n  $('.footer-links .node-header a, .overview .node-header a', context).each((i, element) => {\n    if (!element.strip) {\n      element.strip = new Strip(element);\n    }\n  });\n\n  // Relocate Google Translate dependent on viewport\n  $('.page-header', context).each((i, element) => {\n    if (!element.Translate) {\n      element.Translate = new Translate(element);\n    }\n  });\n\n  // Add Sitemap output using the digitaldcore.js function\n\n  const $map = $('#sitemap', context);\n  const $nav = $('#sitemap .content', context);\n\n  if ($map.length && $nav.length) {\n    Drupal.digitaldcoreCreateSiteMap($map, $nav);\n    $map.addClass('ready');\n  }\n});\n\n\n\n// WEBPACK FOOTER //\n// ./theme.js","/*!\n * headroom.js v0.9.3 - Give your page some headroom. Hide your header until you need it\n * Copyright (c) 2016 Nick Williams - http://wicky.nillia.ms/headroom.js\n * License: MIT\n */\n\n(function(root, factory) {\n  'use strict';\n\n  if (typeof define === 'function' && define.amd) {\n    // AMD. Register as an anonymous module.\n    define([], factory);\n  }\n  else if (typeof exports === 'object') {\n    // COMMONJS\n    module.exports = factory();\n  }\n  else {\n    // BROWSER\n    root.Headroom = factory();\n  }\n}(this, function() {\n  'use strict';\n\n  /* exported features */\n  \n  var features = {\n    bind : !!(function(){}.bind),\n    classList : 'classList' in document.documentElement,\n    rAF : !!(window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame)\n  };\n  window.requestAnimationFrame = window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame;\n  \n  /**\n   * Handles debouncing of events via requestAnimationFrame\n   * @see http://www.html5rocks.com/en/tutorials/speed/animations/\n   * @param {Function} callback The callback to handle whichever event\n   */\n  function Debouncer (callback) {\n    this.callback = callback;\n    this.ticking = false;\n  }\n  Debouncer.prototype = {\n    constructor : Debouncer,\n  \n    /**\n     * dispatches the event to the supplied callback\n     * @private\n     */\n    update : function() {\n      this.callback && this.callback();\n      this.ticking = false;\n    },\n  \n    /**\n     * ensures events don't get stacked\n     * @private\n     */\n    requestTick : function() {\n      if(!this.ticking) {\n        requestAnimationFrame(this.rafCallback || (this.rafCallback = this.update.bind(this)));\n        this.ticking = true;\n      }\n    },\n  \n    /**\n     * Attach this as the event listeners\n     */\n    handleEvent : function() {\n      this.requestTick();\n    }\n  };\n  /**\n   * Check if object is part of the DOM\n   * @constructor\n   * @param {Object} obj element to check\n   */\n  function isDOMElement(obj) {\n    return obj && typeof window !== 'undefined' && (obj === window || obj.nodeType);\n  }\n  \n  /**\n   * Helper function for extending objects\n   */\n  function extend (object /*, objectN ... */) {\n    if(arguments.length <= 0) {\n      throw new Error('Missing arguments in extend function');\n    }\n  \n    var result = object || {},\n        key,\n        i;\n  \n    for (i = 1; i < arguments.length; i++) {\n      var replacement = arguments[i] || {};\n  \n      for (key in replacement) {\n        // Recurse into object except if the object is a DOM element\n        if(typeof result[key] === 'object' && ! isDOMElement(result[key])) {\n          result[key] = extend(result[key], replacement[key]);\n        }\n        else {\n          result[key] = result[key] || replacement[key];\n        }\n      }\n    }\n  \n    return result;\n  }\n  \n  /**\n   * Helper function for normalizing tolerance option to object format\n   */\n  function normalizeTolerance (t) {\n    return t === Object(t) ? t : { down : t, up : t };\n  }\n  \n  /**\n   * UI enhancement for fixed headers.\n   * Hides header when scrolling down\n   * Shows header when scrolling up\n   * @constructor\n   * @param {DOMElement} elem the header element\n   * @param {Object} options options for the widget\n   */\n  function Headroom (elem, options) {\n    options = extend(options, Headroom.options);\n  \n    this.lastKnownScrollY = 0;\n    this.elem             = elem;\n    this.tolerance        = normalizeTolerance(options.tolerance);\n    this.classes          = options.classes;\n    this.offset           = options.offset;\n    this.scroller         = options.scroller;\n    this.initialised      = false;\n    this.onPin            = options.onPin;\n    this.onUnpin          = options.onUnpin;\n    this.onTop            = options.onTop;\n    this.onNotTop         = options.onNotTop;\n    this.onBottom         = options.onBottom;\n    this.onNotBottom      = options.onNotBottom;\n  }\n  Headroom.prototype = {\n    constructor : Headroom,\n  \n    /**\n     * Initialises the widget\n     */\n    init : function() {\n      if(!Headroom.cutsTheMustard) {\n        return;\n      }\n  \n      this.debouncer = new Debouncer(this.update.bind(this));\n      this.elem.classList.add(this.classes.initial);\n  \n      // defer event registration to handle browser \n      // potentially restoring previous scroll position\n      setTimeout(this.attachEvent.bind(this), 100);\n  \n      return this;\n    },\n  \n    /**\n     * Unattaches events and removes any classes that were added\n     */\n    destroy : function() {\n      var classes = this.classes;\n  \n      this.initialised = false;\n      this.elem.classList.remove(classes.unpinned, classes.pinned, classes.top, classes.notTop, classes.initial);\n      this.scroller.removeEventListener('scroll', this.debouncer, false);\n    },\n  \n    /**\n     * Attaches the scroll event\n     * @private\n     */\n    attachEvent : function() {\n      if(!this.initialised){\n        this.lastKnownScrollY = this.getScrollY();\n        this.initialised = true;\n        this.scroller.addEventListener('scroll', this.debouncer, false);\n  \n        this.debouncer.handleEvent();\n      }\n    },\n    \n    /**\n     * Unpins the header if it's currently pinned\n     */\n    unpin : function() {\n      var classList = this.elem.classList,\n        classes = this.classes;\n      \n      if(classList.contains(classes.pinned) || !classList.contains(classes.unpinned)) {\n        classList.add(classes.unpinned);\n        classList.remove(classes.pinned);\n        this.onUnpin && this.onUnpin.call(this);\n      }\n    },\n  \n    /**\n     * Pins the header if it's currently unpinned\n     */\n    pin : function() {\n      var classList = this.elem.classList,\n        classes = this.classes;\n      \n      if(classList.contains(classes.unpinned)) {\n        classList.remove(classes.unpinned);\n        classList.add(classes.pinned);\n        this.onPin && this.onPin.call(this);\n      }\n    },\n  \n    /**\n     * Handles the top states\n     */\n    top : function() {\n      var classList = this.elem.classList,\n        classes = this.classes;\n      \n      if(!classList.contains(classes.top)) {\n        classList.add(classes.top);\n        classList.remove(classes.notTop);\n        this.onTop && this.onTop.call(this);\n      }\n    },\n  \n    /**\n     * Handles the not top state\n     */\n    notTop : function() {\n      var classList = this.elem.classList,\n        classes = this.classes;\n      \n      if(!classList.contains(classes.notTop)) {\n        classList.add(classes.notTop);\n        classList.remove(classes.top);\n        this.onNotTop && this.onNotTop.call(this);\n      }\n    },\n  \n    bottom : function() {\n      var classList = this.elem.classList,\n        classes = this.classes;\n      \n      if(!classList.contains(classes.bottom)) {\n        classList.add(classes.bottom);\n        classList.remove(classes.notBottom);\n        this.onBottom && this.onBottom.call(this);\n      }\n    },\n  \n    /**\n     * Handles the not top state\n     */\n    notBottom : function() {\n      var classList = this.elem.classList,\n        classes = this.classes;\n      \n      if(!classList.contains(classes.notBottom)) {\n        classList.add(classes.notBottom);\n        classList.remove(classes.bottom);\n        this.onNotBottom && this.onNotBottom.call(this);\n      }\n    },\n  \n    /**\n     * Gets the Y scroll position\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/Window.scrollY\n     * @return {Number} pixels the page has scrolled along the Y-axis\n     */\n    getScrollY : function() {\n      return (this.scroller.pageYOffset !== undefined)\n        ? this.scroller.pageYOffset\n        : (this.scroller.scrollTop !== undefined)\n          ? this.scroller.scrollTop\n          : (document.documentElement || document.body.parentNode || document.body).scrollTop;\n    },\n  \n    /**\n     * Gets the height of the viewport\n     * @see http://andylangton.co.uk/blog/development/get-viewport-size-width-and-height-javascript\n     * @return {int} the height of the viewport in pixels\n     */\n    getViewportHeight : function () {\n      return window.innerHeight\n        || document.documentElement.clientHeight\n        || document.body.clientHeight;\n    },\n  \n    /**\n     * Gets the physical height of the DOM element\n     * @param  {Object}  elm the element to calculate the physical height of which\n     * @return {int}     the physical height of the element in pixels\n     */\n    getElementPhysicalHeight : function (elm) {\n      return Math.max(\n        elm.offsetHeight,\n        elm.clientHeight\n      );\n    },\n  \n    /**\n     * Gets the physical height of the scroller element\n     * @return {int} the physical height of the scroller element in pixels\n     */\n    getScrollerPhysicalHeight : function () {\n      return (this.scroller === window || this.scroller === document.body)\n        ? this.getViewportHeight()\n        : this.getElementPhysicalHeight(this.scroller);\n    },\n  \n    /**\n     * Gets the height of the document\n     * @see http://james.padolsey.com/javascript/get-document-height-cross-browser/\n     * @return {int} the height of the document in pixels\n     */\n    getDocumentHeight : function () {\n      var body = document.body,\n        documentElement = document.documentElement;\n    \n      return Math.max(\n        body.scrollHeight, documentElement.scrollHeight,\n        body.offsetHeight, documentElement.offsetHeight,\n        body.clientHeight, documentElement.clientHeight\n      );\n    },\n  \n    /**\n     * Gets the height of the DOM element\n     * @param  {Object}  elm the element to calculate the height of which\n     * @return {int}     the height of the element in pixels\n     */\n    getElementHeight : function (elm) {\n      return Math.max(\n        elm.scrollHeight,\n        elm.offsetHeight,\n        elm.clientHeight\n      );\n    },\n  \n    /**\n     * Gets the height of the scroller element\n     * @return {int} the height of the scroller element in pixels\n     */\n    getScrollerHeight : function () {\n      return (this.scroller === window || this.scroller === document.body)\n        ? this.getDocumentHeight()\n        : this.getElementHeight(this.scroller);\n    },\n  \n    /**\n     * determines if the scroll position is outside of document boundaries\n     * @param  {int}  currentScrollY the current y scroll position\n     * @return {bool} true if out of bounds, false otherwise\n     */\n    isOutOfBounds : function (currentScrollY) {\n      var pastTop  = currentScrollY < 0,\n        pastBottom = currentScrollY + this.getScrollerPhysicalHeight() > this.getScrollerHeight();\n      \n      return pastTop || pastBottom;\n    },\n  \n    /**\n     * determines if the tolerance has been exceeded\n     * @param  {int} currentScrollY the current scroll y position\n     * @return {bool} true if tolerance exceeded, false otherwise\n     */\n    toleranceExceeded : function (currentScrollY, direction) {\n      return Math.abs(currentScrollY-this.lastKnownScrollY) >= this.tolerance[direction];\n    },\n  \n    /**\n     * determine if it is appropriate to unpin\n     * @param  {int} currentScrollY the current y scroll position\n     * @param  {bool} toleranceExceeded has the tolerance been exceeded?\n     * @return {bool} true if should unpin, false otherwise\n     */\n    shouldUnpin : function (currentScrollY, toleranceExceeded) {\n      var scrollingDown = currentScrollY > this.lastKnownScrollY,\n        pastOffset = currentScrollY >= this.offset;\n  \n      return scrollingDown && pastOffset && toleranceExceeded;\n    },\n  \n    /**\n     * determine if it is appropriate to pin\n     * @param  {int} currentScrollY the current y scroll position\n     * @param  {bool} toleranceExceeded has the tolerance been exceeded?\n     * @return {bool} true if should pin, false otherwise\n     */\n    shouldPin : function (currentScrollY, toleranceExceeded) {\n      var scrollingUp  = currentScrollY < this.lastKnownScrollY,\n        pastOffset = currentScrollY <= this.offset;\n  \n      return (scrollingUp && toleranceExceeded) || pastOffset;\n    },\n  \n    /**\n     * Handles updating the state of the widget\n     */\n    update : function() {\n      var currentScrollY  = this.getScrollY(),\n        scrollDirection = currentScrollY > this.lastKnownScrollY ? 'down' : 'up',\n        toleranceExceeded = this.toleranceExceeded(currentScrollY, scrollDirection);\n  \n      if(this.isOutOfBounds(currentScrollY)) { // Ignore bouncy scrolling in OSX\n        return;\n      }\n  \n      if (currentScrollY <= this.offset ) {\n        this.top();\n      } else {\n        this.notTop();\n      }\n  \n      if(currentScrollY + this.getViewportHeight() >= this.getScrollerHeight()) {\n        this.bottom();\n      }\n      else {\n        this.notBottom();\n      }\n  \n      if(this.shouldUnpin(currentScrollY, toleranceExceeded)) {\n        this.unpin();\n      }\n      else if(this.shouldPin(currentScrollY, toleranceExceeded)) {\n        this.pin();\n      }\n  \n      this.lastKnownScrollY = currentScrollY;\n    }\n  };\n  /**\n   * Default options\n   * @type {Object}\n   */\n  Headroom.options = {\n    tolerance : {\n      up : 0,\n      down : 0\n    },\n    offset : 0,\n    scroller: window,\n    classes : {\n      pinned : 'headroom--pinned',\n      unpinned : 'headroom--unpinned',\n      top : 'headroom--top',\n      notTop : 'headroom--not-top',\n      bottom : 'headroom--bottom',\n      notBottom : 'headroom--not-bottom',\n      initial : 'headroom'\n    }\n  };\n  Headroom.cutsTheMustard = typeof features !== 'undefined' && features.rAF && features.bind && features.classList;\n\n  return Headroom;\n}));\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/headroom.js/dist/headroom.js\n// module id = 29\n// module chunks = 0","//! moment.js\n//! version : 2.18.1\n//! authors : Tim Wood, Iskren Chernev, Moment.js contributors\n//! license : MIT\n//! momentjs.com\n\n;(function (global, factory) {\n    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n    typeof define === 'function' && define.amd ? define(factory) :\n    global.moment = factory()\n}(this, (function () { 'use strict';\n\nvar hookCallback;\n\nfunction hooks () {\n    return hookCallback.apply(null, arguments);\n}\n\n// This is done to register the method called with moment()\n// without creating circular dependencies.\nfunction setHookCallback (callback) {\n    hookCallback = callback;\n}\n\nfunction isArray(input) {\n    return input instanceof Array || Object.prototype.toString.call(input) === '[object Array]';\n}\n\nfunction isObject(input) {\n    // IE8 will treat undefined and null as object if it wasn't for\n    // input != null\n    return input != null && Object.prototype.toString.call(input) === '[object Object]';\n}\n\nfunction isObjectEmpty(obj) {\n    var k;\n    for (k in obj) {\n        // even if its not own property I'd still call it non-empty\n        return false;\n    }\n    return true;\n}\n\nfunction isUndefined(input) {\n    return input === void 0;\n}\n\nfunction isNumber(input) {\n    return typeof input === 'number' || Object.prototype.toString.call(input) === '[object Number]';\n}\n\nfunction isDate(input) {\n    return input instanceof Date || Object.prototype.toString.call(input) === '[object Date]';\n}\n\nfunction map(arr, fn) {\n    var res = [], i;\n    for (i = 0; i < arr.length; ++i) {\n        res.push(fn(arr[i], i));\n    }\n    return res;\n}\n\nfunction hasOwnProp(a, b) {\n    return Object.prototype.hasOwnProperty.call(a, b);\n}\n\nfunction extend(a, b) {\n    for (var i in b) {\n        if (hasOwnProp(b, i)) {\n            a[i] = b[i];\n        }\n    }\n\n    if (hasOwnProp(b, 'toString')) {\n        a.toString = b.toString;\n    }\n\n    if (hasOwnProp(b, 'valueOf')) {\n        a.valueOf = b.valueOf;\n    }\n\n    return a;\n}\n\nfunction createUTC (input, format, locale, strict) {\n    return createLocalOrUTC(input, format, locale, strict, true).utc();\n}\n\nfunction defaultParsingFlags() {\n    // We need to deep clone this object.\n    return {\n        empty           : false,\n        unusedTokens    : [],\n        unusedInput     : [],\n        overflow        : -2,\n        charsLeftOver   : 0,\n        nullInput       : false,\n        invalidMonth    : null,\n        invalidFormat   : false,\n        userInvalidated : false,\n        iso             : false,\n        parsedDateParts : [],\n        meridiem        : null,\n        rfc2822         : false,\n        weekdayMismatch : false\n    };\n}\n\nfunction getParsingFlags(m) {\n    if (m._pf == null) {\n        m._pf = defaultParsingFlags();\n    }\n    return m._pf;\n}\n\nvar some;\nif (Array.prototype.some) {\n    some = Array.prototype.some;\n} else {\n    some = function (fun) {\n        var t = Object(this);\n        var len = t.length >>> 0;\n\n        for (var i = 0; i < len; i++) {\n            if (i in t && fun.call(this, t[i], i, t)) {\n                return true;\n            }\n        }\n\n        return false;\n    };\n}\n\nvar some$1 = some;\n\nfunction isValid(m) {\n    if (m._isValid == null) {\n        var flags = getParsingFlags(m);\n        var parsedParts = some$1.call(flags.parsedDateParts, function (i) {\n            return i != null;\n        });\n        var isNowValid = !isNaN(m._d.getTime()) &&\n            flags.overflow < 0 &&\n            !flags.empty &&\n            !flags.invalidMonth &&\n            !flags.invalidWeekday &&\n            !flags.nullInput &&\n            !flags.invalidFormat &&\n            !flags.userInvalidated &&\n            (!flags.meridiem || (flags.meridiem && parsedParts));\n\n        if (m._strict) {\n            isNowValid = isNowValid &&\n                flags.charsLeftOver === 0 &&\n                flags.unusedTokens.length === 0 &&\n                flags.bigHour === undefined;\n        }\n\n        if (Object.isFrozen == null || !Object.isFrozen(m)) {\n            m._isValid = isNowValid;\n        }\n        else {\n            return isNowValid;\n        }\n    }\n    return m._isValid;\n}\n\nfunction createInvalid (flags) {\n    var m = createUTC(NaN);\n    if (flags != null) {\n        extend(getParsingFlags(m), flags);\n    }\n    else {\n        getParsingFlags(m).userInvalidated = true;\n    }\n\n    return m;\n}\n\n// Plugins that add properties should also add the key here (null value),\n// so we can properly clone ourselves.\nvar momentProperties = hooks.momentProperties = [];\n\nfunction copyConfig(to, from) {\n    var i, prop, val;\n\n    if (!isUndefined(from._isAMomentObject)) {\n        to._isAMomentObject = from._isAMomentObject;\n    }\n    if (!isUndefined(from._i)) {\n        to._i = from._i;\n    }\n    if (!isUndefined(from._f)) {\n        to._f = from._f;\n    }\n    if (!isUndefined(from._l)) {\n        to._l = from._l;\n    }\n    if (!isUndefined(from._strict)) {\n        to._strict = from._strict;\n    }\n    if (!isUndefined(from._tzm)) {\n        to._tzm = from._tzm;\n    }\n    if (!isUndefined(from._isUTC)) {\n        to._isUTC = from._isUTC;\n    }\n    if (!isUndefined(from._offset)) {\n        to._offset = from._offset;\n    }\n    if (!isUndefined(from._pf)) {\n        to._pf = getParsingFlags(from);\n    }\n    if (!isUndefined(from._locale)) {\n        to._locale = from._locale;\n    }\n\n    if (momentProperties.length > 0) {\n        for (i = 0; i < momentProperties.length; i++) {\n            prop = momentProperties[i];\n            val = from[prop];\n            if (!isUndefined(val)) {\n                to[prop] = val;\n            }\n        }\n    }\n\n    return to;\n}\n\nvar updateInProgress = false;\n\n// Moment prototype object\nfunction Moment(config) {\n    copyConfig(this, config);\n    this._d = new Date(config._d != null ? config._d.getTime() : NaN);\n    if (!this.isValid()) {\n        this._d = new Date(NaN);\n    }\n    // Prevent infinite loop in case updateOffset creates new moment\n    // objects.\n    if (updateInProgress === false) {\n        updateInProgress = true;\n        hooks.updateOffset(this);\n        updateInProgress = false;\n    }\n}\n\nfunction isMoment (obj) {\n    return obj instanceof Moment || (obj != null && obj._isAMomentObject != null);\n}\n\nfunction absFloor (number) {\n    if (number < 0) {\n        // -0 -> 0\n        return Math.ceil(number) || 0;\n    } else {\n        return Math.floor(number);\n    }\n}\n\nfunction toInt(argumentForCoercion) {\n    var coercedNumber = +argumentForCoercion,\n        value = 0;\n\n    if (coercedNumber !== 0 && isFinite(coercedNumber)) {\n        value = absFloor(coercedNumber);\n    }\n\n    return value;\n}\n\n// compare two arrays, return the number of differences\nfunction compareArrays(array1, array2, dontConvert) {\n    var len = Math.min(array1.length, array2.length),\n        lengthDiff = Math.abs(array1.length - array2.length),\n        diffs = 0,\n        i;\n    for (i = 0; i < len; i++) {\n        if ((dontConvert && array1[i] !== array2[i]) ||\n            (!dontConvert && toInt(array1[i]) !== toInt(array2[i]))) {\n            diffs++;\n        }\n    }\n    return diffs + lengthDiff;\n}\n\nfunction warn(msg) {\n    if (hooks.suppressDeprecationWarnings === false &&\n            (typeof console !==  'undefined') && console.warn) {\n        console.warn('Deprecation warning: ' + msg);\n    }\n}\n\nfunction deprecate(msg, fn) {\n    var firstTime = true;\n\n    return extend(function () {\n        if (hooks.deprecationHandler != null) {\n            hooks.deprecationHandler(null, msg);\n        }\n        if (firstTime) {\n            var args = [];\n            var arg;\n            for (var i = 0; i < arguments.length; i++) {\n                arg = '';\n                if (typeof arguments[i] === 'object') {\n                    arg += '\\n[' + i + '] ';\n                    for (var key in arguments[0]) {\n                        arg += key + ': ' + arguments[0][key] + ', ';\n                    }\n                    arg = arg.slice(0, -2); // Remove trailing comma and space\n                } else {\n                    arg = arguments[i];\n                }\n                args.push(arg);\n            }\n            warn(msg + '\\nArguments: ' + Array.prototype.slice.call(args).join('') + '\\n' + (new Error()).stack);\n            firstTime = false;\n        }\n        return fn.apply(this, arguments);\n    }, fn);\n}\n\nvar deprecations = {};\n\nfunction deprecateSimple(name, msg) {\n    if (hooks.deprecationHandler != null) {\n        hooks.deprecationHandler(name, msg);\n    }\n    if (!deprecations[name]) {\n        warn(msg);\n        deprecations[name] = true;\n    }\n}\n\nhooks.suppressDeprecationWarnings = false;\nhooks.deprecationHandler = null;\n\nfunction isFunction(input) {\n    return input instanceof Function || Object.prototype.toString.call(input) === '[object Function]';\n}\n\nfunction set (config) {\n    var prop, i;\n    for (i in config) {\n        prop = config[i];\n        if (isFunction(prop)) {\n            this[i] = prop;\n        } else {\n            this['_' + i] = prop;\n        }\n    }\n    this._config = config;\n    // Lenient ordinal parsing accepts just a number in addition to\n    // number + (possibly) stuff coming from _dayOfMonthOrdinalParse.\n    // TODO: Remove \"ordinalParse\" fallback in next major release.\n    this._dayOfMonthOrdinalParseLenient = new RegExp(\n        (this._dayOfMonthOrdinalParse.source || this._ordinalParse.source) +\n            '|' + (/\\d{1,2}/).source);\n}\n\nfunction mergeConfigs(parentConfig, childConfig) {\n    var res = extend({}, parentConfig), prop;\n    for (prop in childConfig) {\n        if (hasOwnProp(childConfig, prop)) {\n            if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) {\n                res[prop] = {};\n                extend(res[prop], parentConfig[prop]);\n                extend(res[prop], childConfig[prop]);\n            } else if (childConfig[prop] != null) {\n                res[prop] = childConfig[prop];\n            } else {\n                delete res[prop];\n            }\n        }\n    }\n    for (prop in parentConfig) {\n        if (hasOwnProp(parentConfig, prop) &&\n                !hasOwnProp(childConfig, prop) &&\n                isObject(parentConfig[prop])) {\n            // make sure changes to properties don't modify parent config\n            res[prop] = extend({}, res[prop]);\n        }\n    }\n    return res;\n}\n\nfunction Locale(config) {\n    if (config != null) {\n        this.set(config);\n    }\n}\n\nvar keys;\n\nif (Object.keys) {\n    keys = Object.keys;\n} else {\n    keys = function (obj) {\n        var i, res = [];\n        for (i in obj) {\n            if (hasOwnProp(obj, i)) {\n                res.push(i);\n            }\n        }\n        return res;\n    };\n}\n\nvar keys$1 = keys;\n\nvar defaultCalendar = {\n    sameDay : '[Today at] LT',\n    nextDay : '[Tomorrow at] LT',\n    nextWeek : 'dddd [at] LT',\n    lastDay : '[Yesterday at] LT',\n    lastWeek : '[Last] dddd [at] LT',\n    sameElse : 'L'\n};\n\nfunction calendar (key, mom, now) {\n    var output = this._calendar[key] || this._calendar['sameElse'];\n    return isFunction(output) ? output.call(mom, now) : output;\n}\n\nvar defaultLongDateFormat = {\n    LTS  : 'h:mm:ss A',\n    LT   : 'h:mm A',\n    L    : 'MM/DD/YYYY',\n    LL   : 'MMMM D, YYYY',\n    LLL  : 'MMMM D, YYYY h:mm A',\n    LLLL : 'dddd, MMMM D, YYYY h:mm A'\n};\n\nfunction longDateFormat (key) {\n    var format = this._longDateFormat[key],\n        formatUpper = this._longDateFormat[key.toUpperCase()];\n\n    if (format || !formatUpper) {\n        return format;\n    }\n\n    this._longDateFormat[key] = formatUpper.replace(/MMMM|MM|DD|dddd/g, function (val) {\n        return val.slice(1);\n    });\n\n    return this._longDateFormat[key];\n}\n\nvar defaultInvalidDate = 'Invalid date';\n\nfunction invalidDate () {\n    return this._invalidDate;\n}\n\nvar defaultOrdinal = '%d';\nvar defaultDayOfMonthOrdinalParse = /\\d{1,2}/;\n\nfunction ordinal (number) {\n    return this._ordinal.replace('%d', number);\n}\n\nvar defaultRelativeTime = {\n    future : 'in %s',\n    past   : '%s ago',\n    s  : 'a few seconds',\n    ss : '%d seconds',\n    m  : 'a minute',\n    mm : '%d minutes',\n    h  : 'an hour',\n    hh : '%d hours',\n    d  : 'a day',\n    dd : '%d days',\n    M  : 'a month',\n    MM : '%d months',\n    y  : 'a year',\n    yy : '%d years'\n};\n\nfunction relativeTime (number, withoutSuffix, string, isFuture) {\n    var output = this._relativeTime[string];\n    return (isFunction(output)) ?\n        output(number, withoutSuffix, string, isFuture) :\n        output.replace(/%d/i, number);\n}\n\nfunction pastFuture (diff, output) {\n    var format = this._relativeTime[diff > 0 ? 'future' : 'past'];\n    return isFunction(format) ? format(output) : format.replace(/%s/i, output);\n}\n\nvar aliases = {};\n\nfunction addUnitAlias (unit, shorthand) {\n    var lowerCase = unit.toLowerCase();\n    aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit;\n}\n\nfunction normalizeUnits(units) {\n    return typeof units === 'string' ? aliases[units] || aliases[units.toLowerCase()] : undefined;\n}\n\nfunction normalizeObjectUnits(inputObject) {\n    var normalizedInput = {},\n        normalizedProp,\n        prop;\n\n    for (prop in inputObject) {\n        if (hasOwnProp(inputObject, prop)) {\n            normalizedProp = normalizeUnits(prop);\n            if (normalizedProp) {\n                normalizedInput[normalizedProp] = inputObject[prop];\n            }\n        }\n    }\n\n    return normalizedInput;\n}\n\nvar priorities = {};\n\nfunction addUnitPriority(unit, priority) {\n    priorities[unit] = priority;\n}\n\nfunction getPrioritizedUnits(unitsObj) {\n    var units = [];\n    for (var u in unitsObj) {\n        units.push({unit: u, priority: priorities[u]});\n    }\n    units.sort(function (a, b) {\n        return a.priority - b.priority;\n    });\n    return units;\n}\n\nfunction makeGetSet (unit, keepTime) {\n    return function (value) {\n        if (value != null) {\n            set$1(this, unit, value);\n            hooks.updateOffset(this, keepTime);\n            return this;\n        } else {\n            return get(this, unit);\n        }\n    };\n}\n\nfunction get (mom, unit) {\n    return mom.isValid() ?\n        mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]() : NaN;\n}\n\nfunction set$1 (mom, unit, value) {\n    if (mom.isValid()) {\n        mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value);\n    }\n}\n\n// MOMENTS\n\nfunction stringGet (units) {\n    units = normalizeUnits(units);\n    if (isFunction(this[units])) {\n        return this[units]();\n    }\n    return this;\n}\n\n\nfunction stringSet (units, value) {\n    if (typeof units === 'object') {\n        units = normalizeObjectUnits(units);\n        var prioritized = getPrioritizedUnits(units);\n        for (var i = 0; i < prioritized.length; i++) {\n            this[prioritized[i].unit](units[prioritized[i].unit]);\n        }\n    } else {\n        units = normalizeUnits(units);\n        if (isFunction(this[units])) {\n            return this[units](value);\n        }\n    }\n    return this;\n}\n\nfunction zeroFill(number, targetLength, forceSign) {\n    var absNumber = '' + Math.abs(number),\n        zerosToFill = targetLength - absNumber.length,\n        sign = number >= 0;\n    return (sign ? (forceSign ? '+' : '') : '-') +\n        Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) + absNumber;\n}\n\nvar formattingTokens = /(\\[[^\\[]*\\])|(\\\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|kk?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g;\n\nvar localFormattingTokens = /(\\[[^\\[]*\\])|(\\\\)?(LTS|LT|LL?L?L?|l{1,4})/g;\n\nvar formatFunctions = {};\n\nvar formatTokenFunctions = {};\n\n// token:    'M'\n// padded:   ['MM', 2]\n// ordinal:  'Mo'\n// callback: function () { this.month() + 1 }\nfunction addFormatToken (token, padded, ordinal, callback) {\n    var func = callback;\n    if (typeof callback === 'string') {\n        func = function () {\n            return this[callback]();\n        };\n    }\n    if (token) {\n        formatTokenFunctions[token] = func;\n    }\n    if (padded) {\n        formatTokenFunctions[padded[0]] = function () {\n            return zeroFill(func.apply(this, arguments), padded[1], padded[2]);\n        };\n    }\n    if (ordinal) {\n        formatTokenFunctions[ordinal] = function () {\n            return this.localeData().ordinal(func.apply(this, arguments), token);\n        };\n    }\n}\n\nfunction removeFormattingTokens(input) {\n    if (input.match(/\\[[\\s\\S]/)) {\n        return input.replace(/^\\[|\\]$/g, '');\n    }\n    return input.replace(/\\\\/g, '');\n}\n\nfunction makeFormatFunction(format) {\n    var array = format.match(formattingTokens), i, length;\n\n    for (i = 0, length = array.length; i < length; i++) {\n        if (formatTokenFunctions[array[i]]) {\n            array[i] = formatTokenFunctions[array[i]];\n        } else {\n            array[i] = removeFormattingTokens(array[i]);\n        }\n    }\n\n    return function (mom) {\n        var output = '', i;\n        for (i = 0; i < length; i++) {\n            output += isFunction(array[i]) ? array[i].call(mom, format) : array[i];\n        }\n        return output;\n    };\n}\n\n// format date using native date object\nfunction formatMoment(m, format) {\n    if (!m.isValid()) {\n        return m.localeData().invalidDate();\n    }\n\n    format = expandFormat(format, m.localeData());\n    formatFunctions[format] = formatFunctions[format] || makeFormatFunction(format);\n\n    return formatFunctions[format](m);\n}\n\nfunction expandFormat(format, locale) {\n    var i = 5;\n\n    function replaceLongDateFormatTokens(input) {\n        return locale.longDateFormat(input) || input;\n    }\n\n    localFormattingTokens.lastIndex = 0;\n    while (i >= 0 && localFormattingTokens.test(format)) {\n        format = format.replace(localFormattingTokens, replaceLongDateFormatTokens);\n        localFormattingTokens.lastIndex = 0;\n        i -= 1;\n    }\n\n    return format;\n}\n\nvar match1         = /\\d/;            //       0 - 9\nvar match2         = /\\d\\d/;          //      00 - 99\nvar match3         = /\\d{3}/;         //     000 - 999\nvar match4         = /\\d{4}/;         //    0000 - 9999\nvar match6         = /[+-]?\\d{6}/;    // -999999 - 999999\nvar match1to2      = /\\d\\d?/;         //       0 - 99\nvar match3to4      = /\\d\\d\\d\\d?/;     //     999 - 9999\nvar match5to6      = /\\d\\d\\d\\d\\d\\d?/; //   99999 - 999999\nvar match1to3      = /\\d{1,3}/;       //       0 - 999\nvar match1to4      = /\\d{1,4}/;       //       0 - 9999\nvar match1to6      = /[+-]?\\d{1,6}/;  // -999999 - 999999\n\nvar matchUnsigned  = /\\d+/;           //       0 - inf\nvar matchSigned    = /[+-]?\\d+/;      //    -inf - inf\n\nvar matchOffset    = /Z|[+-]\\d\\d:?\\d\\d/gi; // +00:00 -00:00 +0000 -0000 or Z\nvar matchShortOffset = /Z|[+-]\\d\\d(?::?\\d\\d)?/gi; // +00 -00 +00:00 -00:00 +0000 -0000 or Z\n\nvar matchTimestamp = /[+-]?\\d+(\\.\\d{1,3})?/; // 123456789 123456789.123\n\n// any word (or two) characters or numbers including two/three word month in arabic.\n// includes scottish gaelic two word and hyphenated months\nvar matchWord = /[0-9]*['a-z\\u00A0-\\u05FF\\u0700-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF]+|[\\u0600-\\u06FF\\/]+(\\s*?[\\u0600-\\u06FF]+){1,2}/i;\n\n\nvar regexes = {};\n\nfunction addRegexToken (token, regex, strictRegex) {\n    regexes[token] = isFunction(regex) ? regex : function (isStrict, localeData) {\n        return (isStrict && strictRegex) ? strictRegex : regex;\n    };\n}\n\nfunction getParseRegexForToken (token, config) {\n    if (!hasOwnProp(regexes, token)) {\n        return new RegExp(unescapeFormat(token));\n    }\n\n    return regexes[token](config._strict, config._locale);\n}\n\n// Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript\nfunction unescapeFormat(s) {\n    return regexEscape(s.replace('\\\\', '').replace(/\\\\(\\[)|\\\\(\\])|\\[([^\\]\\[]*)\\]|\\\\(.)/g, function (matched, p1, p2, p3, p4) {\n        return p1 || p2 || p3 || p4;\n    }));\n}\n\nfunction regexEscape(s) {\n    return s.replace(/[-\\/\\\\^$*+?.()|[\\]{}]/g, '\\\\$&');\n}\n\nvar tokens = {};\n\nfunction addParseToken (token, callback) {\n    var i, func = callback;\n    if (typeof token === 'string') {\n        token = [token];\n    }\n    if (isNumber(callback)) {\n        func = function (input, array) {\n            array[callback] = toInt(input);\n        };\n    }\n    for (i = 0; i < token.length; i++) {\n        tokens[token[i]] = func;\n    }\n}\n\nfunction addWeekParseToken (token, callback) {\n    addParseToken(token, function (input, array, config, token) {\n        config._w = config._w || {};\n        callback(input, config._w, config, token);\n    });\n}\n\nfunction addTimeToArrayFromToken(token, input, config) {\n    if (input != null && hasOwnProp(tokens, token)) {\n        tokens[token](input, config._a, config, token);\n    }\n}\n\nvar YEAR = 0;\nvar MONTH = 1;\nvar DATE = 2;\nvar HOUR = 3;\nvar MINUTE = 4;\nvar SECOND = 5;\nvar MILLISECOND = 6;\nvar WEEK = 7;\nvar WEEKDAY = 8;\n\nvar indexOf;\n\nif (Array.prototype.indexOf) {\n    indexOf = Array.prototype.indexOf;\n} else {\n    indexOf = function (o) {\n        // I know\n        var i;\n        for (i = 0; i < this.length; ++i) {\n            if (this[i] === o) {\n                return i;\n            }\n        }\n        return -1;\n    };\n}\n\nvar indexOf$1 = indexOf;\n\nfunction daysInMonth(year, month) {\n    return new Date(Date.UTC(year, month + 1, 0)).getUTCDate();\n}\n\n// FORMATTING\n\naddFormatToken('M', ['MM', 2], 'Mo', function () {\n    return this.month() + 1;\n});\n\naddFormatToken('MMM', 0, 0, function (format) {\n    return this.localeData().monthsShort(this, format);\n});\n\naddFormatToken('MMMM', 0, 0, function (format) {\n    return this.localeData().months(this, format);\n});\n\n// ALIASES\n\naddUnitAlias('month', 'M');\n\n// PRIORITY\n\naddUnitPriority('month', 8);\n\n// PARSING\n\naddRegexToken('M',    match1to2);\naddRegexToken('MM',   match1to2, match2);\naddRegexToken('MMM',  function (isStrict, locale) {\n    return locale.monthsShortRegex(isStrict);\n});\naddRegexToken('MMMM', function (isStrict, locale) {\n    return locale.monthsRegex(isStrict);\n});\n\naddParseToken(['M', 'MM'], function (input, array) {\n    array[MONTH] = toInt(input) - 1;\n});\n\naddParseToken(['MMM', 'MMMM'], function (input, array, config, token) {\n    var month = config._locale.monthsParse(input, token, config._strict);\n    // if we didn't find a month name, mark the date as invalid.\n    if (month != null) {\n        array[MONTH] = month;\n    } else {\n        getParsingFlags(config).invalidMonth = input;\n    }\n});\n\n// LOCALES\n\nvar MONTHS_IN_FORMAT = /D[oD]?(\\[[^\\[\\]]*\\]|\\s)+MMMM?/;\nvar defaultLocaleMonths = 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_');\nfunction localeMonths (m, format) {\n    if (!m) {\n        return isArray(this._months) ? this._months :\n            this._months['standalone'];\n    }\n    return isArray(this._months) ? this._months[m.month()] :\n        this._months[(this._months.isFormat || MONTHS_IN_FORMAT).test(format) ? 'format' : 'standalone'][m.month()];\n}\n\nvar defaultLocaleMonthsShort = 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_');\nfunction localeMonthsShort (m, format) {\n    if (!m) {\n        return isArray(this._monthsShort) ? this._monthsShort :\n            this._monthsShort['standalone'];\n    }\n    return isArray(this._monthsShort) ? this._monthsShort[m.month()] :\n        this._monthsShort[MONTHS_IN_FORMAT.test(format) ? 'format' : 'standalone'][m.month()];\n}\n\nfunction handleStrictParse(monthName, format, strict) {\n    var i, ii, mom, llc = monthName.toLocaleLowerCase();\n    if (!this._monthsParse) {\n        // this is not used\n        this._monthsParse = [];\n        this._longMonthsParse = [];\n        this._shortMonthsParse = [];\n        for (i = 0; i < 12; ++i) {\n            mom = createUTC([2000, i]);\n            this._shortMonthsParse[i] = this.monthsShort(mom, '').toLocaleLowerCase();\n            this._longMonthsParse[i] = this.months(mom, '').toLocaleLowerCase();\n        }\n    }\n\n    if (strict) {\n        if (format === 'MMM') {\n            ii = indexOf$1.call(this._shortMonthsParse, llc);\n            return ii !== -1 ? ii : null;\n        } else {\n            ii = indexOf$1.call(this._longMonthsParse, llc);\n            return ii !== -1 ? ii : null;\n        }\n    } else {\n        if (format === 'MMM') {\n            ii = indexOf$1.call(this._shortMonthsParse, llc);\n            if (ii !== -1) {\n                return ii;\n            }\n            ii = indexOf$1.call(this._longMonthsParse, llc);\n            return ii !== -1 ? ii : null;\n        } else {\n            ii = indexOf$1.call(this._longMonthsParse, llc);\n            if (ii !== -1) {\n                return ii;\n            }\n            ii = indexOf$1.call(this._shortMonthsParse, llc);\n            return ii !== -1 ? ii : null;\n        }\n    }\n}\n\nfunction localeMonthsParse (monthName, format, strict) {\n    var i, mom, regex;\n\n    if (this._monthsParseExact) {\n        return handleStrictParse.call(this, monthName, format, strict);\n    }\n\n    if (!this._monthsParse) {\n        this._monthsParse = [];\n        this._longMonthsParse = [];\n        this._shortMonthsParse = [];\n    }\n\n    // TODO: add sorting\n    // Sorting makes sure if one month (or abbr) is a prefix of another\n    // see sorting in computeMonthsParse\n    for (i = 0; i < 12; i++) {\n        // make the regex if we don't have it already\n        mom = createUTC([2000, i]);\n        if (strict && !this._longMonthsParse[i]) {\n            this._longMonthsParse[i] = new RegExp('^' + this.months(mom, '').replace('.', '') + '$', 'i');\n            this._shortMonthsParse[i] = new RegExp('^' + this.monthsShort(mom, '').replace('.', '') + '$', 'i');\n        }\n        if (!strict && !this._monthsParse[i]) {\n            regex = '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, '');\n            this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i');\n        }\n        // test the regex\n        if (strict && format === 'MMMM' && this._longMonthsParse[i].test(monthName)) {\n            return i;\n        } else if (strict && format === 'MMM' && this._shortMonthsParse[i].test(monthName)) {\n            return i;\n        } else if (!strict && this._monthsParse[i].test(monthName)) {\n            return i;\n        }\n    }\n}\n\n// MOMENTS\n\nfunction setMonth (mom, value) {\n    var dayOfMonth;\n\n    if (!mom.isValid()) {\n        // No op\n        return mom;\n    }\n\n    if (typeof value === 'string') {\n        if (/^\\d+$/.test(value)) {\n            value = toInt(value);\n        } else {\n            value = mom.localeData().monthsParse(value);\n            // TODO: Another silent failure?\n            if (!isNumber(value)) {\n                return mom;\n            }\n        }\n    }\n\n    dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value));\n    mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth);\n    return mom;\n}\n\nfunction getSetMonth (value) {\n    if (value != null) {\n        setMonth(this, value);\n        hooks.updateOffset(this, true);\n        return this;\n    } else {\n        return get(this, 'Month');\n    }\n}\n\nfunction getDaysInMonth () {\n    return daysInMonth(this.year(), this.month());\n}\n\nvar defaultMonthsShortRegex = matchWord;\nfunction monthsShortRegex (isStrict) {\n    if (this._monthsParseExact) {\n        if (!hasOwnProp(this, '_monthsRegex')) {\n            computeMonthsParse.call(this);\n        }\n        if (isStrict) {\n            return this._monthsShortStrictRegex;\n        } else {\n            return this._monthsShortRegex;\n        }\n    } else {\n        if (!hasOwnProp(this, '_monthsShortRegex')) {\n            this._monthsShortRegex = defaultMonthsShortRegex;\n        }\n        return this._monthsShortStrictRegex && isStrict ?\n            this._monthsShortStrictRegex : this._monthsShortRegex;\n    }\n}\n\nvar defaultMonthsRegex = matchWord;\nfunction monthsRegex (isStrict) {\n    if (this._monthsParseExact) {\n        if (!hasOwnProp(this, '_monthsRegex')) {\n            computeMonthsParse.call(this);\n        }\n        if (isStrict) {\n            return this._monthsStrictRegex;\n        } else {\n            return this._monthsRegex;\n        }\n    } else {\n        if (!hasOwnProp(this, '_monthsRegex')) {\n            this._monthsRegex = defaultMonthsRegex;\n        }\n        return this._monthsStrictRegex && isStrict ?\n            this._monthsStrictRegex : this._monthsRegex;\n    }\n}\n\nfunction computeMonthsParse () {\n    function cmpLenRev(a, b) {\n        return b.length - a.length;\n    }\n\n    var shortPieces = [], longPieces = [], mixedPieces = [],\n        i, mom;\n    for (i = 0; i < 12; i++) {\n        // make the regex if we don't have it already\n        mom = createUTC([2000, i]);\n        shortPieces.push(this.monthsShort(mom, ''));\n        longPieces.push(this.months(mom, ''));\n        mixedPieces.push(this.months(mom, ''));\n        mixedPieces.push(this.monthsShort(mom, ''));\n    }\n    // Sorting makes sure if one month (or abbr) is a prefix of another it\n    // will match the longer piece.\n    shortPieces.sort(cmpLenRev);\n    longPieces.sort(cmpLenRev);\n    mixedPieces.sort(cmpLenRev);\n    for (i = 0; i < 12; i++) {\n        shortPieces[i] = regexEscape(shortPieces[i]);\n        longPieces[i] = regexEscape(longPieces[i]);\n    }\n    for (i = 0; i < 24; i++) {\n        mixedPieces[i] = regexEscape(mixedPieces[i]);\n    }\n\n    this._monthsRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');\n    this._monthsShortRegex = this._monthsRegex;\n    this._monthsStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');\n    this._monthsShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');\n}\n\n// FORMATTING\n\naddFormatToken('Y', 0, 0, function () {\n    var y = this.year();\n    return y <= 9999 ? '' + y : '+' + y;\n});\n\naddFormatToken(0, ['YY', 2], 0, function () {\n    return this.year() % 100;\n});\n\naddFormatToken(0, ['YYYY',   4],       0, 'year');\naddFormatToken(0, ['YYYYY',  5],       0, 'year');\naddFormatToken(0, ['YYYYYY', 6, true], 0, 'year');\n\n// ALIASES\n\naddUnitAlias('year', 'y');\n\n// PRIORITIES\n\naddUnitPriority('year', 1);\n\n// PARSING\n\naddRegexToken('Y',      matchSigned);\naddRegexToken('YY',     match1to2, match2);\naddRegexToken('YYYY',   match1to4, match4);\naddRegexToken('YYYYY',  match1to6, match6);\naddRegexToken('YYYYYY', match1to6, match6);\n\naddParseToken(['YYYYY', 'YYYYYY'], YEAR);\naddParseToken('YYYY', function (input, array) {\n    array[YEAR] = input.length === 2 ? hooks.parseTwoDigitYear(input) : toInt(input);\n});\naddParseToken('YY', function (input, array) {\n    array[YEAR] = hooks.parseTwoDigitYear(input);\n});\naddParseToken('Y', function (input, array) {\n    array[YEAR] = parseInt(input, 10);\n});\n\n// HELPERS\n\nfunction daysInYear(year) {\n    return isLeapYear(year) ? 366 : 365;\n}\n\nfunction isLeapYear(year) {\n    return (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;\n}\n\n// HOOKS\n\nhooks.parseTwoDigitYear = function (input) {\n    return toInt(input) + (toInt(input) > 68 ? 1900 : 2000);\n};\n\n// MOMENTS\n\nvar getSetYear = makeGetSet('FullYear', true);\n\nfunction getIsLeapYear () {\n    return isLeapYear(this.year());\n}\n\nfunction createDate (y, m, d, h, M, s, ms) {\n    // can't just apply() to create a date:\n    // https://stackoverflow.com/q/181348\n    var date = new Date(y, m, d, h, M, s, ms);\n\n    // the date constructor remaps years 0-99 to 1900-1999\n    if (y < 100 && y >= 0 && isFinite(date.getFullYear())) {\n        date.setFullYear(y);\n    }\n    return date;\n}\n\nfunction createUTCDate (y) {\n    var date = new Date(Date.UTC.apply(null, arguments));\n\n    // the Date.UTC function remaps years 0-99 to 1900-1999\n    if (y < 100 && y >= 0 && isFinite(date.getUTCFullYear())) {\n        date.setUTCFullYear(y);\n    }\n    return date;\n}\n\n// start-of-first-week - start-of-year\nfunction firstWeekOffset(year, dow, doy) {\n    var // first-week day -- which january is always in the first week (4 for iso, 1 for other)\n        fwd = 7 + dow - doy,\n        // first-week day local weekday -- which local weekday is fwd\n        fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7;\n\n    return -fwdlw + fwd - 1;\n}\n\n// https://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday\nfunction dayOfYearFromWeeks(year, week, weekday, dow, doy) {\n    var localWeekday = (7 + weekday - dow) % 7,\n        weekOffset = firstWeekOffset(year, dow, doy),\n        dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset,\n        resYear, resDayOfYear;\n\n    if (dayOfYear <= 0) {\n        resYear = year - 1;\n        resDayOfYear = daysInYear(resYear) + dayOfYear;\n    } else if (dayOfYear > daysInYear(year)) {\n        resYear = year + 1;\n        resDayOfYear = dayOfYear - daysInYear(year);\n    } else {\n        resYear = year;\n        resDayOfYear = dayOfYear;\n    }\n\n    return {\n        year: resYear,\n        dayOfYear: resDayOfYear\n    };\n}\n\nfunction weekOfYear(mom, dow, doy) {\n    var weekOffset = firstWeekOffset(mom.year(), dow, doy),\n        week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1,\n        resWeek, resYear;\n\n    if (week < 1) {\n        resYear = mom.year() - 1;\n        resWeek = week + weeksInYear(resYear, dow, doy);\n    } else if (week > weeksInYear(mom.year(), dow, doy)) {\n        resWeek = week - weeksInYear(mom.year(), dow, doy);\n        resYear = mom.year() + 1;\n    } else {\n        resYear = mom.year();\n        resWeek = week;\n    }\n\n    return {\n        week: resWeek,\n        year: resYear\n    };\n}\n\nfunction weeksInYear(year, dow, doy) {\n    var weekOffset = firstWeekOffset(year, dow, doy),\n        weekOffsetNext = firstWeekOffset(year + 1, dow, doy);\n    return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;\n}\n\n// FORMATTING\n\naddFormatToken('w', ['ww', 2], 'wo', 'week');\naddFormatToken('W', ['WW', 2], 'Wo', 'isoWeek');\n\n// ALIASES\n\naddUnitAlias('week', 'w');\naddUnitAlias('isoWeek', 'W');\n\n// PRIORITIES\n\naddUnitPriority('week', 5);\naddUnitPriority('isoWeek', 5);\n\n// PARSING\n\naddRegexToken('w',  match1to2);\naddRegexToken('ww', match1to2, match2);\naddRegexToken('W',  match1to2);\naddRegexToken('WW', match1to2, match2);\n\naddWeekParseToken(['w', 'ww', 'W', 'WW'], function (input, week, config, token) {\n    week[token.substr(0, 1)] = toInt(input);\n});\n\n// HELPERS\n\n// LOCALES\n\nfunction localeWeek (mom) {\n    return weekOfYear(mom, this._week.dow, this._week.doy).week;\n}\n\nvar defaultLocaleWeek = {\n    dow : 0, // Sunday is the first day of the week.\n    doy : 6  // The week that contains Jan 1st is the first week of the year.\n};\n\nfunction localeFirstDayOfWeek () {\n    return this._week.dow;\n}\n\nfunction localeFirstDayOfYear () {\n    return this._week.doy;\n}\n\n// MOMENTS\n\nfunction getSetWeek (input) {\n    var week = this.localeData().week(this);\n    return input == null ? week : this.add((input - week) * 7, 'd');\n}\n\nfunction getSetISOWeek (input) {\n    var week = weekOfYear(this, 1, 4).week;\n    return input == null ? week : this.add((input - week) * 7, 'd');\n}\n\n// FORMATTING\n\naddFormatToken('d', 0, 'do', 'day');\n\naddFormatToken('dd', 0, 0, function (format) {\n    return this.localeData().weekdaysMin(this, format);\n});\n\naddFormatToken('ddd', 0, 0, function (format) {\n    return this.localeData().weekdaysShort(this, format);\n});\n\naddFormatToken('dddd', 0, 0, function (format) {\n    return this.localeData().weekdays(this, format);\n});\n\naddFormatToken('e', 0, 0, 'weekday');\naddFormatToken('E', 0, 0, 'isoWeekday');\n\n// ALIASES\n\naddUnitAlias('day', 'd');\naddUnitAlias('weekday', 'e');\naddUnitAlias('isoWeekday', 'E');\n\n// PRIORITY\naddUnitPriority('day', 11);\naddUnitPriority('weekday', 11);\naddUnitPriority('isoWeekday', 11);\n\n// PARSING\n\naddRegexToken('d',    match1to2);\naddRegexToken('e',    match1to2);\naddRegexToken('E',    match1to2);\naddRegexToken('dd',   function (isStrict, locale) {\n    return locale.weekdaysMinRegex(isStrict);\n});\naddRegexToken('ddd',   function (isStrict, locale) {\n    return locale.weekdaysShortRegex(isStrict);\n});\naddRegexToken('dddd',   function (isStrict, locale) {\n    return locale.weekdaysRegex(isStrict);\n});\n\naddWeekParseToken(['dd', 'ddd', 'dddd'], function (input, week, config, token) {\n    var weekday = config._locale.weekdaysParse(input, token, config._strict);\n    // if we didn't get a weekday name, mark the date as invalid\n    if (weekday != null) {\n        week.d = weekday;\n    } else {\n        getParsingFlags(config).invalidWeekday = input;\n    }\n});\n\naddWeekParseToken(['d', 'e', 'E'], function (input, week, config, token) {\n    week[token] = toInt(input);\n});\n\n// HELPERS\n\nfunction parseWeekday(input, locale) {\n    if (typeof input !== 'string') {\n        return input;\n    }\n\n    if (!isNaN(input)) {\n        return parseInt(input, 10);\n    }\n\n    input = locale.weekdaysParse(input);\n    if (typeof input === 'number') {\n        return input;\n    }\n\n    return null;\n}\n\nfunction parseIsoWeekday(input, locale) {\n    if (typeof input === 'string') {\n        return locale.weekdaysParse(input) % 7 || 7;\n    }\n    return isNaN(input) ? null : input;\n}\n\n// LOCALES\n\nvar defaultLocaleWeekdays = 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_');\nfunction localeWeekdays (m, format) {\n    if (!m) {\n        return isArray(this._weekdays) ? this._weekdays :\n            this._weekdays['standalone'];\n    }\n    return isArray(this._weekdays) ? this._weekdays[m.day()] :\n        this._weekdays[this._weekdays.isFormat.test(format) ? 'format' : 'standalone'][m.day()];\n}\n\nvar defaultLocaleWeekdaysShort = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_');\nfunction localeWeekdaysShort (m) {\n    return (m) ? this._weekdaysShort[m.day()] : this._weekdaysShort;\n}\n\nvar defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_');\nfunction localeWeekdaysMin (m) {\n    return (m) ? this._weekdaysMin[m.day()] : this._weekdaysMin;\n}\n\nfunction handleStrictParse$1(weekdayName, format, strict) {\n    var i, ii, mom, llc = weekdayName.toLocaleLowerCase();\n    if (!this._weekdaysParse) {\n        this._weekdaysParse = [];\n        this._shortWeekdaysParse = [];\n        this._minWeekdaysParse = [];\n\n        for (i = 0; i < 7; ++i) {\n            mom = createUTC([2000, 1]).day(i);\n            this._minWeekdaysParse[i] = this.weekdaysMin(mom, '').toLocaleLowerCase();\n            this._shortWeekdaysParse[i] = this.weekdaysShort(mom, '').toLocaleLowerCase();\n            this._weekdaysParse[i] = this.weekdays(mom, '').toLocaleLowerCase();\n        }\n    }\n\n    if (strict) {\n        if (format === 'dddd') {\n            ii = indexOf$1.call(this._weekdaysParse, llc);\n            return ii !== -1 ? ii : null;\n        } else if (format === 'ddd') {\n            ii = indexOf$1.call(this._shortWeekdaysParse, llc);\n            return ii !== -1 ? ii : null;\n        } else {\n            ii = indexOf$1.call(this._minWeekdaysParse, llc);\n            return ii !== -1 ? ii : null;\n        }\n    } else {\n        if (format === 'dddd') {\n            ii = indexOf$1.call(this._weekdaysParse, llc);\n            if (ii !== -1) {\n                return ii;\n            }\n            ii = indexOf$1.call(this._shortWeekdaysParse, llc);\n            if (ii !== -1) {\n                return ii;\n            }\n            ii = indexOf$1.call(this._minWeekdaysParse, llc);\n            return ii !== -1 ? ii : null;\n        } else if (format === 'ddd') {\n            ii = indexOf$1.call(this._shortWeekdaysParse, llc);\n            if (ii !== -1) {\n                return ii;\n            }\n            ii = indexOf$1.call(this._weekdaysParse, llc);\n            if (ii !== -1) {\n                return ii;\n            }\n            ii = indexOf$1.call(this._minWeekdaysParse, llc);\n            return ii !== -1 ? ii : null;\n        } else {\n            ii = indexOf$1.call(this._minWeekdaysParse, llc);\n            if (ii !== -1) {\n                return ii;\n            }\n            ii = indexOf$1.call(this._weekdaysParse, llc);\n            if (ii !== -1) {\n                return ii;\n            }\n            ii = indexOf$1.call(this._shortWeekdaysParse, llc);\n            return ii !== -1 ? ii : null;\n        }\n    }\n}\n\nfunction localeWeekdaysParse (weekdayName, format, strict) {\n    var i, mom, regex;\n\n    if (this._weekdaysParseExact) {\n        return handleStrictParse$1.call(this, weekdayName, format, strict);\n    }\n\n    if (!this._weekdaysParse) {\n        this._weekdaysParse = [];\n        this._minWeekdaysParse = [];\n        this._shortWeekdaysParse = [];\n        this._fullWeekdaysParse = [];\n    }\n\n    for (i = 0; i < 7; i++) {\n        // make the regex if we don't have it already\n\n        mom = createUTC([2000, 1]).day(i);\n        if (strict && !this._fullWeekdaysParse[i]) {\n            this._fullWeekdaysParse[i] = new RegExp('^' + this.weekdays(mom, '').replace('.', '\\.?') + '$', 'i');\n            this._shortWeekdaysParse[i] = new RegExp('^' + this.weekdaysShort(mom, '').replace('.', '\\.?') + '$', 'i');\n            this._minWeekdaysParse[i] = new RegExp('^' + this.weekdaysMin(mom, '').replace('.', '\\.?') + '$', 'i');\n        }\n        if (!this._weekdaysParse[i]) {\n            regex = '^' + this.weekdays(mom, '') + '|^' + this.weekdaysShort(mom, '') + '|^' + this.weekdaysMin(mom, '');\n            this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i');\n        }\n        // test the regex\n        if (strict && format === 'dddd' && this._fullWeekdaysParse[i].test(weekdayName)) {\n            return i;\n        } else if (strict && format === 'ddd' && this._shortWeekdaysParse[i].test(weekdayName)) {\n            return i;\n        } else if (strict && format === 'dd' && this._minWeekdaysParse[i].test(weekdayName)) {\n            return i;\n        } else if (!strict && this._weekdaysParse[i].test(weekdayName)) {\n            return i;\n        }\n    }\n}\n\n// MOMENTS\n\nfunction getSetDayOfWeek (input) {\n    if (!this.isValid()) {\n        return input != null ? this : NaN;\n    }\n    var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay();\n    if (input != null) {\n        input = parseWeekday(input, this.localeData());\n        return this.add(input - day, 'd');\n    } else {\n        return day;\n    }\n}\n\nfunction getSetLocaleDayOfWeek (input) {\n    if (!this.isValid()) {\n        return input != null ? this : NaN;\n    }\n    var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7;\n    return input == null ? weekday : this.add(input - weekday, 'd');\n}\n\nfunction getSetISODayOfWeek (input) {\n    if (!this.isValid()) {\n        return input != null ? this : NaN;\n    }\n\n    // behaves the same as moment#day except\n    // as a getter, returns 7 instead of 0 (1-7 range instead of 0-6)\n    // as a setter, sunday should belong to the previous week.\n\n    if (input != null) {\n        var weekday = parseIsoWeekday(input, this.localeData());\n        return this.day(this.day() % 7 ? weekday : weekday - 7);\n    } else {\n        return this.day() || 7;\n    }\n}\n\nvar defaultWeekdaysRegex = matchWord;\nfunction weekdaysRegex (isStrict) {\n    if (this._weekdaysParseExact) {\n        if (!hasOwnProp(this, '_weekdaysRegex')) {\n            computeWeekdaysParse.call(this);\n        }\n        if (isStrict) {\n            return this._weekdaysStrictRegex;\n        } else {\n            return this._weekdaysRegex;\n        }\n    } else {\n        if (!hasOwnProp(this, '_weekdaysRegex')) {\n            this._weekdaysRegex = defaultWeekdaysRegex;\n        }\n        return this._weekdaysStrictRegex && isStrict ?\n            this._weekdaysStrictRegex : this._weekdaysRegex;\n    }\n}\n\nvar defaultWeekdaysShortRegex = matchWord;\nfunction weekdaysShortRegex (isStrict) {\n    if (this._weekdaysParseExact) {\n        if (!hasOwnProp(this, '_weekdaysRegex')) {\n            computeWeekdaysParse.call(this);\n        }\n        if (isStrict) {\n            return this._weekdaysShortStrictRegex;\n        } else {\n            return this._weekdaysShortRegex;\n        }\n    } else {\n        if (!hasOwnProp(this, '_weekdaysShortRegex')) {\n            this._weekdaysShortRegex = defaultWeekdaysShortRegex;\n        }\n        return this._weekdaysShortStrictRegex && isStrict ?\n            this._weekdaysShortStrictRegex : this._weekdaysShortRegex;\n    }\n}\n\nvar defaultWeekdaysMinRegex = matchWord;\nfunction weekdaysMinRegex (isStrict) {\n    if (this._weekdaysParseExact) {\n        if (!hasOwnProp(this, '_weekdaysRegex')) {\n            computeWeekdaysParse.call(this);\n        }\n        if (isStrict) {\n            return this._weekdaysMinStrictRegex;\n        } else {\n            return this._weekdaysMinRegex;\n        }\n    } else {\n        if (!hasOwnProp(this, '_weekdaysMinRegex')) {\n            this._weekdaysMinRegex = defaultWeekdaysMinRegex;\n        }\n        return this._weekdaysMinStrictRegex && isStrict ?\n            this._weekdaysMinStrictRegex : this._weekdaysMinRegex;\n    }\n}\n\n\nfunction computeWeekdaysParse () {\n    function cmpLenRev(a, b) {\n        return b.length - a.length;\n    }\n\n    var minPieces = [], shortPieces = [], longPieces = [], mixedPieces = [],\n        i, mom, minp, shortp, longp;\n    for (i = 0; i < 7; i++) {\n        // make the regex if we don't have it already\n        mom = createUTC([2000, 1]).day(i);\n        minp = this.weekdaysMin(mom, '');\n        shortp = this.weekdaysShort(mom, '');\n        longp = this.weekdays(mom, '');\n        minPieces.push(minp);\n        shortPieces.push(shortp);\n        longPieces.push(longp);\n        mixedPieces.push(minp);\n        mixedPieces.push(shortp);\n        mixedPieces.push(longp);\n    }\n    // Sorting makes sure if one weekday (or abbr) is a prefix of another it\n    // will match the longer piece.\n    minPieces.sort(cmpLenRev);\n    shortPieces.sort(cmpLenRev);\n    longPieces.sort(cmpLenRev);\n    mixedPieces.sort(cmpLenRev);\n    for (i = 0; i < 7; i++) {\n        shortPieces[i] = regexEscape(shortPieces[i]);\n        longPieces[i] = regexEscape(longPieces[i]);\n        mixedPieces[i] = regexEscape(mixedPieces[i]);\n    }\n\n    this._weekdaysRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');\n    this._weekdaysShortRegex = this._weekdaysRegex;\n    this._weekdaysMinRegex = this._weekdaysRegex;\n\n    this._weekdaysStrictRegex = new RegExp('^(' + longPieces.join('|') + ')', 'i');\n    this._weekdaysShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')', 'i');\n    this._weekdaysMinStrictRegex = new RegExp('^(' + minPieces.join('|') + ')', 'i');\n}\n\n// FORMATTING\n\nfunction hFormat() {\n    return this.hours() % 12 || 12;\n}\n\nfunction kFormat() {\n    return this.hours() || 24;\n}\n\naddFormatToken('H', ['HH', 2], 0, 'hour');\naddFormatToken('h', ['hh', 2], 0, hFormat);\naddFormatToken('k', ['kk', 2], 0, kFormat);\n\naddFormatToken('hmm', 0, 0, function () {\n    return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2);\n});\n\naddFormatToken('hmmss', 0, 0, function () {\n    return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2) +\n        zeroFill(this.seconds(), 2);\n});\n\naddFormatToken('Hmm', 0, 0, function () {\n    return '' + this.hours() + zeroFill(this.minutes(), 2);\n});\n\naddFormatToken('Hmmss', 0, 0, function () {\n    return '' + this.hours() + zeroFill(this.minutes(), 2) +\n        zeroFill(this.seconds(), 2);\n});\n\nfunction meridiem (token, lowercase) {\n    addFormatToken(token, 0, 0, function () {\n        return this.localeData().meridiem(this.hours(), this.minutes(), lowercase);\n    });\n}\n\nmeridiem('a', true);\nmeridiem('A', false);\n\n// ALIASES\n\naddUnitAlias('hour', 'h');\n\n// PRIORITY\naddUnitPriority('hour', 13);\n\n// PARSING\n\nfunction matchMeridiem (isStrict, locale) {\n    return locale._meridiemParse;\n}\n\naddRegexToken('a',  matchMeridiem);\naddRegexToken('A',  matchMeridiem);\naddRegexToken('H',  match1to2);\naddRegexToken('h',  match1to2);\naddRegexToken('k',  match1to2);\naddRegexToken('HH', match1to2, match2);\naddRegexToken('hh', match1to2, match2);\naddRegexToken('kk', match1to2, match2);\n\naddRegexToken('hmm', match3to4);\naddRegexToken('hmmss', match5to6);\naddRegexToken('Hmm', match3to4);\naddRegexToken('Hmmss', match5to6);\n\naddParseToken(['H', 'HH'], HOUR);\naddParseToken(['k', 'kk'], function (input, array, config) {\n    var kInput = toInt(input);\n    array[HOUR] = kInput === 24 ? 0 : kInput;\n});\naddParseToken(['a', 'A'], function (input, array, config) {\n    config._isPm = config._locale.isPM(input);\n    config._meridiem = input;\n});\naddParseToken(['h', 'hh'], function (input, array, config) {\n    array[HOUR] = toInt(input);\n    getParsingFlags(config).bigHour = true;\n});\naddParseToken('hmm', function (input, array, config) {\n    var pos = input.length - 2;\n    array[HOUR] = toInt(input.substr(0, pos));\n    array[MINUTE] = toInt(input.substr(pos));\n    getParsingFlags(config).bigHour = true;\n});\naddParseToken('hmmss', function (input, array, config) {\n    var pos1 = input.length - 4;\n    var pos2 = input.length - 2;\n    array[HOUR] = toInt(input.substr(0, pos1));\n    array[MINUTE] = toInt(input.substr(pos1, 2));\n    array[SECOND] = toInt(input.substr(pos2));\n    getParsingFlags(config).bigHour = true;\n});\naddParseToken('Hmm', function (input, array, config) {\n    var pos = input.length - 2;\n    array[HOUR] = toInt(input.substr(0, pos));\n    array[MINUTE] = toInt(input.substr(pos));\n});\naddParseToken('Hmmss', function (input, array, config) {\n    var pos1 = input.length - 4;\n    var pos2 = input.length - 2;\n    array[HOUR] = toInt(input.substr(0, pos1));\n    array[MINUTE] = toInt(input.substr(pos1, 2));\n    array[SECOND] = toInt(input.substr(pos2));\n});\n\n// LOCALES\n\nfunction localeIsPM (input) {\n    // IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays\n    // Using charAt should be more compatible.\n    return ((input + '').toLowerCase().charAt(0) === 'p');\n}\n\nvar defaultLocaleMeridiemParse = /[ap]\\.?m?\\.?/i;\nfunction localeMeridiem (hours, minutes, isLower) {\n    if (hours > 11) {\n        return isLower ? 'pm' : 'PM';\n    } else {\n        return isLower ? 'am' : 'AM';\n    }\n}\n\n\n// MOMENTS\n\n// Setting the hour should keep the time, because the user explicitly\n// specified which hour he wants. So trying to maintain the same hour (in\n// a new timezone) makes sense. Adding/subtracting hours does not follow\n// this rule.\nvar getSetHour = makeGetSet('Hours', true);\n\n// months\n// week\n// weekdays\n// meridiem\nvar baseConfig = {\n    calendar: defaultCalendar,\n    longDateFormat: defaultLongDateFormat,\n    invalidDate: defaultInvalidDate,\n    ordinal: defaultOrdinal,\n    dayOfMonthOrdinalParse: defaultDayOfMonthOrdinalParse,\n    relativeTime: defaultRelativeTime,\n\n    months: defaultLocaleMonths,\n    monthsShort: defaultLocaleMonthsShort,\n\n    week: defaultLocaleWeek,\n\n    weekdays: defaultLocaleWeekdays,\n    weekdaysMin: defaultLocaleWeekdaysMin,\n    weekdaysShort: defaultLocaleWeekdaysShort,\n\n    meridiemParse: defaultLocaleMeridiemParse\n};\n\n// internal storage for locale config files\nvar locales = {};\nvar localeFamilies = {};\nvar globalLocale;\n\nfunction normalizeLocale(key) {\n    return key ? key.toLowerCase().replace('_', '-') : key;\n}\n\n// pick the locale from the array\n// try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each\n// substring from most specific to least, but move to the next array item if it's a more specific variant than the current root\nfunction chooseLocale(names) {\n    var i = 0, j, next, locale, split;\n\n    while (i < names.length) {\n        split = normalizeLocale(names[i]).split('-');\n        j = split.length;\n        next = normalizeLocale(names[i + 1]);\n        next = next ? next.split('-') : null;\n        while (j > 0) {\n            locale = loadLocale(split.slice(0, j).join('-'));\n            if (locale) {\n                return locale;\n            }\n            if (next && next.length >= j && compareArrays(split, next, true) >= j - 1) {\n                //the next array item is better than a shallower substring of this one\n                break;\n            }\n            j--;\n        }\n        i++;\n    }\n    return null;\n}\n\nfunction loadLocale(name) {\n    var oldLocale = null;\n    // TODO: Find a better way to register and load all the locales in Node\n    if (!locales[name] && (typeof module !== 'undefined') &&\n            module && module.exports) {\n        try {\n            oldLocale = globalLocale._abbr;\n            require('./locale/' + name);\n            // because defineLocale currently also sets the global locale, we\n            // want to undo that for lazy loaded locales\n            getSetGlobalLocale(oldLocale);\n        } catch (e) { }\n    }\n    return locales[name];\n}\n\n// This function will load locale and then set the global locale.  If\n// no arguments are passed in, it will simply return the current global\n// locale key.\nfunction getSetGlobalLocale (key, values) {\n    var data;\n    if (key) {\n        if (isUndefined(values)) {\n            data = getLocale(key);\n        }\n        else {\n            data = defineLocale(key, values);\n        }\n\n        if (data) {\n            // moment.duration._locale = moment._locale = data;\n            globalLocale = data;\n        }\n    }\n\n    return globalLocale._abbr;\n}\n\nfunction defineLocale (name, config) {\n    if (config !== null) {\n        var parentConfig = baseConfig;\n        config.abbr = name;\n        if (locales[name] != null) {\n            deprecateSimple('defineLocaleOverride',\n                    'use moment.updateLocale(localeName, config) to change ' +\n                    'an existing locale. moment.defineLocale(localeName, ' +\n                    'config) should only be used for creating a new locale ' +\n                    'See http://momentjs.com/guides/#/warnings/define-locale/ for more info.');\n            parentConfig = locales[name]._config;\n        } else if (config.parentLocale != null) {\n            if (locales[config.parentLocale] != null) {\n                parentConfig = locales[config.parentLocale]._config;\n            } else {\n                if (!localeFamilies[config.parentLocale]) {\n                    localeFamilies[config.parentLocale] = [];\n                }\n                localeFamilies[config.parentLocale].push({\n                    name: name,\n                    config: config\n                });\n                return null;\n            }\n        }\n        locales[name] = new Locale(mergeConfigs(parentConfig, config));\n\n        if (localeFamilies[name]) {\n            localeFamilies[name].forEach(function (x) {\n                defineLocale(x.name, x.config);\n            });\n        }\n\n        // backwards compat for now: also set the locale\n        // make sure we set the locale AFTER all child locales have been\n        // created, so we won't end up with the child locale set.\n        getSetGlobalLocale(name);\n\n\n        return locales[name];\n    } else {\n        // useful for testing\n        delete locales[name];\n        return null;\n    }\n}\n\nfunction updateLocale(name, config) {\n    if (config != null) {\n        var locale, parentConfig = baseConfig;\n        // MERGE\n        if (locales[name] != null) {\n            parentConfig = locales[name]._config;\n        }\n        config = mergeConfigs(parentConfig, config);\n        locale = new Locale(config);\n        locale.parentLocale = locales[name];\n        locales[name] = locale;\n\n        // backwards compat for now: also set the locale\n        getSetGlobalLocale(name);\n    } else {\n        // pass null for config to unupdate, useful for tests\n        if (locales[name] != null) {\n            if (locales[name].parentLocale != null) {\n                locales[name] = locales[name].parentLocale;\n            } else if (locales[name] != null) {\n                delete locales[name];\n            }\n        }\n    }\n    return locales[name];\n}\n\n// returns locale data\nfunction getLocale (key) {\n    var locale;\n\n    if (key && key._locale && key._locale._abbr) {\n        key = key._locale._abbr;\n    }\n\n    if (!key) {\n        return globalLocale;\n    }\n\n    if (!isArray(key)) {\n        //short-circuit everything else\n        locale = loadLocale(key);\n        if (locale) {\n            return locale;\n        }\n        key = [key];\n    }\n\n    return chooseLocale(key);\n}\n\nfunction listLocales() {\n    return keys$1(locales);\n}\n\nfunction checkOverflow (m) {\n    var overflow;\n    var a = m._a;\n\n    if (a && getParsingFlags(m).overflow === -2) {\n        overflow =\n            a[MONTH]       < 0 || a[MONTH]       > 11  ? MONTH :\n            a[DATE]        < 1 || a[DATE]        > daysInMonth(a[YEAR], a[MONTH]) ? DATE :\n            a[HOUR]        < 0 || a[HOUR]        > 24 || (a[HOUR] === 24 && (a[MINUTE] !== 0 || a[SECOND] !== 0 || a[MILLISECOND] !== 0)) ? HOUR :\n            a[MINUTE]      < 0 || a[MINUTE]      > 59  ? MINUTE :\n            a[SECOND]      < 0 || a[SECOND]      > 59  ? SECOND :\n            a[MILLISECOND] < 0 || a[MILLISECOND] > 999 ? MILLISECOND :\n            -1;\n\n        if (getParsingFlags(m)._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) {\n            overflow = DATE;\n        }\n        if (getParsingFlags(m)._overflowWeeks && overflow === -1) {\n            overflow = WEEK;\n        }\n        if (getParsingFlags(m)._overflowWeekday && overflow === -1) {\n            overflow = WEEKDAY;\n        }\n\n        getParsingFlags(m).overflow = overflow;\n    }\n\n    return m;\n}\n\n// iso 8601 regex\n// 0000-00-00 0000-W00 or 0000-W00-0 + T + 00 or 00:00 or 00:00:00 or 00:00:00.000 + +00:00 or +0000 or +00)\nvar extendedIsoRegex = /^\\s*((?:[+-]\\d{6}|\\d{4})-(?:\\d\\d-\\d\\d|W\\d\\d-\\d|W\\d\\d|\\d\\d\\d|\\d\\d))(?:(T| )(\\d\\d(?::\\d\\d(?::\\d\\d(?:[.,]\\d+)?)?)?)([\\+\\-]\\d\\d(?::?\\d\\d)?|\\s*Z)?)?$/;\nvar basicIsoRegex = /^\\s*((?:[+-]\\d{6}|\\d{4})(?:\\d\\d\\d\\d|W\\d\\d\\d|W\\d\\d|\\d\\d\\d|\\d\\d))(?:(T| )(\\d\\d(?:\\d\\d(?:\\d\\d(?:[.,]\\d+)?)?)?)([\\+\\-]\\d\\d(?::?\\d\\d)?|\\s*Z)?)?$/;\n\nvar tzRegex = /Z|[+-]\\d\\d(?::?\\d\\d)?/;\n\nvar isoDates = [\n    ['YYYYYY-MM-DD', /[+-]\\d{6}-\\d\\d-\\d\\d/],\n    ['YYYY-MM-DD', /\\d{4}-\\d\\d-\\d\\d/],\n    ['GGGG-[W]WW-E', /\\d{4}-W\\d\\d-\\d/],\n    ['GGGG-[W]WW', /\\d{4}-W\\d\\d/, false],\n    ['YYYY-DDD', /\\d{4}-\\d{3}/],\n    ['YYYY-MM', /\\d{4}-\\d\\d/, false],\n    ['YYYYYYMMDD', /[+-]\\d{10}/],\n    ['YYYYMMDD', /\\d{8}/],\n    // YYYYMM is NOT allowed by the standard\n    ['GGGG[W]WWE', /\\d{4}W\\d{3}/],\n    ['GGGG[W]WW', /\\d{4}W\\d{2}/, false],\n    ['YYYYDDD', /\\d{7}/]\n];\n\n// iso time formats and regexes\nvar isoTimes = [\n    ['HH:mm:ss.SSSS', /\\d\\d:\\d\\d:\\d\\d\\.\\d+/],\n    ['HH:mm:ss,SSSS', /\\d\\d:\\d\\d:\\d\\d,\\d+/],\n    ['HH:mm:ss', /\\d\\d:\\d\\d:\\d\\d/],\n    ['HH:mm', /\\d\\d:\\d\\d/],\n    ['HHmmss.SSSS', /\\d\\d\\d\\d\\d\\d\\.\\d+/],\n    ['HHmmss,SSSS', /\\d\\d\\d\\d\\d\\d,\\d+/],\n    ['HHmmss', /\\d\\d\\d\\d\\d\\d/],\n    ['HHmm', /\\d\\d\\d\\d/],\n    ['HH', /\\d\\d/]\n];\n\nvar aspNetJsonRegex = /^\\/?Date\\((\\-?\\d+)/i;\n\n// date from iso format\nfunction configFromISO(config) {\n    var i, l,\n        string = config._i,\n        match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string),\n        allowTime, dateFormat, timeFormat, tzFormat;\n\n    if (match) {\n        getParsingFlags(config).iso = true;\n\n        for (i = 0, l = isoDates.length; i < l; i++) {\n            if (isoDates[i][1].exec(match[1])) {\n                dateFormat = isoDates[i][0];\n                allowTime = isoDates[i][2] !== false;\n                break;\n            }\n        }\n        if (dateFormat == null) {\n            config._isValid = false;\n            return;\n        }\n        if (match[3]) {\n            for (i = 0, l = isoTimes.length; i < l; i++) {\n                if (isoTimes[i][1].exec(match[3])) {\n                    // match[2] should be 'T' or space\n                    timeFormat = (match[2] || ' ') + isoTimes[i][0];\n                    break;\n                }\n            }\n            if (timeFormat == null) {\n                config._isValid = false;\n                return;\n            }\n        }\n        if (!allowTime && timeFormat != null) {\n            config._isValid = false;\n            return;\n        }\n        if (match[4]) {\n            if (tzRegex.exec(match[4])) {\n                tzFormat = 'Z';\n            } else {\n                config._isValid = false;\n                return;\n            }\n        }\n        config._f = dateFormat + (timeFormat || '') + (tzFormat || '');\n        configFromStringAndFormat(config);\n    } else {\n        config._isValid = false;\n    }\n}\n\n// RFC 2822 regex: For details see https://tools.ietf.org/html/rfc2822#section-3.3\nvar basicRfcRegex = /^((?:Mon|Tue|Wed|Thu|Fri|Sat|Sun),?\\s)?(\\d?\\d\\s(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\\s(?:\\d\\d)?\\d\\d\\s)(\\d\\d:\\d\\d)(\\:\\d\\d)?(\\s(?:UT|GMT|[ECMP][SD]T|[A-IK-Za-ik-z]|[+-]\\d{4}))$/;\n\n// date and time from ref 2822 format\nfunction configFromRFC2822(config) {\n    var string, match, dayFormat,\n        dateFormat, timeFormat, tzFormat;\n    var timezones = {\n        ' GMT': ' +0000',\n        ' EDT': ' -0400',\n        ' EST': ' -0500',\n        ' CDT': ' -0500',\n        ' CST': ' -0600',\n        ' MDT': ' -0600',\n        ' MST': ' -0700',\n        ' PDT': ' -0700',\n        ' PST': ' -0800'\n    };\n    var military = 'YXWVUTSRQPONZABCDEFGHIKLM';\n    var timezone, timezoneIndex;\n\n    string = config._i\n        .replace(/\\([^\\)]*\\)|[\\n\\t]/g, ' ') // Remove comments and folding whitespace\n        .replace(/(\\s\\s+)/g, ' ') // Replace multiple-spaces with a single space\n        .replace(/^\\s|\\s$/g, ''); // Remove leading and trailing spaces\n    match = basicRfcRegex.exec(string);\n\n    if (match) {\n        dayFormat = match[1] ? 'ddd' + ((match[1].length === 5) ? ', ' : ' ') : '';\n        dateFormat = 'D MMM ' + ((match[2].length > 10) ? 'YYYY ' : 'YY ');\n        timeFormat = 'HH:mm' + (match[4] ? ':ss' : '');\n\n        // TODO: Replace the vanilla JS Date object with an indepentent day-of-week check.\n        if (match[1]) { // day of week given\n            var momentDate = new Date(match[2]);\n            var momentDay = ['Sun','Mon','Tue','Wed','Thu','Fri','Sat'][momentDate.getDay()];\n\n            if (match[1].substr(0,3) !== momentDay) {\n                getParsingFlags(config).weekdayMismatch = true;\n                config._isValid = false;\n                return;\n            }\n        }\n\n        switch (match[5].length) {\n            case 2: // military\n                if (timezoneIndex === 0) {\n                    timezone = ' +0000';\n                } else {\n                    timezoneIndex = military.indexOf(match[5][1].toUpperCase()) - 12;\n                    timezone = ((timezoneIndex < 0) ? ' -' : ' +') +\n                        (('' + timezoneIndex).replace(/^-?/, '0')).match(/..$/)[0] + '00';\n                }\n                break;\n            case 4: // Zone\n                timezone = timezones[match[5]];\n                break;\n            default: // UT or +/-9999\n                timezone = timezones[' GMT'];\n        }\n        match[5] = timezone;\n        config._i = match.splice(1).join('');\n        tzFormat = ' ZZ';\n        config._f = dayFormat + dateFormat + timeFormat + tzFormat;\n        configFromStringAndFormat(config);\n        getParsingFlags(config).rfc2822 = true;\n    } else {\n        config._isValid = false;\n    }\n}\n\n// date from iso format or fallback\nfunction configFromString(config) {\n    var matched = aspNetJsonRegex.exec(config._i);\n\n    if (matched !== null) {\n        config._d = new Date(+matched[1]);\n        return;\n    }\n\n    configFromISO(config);\n    if (config._isValid === false) {\n        delete config._isValid;\n    } else {\n        return;\n    }\n\n    configFromRFC2822(config);\n    if (config._isValid === false) {\n        delete config._isValid;\n    } else {\n        return;\n    }\n\n    // Final attempt, use Input Fallback\n    hooks.createFromInputFallback(config);\n}\n\nhooks.createFromInputFallback = deprecate(\n    'value provided is not in a recognized RFC2822 or ISO format. moment construction falls back to js Date(), ' +\n    'which is not reliable across all browsers and versions. Non RFC2822/ISO date formats are ' +\n    'discouraged and will be removed in an upcoming major release. Please refer to ' +\n    'http://momentjs.com/guides/#/warnings/js-date/ for more info.',\n    function (config) {\n        config._d = new Date(config._i + (config._useUTC ? ' UTC' : ''));\n    }\n);\n\n// Pick the first defined of two or three arguments.\nfunction defaults(a, b, c) {\n    if (a != null) {\n        return a;\n    }\n    if (b != null) {\n        return b;\n    }\n    return c;\n}\n\nfunction currentDateArray(config) {\n    // hooks is actually the exported moment object\n    var nowValue = new Date(hooks.now());\n    if (config._useUTC) {\n        return [nowValue.getUTCFullYear(), nowValue.getUTCMonth(), nowValue.getUTCDate()];\n    }\n    return [nowValue.getFullYear(), nowValue.getMonth(), nowValue.getDate()];\n}\n\n// convert an array to a date.\n// the array should mirror the parameters below\n// note: all values past the year are optional and will default to the lowest possible value.\n// [year, month, day , hour, minute, second, millisecond]\nfunction configFromArray (config) {\n    var i, date, input = [], currentDate, yearToUse;\n\n    if (config._d) {\n        return;\n    }\n\n    currentDate = currentDateArray(config);\n\n    //compute day of the year from weeks and weekdays\n    if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {\n        dayOfYearFromWeekInfo(config);\n    }\n\n    //if the day of the year is set, figure out what it is\n    if (config._dayOfYear != null) {\n        yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);\n\n        if (config._dayOfYear > daysInYear(yearToUse) || config._dayOfYear === 0) {\n            getParsingFlags(config)._overflowDayOfYear = true;\n        }\n\n        date = createUTCDate(yearToUse, 0, config._dayOfYear);\n        config._a[MONTH] = date.getUTCMonth();\n        config._a[DATE] = date.getUTCDate();\n    }\n\n    // Default to current date.\n    // * if no year, month, day of month are given, default to today\n    // * if day of month is given, default month and year\n    // * if month is given, default only year\n    // * if year is given, don't default anything\n    for (i = 0; i < 3 && config._a[i] == null; ++i) {\n        config._a[i] = input[i] = currentDate[i];\n    }\n\n    // Zero out whatever was not defaulted, including time\n    for (; i < 7; i++) {\n        config._a[i] = input[i] = (config._a[i] == null) ? (i === 2 ? 1 : 0) : config._a[i];\n    }\n\n    // Check for 24:00:00.000\n    if (config._a[HOUR] === 24 &&\n            config._a[MINUTE] === 0 &&\n            config._a[SECOND] === 0 &&\n            config._a[MILLISECOND] === 0) {\n        config._nextDay = true;\n        config._a[HOUR] = 0;\n    }\n\n    config._d = (config._useUTC ? createUTCDate : createDate).apply(null, input);\n    // Apply timezone offset from input. The actual utcOffset can be changed\n    // with parseZone.\n    if (config._tzm != null) {\n        config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm);\n    }\n\n    if (config._nextDay) {\n        config._a[HOUR] = 24;\n    }\n}\n\nfunction dayOfYearFromWeekInfo(config) {\n    var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow;\n\n    w = config._w;\n    if (w.GG != null || w.W != null || w.E != null) {\n        dow = 1;\n        doy = 4;\n\n        // TODO: We need to take the current isoWeekYear, but that depends on\n        // how we interpret now (local, utc, fixed offset). So create\n        // a now version of current config (take local/utc/offset flags, and\n        // create now).\n        weekYear = defaults(w.GG, config._a[YEAR], weekOfYear(createLocal(), 1, 4).year);\n        week = defaults(w.W, 1);\n        weekday = defaults(w.E, 1);\n        if (weekday < 1 || weekday > 7) {\n            weekdayOverflow = true;\n        }\n    } else {\n        dow = config._locale._week.dow;\n        doy = config._locale._week.doy;\n\n        var curWeek = weekOfYear(createLocal(), dow, doy);\n\n        weekYear = defaults(w.gg, config._a[YEAR], curWeek.year);\n\n        // Default to current week.\n        week = defaults(w.w, curWeek.week);\n\n        if (w.d != null) {\n            // weekday -- low day numbers are considered next week\n            weekday = w.d;\n            if (weekday < 0 || weekday > 6) {\n                weekdayOverflow = true;\n            }\n        } else if (w.e != null) {\n            // local weekday -- counting starts from begining of week\n            weekday = w.e + dow;\n            if (w.e < 0 || w.e > 6) {\n                weekdayOverflow = true;\n            }\n        } else {\n            // default to begining of week\n            weekday = dow;\n        }\n    }\n    if (week < 1 || week > weeksInYear(weekYear, dow, doy)) {\n        getParsingFlags(config)._overflowWeeks = true;\n    } else if (weekdayOverflow != null) {\n        getParsingFlags(config)._overflowWeekday = true;\n    } else {\n        temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy);\n        config._a[YEAR] = temp.year;\n        config._dayOfYear = temp.dayOfYear;\n    }\n}\n\n// constant that refers to the ISO standard\nhooks.ISO_8601 = function () {};\n\n// constant that refers to the RFC 2822 form\nhooks.RFC_2822 = function () {};\n\n// date from string and format string\nfunction configFromStringAndFormat(config) {\n    // TODO: Move this to another part of the creation flow to prevent circular deps\n    if (config._f === hooks.ISO_8601) {\n        configFromISO(config);\n        return;\n    }\n    if (config._f === hooks.RFC_2822) {\n        configFromRFC2822(config);\n        return;\n    }\n    config._a = [];\n    getParsingFlags(config).empty = true;\n\n    // This array is used to make a Date, either with `new Date` or `Date.UTC`\n    var string = '' + config._i,\n        i, parsedInput, tokens, token, skipped,\n        stringLength = string.length,\n        totalParsedInputLength = 0;\n\n    tokens = expandFormat(config._f, config._locale).match(formattingTokens) || [];\n\n    for (i = 0; i < tokens.length; i++) {\n        token = tokens[i];\n        parsedInput = (string.match(getParseRegexForToken(token, config)) || [])[0];\n        // console.log('token', token, 'parsedInput', parsedInput,\n        //         'regex', getParseRegexForToken(token, config));\n        if (parsedInput) {\n            skipped = string.substr(0, string.indexOf(parsedInput));\n            if (skipped.length > 0) {\n                getParsingFlags(config).unusedInput.push(skipped);\n            }\n            string = string.slice(string.indexOf(parsedInput) + parsedInput.length);\n            totalParsedInputLength += parsedInput.length;\n        }\n        // don't parse if it's not a known token\n        if (formatTokenFunctions[token]) {\n            if (parsedInput) {\n                getParsingFlags(config).empty = false;\n            }\n            else {\n                getParsingFlags(config).unusedTokens.push(token);\n            }\n            addTimeToArrayFromToken(token, parsedInput, config);\n        }\n        else if (config._strict && !parsedInput) {\n            getParsingFlags(config).unusedTokens.push(token);\n        }\n    }\n\n    // add remaining unparsed input length to the string\n    getParsingFlags(config).charsLeftOver = stringLength - totalParsedInputLength;\n    if (string.length > 0) {\n        getParsingFlags(config).unusedInput.push(string);\n    }\n\n    // clear _12h flag if hour is <= 12\n    if (config._a[HOUR] <= 12 &&\n        getParsingFlags(config).bigHour === true &&\n        config._a[HOUR] > 0) {\n        getParsingFlags(config).bigHour = undefined;\n    }\n\n    getParsingFlags(config).parsedDateParts = config._a.slice(0);\n    getParsingFlags(config).meridiem = config._meridiem;\n    // handle meridiem\n    config._a[HOUR] = meridiemFixWrap(config._locale, config._a[HOUR], config._meridiem);\n\n    configFromArray(config);\n    checkOverflow(config);\n}\n\n\nfunction meridiemFixWrap (locale, hour, meridiem) {\n    var isPm;\n\n    if (meridiem == null) {\n        // nothing to do\n        return hour;\n    }\n    if (locale.meridiemHour != null) {\n        return locale.meridiemHour(hour, meridiem);\n    } else if (locale.isPM != null) {\n        // Fallback\n        isPm = locale.isPM(meridiem);\n        if (isPm && hour < 12) {\n            hour += 12;\n        }\n        if (!isPm && hour === 12) {\n            hour = 0;\n        }\n        return hour;\n    } else {\n        // this is not supposed to happen\n        return hour;\n    }\n}\n\n// date from string and array of format strings\nfunction configFromStringAndArray(config) {\n    var tempConfig,\n        bestMoment,\n\n        scoreToBeat,\n        i,\n        currentScore;\n\n    if (config._f.length === 0) {\n        getParsingFlags(config).invalidFormat = true;\n        config._d = new Date(NaN);\n        return;\n    }\n\n    for (i = 0; i < config._f.length; i++) {\n        currentScore = 0;\n        tempConfig = copyConfig({}, config);\n        if (config._useUTC != null) {\n            tempConfig._useUTC = config._useUTC;\n        }\n        tempConfig._f = config._f[i];\n        configFromStringAndFormat(tempConfig);\n\n        if (!isValid(tempConfig)) {\n            continue;\n        }\n\n        // if there is any input that was not parsed add a penalty for that format\n        currentScore += getParsingFlags(tempConfig).charsLeftOver;\n\n        //or tokens\n        currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10;\n\n        getParsingFlags(tempConfig).score = currentScore;\n\n        if (scoreToBeat == null || currentScore < scoreToBeat) {\n            scoreToBeat = currentScore;\n            bestMoment = tempConfig;\n        }\n    }\n\n    extend(config, bestMoment || tempConfig);\n}\n\nfunction configFromObject(config) {\n    if (config._d) {\n        return;\n    }\n\n    var i = normalizeObjectUnits(config._i);\n    config._a = map([i.year, i.month, i.day || i.date, i.hour, i.minute, i.second, i.millisecond], function (obj) {\n        return obj && parseInt(obj, 10);\n    });\n\n    configFromArray(config);\n}\n\nfunction createFromConfig (config) {\n    var res = new Moment(checkOverflow(prepareConfig(config)));\n    if (res._nextDay) {\n        // Adding is smart enough around DST\n        res.add(1, 'd');\n        res._nextDay = undefined;\n    }\n\n    return res;\n}\n\nfunction prepareConfig (config) {\n    var input = config._i,\n        format = config._f;\n\n    config._locale = config._locale || getLocale(config._l);\n\n    if (input === null || (format === undefined && input === '')) {\n        return createInvalid({nullInput: true});\n    }\n\n    if (typeof input === 'string') {\n        config._i = input = config._locale.preparse(input);\n    }\n\n    if (isMoment(input)) {\n        return new Moment(checkOverflow(input));\n    } else if (isDate(input)) {\n        config._d = input;\n    } else if (isArray(format)) {\n        configFromStringAndArray(config);\n    } else if (format) {\n        configFromStringAndFormat(config);\n    }  else {\n        configFromInput(config);\n    }\n\n    if (!isValid(config)) {\n        config._d = null;\n    }\n\n    return config;\n}\n\nfunction configFromInput(config) {\n    var input = config._i;\n    if (isUndefined(input)) {\n        config._d = new Date(hooks.now());\n    } else if (isDate(input)) {\n        config._d = new Date(input.valueOf());\n    } else if (typeof input === 'string') {\n        configFromString(config);\n    } else if (isArray(input)) {\n        config._a = map(input.slice(0), function (obj) {\n            return parseInt(obj, 10);\n        });\n        configFromArray(config);\n    } else if (isObject(input)) {\n        configFromObject(config);\n    } else if (isNumber(input)) {\n        // from milliseconds\n        config._d = new Date(input);\n    } else {\n        hooks.createFromInputFallback(config);\n    }\n}\n\nfunction createLocalOrUTC (input, format, locale, strict, isUTC) {\n    var c = {};\n\n    if (locale === true || locale === false) {\n        strict = locale;\n        locale = undefined;\n    }\n\n    if ((isObject(input) && isObjectEmpty(input)) ||\n            (isArray(input) && input.length === 0)) {\n        input = undefined;\n    }\n    // object construction must be done this way.\n    // https://github.com/moment/moment/issues/1423\n    c._isAMomentObject = true;\n    c._useUTC = c._isUTC = isUTC;\n    c._l = locale;\n    c._i = input;\n    c._f = format;\n    c._strict = strict;\n\n    return createFromConfig(c);\n}\n\nfunction createLocal (input, format, locale, strict) {\n    return createLocalOrUTC(input, format, locale, strict, false);\n}\n\nvar prototypeMin = deprecate(\n    'moment().min is deprecated, use moment.max instead. http://momentjs.com/guides/#/warnings/min-max/',\n    function () {\n        var other = createLocal.apply(null, arguments);\n        if (this.isValid() && other.isValid()) {\n            return other < this ? this : other;\n        } else {\n            return createInvalid();\n        }\n    }\n);\n\nvar prototypeMax = deprecate(\n    'moment().max is deprecated, use moment.min instead. http://momentjs.com/guides/#/warnings/min-max/',\n    function () {\n        var other = createLocal.apply(null, arguments);\n        if (this.isValid() && other.isValid()) {\n            return other > this ? this : other;\n        } else {\n            return createInvalid();\n        }\n    }\n);\n\n// Pick a moment m from moments so that m[fn](other) is true for all\n// other. This relies on the function fn to be transitive.\n//\n// moments should either be an array of moment objects or an array, whose\n// first element is an array of moment objects.\nfunction pickBy(fn, moments) {\n    var res, i;\n    if (moments.length === 1 && isArray(moments[0])) {\n        moments = moments[0];\n    }\n    if (!moments.length) {\n        return createLocal();\n    }\n    res = moments[0];\n    for (i = 1; i < moments.length; ++i) {\n        if (!moments[i].isValid() || moments[i][fn](res)) {\n            res = moments[i];\n        }\n    }\n    return res;\n}\n\n// TODO: Use [].sort instead?\nfunction min () {\n    var args = [].slice.call(arguments, 0);\n\n    return pickBy('isBefore', args);\n}\n\nfunction max () {\n    var args = [].slice.call(arguments, 0);\n\n    return pickBy('isAfter', args);\n}\n\nvar now = function () {\n    return Date.now ? Date.now() : +(new Date());\n};\n\nvar ordering = ['year', 'quarter', 'month', 'week', 'day', 'hour', 'minute', 'second', 'millisecond'];\n\nfunction isDurationValid(m) {\n    for (var key in m) {\n        if (!(ordering.indexOf(key) !== -1 && (m[key] == null || !isNaN(m[key])))) {\n            return false;\n        }\n    }\n\n    var unitHasDecimal = false;\n    for (var i = 0; i < ordering.length; ++i) {\n        if (m[ordering[i]]) {\n            if (unitHasDecimal) {\n                return false; // only allow non-integers for smallest unit\n            }\n            if (parseFloat(m[ordering[i]]) !== toInt(m[ordering[i]])) {\n                unitHasDecimal = true;\n            }\n        }\n    }\n\n    return true;\n}\n\nfunction isValid$1() {\n    return this._isValid;\n}\n\nfunction createInvalid$1() {\n    return createDuration(NaN);\n}\n\nfunction Duration (duration) {\n    var normalizedInput = normalizeObjectUnits(duration),\n        years = normalizedInput.year || 0,\n        quarters = normalizedInput.quarter || 0,\n        months = normalizedInput.month || 0,\n        weeks = normalizedInput.week || 0,\n        days = normalizedInput.day || 0,\n        hours = normalizedInput.hour || 0,\n        minutes = normalizedInput.minute || 0,\n        seconds = normalizedInput.second || 0,\n        milliseconds = normalizedInput.millisecond || 0;\n\n    this._isValid = isDurationValid(normalizedInput);\n\n    // representation for dateAddRemove\n    this._milliseconds = +milliseconds +\n        seconds * 1e3 + // 1000\n        minutes * 6e4 + // 1000 * 60\n        hours * 1000 * 60 * 60; //using 1000 * 60 * 60 instead of 36e5 to avoid floating point rounding errors https://github.com/moment/moment/issues/2978\n    // Because of dateAddRemove treats 24 hours as different from a\n    // day when working around DST, we need to store them separately\n    this._days = +days +\n        weeks * 7;\n    // It is impossible translate months into days without knowing\n    // which months you are are talking about, so we have to store\n    // it separately.\n    this._months = +months +\n        quarters * 3 +\n        years * 12;\n\n    this._data = {};\n\n    this._locale = getLocale();\n\n    this._bubble();\n}\n\nfunction isDuration (obj) {\n    return obj instanceof Duration;\n}\n\nfunction absRound (number) {\n    if (number < 0) {\n        return Math.round(-1 * number) * -1;\n    } else {\n        return Math.round(number);\n    }\n}\n\n// FORMATTING\n\nfunction offset (token, separator) {\n    addFormatToken(token, 0, 0, function () {\n        var offset = this.utcOffset();\n        var sign = '+';\n        if (offset < 0) {\n            offset = -offset;\n            sign = '-';\n        }\n        return sign + zeroFill(~~(offset / 60), 2) + separator + zeroFill(~~(offset) % 60, 2);\n    });\n}\n\noffset('Z', ':');\noffset('ZZ', '');\n\n// PARSING\n\naddRegexToken('Z',  matchShortOffset);\naddRegexToken('ZZ', matchShortOffset);\naddParseToken(['Z', 'ZZ'], function (input, array, config) {\n    config._useUTC = true;\n    config._tzm = offsetFromString(matchShortOffset, input);\n});\n\n// HELPERS\n\n// timezone chunker\n// '+10:00' > ['10',  '00']\n// '-1530'  > ['-15', '30']\nvar chunkOffset = /([\\+\\-]|\\d\\d)/gi;\n\nfunction offsetFromString(matcher, string) {\n    var matches = (string || '').match(matcher);\n\n    if (matches === null) {\n        return null;\n    }\n\n    var chunk   = matches[matches.length - 1] || [];\n    var parts   = (chunk + '').match(chunkOffset) || ['-', 0, 0];\n    var minutes = +(parts[1] * 60) + toInt(parts[2]);\n\n    return minutes === 0 ?\n      0 :\n      parts[0] === '+' ? minutes : -minutes;\n}\n\n// Return a moment from input, that is local/utc/zone equivalent to model.\nfunction cloneWithOffset(input, model) {\n    var res, diff;\n    if (model._isUTC) {\n        res = model.clone();\n        diff = (isMoment(input) || isDate(input) ? input.valueOf() : createLocal(input).valueOf()) - res.valueOf();\n        // Use low-level api, because this fn is low-level api.\n        res._d.setTime(res._d.valueOf() + diff);\n        hooks.updateOffset(res, false);\n        return res;\n    } else {\n        return createLocal(input).local();\n    }\n}\n\nfunction getDateOffset (m) {\n    // On Firefox.24 Date#getTimezoneOffset returns a floating point.\n    // https://github.com/moment/moment/pull/1871\n    return -Math.round(m._d.getTimezoneOffset() / 15) * 15;\n}\n\n// HOOKS\n\n// This function will be called whenever a moment is mutated.\n// It is intended to keep the offset in sync with the timezone.\nhooks.updateOffset = function () {};\n\n// MOMENTS\n\n// keepLocalTime = true means only change the timezone, without\n// affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]-->\n// 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset\n// +0200, so we adjust the time as needed, to be valid.\n//\n// Keeping the time actually adds/subtracts (one hour)\n// from the actual represented time. That is why we call updateOffset\n// a second time. In case it wants us to change the offset again\n// _changeInProgress == true case, then we have to adjust, because\n// there is no such time in the given timezone.\nfunction getSetOffset (input, keepLocalTime, keepMinutes) {\n    var offset = this._offset || 0,\n        localAdjust;\n    if (!this.isValid()) {\n        return input != null ? this : NaN;\n    }\n    if (input != null) {\n        if (typeof input === 'string') {\n            input = offsetFromString(matchShortOffset, input);\n            if (input === null) {\n                return this;\n            }\n        } else if (Math.abs(input) < 16 && !keepMinutes) {\n            input = input * 60;\n        }\n        if (!this._isUTC && keepLocalTime) {\n            localAdjust = getDateOffset(this);\n        }\n        this._offset = input;\n        this._isUTC = true;\n        if (localAdjust != null) {\n            this.add(localAdjust, 'm');\n        }\n        if (offset !== input) {\n            if (!keepLocalTime || this._changeInProgress) {\n                addSubtract(this, createDuration(input - offset, 'm'), 1, false);\n            } else if (!this._changeInProgress) {\n                this._changeInProgress = true;\n                hooks.updateOffset(this, true);\n                this._changeInProgress = null;\n            }\n        }\n        return this;\n    } else {\n        return this._isUTC ? offset : getDateOffset(this);\n    }\n}\n\nfunction getSetZone (input, keepLocalTime) {\n    if (input != null) {\n        if (typeof input !== 'string') {\n            input = -input;\n        }\n\n        this.utcOffset(input, keepLocalTime);\n\n        return this;\n    } else {\n        return -this.utcOffset();\n    }\n}\n\nfunction setOffsetToUTC (keepLocalTime) {\n    return this.utcOffset(0, keepLocalTime);\n}\n\nfunction setOffsetToLocal (keepLocalTime) {\n    if (this._isUTC) {\n        this.utcOffset(0, keepLocalTime);\n        this._isUTC = false;\n\n        if (keepLocalTime) {\n            this.subtract(getDateOffset(this), 'm');\n        }\n    }\n    return this;\n}\n\nfunction setOffsetToParsedOffset () {\n    if (this._tzm != null) {\n        this.utcOffset(this._tzm, false, true);\n    } else if (typeof this._i === 'string') {\n        var tZone = offsetFromString(matchOffset, this._i);\n        if (tZone != null) {\n            this.utcOffset(tZone);\n        }\n        else {\n            this.utcOffset(0, true);\n        }\n    }\n    return this;\n}\n\nfunction hasAlignedHourOffset (input) {\n    if (!this.isValid()) {\n        return false;\n    }\n    input = input ? createLocal(input).utcOffset() : 0;\n\n    return (this.utcOffset() - input) % 60 === 0;\n}\n\nfunction isDaylightSavingTime () {\n    return (\n        this.utcOffset() > this.clone().month(0).utcOffset() ||\n        this.utcOffset() > this.clone().month(5).utcOffset()\n    );\n}\n\nfunction isDaylightSavingTimeShifted () {\n    if (!isUndefined(this._isDSTShifted)) {\n        return this._isDSTShifted;\n    }\n\n    var c = {};\n\n    copyConfig(c, this);\n    c = prepareConfig(c);\n\n    if (c._a) {\n        var other = c._isUTC ? createUTC(c._a) : createLocal(c._a);\n        this._isDSTShifted = this.isValid() &&\n            compareArrays(c._a, other.toArray()) > 0;\n    } else {\n        this._isDSTShifted = false;\n    }\n\n    return this._isDSTShifted;\n}\n\nfunction isLocal () {\n    return this.isValid() ? !this._isUTC : false;\n}\n\nfunction isUtcOffset () {\n    return this.isValid() ? this._isUTC : false;\n}\n\nfunction isUtc () {\n    return this.isValid() ? this._isUTC && this._offset === 0 : false;\n}\n\n// ASP.NET json date format regex\nvar aspNetRegex = /^(\\-)?(?:(\\d*)[. ])?(\\d+)\\:(\\d+)(?:\\:(\\d+)(\\.\\d*)?)?$/;\n\n// from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html\n// somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere\n// and further modified to allow for strings containing both week and day\nvar isoRegex = /^(-)?P(?:(-?[0-9,.]*)Y)?(?:(-?[0-9,.]*)M)?(?:(-?[0-9,.]*)W)?(?:(-?[0-9,.]*)D)?(?:T(?:(-?[0-9,.]*)H)?(?:(-?[0-9,.]*)M)?(?:(-?[0-9,.]*)S)?)?$/;\n\nfunction createDuration (input, key) {\n    var duration = input,\n        // matching against regexp is expensive, do it on demand\n        match = null,\n        sign,\n        ret,\n        diffRes;\n\n    if (isDuration(input)) {\n        duration = {\n            ms : input._milliseconds,\n            d  : input._days,\n            M  : input._months\n        };\n    } else if (isNumber(input)) {\n        duration = {};\n        if (key) {\n            duration[key] = input;\n        } else {\n            duration.milliseconds = input;\n        }\n    } else if (!!(match = aspNetRegex.exec(input))) {\n        sign = (match[1] === '-') ? -1 : 1;\n        duration = {\n            y  : 0,\n            d  : toInt(match[DATE])                         * sign,\n            h  : toInt(match[HOUR])                         * sign,\n            m  : toInt(match[MINUTE])                       * sign,\n            s  : toInt(match[SECOND])                       * sign,\n            ms : toInt(absRound(match[MILLISECOND] * 1000)) * sign // the millisecond decimal point is included in the match\n        };\n    } else if (!!(match = isoRegex.exec(input))) {\n        sign = (match[1] === '-') ? -1 : 1;\n        duration = {\n            y : parseIso(match[2], sign),\n            M : parseIso(match[3], sign),\n            w : parseIso(match[4], sign),\n            d : parseIso(match[5], sign),\n            h : parseIso(match[6], sign),\n            m : parseIso(match[7], sign),\n            s : parseIso(match[8], sign)\n        };\n    } else if (duration == null) {// checks for null or undefined\n        duration = {};\n    } else if (typeof duration === 'object' && ('from' in duration || 'to' in duration)) {\n        diffRes = momentsDifference(createLocal(duration.from), createLocal(duration.to));\n\n        duration = {};\n        duration.ms = diffRes.milliseconds;\n        duration.M = diffRes.months;\n    }\n\n    ret = new Duration(duration);\n\n    if (isDuration(input) && hasOwnProp(input, '_locale')) {\n        ret._locale = input._locale;\n    }\n\n    return ret;\n}\n\ncreateDuration.fn = Duration.prototype;\ncreateDuration.invalid = createInvalid$1;\n\nfunction parseIso (inp, sign) {\n    // We'd normally use ~~inp for this, but unfortunately it also\n    // converts floats to ints.\n    // inp may be undefined, so careful calling replace on it.\n    var res = inp && parseFloat(inp.replace(',', '.'));\n    // apply sign while we're at it\n    return (isNaN(res) ? 0 : res) * sign;\n}\n\nfunction positiveMomentsDifference(base, other) {\n    var res = {milliseconds: 0, months: 0};\n\n    res.months = other.month() - base.month() +\n        (other.year() - base.year()) * 12;\n    if (base.clone().add(res.months, 'M').isAfter(other)) {\n        --res.months;\n    }\n\n    res.milliseconds = +other - +(base.clone().add(res.months, 'M'));\n\n    return res;\n}\n\nfunction momentsDifference(base, other) {\n    var res;\n    if (!(base.isValid() && other.isValid())) {\n        return {milliseconds: 0, months: 0};\n    }\n\n    other = cloneWithOffset(other, base);\n    if (base.isBefore(other)) {\n        res = positiveMomentsDifference(base, other);\n    } else {\n        res = positiveMomentsDifference(other, base);\n        res.milliseconds = -res.milliseconds;\n        res.months = -res.months;\n    }\n\n    return res;\n}\n\n// TODO: remove 'name' arg after deprecation is removed\nfunction createAdder(direction, name) {\n    return function (val, period) {\n        var dur, tmp;\n        //invert the arguments, but complain about it\n        if (period !== null && !isNaN(+period)) {\n            deprecateSimple(name, 'moment().' + name  + '(period, number) is deprecated. Please use moment().' + name + '(number, period). ' +\n            'See http://momentjs.com/guides/#/warnings/add-inverted-param/ for more info.');\n            tmp = val; val = period; period = tmp;\n        }\n\n        val = typeof val === 'string' ? +val : val;\n        dur = createDuration(val, period);\n        addSubtract(this, dur, direction);\n        return this;\n    };\n}\n\nfunction addSubtract (mom, duration, isAdding, updateOffset) {\n    var milliseconds = duration._milliseconds,\n        days = absRound(duration._days),\n        months = absRound(duration._months);\n\n    if (!mom.isValid()) {\n        // No op\n        return;\n    }\n\n    updateOffset = updateOffset == null ? true : updateOffset;\n\n    if (milliseconds) {\n        mom._d.setTime(mom._d.valueOf() + milliseconds * isAdding);\n    }\n    if (days) {\n        set$1(mom, 'Date', get(mom, 'Date') + days * isAdding);\n    }\n    if (months) {\n        setMonth(mom, get(mom, 'Month') + months * isAdding);\n    }\n    if (updateOffset) {\n        hooks.updateOffset(mom, days || months);\n    }\n}\n\nvar add      = createAdder(1, 'add');\nvar subtract = createAdder(-1, 'subtract');\n\nfunction getCalendarFormat(myMoment, now) {\n    var diff = myMoment.diff(now, 'days', true);\n    return diff < -6 ? 'sameElse' :\n            diff < -1 ? 'lastWeek' :\n            diff < 0 ? 'lastDay' :\n            diff < 1 ? 'sameDay' :\n            diff < 2 ? 'nextDay' :\n            diff < 7 ? 'nextWeek' : 'sameElse';\n}\n\nfunction calendar$1 (time, formats) {\n    // We want to compare the start of today, vs this.\n    // Getting start-of-today depends on whether we're local/utc/offset or not.\n    var now = time || createLocal(),\n        sod = cloneWithOffset(now, this).startOf('day'),\n        format = hooks.calendarFormat(this, sod) || 'sameElse';\n\n    var output = formats && (isFunction(formats[format]) ? formats[format].call(this, now) : formats[format]);\n\n    return this.format(output || this.localeData().calendar(format, this, createLocal(now)));\n}\n\nfunction clone () {\n    return new Moment(this);\n}\n\nfunction isAfter (input, units) {\n    var localInput = isMoment(input) ? input : createLocal(input);\n    if (!(this.isValid() && localInput.isValid())) {\n        return false;\n    }\n    units = normalizeUnits(!isUndefined(units) ? units : 'millisecond');\n    if (units === 'millisecond') {\n        return this.valueOf() > localInput.valueOf();\n    } else {\n        return localInput.valueOf() < this.clone().startOf(units).valueOf();\n    }\n}\n\nfunction isBefore (input, units) {\n    var localInput = isMoment(input) ? input : createLocal(input);\n    if (!(this.isValid() && localInput.isValid())) {\n        return false;\n    }\n    units = normalizeUnits(!isUndefined(units) ? units : 'millisecond');\n    if (units === 'millisecond') {\n        return this.valueOf() < localInput.valueOf();\n    } else {\n        return this.clone().endOf(units).valueOf() < localInput.valueOf();\n    }\n}\n\nfunction isBetween (from, to, units, inclusivity) {\n    inclusivity = inclusivity || '()';\n    return (inclusivity[0] === '(' ? this.isAfter(from, units) : !this.isBefore(from, units)) &&\n        (inclusivity[1] === ')' ? this.isBefore(to, units) : !this.isAfter(to, units));\n}\n\nfunction isSame (input, units) {\n    var localInput = isMoment(input) ? input : createLocal(input),\n        inputMs;\n    if (!(this.isValid() && localInput.isValid())) {\n        return false;\n    }\n    units = normalizeUnits(units || 'millisecond');\n    if (units === 'millisecond') {\n        return this.valueOf() === localInput.valueOf();\n    } else {\n        inputMs = localInput.valueOf();\n        return this.clone().startOf(units).valueOf() <= inputMs && inputMs <= this.clone().endOf(units).valueOf();\n    }\n}\n\nfunction isSameOrAfter (input, units) {\n    return this.isSame(input, units) || this.isAfter(input,units);\n}\n\nfunction isSameOrBefore (input, units) {\n    return this.isSame(input, units) || this.isBefore(input,units);\n}\n\nfunction diff (input, units, asFloat) {\n    var that,\n        zoneDelta,\n        delta, output;\n\n    if (!this.isValid()) {\n        return NaN;\n    }\n\n    that = cloneWithOffset(input, this);\n\n    if (!that.isValid()) {\n        return NaN;\n    }\n\n    zoneDelta = (that.utcOffset() - this.utcOffset()) * 6e4;\n\n    units = normalizeUnits(units);\n\n    if (units === 'year' || units === 'month' || units === 'quarter') {\n        output = monthDiff(this, that);\n        if (units === 'quarter') {\n            output = output / 3;\n        } else if (units === 'year') {\n            output = output / 12;\n        }\n    } else {\n        delta = this - that;\n        output = units === 'second' ? delta / 1e3 : // 1000\n            units === 'minute' ? delta / 6e4 : // 1000 * 60\n            units === 'hour' ? delta / 36e5 : // 1000 * 60 * 60\n            units === 'day' ? (delta - zoneDelta) / 864e5 : // 1000 * 60 * 60 * 24, negate dst\n            units === 'week' ? (delta - zoneDelta) / 6048e5 : // 1000 * 60 * 60 * 24 * 7, negate dst\n            delta;\n    }\n    return asFloat ? output : absFloor(output);\n}\n\nfunction monthDiff (a, b) {\n    // difference in months\n    var wholeMonthDiff = ((b.year() - a.year()) * 12) + (b.month() - a.month()),\n        // b is in (anchor - 1 month, anchor + 1 month)\n        anchor = a.clone().add(wholeMonthDiff, 'months'),\n        anchor2, adjust;\n\n    if (b - anchor < 0) {\n        anchor2 = a.clone().add(wholeMonthDiff - 1, 'months');\n        // linear across the month\n        adjust = (b - anchor) / (anchor - anchor2);\n    } else {\n        anchor2 = a.clone().add(wholeMonthDiff + 1, 'months');\n        // linear across the month\n        adjust = (b - anchor) / (anchor2 - anchor);\n    }\n\n    //check for negative zero, return zero if negative zero\n    return -(wholeMonthDiff + adjust) || 0;\n}\n\nhooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ';\nhooks.defaultFormatUtc = 'YYYY-MM-DDTHH:mm:ss[Z]';\n\nfunction toString () {\n    return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ');\n}\n\nfunction toISOString() {\n    if (!this.isValid()) {\n        return null;\n    }\n    var m = this.clone().utc();\n    if (m.year() < 0 || m.year() > 9999) {\n        return formatMoment(m, 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]');\n    }\n    if (isFunction(Date.prototype.toISOString)) {\n        // native implementation is ~50x faster, use it when we can\n        return this.toDate().toISOString();\n    }\n    return formatMoment(m, 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]');\n}\n\n/**\n * Return a human readable representation of a moment that can\n * also be evaluated to get a new moment which is the same\n *\n * @link https://nodejs.org/dist/latest/docs/api/util.html#util_custom_inspect_function_on_objects\n */\nfunction inspect () {\n    if (!this.isValid()) {\n        return 'moment.invalid(/* ' + this._i + ' */)';\n    }\n    var func = 'moment';\n    var zone = '';\n    if (!this.isLocal()) {\n        func = this.utcOffset() === 0 ? 'moment.utc' : 'moment.parseZone';\n        zone = 'Z';\n    }\n    var prefix = '[' + func + '(\"]';\n    var year = (0 <= this.year() && this.year() <= 9999) ? 'YYYY' : 'YYYYYY';\n    var datetime = '-MM-DD[T]HH:mm:ss.SSS';\n    var suffix = zone + '[\")]';\n\n    return this.format(prefix + year + datetime + suffix);\n}\n\nfunction format (inputString) {\n    if (!inputString) {\n        inputString = this.isUtc() ? hooks.defaultFormatUtc : hooks.defaultFormat;\n    }\n    var output = formatMoment(this, inputString);\n    return this.localeData().postformat(output);\n}\n\nfunction from (time, withoutSuffix) {\n    if (this.isValid() &&\n            ((isMoment(time) && time.isValid()) ||\n             createLocal(time).isValid())) {\n        return createDuration({to: this, from: time}).locale(this.locale()).humanize(!withoutSuffix);\n    } else {\n        return this.localeData().invalidDate();\n    }\n}\n\nfunction fromNow (withoutSuffix) {\n    return this.from(createLocal(), withoutSuffix);\n}\n\nfunction to (time, withoutSuffix) {\n    if (this.isValid() &&\n            ((isMoment(time) && time.isValid()) ||\n             createLocal(time).isValid())) {\n        return createDuration({from: this, to: time}).locale(this.locale()).humanize(!withoutSuffix);\n    } else {\n        return this.localeData().invalidDate();\n    }\n}\n\nfunction toNow (withoutSuffix) {\n    return this.to(createLocal(), withoutSuffix);\n}\n\n// If passed a locale key, it will set the locale for this\n// instance.  Otherwise, it will return the locale configuration\n// variables for this instance.\nfunction locale (key) {\n    var newLocaleData;\n\n    if (key === undefined) {\n        return this._locale._abbr;\n    } else {\n        newLocaleData = getLocale(key);\n        if (newLocaleData != null) {\n            this._locale = newLocaleData;\n        }\n        return this;\n    }\n}\n\nvar lang = deprecate(\n    'moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.',\n    function (key) {\n        if (key === undefined) {\n            return this.localeData();\n        } else {\n            return this.locale(key);\n        }\n    }\n);\n\nfunction localeData () {\n    return this._locale;\n}\n\nfunction startOf (units) {\n    units = normalizeUnits(units);\n    // the following switch intentionally omits break keywords\n    // to utilize falling through the cases.\n    switch (units) {\n        case 'year':\n            this.month(0);\n            /* falls through */\n        case 'quarter':\n        case 'month':\n            this.date(1);\n            /* falls through */\n        case 'week':\n        case 'isoWeek':\n        case 'day':\n        case 'date':\n            this.hours(0);\n            /* falls through */\n        case 'hour':\n            this.minutes(0);\n            /* falls through */\n        case 'minute':\n            this.seconds(0);\n            /* falls through */\n        case 'second':\n            this.milliseconds(0);\n    }\n\n    // weeks are a special case\n    if (units === 'week') {\n        this.weekday(0);\n    }\n    if (units === 'isoWeek') {\n        this.isoWeekday(1);\n    }\n\n    // quarters are also special\n    if (units === 'quarter') {\n        this.month(Math.floor(this.month() / 3) * 3);\n    }\n\n    return this;\n}\n\nfunction endOf (units) {\n    units = normalizeUnits(units);\n    if (units === undefined || units === 'millisecond') {\n        return this;\n    }\n\n    // 'date' is an alias for 'day', so it should be considered as such.\n    if (units === 'date') {\n        units = 'day';\n    }\n\n    return this.startOf(units).add(1, (units === 'isoWeek' ? 'week' : units)).subtract(1, 'ms');\n}\n\nfunction valueOf () {\n    return this._d.valueOf() - ((this._offset || 0) * 60000);\n}\n\nfunction unix () {\n    return Math.floor(this.valueOf() / 1000);\n}\n\nfunction toDate () {\n    return new Date(this.valueOf());\n}\n\nfunction toArray () {\n    var m = this;\n    return [m.year(), m.month(), m.date(), m.hour(), m.minute(), m.second(), m.millisecond()];\n}\n\nfunction toObject () {\n    var m = this;\n    return {\n        years: m.year(),\n        months: m.month(),\n        date: m.date(),\n        hours: m.hours(),\n        minutes: m.minutes(),\n        seconds: m.seconds(),\n        milliseconds: m.milliseconds()\n    };\n}\n\nfunction toJSON () {\n    // new Date(NaN).toJSON() === null\n    return this.isValid() ? this.toISOString() : null;\n}\n\nfunction isValid$2 () {\n    return isValid(this);\n}\n\nfunction parsingFlags () {\n    return extend({}, getParsingFlags(this));\n}\n\nfunction invalidAt () {\n    return getParsingFlags(this).overflow;\n}\n\nfunction creationData() {\n    return {\n        input: this._i,\n        format: this._f,\n        locale: this._locale,\n        isUTC: this._isUTC,\n        strict: this._strict\n    };\n}\n\n// FORMATTING\n\naddFormatToken(0, ['gg', 2], 0, function () {\n    return this.weekYear() % 100;\n});\n\naddFormatToken(0, ['GG', 2], 0, function () {\n    return this.isoWeekYear() % 100;\n});\n\nfunction addWeekYearFormatToken (token, getter) {\n    addFormatToken(0, [token, token.length], 0, getter);\n}\n\naddWeekYearFormatToken('gggg',     'weekYear');\naddWeekYearFormatToken('ggggg',    'weekYear');\naddWeekYearFormatToken('GGGG',  'isoWeekYear');\naddWeekYearFormatToken('GGGGG', 'isoWeekYear');\n\n// ALIASES\n\naddUnitAlias('weekYear', 'gg');\naddUnitAlias('isoWeekYear', 'GG');\n\n// PRIORITY\n\naddUnitPriority('weekYear', 1);\naddUnitPriority('isoWeekYear', 1);\n\n\n// PARSING\n\naddRegexToken('G',      matchSigned);\naddRegexToken('g',      matchSigned);\naddRegexToken('GG',     match1to2, match2);\naddRegexToken('gg',     match1to2, match2);\naddRegexToken('GGGG',   match1to4, match4);\naddRegexToken('gggg',   match1to4, match4);\naddRegexToken('GGGGG',  match1to6, match6);\naddRegexToken('ggggg',  match1to6, match6);\n\naddWeekParseToken(['gggg', 'ggggg', 'GGGG', 'GGGGG'], function (input, week, config, token) {\n    week[token.substr(0, 2)] = toInt(input);\n});\n\naddWeekParseToken(['gg', 'GG'], function (input, week, config, token) {\n    week[token] = hooks.parseTwoDigitYear(input);\n});\n\n// MOMENTS\n\nfunction getSetWeekYear (input) {\n    return getSetWeekYearHelper.call(this,\n            input,\n            this.week(),\n            this.weekday(),\n            this.localeData()._week.dow,\n            this.localeData()._week.doy);\n}\n\nfunction getSetISOWeekYear (input) {\n    return getSetWeekYearHelper.call(this,\n            input, this.isoWeek(), this.isoWeekday(), 1, 4);\n}\n\nfunction getISOWeeksInYear () {\n    return weeksInYear(this.year(), 1, 4);\n}\n\nfunction getWeeksInYear () {\n    var weekInfo = this.localeData()._week;\n    return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy);\n}\n\nfunction getSetWeekYearHelper(input, week, weekday, dow, doy) {\n    var weeksTarget;\n    if (input == null) {\n        return weekOfYear(this, dow, doy).year;\n    } else {\n        weeksTarget = weeksInYear(input, dow, doy);\n        if (week > weeksTarget) {\n            week = weeksTarget;\n        }\n        return setWeekAll.call(this, input, week, weekday, dow, doy);\n    }\n}\n\nfunction setWeekAll(weekYear, week, weekday, dow, doy) {\n    var dayOfYearData = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy),\n        date = createUTCDate(dayOfYearData.year, 0, dayOfYearData.dayOfYear);\n\n    this.year(date.getUTCFullYear());\n    this.month(date.getUTCMonth());\n    this.date(date.getUTCDate());\n    return this;\n}\n\n// FORMATTING\n\naddFormatToken('Q', 0, 'Qo', 'quarter');\n\n// ALIASES\n\naddUnitAlias('quarter', 'Q');\n\n// PRIORITY\n\naddUnitPriority('quarter', 7);\n\n// PARSING\n\naddRegexToken('Q', match1);\naddParseToken('Q', function (input, array) {\n    array[MONTH] = (toInt(input) - 1) * 3;\n});\n\n// MOMENTS\n\nfunction getSetQuarter (input) {\n    return input == null ? Math.ceil((this.month() + 1) / 3) : this.month((input - 1) * 3 + this.month() % 3);\n}\n\n// FORMATTING\n\naddFormatToken('D', ['DD', 2], 'Do', 'date');\n\n// ALIASES\n\naddUnitAlias('date', 'D');\n\n// PRIOROITY\naddUnitPriority('date', 9);\n\n// PARSING\n\naddRegexToken('D',  match1to2);\naddRegexToken('DD', match1to2, match2);\naddRegexToken('Do', function (isStrict, locale) {\n    // TODO: Remove \"ordinalParse\" fallback in next major release.\n    return isStrict ?\n      (locale._dayOfMonthOrdinalParse || locale._ordinalParse) :\n      locale._dayOfMonthOrdinalParseLenient;\n});\n\naddParseToken(['D', 'DD'], DATE);\naddParseToken('Do', function (input, array) {\n    array[DATE] = toInt(input.match(match1to2)[0], 10);\n});\n\n// MOMENTS\n\nvar getSetDayOfMonth = makeGetSet('Date', true);\n\n// FORMATTING\n\naddFormatToken('DDD', ['DDDD', 3], 'DDDo', 'dayOfYear');\n\n// ALIASES\n\naddUnitAlias('dayOfYear', 'DDD');\n\n// PRIORITY\naddUnitPriority('dayOfYear', 4);\n\n// PARSING\n\naddRegexToken('DDD',  match1to3);\naddRegexToken('DDDD', match3);\naddParseToken(['DDD', 'DDDD'], function (input, array, config) {\n    config._dayOfYear = toInt(input);\n});\n\n// HELPERS\n\n// MOMENTS\n\nfunction getSetDayOfYear (input) {\n    var dayOfYear = Math.round((this.clone().startOf('day') - this.clone().startOf('year')) / 864e5) + 1;\n    return input == null ? dayOfYear : this.add((input - dayOfYear), 'd');\n}\n\n// FORMATTING\n\naddFormatToken('m', ['mm', 2], 0, 'minute');\n\n// ALIASES\n\naddUnitAlias('minute', 'm');\n\n// PRIORITY\n\naddUnitPriority('minute', 14);\n\n// PARSING\n\naddRegexToken('m',  match1to2);\naddRegexToken('mm', match1to2, match2);\naddParseToken(['m', 'mm'], MINUTE);\n\n// MOMENTS\n\nvar getSetMinute = makeGetSet('Minutes', false);\n\n// FORMATTING\n\naddFormatToken('s', ['ss', 2], 0, 'second');\n\n// ALIASES\n\naddUnitAlias('second', 's');\n\n// PRIORITY\n\naddUnitPriority('second', 15);\n\n// PARSING\n\naddRegexToken('s',  match1to2);\naddRegexToken('ss', match1to2, match2);\naddParseToken(['s', 'ss'], SECOND);\n\n// MOMENTS\n\nvar getSetSecond = makeGetSet('Seconds', false);\n\n// FORMATTING\n\naddFormatToken('S', 0, 0, function () {\n    return ~~(this.millisecond() / 100);\n});\n\naddFormatToken(0, ['SS', 2], 0, function () {\n    return ~~(this.millisecond() / 10);\n});\n\naddFormatToken(0, ['SSS', 3], 0, 'millisecond');\naddFormatToken(0, ['SSSS', 4], 0, function () {\n    return this.millisecond() * 10;\n});\naddFormatToken(0, ['SSSSS', 5], 0, function () {\n    return this.millisecond() * 100;\n});\naddFormatToken(0, ['SSSSSS', 6], 0, function () {\n    return this.millisecond() * 1000;\n});\naddFormatToken(0, ['SSSSSSS', 7], 0, function () {\n    return this.millisecond() * 10000;\n});\naddFormatToken(0, ['SSSSSSSS', 8], 0, function () {\n    return this.millisecond() * 100000;\n});\naddFormatToken(0, ['SSSSSSSSS', 9], 0, function () {\n    return this.millisecond() * 1000000;\n});\n\n\n// ALIASES\n\naddUnitAlias('millisecond', 'ms');\n\n// PRIORITY\n\naddUnitPriority('millisecond', 16);\n\n// PARSING\n\naddRegexToken('S',    match1to3, match1);\naddRegexToken('SS',   match1to3, match2);\naddRegexToken('SSS',  match1to3, match3);\n\nvar token;\nfor (token = 'SSSS'; token.length <= 9; token += 'S') {\n    addRegexToken(token, matchUnsigned);\n}\n\nfunction parseMs(input, array) {\n    array[MILLISECOND] = toInt(('0.' + input) * 1000);\n}\n\nfor (token = 'S'; token.length <= 9; token += 'S') {\n    addParseToken(token, parseMs);\n}\n// MOMENTS\n\nvar getSetMillisecond = makeGetSet('Milliseconds', false);\n\n// FORMATTING\n\naddFormatToken('z',  0, 0, 'zoneAbbr');\naddFormatToken('zz', 0, 0, 'zoneName');\n\n// MOMENTS\n\nfunction getZoneAbbr () {\n    return this._isUTC ? 'UTC' : '';\n}\n\nfunction getZoneName () {\n    return this._isUTC ? 'Coordinated Universal Time' : '';\n}\n\nvar proto = Moment.prototype;\n\nproto.add               = add;\nproto.calendar          = calendar$1;\nproto.clone             = clone;\nproto.diff              = diff;\nproto.endOf             = endOf;\nproto.format            = format;\nproto.from              = from;\nproto.fromNow           = fromNow;\nproto.to                = to;\nproto.toNow             = toNow;\nproto.get               = stringGet;\nproto.invalidAt         = invalidAt;\nproto.isAfter           = isAfter;\nproto.isBefore          = isBefore;\nproto.isBetween         = isBetween;\nproto.isSame            = isSame;\nproto.isSameOrAfter     = isSameOrAfter;\nproto.isSameOrBefore    = isSameOrBefore;\nproto.isValid           = isValid$2;\nproto.lang              = lang;\nproto.locale            = locale;\nproto.localeData        = localeData;\nproto.max               = prototypeMax;\nproto.min               = prototypeMin;\nproto.parsingFlags      = parsingFlags;\nproto.set               = stringSet;\nproto.startOf           = startOf;\nproto.subtract          = subtract;\nproto.toArray           = toArray;\nproto.toObject          = toObject;\nproto.toDate            = toDate;\nproto.toISOString       = toISOString;\nproto.inspect           = inspect;\nproto.toJSON            = toJSON;\nproto.toString          = toString;\nproto.unix              = unix;\nproto.valueOf           = valueOf;\nproto.creationData      = creationData;\n\n// Year\nproto.year       = getSetYear;\nproto.isLeapYear = getIsLeapYear;\n\n// Week Year\nproto.weekYear    = getSetWeekYear;\nproto.isoWeekYear = getSetISOWeekYear;\n\n// Quarter\nproto.quarter = proto.quarters = getSetQuarter;\n\n// Month\nproto.month       = getSetMonth;\nproto.daysInMonth = getDaysInMonth;\n\n// Week\nproto.week           = proto.weeks        = getSetWeek;\nproto.isoWeek        = proto.isoWeeks     = getSetISOWeek;\nproto.weeksInYear    = getWeeksInYear;\nproto.isoWeeksInYear = getISOWeeksInYear;\n\n// Day\nproto.date       = getSetDayOfMonth;\nproto.day        = proto.days             = getSetDayOfWeek;\nproto.weekday    = getSetLocaleDayOfWeek;\nproto.isoWeekday = getSetISODayOfWeek;\nproto.dayOfYear  = getSetDayOfYear;\n\n// Hour\nproto.hour = proto.hours = getSetHour;\n\n// Minute\nproto.minute = proto.minutes = getSetMinute;\n\n// Second\nproto.second = proto.seconds = getSetSecond;\n\n// Millisecond\nproto.millisecond = proto.milliseconds = getSetMillisecond;\n\n// Offset\nproto.utcOffset            = getSetOffset;\nproto.utc                  = setOffsetToUTC;\nproto.local                = setOffsetToLocal;\nproto.parseZone            = setOffsetToParsedOffset;\nproto.hasAlignedHourOffset = hasAlignedHourOffset;\nproto.isDST                = isDaylightSavingTime;\nproto.isLocal              = isLocal;\nproto.isUtcOffset          = isUtcOffset;\nproto.isUtc                = isUtc;\nproto.isUTC                = isUtc;\n\n// Timezone\nproto.zoneAbbr = getZoneAbbr;\nproto.zoneName = getZoneName;\n\n// Deprecations\nproto.dates  = deprecate('dates accessor is deprecated. Use date instead.', getSetDayOfMonth);\nproto.months = deprecate('months accessor is deprecated. Use month instead', getSetMonth);\nproto.years  = deprecate('years accessor is deprecated. Use year instead', getSetYear);\nproto.zone   = deprecate('moment().zone is deprecated, use moment().utcOffset instead. http://momentjs.com/guides/#/warnings/zone/', getSetZone);\nproto.isDSTShifted = deprecate('isDSTShifted is deprecated. See http://momentjs.com/guides/#/warnings/dst-shifted/ for more information', isDaylightSavingTimeShifted);\n\nfunction createUnix (input) {\n    return createLocal(input * 1000);\n}\n\nfunction createInZone () {\n    return createLocal.apply(null, arguments).parseZone();\n}\n\nfunction preParsePostFormat (string) {\n    return string;\n}\n\nvar proto$1 = Locale.prototype;\n\nproto$1.calendar        = calendar;\nproto$1.longDateFormat  = longDateFormat;\nproto$1.invalidDate     = invalidDate;\nproto$1.ordinal         = ordinal;\nproto$1.preparse        = preParsePostFormat;\nproto$1.postformat      = preParsePostFormat;\nproto$1.relativeTime    = relativeTime;\nproto$1.pastFuture      = pastFuture;\nproto$1.set             = set;\n\n// Month\nproto$1.months            =        localeMonths;\nproto$1.monthsShort       =        localeMonthsShort;\nproto$1.monthsParse       =        localeMonthsParse;\nproto$1.monthsRegex       = monthsRegex;\nproto$1.monthsShortRegex  = monthsShortRegex;\n\n// Week\nproto$1.week = localeWeek;\nproto$1.firstDayOfYear = localeFirstDayOfYear;\nproto$1.firstDayOfWeek = localeFirstDayOfWeek;\n\n// Day of Week\nproto$1.weekdays       =        localeWeekdays;\nproto$1.weekdaysMin    =        localeWeekdaysMin;\nproto$1.weekdaysShort  =        localeWeekdaysShort;\nproto$1.weekdaysParse  =        localeWeekdaysParse;\n\nproto$1.weekdaysRegex       =        weekdaysRegex;\nproto$1.weekdaysShortRegex  =        weekdaysShortRegex;\nproto$1.weekdaysMinRegex    =        weekdaysMinRegex;\n\n// Hours\nproto$1.isPM = localeIsPM;\nproto$1.meridiem = localeMeridiem;\n\nfunction get$1 (format, index, field, setter) {\n    var locale = getLocale();\n    var utc = createUTC().set(setter, index);\n    return locale[field](utc, format);\n}\n\nfunction listMonthsImpl (format, index, field) {\n    if (isNumber(format)) {\n        index = format;\n        format = undefined;\n    }\n\n    format = format || '';\n\n    if (index != null) {\n        return get$1(format, index, field, 'month');\n    }\n\n    var i;\n    var out = [];\n    for (i = 0; i < 12; i++) {\n        out[i] = get$1(format, i, field, 'month');\n    }\n    return out;\n}\n\n// ()\n// (5)\n// (fmt, 5)\n// (fmt)\n// (true)\n// (true, 5)\n// (true, fmt, 5)\n// (true, fmt)\nfunction listWeekdaysImpl (localeSorted, format, index, field) {\n    if (typeof localeSorted === 'boolean') {\n        if (isNumber(format)) {\n            index = format;\n            format = undefined;\n        }\n\n        format = format || '';\n    } else {\n        format = localeSorted;\n        index = format;\n        localeSorted = false;\n\n        if (isNumber(format)) {\n            index = format;\n            format = undefined;\n        }\n\n        format = format || '';\n    }\n\n    var locale = getLocale(),\n        shift = localeSorted ? locale._week.dow : 0;\n\n    if (index != null) {\n        return get$1(format, (index + shift) % 7, field, 'day');\n    }\n\n    var i;\n    var out = [];\n    for (i = 0; i < 7; i++) {\n        out[i] = get$1(format, (i + shift) % 7, field, 'day');\n    }\n    return out;\n}\n\nfunction listMonths (format, index) {\n    return listMonthsImpl(format, index, 'months');\n}\n\nfunction listMonthsShort (format, index) {\n    return listMonthsImpl(format, index, 'monthsShort');\n}\n\nfunction listWeekdays (localeSorted, format, index) {\n    return listWeekdaysImpl(localeSorted, format, index, 'weekdays');\n}\n\nfunction listWeekdaysShort (localeSorted, format, index) {\n    return listWeekdaysImpl(localeSorted, format, index, 'weekdaysShort');\n}\n\nfunction listWeekdaysMin (localeSorted, format, index) {\n    return listWeekdaysImpl(localeSorted, format, index, 'weekdaysMin');\n}\n\ngetSetGlobalLocale('en', {\n    dayOfMonthOrdinalParse: /\\d{1,2}(th|st|nd|rd)/,\n    ordinal : function (number) {\n        var b = number % 10,\n            output = (toInt(number % 100 / 10) === 1) ? 'th' :\n            (b === 1) ? 'st' :\n            (b === 2) ? 'nd' :\n            (b === 3) ? 'rd' : 'th';\n        return number + output;\n    }\n});\n\n// Side effect imports\nhooks.lang = deprecate('moment.lang is deprecated. Use moment.locale instead.', getSetGlobalLocale);\nhooks.langData = deprecate('moment.langData is deprecated. Use moment.localeData instead.', getLocale);\n\nvar mathAbs = Math.abs;\n\nfunction abs () {\n    var data           = this._data;\n\n    this._milliseconds = mathAbs(this._milliseconds);\n    this._days         = mathAbs(this._days);\n    this._months       = mathAbs(this._months);\n\n    data.milliseconds  = mathAbs(data.milliseconds);\n    data.seconds       = mathAbs(data.seconds);\n    data.minutes       = mathAbs(data.minutes);\n    data.hours         = mathAbs(data.hours);\n    data.months        = mathAbs(data.months);\n    data.years         = mathAbs(data.years);\n\n    return this;\n}\n\nfunction addSubtract$1 (duration, input, value, direction) {\n    var other = createDuration(input, value);\n\n    duration._milliseconds += direction * other._milliseconds;\n    duration._days         += direction * other._days;\n    duration._months       += direction * other._months;\n\n    return duration._bubble();\n}\n\n// supports only 2.0-style add(1, 's') or add(duration)\nfunction add$1 (input, value) {\n    return addSubtract$1(this, input, value, 1);\n}\n\n// supports only 2.0-style subtract(1, 's') or subtract(duration)\nfunction subtract$1 (input, value) {\n    return addSubtract$1(this, input, value, -1);\n}\n\nfunction absCeil (number) {\n    if (number < 0) {\n        return Math.floor(number);\n    } else {\n        return Math.ceil(number);\n    }\n}\n\nfunction bubble () {\n    var milliseconds = this._milliseconds;\n    var days         = this._days;\n    var months       = this._months;\n    var data         = this._data;\n    var seconds, minutes, hours, years, monthsFromDays;\n\n    // if we have a mix of positive and negative values, bubble down first\n    // check: https://github.com/moment/moment/issues/2166\n    if (!((milliseconds >= 0 && days >= 0 && months >= 0) ||\n            (milliseconds <= 0 && days <= 0 && months <= 0))) {\n        milliseconds += absCeil(monthsToDays(months) + days) * 864e5;\n        days = 0;\n        months = 0;\n    }\n\n    // The following code bubbles up values, see the tests for\n    // examples of what that means.\n    data.milliseconds = milliseconds % 1000;\n\n    seconds           = absFloor(milliseconds / 1000);\n    data.seconds      = seconds % 60;\n\n    minutes           = absFloor(seconds / 60);\n    data.minutes      = minutes % 60;\n\n    hours             = absFloor(minutes / 60);\n    data.hours        = hours % 24;\n\n    days += absFloor(hours / 24);\n\n    // convert days to months\n    monthsFromDays = absFloor(daysToMonths(days));\n    months += monthsFromDays;\n    days -= absCeil(monthsToDays(monthsFromDays));\n\n    // 12 months -> 1 year\n    years = absFloor(months / 12);\n    months %= 12;\n\n    data.days   = days;\n    data.months = months;\n    data.years  = years;\n\n    return this;\n}\n\nfunction daysToMonths (days) {\n    // 400 years have 146097 days (taking into account leap year rules)\n    // 400 years have 12 months === 4800\n    return days * 4800 / 146097;\n}\n\nfunction monthsToDays (months) {\n    // the reverse of daysToMonths\n    return months * 146097 / 4800;\n}\n\nfunction as (units) {\n    if (!this.isValid()) {\n        return NaN;\n    }\n    var days;\n    var months;\n    var milliseconds = this._milliseconds;\n\n    units = normalizeUnits(units);\n\n    if (units === 'month' || units === 'year') {\n        days   = this._days   + milliseconds / 864e5;\n        months = this._months + daysToMonths(days);\n        return units === 'month' ? months : months / 12;\n    } else {\n        // handle milliseconds separately because of floating point math errors (issue #1867)\n        days = this._days + Math.round(monthsToDays(this._months));\n        switch (units) {\n            case 'week'   : return days / 7     + milliseconds / 6048e5;\n            case 'day'    : return days         + milliseconds / 864e5;\n            case 'hour'   : return days * 24    + milliseconds / 36e5;\n            case 'minute' : return days * 1440  + milliseconds / 6e4;\n            case 'second' : return days * 86400 + milliseconds / 1000;\n            // Math.floor prevents floating point math errors here\n            case 'millisecond': return Math.floor(days * 864e5) + milliseconds;\n            default: throw new Error('Unknown unit ' + units);\n        }\n    }\n}\n\n// TODO: Use this.as('ms')?\nfunction valueOf$1 () {\n    if (!this.isValid()) {\n        return NaN;\n    }\n    return (\n        this._milliseconds +\n        this._days * 864e5 +\n        (this._months % 12) * 2592e6 +\n        toInt(this._months / 12) * 31536e6\n    );\n}\n\nfunction makeAs (alias) {\n    return function () {\n        return this.as(alias);\n    };\n}\n\nvar asMilliseconds = makeAs('ms');\nvar asSeconds      = makeAs('s');\nvar asMinutes      = makeAs('m');\nvar asHours        = makeAs('h');\nvar asDays         = makeAs('d');\nvar asWeeks        = makeAs('w');\nvar asMonths       = makeAs('M');\nvar asYears        = makeAs('y');\n\nfunction get$2 (units) {\n    units = normalizeUnits(units);\n    return this.isValid() ? this[units + 's']() : NaN;\n}\n\nfunction makeGetter(name) {\n    return function () {\n        return this.isValid() ? this._data[name] : NaN;\n    };\n}\n\nvar milliseconds = makeGetter('milliseconds');\nvar seconds      = makeGetter('seconds');\nvar minutes      = makeGetter('minutes');\nvar hours        = makeGetter('hours');\nvar days         = makeGetter('days');\nvar months       = makeGetter('months');\nvar years        = makeGetter('years');\n\nfunction weeks () {\n    return absFloor(this.days() / 7);\n}\n\nvar round = Math.round;\nvar thresholds = {\n    ss: 44,         // a few seconds to seconds\n    s : 45,         // seconds to minute\n    m : 45,         // minutes to hour\n    h : 22,         // hours to day\n    d : 26,         // days to month\n    M : 11          // months to year\n};\n\n// helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize\nfunction substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) {\n    return locale.relativeTime(number || 1, !!withoutSuffix, string, isFuture);\n}\n\nfunction relativeTime$1 (posNegDuration, withoutSuffix, locale) {\n    var duration = createDuration(posNegDuration).abs();\n    var seconds  = round(duration.as('s'));\n    var minutes  = round(duration.as('m'));\n    var hours    = round(duration.as('h'));\n    var days     = round(duration.as('d'));\n    var months   = round(duration.as('M'));\n    var years    = round(duration.as('y'));\n\n    var a = seconds <= thresholds.ss && ['s', seconds]  ||\n            seconds < thresholds.s   && ['ss', seconds] ||\n            minutes <= 1             && ['m']           ||\n            minutes < thresholds.m   && ['mm', minutes] ||\n            hours   <= 1             && ['h']           ||\n            hours   < thresholds.h   && ['hh', hours]   ||\n            days    <= 1             && ['d']           ||\n            days    < thresholds.d   && ['dd', days]    ||\n            months  <= 1             && ['M']           ||\n            months  < thresholds.M   && ['MM', months]  ||\n            years   <= 1             && ['y']           || ['yy', years];\n\n    a[2] = withoutSuffix;\n    a[3] = +posNegDuration > 0;\n    a[4] = locale;\n    return substituteTimeAgo.apply(null, a);\n}\n\n// This function allows you to set the rounding function for relative time strings\nfunction getSetRelativeTimeRounding (roundingFunction) {\n    if (roundingFunction === undefined) {\n        return round;\n    }\n    if (typeof(roundingFunction) === 'function') {\n        round = roundingFunction;\n        return true;\n    }\n    return false;\n}\n\n// This function allows you to set a threshold for relative time strings\nfunction getSetRelativeTimeThreshold (threshold, limit) {\n    if (thresholds[threshold] === undefined) {\n        return false;\n    }\n    if (limit === undefined) {\n        return thresholds[threshold];\n    }\n    thresholds[threshold] = limit;\n    if (threshold === 's') {\n        thresholds.ss = limit - 1;\n    }\n    return true;\n}\n\nfunction humanize (withSuffix) {\n    if (!this.isValid()) {\n        return this.localeData().invalidDate();\n    }\n\n    var locale = this.localeData();\n    var output = relativeTime$1(this, !withSuffix, locale);\n\n    if (withSuffix) {\n        output = locale.pastFuture(+this, output);\n    }\n\n    return locale.postformat(output);\n}\n\nvar abs$1 = Math.abs;\n\nfunction toISOString$1() {\n    // for ISO strings we do not use the normal bubbling rules:\n    //  * milliseconds bubble up until they become hours\n    //  * days do not bubble at all\n    //  * months bubble up until they become years\n    // This is because there is no context-free conversion between hours and days\n    // (think of clock changes)\n    // and also not between days and months (28-31 days per month)\n    if (!this.isValid()) {\n        return this.localeData().invalidDate();\n    }\n\n    var seconds = abs$1(this._milliseconds) / 1000;\n    var days         = abs$1(this._days);\n    var months       = abs$1(this._months);\n    var minutes, hours, years;\n\n    // 3600 seconds -> 60 minutes -> 1 hour\n    minutes           = absFloor(seconds / 60);\n    hours             = absFloor(minutes / 60);\n    seconds %= 60;\n    minutes %= 60;\n\n    // 12 months -> 1 year\n    years  = absFloor(months / 12);\n    months %= 12;\n\n\n    // inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js\n    var Y = years;\n    var M = months;\n    var D = days;\n    var h = hours;\n    var m = minutes;\n    var s = seconds;\n    var total = this.asSeconds();\n\n    if (!total) {\n        // this is the same as C#'s (Noda) and python (isodate)...\n        // but not other JS (goog.date)\n        return 'P0D';\n    }\n\n    return (total < 0 ? '-' : '') +\n        'P' +\n        (Y ? Y + 'Y' : '') +\n        (M ? M + 'M' : '') +\n        (D ? D + 'D' : '') +\n        ((h || m || s) ? 'T' : '') +\n        (h ? h + 'H' : '') +\n        (m ? m + 'M' : '') +\n        (s ? s + 'S' : '');\n}\n\nvar proto$2 = Duration.prototype;\n\nproto$2.isValid        = isValid$1;\nproto$2.abs            = abs;\nproto$2.add            = add$1;\nproto$2.subtract       = subtract$1;\nproto$2.as             = as;\nproto$2.asMilliseconds = asMilliseconds;\nproto$2.asSeconds      = asSeconds;\nproto$2.asMinutes      = asMinutes;\nproto$2.asHours        = asHours;\nproto$2.asDays         = asDays;\nproto$2.asWeeks        = asWeeks;\nproto$2.asMonths       = asMonths;\nproto$2.asYears        = asYears;\nproto$2.valueOf        = valueOf$1;\nproto$2._bubble        = bubble;\nproto$2.get            = get$2;\nproto$2.milliseconds   = milliseconds;\nproto$2.seconds        = seconds;\nproto$2.minutes        = minutes;\nproto$2.hours          = hours;\nproto$2.days           = days;\nproto$2.weeks          = weeks;\nproto$2.months         = months;\nproto$2.years          = years;\nproto$2.humanize       = humanize;\nproto$2.toISOString    = toISOString$1;\nproto$2.toString       = toISOString$1;\nproto$2.toJSON         = toISOString$1;\nproto$2.locale         = locale;\nproto$2.localeData     = localeData;\n\n// Deprecations\nproto$2.toIsoString = deprecate('toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)', toISOString$1);\nproto$2.lang = lang;\n\n// Side effect imports\n\n// FORMATTING\n\naddFormatToken('X', 0, 0, 'unix');\naddFormatToken('x', 0, 0, 'valueOf');\n\n// PARSING\n\naddRegexToken('x', matchSigned);\naddRegexToken('X', matchTimestamp);\naddParseToken('X', function (input, array, config) {\n    config._d = new Date(parseFloat(input, 10) * 1000);\n});\naddParseToken('x', function (input, array, config) {\n    config._d = new Date(toInt(input));\n});\n\n// Side effect imports\n\n\nhooks.version = '2.18.1';\n\nsetHookCallback(createLocal);\n\nhooks.fn                    = proto;\nhooks.min                   = min;\nhooks.max                   = max;\nhooks.now                   = now;\nhooks.utc                   = createUTC;\nhooks.unix                  = createUnix;\nhooks.months                = listMonths;\nhooks.isDate                = isDate;\nhooks.locale                = getSetGlobalLocale;\nhooks.invalid               = createInvalid;\nhooks.duration              = createDuration;\nhooks.isMoment              = isMoment;\nhooks.weekdays              = listWeekdays;\nhooks.parseZone             = createInZone;\nhooks.localeData            = getLocale;\nhooks.isDuration            = isDuration;\nhooks.monthsShort           = listMonthsShort;\nhooks.weekdaysMin           = listWeekdaysMin;\nhooks.defineLocale          = defineLocale;\nhooks.updateLocale          = updateLocale;\nhooks.locales               = listLocales;\nhooks.weekdaysShort         = listWeekdaysShort;\nhooks.normalizeUnits        = normalizeUnits;\nhooks.relativeTimeRounding = getSetRelativeTimeRounding;\nhooks.relativeTimeThreshold = getSetRelativeTimeThreshold;\nhooks.calendarFormat        = getCalendarFormat;\nhooks.prototype             = proto;\n\nreturn hooks;\n\n})));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/moment/moment.js\n// module id = 30\n// module chunks = 0","module.exports = function(module) {\r\n\tif(!module.webpackPolyfill) {\r\n\t\tmodule.deprecate = function() {};\r\n\t\tmodule.paths = [];\r\n\t\t// module.parent = undefined by default\r\n\t\tif(!module.children) module.children = [];\r\n\t\tObject.defineProperty(module, \"loaded\", {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function() {\r\n\t\t\t\treturn module.l;\r\n\t\t\t}\r\n\t\t});\r\n\t\tObject.defineProperty(module, \"id\", {\r\n\t\t\tenumerable: true,\r\n\t\t\tget: function() {\r\n\t\t\t\treturn module.i;\r\n\t\t\t}\r\n\t\t});\r\n\t\tmodule.webpackPolyfill = 1;\r\n\t}\r\n\treturn module;\r\n};\r\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../~/webpack/buildin/module.js\n// module id = 31\n// module chunks = 0"],"sourceRoot":""}