{"version":3,"sources":["node_modules/browser-pack/_prelude.js","src/js/main.js","node_modules/jquery/dist/jquery.js","node_modules/bootstrap/dist/js/npm.js","node_modules/lodash/index.js","node_modules/bootstrap/js/transition.js","node_modules/bootstrap/js/button.js","node_modules/bootstrap/js/dropdown.js","node_modules/bootstrap/js/collapse.js","node_modules/bootstrap/js/alert.js","node_modules/bootstrap/js/popover.js","node_modules/bootstrap/js/modal.js","node_modules/bootstrap/js/scrollspy.js","node_modules/bootstrap/js/carousel.js","node_modules/bootstrap/js/tab.js","node_modules/bootstrap/js/affix.js","node_modules/bootstrap/js/tooltip.js"],"names":["init","console","log","$","require","__browserify_shim_require__","module","exports","define","browserify_shim__define__module__export__","global","factory","document","w","Error","window","this","noGlobal","isArrayLike","obj","length","type","jQuery","isWindow","winnow","elements","qualifier","not","isFunction","grep","elem","i","call","nodeType","risSimple","test","filter","indexOf","sibling","cur","dir","createOptions","options","object","each","match","rnotwhite","_","flag","completed","removeEventListener","ready","Data","expando","uid","dataAttr","key","data","name","undefined","replace","rmultiDash","toLowerCase","getAttribute","rbrace","parseJSON","e","dataUser","set","adjustCSS","prop","valueParts","tween","adjusted","scale","maxIterations","currentValue","css","initial","unit","cssNumber","initialInUnit","rcssNum","exec","style","start","end","getAll","context","tag","ret","getElementsByTagName","querySelectorAll","nodeName","merge","setGlobalEval","elems","refElements","l","dataPriv","get","buildFragment","scripts","selection","ignored","tmp","wrap","contains","j","fragment","createDocumentFragment","nodes","rhtml","appendChild","createElement","rtagName","wrapMap","_default","innerHTML","htmlPrefilter","lastChild","childNodes","firstChild","textContent","push","createTextNode","inArray","ownerDocument","rscriptType","returnTrue","returnFalse","safeActiveElement","activeElement","err","on","types","selector","fn","one","origFn","event","off","apply","arguments","guid","add","manipulationTarget","content","disableScript","restoreScript","rscriptTypeMasked","removeAttribute","cloneCopyEvent","src","dest","pdataOld","pdataCur","udataOld","udataCur","events","hasData","access","handle","extend","fixInput","rcheckableType","checked","defaultValue","domManip","collection","args","callback","concat","first","hasScripts","node","doc","iNoClone","value","support","checkClone","rchecked","index","self","eq","html","map","clone","_evalUrl","globalEval","rcleanScript","remove","keepData","cleanData","parentNode","removeChild","actualDisplay","appendTo","body","display","detach","defaultDisplay","elemdisplay","iframe","documentElement","contentDocument","write","close","curCSS","computed","width","minWidth","maxWidth","getStyles","getPropertyValue","pixelMarginRight","rnumnonpx","rmargin","addGetHookIf","conditionFn","hookFn","vendorPropName","emptyStyle","capName","toUpperCase","slice","cssPrefixes","setPositiveNumber","subtract","matches","Math","max","augmentWidthOrHeight","extra","isBorderBox","styles","val","cssExpand","getWidthOrHeight","valueIsBorderBox","offsetWidth","offsetHeight","msFullscreenElement","top","getClientRects","round","getBoundingClientRect","boxSizingReliable","parseFloat","showHide","show","hidden","values","isHidden","Tween","easing","prototype","createFxNow","setTimeout","fxNow","now","genFx","includeWidth","which","attrs","height","opacity","createTween","animation","Animation","tweeners","defaultPrefilter","props","opts","toggle","hooks","oldfire","checkDisplay","anim","orig","dataShow","queue","_queueHooks","unqueued","empty","fire","always","overflow","overflowX","overflowY","rfxtypes","isEmptyObject","done","hide","propFilter","specialEasing","camelCase","isArray","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","selected","inspected","prefilterOrFactory","dataTypeOrTransport","seekingTransport","transports","ajaxExtend","target","deep","flatOptions","ajaxSettings","ajaxHandleResponses","s","responses","ct","finalDataType","firstDataType","contents","shift","mimeType","getResponseHeader","converters","ajaxConvert","response","isSuccess","conv2","current","conv","prev","responseFields","dataFilter","split","state","error","buildParams","prefix","traditional","v","rbracket","getWindow","defaultView","arr","class2type","toString","hasOwn","hasOwnProperty","version","rtrim","rmsPrefix","rdashAlpha","fcamelCase","all","letter","jquery","constructor","toArray","num","pushStack","prevObject","last","len","sort","splice","copy","copyIsArray","isPlainObject","random","isReady","msg","noop","Array","isNumeric","realStringObj","code","script","indirect","eval","trim","text","head","string","makeArray","results","Object","second","invert","callbackInverse","callbackExpect","arg","Date","Symbol","iterator","Sizzle","seed","m","nid","nidselect","groups","newSelector","newContext","preferredDoc","setDocument","documentIsHTML","rquickExpr","getElementById","id","getElementsByClassName","qsa","compilerCache","rbuggyQSA","rescape","setAttribute","tokenize","ridentifier","toSelector","join","rsibling","testContext","qsaError","select","createCache","cache","keys","Expr","cacheLength","markFunction","assert","div","addHandle","handler","attrHandle","siblingCheck","a","b","diff","sourceIndex","MAX_NEGATIVE","nextSibling","createInputPseudo","createButtonPseudo","createPositionalPseudo","argument","matchIndexes","setFilters","tokens","addCombinator","matcher","combinator","base","checkNonElements","doneName","xml","oldCache","uniqueCache","outerCache","newCache","dirruns","uniqueID","elementMatcher","matchers","multipleContexts","contexts","condense","unmatched","newUnmatched","mapped","setMatcher","preFilter","postFilter","postFinder","postSelector","preMap","postMap","preexisting","matcherIn","matcherOut","matcherFromTokens","checkContext","leadingRelative","relative","implicitRelative","matchContext","matchAnyContext","outermostContext","matcherFromGroupMatchers","elementMatchers","setMatchers","bySet","byElement","superMatcher","outermost","matchedCount","setMatched","contextBackup","find","dirrunsUnique","pop","uniqueSort","getText","isXML","compile","sortInput","hasDuplicate","docElem","rbuggyMatches","classCache","tokenCache","sortOrder","push_native","list","booleans","whitespace","identifier","attributes","pseudos","rwhitespace","RegExp","rcomma","rcombinators","rattributeQuotes","rpseudo","matchExpr","ID","CLASS","TAG","ATTR","PSEUDO","CHILD","bool","needsContext","rinputs","rheader","rnative","runescape","funescape","escaped","escapedWhitespace","high","String","fromCharCode","unloadHandler","els","hasCompare","parent","addEventListener","attachEvent","className","createComment","getById","getElementsByName","attrId","getAttributeNode","input","matchesSelector","webkitMatchesSelector","mozMatchesSelector","oMatchesSelector","msMatchesSelector","disconnectedMatch","compareDocumentPosition","adown","bup","compare","sortDetached","aup","ap","bp","expr","attr","specified","duplicates","detectDuplicates","sortStable","nodeValue","selectors","createPseudo",">"," ","+","~","excess","unquoted","nodeNameSelector","pattern","operator","check","what","simple","forward","ofType","nodeIndex","useCache","pseudo","idx","matched","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","n","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","readyState","doScroll","chainable","emptyGet","raw","bulk","acceptData","owner","register","defineProperty","writable","configurable","stored","camel","removeData","_data","_removeData","camelKey","dequeue","startLength","setter","clearQueue","count","defer","pnum","source","el","option","thead","col","tr","td","optgroup","tbody","tfoot","colgroup","caption","th","cloneNode","noCloneChecked","rkeyEvent","rmouseEvent","rtypenamespace","handleObjIn","eventHandle","t","handleObj","special","handlers","namespaces","origType","elemData","triggered","dispatch","delegateType","bindType","namespace","delegateCount","setup","mappedTypes","origCount","teardown","removeEvent","fix","handlerQueue","delegateTarget","preDispatch","isPropagationStopped","currentTarget","isImmediatePropagationStopped","rnamespace","preventDefault","stopPropagation","postDispatch","sel","isNaN","fixHooks","keyHooks","original","charCode","keyCode","mouseHooks","eventDoc","pageX","clientX","scrollLeft","clientLeft","pageY","clientY","scrollTop","clientTop","originalEvent","fixHook","Event","load","noBubble","trigger","blur","click","beforeunload","returnValue","isDefaultPrevented","defaultPrevented","timeStamp","stopImmediatePropagation","mouseenter","mouseleave","pointerenter","pointerleave","related","relatedTarget","rxhtmlTag","rnoInnerhtml","dataAndEvents","deepDataAndEvents","srcElements","destElements","inPage","append","prepend","insertBefore","before","after","replaceWith","replaceChild","prependTo","insertAfter","replaceAll","insert","HTML","BODY","view","opener","getComputedStyle","swap","old","computeStyleTests","cssText","container","divStyle","pixelPositionVal","reliableMarginLeftVal","marginLeft","boxSizingReliableVal","marginRight","pixelMarginRightVal","backgroundClip","clearCloneStyle","pixelPosition","reliableMarginLeft","reliableMarginRight","marginDiv","rdisplayswap","cssShow","position","visibility","cssNormalTransform","letterSpacing","fontWeight","animationIterationCount","columnCount","fillOpacity","flexGrow","flexShrink","lineHeight","order","orphans","widows","zIndex","zoom","cssProps","float","origName","isFinite","left","margin","padding","border","suffix","expanded","parts","propHooks","eased","step","linear","p","swing","cos","PI","timerId","rrun","*","tweener","prefilter","speed","opt","speeds","fadeTo","to","animate","optall","doAnimation","finish","stopQueue","timers","cssFn","slideDown","slideUp","slideToggle","fadeIn","fadeOut","fadeToggle","interval","setInterval","clearInterval","slow","fast","delay","time","timeout","clearTimeout","checkOn","optSelected","optDisabled","radioValue","boolHook","removeAttr","nType","attrHooks","propName","attrNames","propFix","getter","rfocusable","rclickable","removeProp","tabindex","parseInt","for","class","rclass","addClass","classes","curValue","clazz","finalValue","removeClass","toggleClass","stateVal","classNames","hasClass","rreturn","rspaces","valHooks","optionSet","rfocusMorph","onlyHandlers","bubbleType","ontype","eventPath","isTrigger","parentWindow","simulate","isSimulated","hover","fnOver","fnOut","focusin","attaches","nonce","rquery","JSON","parse","parseXML","DOMParser","parseFromString","rhash","rts","rheaders","rlocalProtocol","rnoContent","rprotocol","allTypes","originAnchor","active","lastModified","etag","url","isLocal","protocol","processData","async","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","urlAnchor","requestHeaders","requestHeadersNames","strAbort","getAllResponseHeaders","setRequestHeader","lname","overrideMimeType","abort","finalText","method","crossDomain","host","param","hasContent","beforeSend","send","getJSON","getScript","throws","wrapAll","firstElementChild","wrapInner","unwrap","visible","r20","rCRLF","rsubmitterTypes","rsubmittable","encodeURIComponent","serialize","serializeArray","xhr","XMLHttpRequest","xhrSuccessStatus",0,1223,"xhrSupported","cors","errorCallback","open","username","xhrFields","onload","onerror","onabort","onreadystatechange","responseType","responseText","binary","text script","charset","scriptCharset","evt","oldCallbacks","rjsonp","jsonp","jsonpCallback","originalSettings","callbackName","overwritten","responseContainer","jsonProp","keepScripts","parsed","_load","params","animated","offset","setOffset","curPosition","curLeft","curCSSTop","curTop","curOffset","curCSSLeft","calculatePosition","curElem","using","win","box","pageYOffset","pageXOffset","offsetParent","parentOffset","scrollTo","Height","Width","","defaultExtra","funcName","bind","unbind","delegate","undelegate","size","andSelf","amd","_jQuery","_$","noConflict","ex","baseCompareAscending","other","valIsNull","valIsUndef","valIsReflexive","othIsNull","othIsUndef","othIsReflexive","baseFindIndex","array","predicate","fromRight","baseIndexOf","fromIndex","indexOfNaN","baseIsFunction","baseToString","charsLeftIndex","chars","charAt","charsRightIndex","compareAscending","criteria","compareMultiple","orders","objCriteria","othCriteria","ordersLength","deburrLetter","deburredLetters","escapeHtmlChar","chr","htmlEscapes","escapeRegExpChar","leadingChar","whitespaceChar","regexpEscapes","stringEscapes","escapeStringChar","isObjectLike","isSpace","replaceHolders","placeholder","resIndex","PLACEHOLDER","sortedUniq","iteratee","seen","trimmedLeftIndex","charCodeAt","trimmedRightIndex","unescapeHtmlChar","htmlUnescapes","runInContext","lodash","LazyWrapper","LodashWrapper","wrapperClone","baseLodash","chainAll","actions","__wrapped__","__actions__","__chain__","__dir__","__filtered__","__iteratees__","__takeCount__","POSITIVE_INFINITY","__views__","lazyClone","arrayCopy","lazyReverse","lazyValue","isArr","isRight","arrLength","getView","iteratees","iterLength","takeCount","nativeMin","LARGE_ARRAY_SIZE","baseWrapperValue","outer","iterIndex","LAZY_MAP_FLAG","LAZY_FILTER_FLAG","MapCache","__data__","mapDelete","mapGet","mapHas","mapSet","SetCache","nativeCreate","Set","cacheIndexOf","isObject","cachePush","arrayConcat","othIndex","othLength","arrayEach","arrayEachRight","arrayEvery","arrayExtremum","comparator","exValue","arrayFilter","arrayMap","arrayPush","arrayReduce","accumulator","initFromArray","arrayReduceRight","arraySome","arraySum","assignDefaults","objectValue","sourceValue","assignOwnDefaults","assignWith","customizer","baseAssign","baseCopy","baseAt","isNil","propsLength","isIndex","baseCallback","thisArg","argCount","bindCallback","identity","baseMatches","property","baseMatchesProperty","baseClone","isDeep","stackA","stackB","initCloneArray","objToString","isFunc","funcTag","objectTag","argsTag","cloneableTags","initCloneByTag","initCloneObject","baseForOwn","subValue","baseDelay","TypeError","FUNC_ERROR_TEXT","baseDifference","getIndexOf","isCommon","valuesLength","valuesIndex","baseEvery","baseEach","baseExtremum","baseFill","baseFilter","baseFind","eachFunc","retKey","baseFlatten","isStrict","isArguments","baseForIn","baseFor","keysIn","baseForOwnRight","baseForRight","baseFunctions","baseGet","path","pathKey","toObject","baseIsEqual","isLoose","baseIsEqualDeep","equalFunc","objIsArr","othIsArr","objTag","arrayTag","othTag","isTypedArray","objIsObj","othIsObj","isSameTag","equalByTag","objIsWrapped","othIsWrapped","equalArrays","equalObjects","baseIsMatch","matchData","noCustomizer","objValue","srcValue","baseMap","getMatchData","isKey","isStrictComparable","toPath","baseSlice","baseMerge","isSrcArr","baseMergeDeep","mergeFunc","toPlainObject","baseProperty","basePropertyDeep","basePullAt","indexes","previous","baseRandom","min","nativeFloor","nativeRandom","baseReduce","initFromCollection","baseSome","baseSortBy","comparer","baseSortByOrder","getCallback","baseSum","baseUniq","isLarge","seenIndex","baseValues","baseWhile","isDrop","action","binaryIndex","retHighest","low","HALF_MAX_ARRAY_LENGTH","mid","binaryIndexBy","valIsNaN","isDef","isReflexive","setLow","MAX_ARRAY_INDEX","bufferClone","buffer","ArrayBuffer","byteLength","Uint8Array","composeArgs","partials","holders","holdersLength","argsIndex","argsLength","nativeMax","leftIndex","leftLength","composeArgsRight","holdersIndex","rightIndex","rightLength","createAggregator","initializer","createAssigner","assigner","restParam","sources","guard","isIterateeCall","createBaseEach","getLength","isLength","iterable","createBaseFor","keysFunc","createBindWrapper","wrapper","Ctor","createCtorWrapper","createCompounder","words","deburr","thisBinding","baseCreate","createCurry","curryFunc","arity","createWrapper","createDefaults","createExtremum","toIterable","createFind","createFindIndex","createFindKey","objectFunc","createFlow","funcs","thru","getFuncName","getData","isLaziable","ARY_FLAG","CURRY_FLAG","PARTIAL_FLAG","REARG_FLAG","plant","createForEach","arrayFunc","createForIn","createForOwn","createObjectMapper","isMapKeys","createPadDir","createPadding","createPartial","partialFunc","createReduce","createHybridWrapper","bitmask","partialsRight","holdersRight","argPos","ary","isCurry","isCurryRight","argsHolders","newArgPos","newArity","newsHolders","newHoldersRight","newPartials","newPartialsRight","PARTIAL_RIGHT_FLAG","isCurryBound","BIND_FLAG","BIND_KEY_FLAG","newData","setData","isBind","isBindKey","reorder","isAry","CURRY_BOUND_FLAG","CURRY_RIGHT_FLAG","strLength","nativeIsFinite","padLength","repeat","nativeCeil","createPartialWrapper","createRound","methodName","number","precision","pow","createSortedIndex","mergeData","baseSetData","arrValue","othValue","boolTag","dateTag","errorTag","message","numberTag","regexpTag","stringTag","objProps","objLength","othProps","skipCtor","objCtor","othCtor","realNames","otherFunc","pairs","getNative","isNative","transforms","arrayBufferTag","float32Tag","float64Tag","int8Tag","int16Tag","int32Tag","uint8Tag","uint8ClampedTag","uint16Tag","uint32Tag","byteOffset","reFlags","lastIndex","invokePath","reIsUint","MAX_SAFE_INTEGER","reIsPlainProp","reIsDeepProp","srcBitmask","newBitmask","isCombo","mergeDefaults","pickByArray","pickByCallback","oldArray","shimKeys","allowIndexes","rePropName","quote","reEscapeChar","chunk","compact","drop","dropRight","dropRightWhile","dropWhile","fill","flatten","flattenDeep","lastIndexOf","pull","rest","take","takeRight","takeRightWhile","takeWhile","uniq","isSorted","unzip","group","unzipWith","xor","zipObject","chain","tap","interceptor","wrapperChain","wrapperCommit","wrapperPlant","wrapperReverse","wrapped","wrapperToString","wrapperValue","every","findWhere","includes","isString","pluck","sample","rand","shuffle","some","sortBy","sortByOrder","where","debounce","cancel","timeoutId","maxTimeoutId","lastCalled","trailingCall","isCalled","delayed","stamp","maxDelayed","trailing","debounced","leading","maxWait","leadingCall","memoize","resolver","memoized","Cache","negate","otherArgs","spread","throttle","cloneDeep","gte","propertyIsEnumerable","isBoolean","isDate","isElement","isEmpty","isEqual","isError","isMatch","isNumber","reIsNative","fnToString","reIsHostCtor","isNull","isRegExp","typedArrayTags","isUndefined","lte","create","functions","multiValue","isProto","skipIndexes","nested","transform","valuesIn","inRange","floating","noMin","noMax","capitalize","reLatin1","reComboMark","endsWith","escape","reHasUnescapedHtml","reUnescapedHtml","escapeRegExp","reHasRegExpChars","reRegExpChars","pad","radix","nativeParseInt","reHasHexPrefix","startsWith","template","otherOptions","templateSettings","isEscaping","isEvaluating","imports","importsKeys","importsValues","interpolate","reNoMatch","reDelimiters","reInterpolate","reEsTemplate","evaluate","sourceURL","templateCounter","escapeValue","interpolateValue","esTemplateValue","evaluateValue","reUnescapedString","variable","reEmptyStringLeading","reEmptyStringMiddle","reEmptyStringTrailing","attempt","Function","trimLeft","trimRight","trunc","DEFAULT_TRUNC_LENGTH","omission","DEFAULT_TRUNC_OMISSION","separator","search","newEnd","substring","unescape","reHasEscapedHtml","reEscapedHtml","reWords","constant","matchesProperty","mixin","isObj","methodNames","oldDash","propertyOf","range","times","MAX_ARRAY_LENGTH","uniqueId","idCounter","augend","addend","sum","defaults","pick","contextProps","Number","arrayProto","objectProto","stringProto","WeakMap","ceil","floor","nativeIsArray","nativeKeys","nativeNow","NEGATIVE_INFINITY","metaMap","reEscape","reEvaluate","baseEachRight","HOT_SPAN","HOT_COUNT","difference","findIndex","findLastIndex","intersection","arrays","caches","pullAt","sortedIndex","sortedLastIndex","union","without","zip","zipWith","wrapperConcat","at","countBy","findLast","forEach","forEachRight","groupBy","indexBy","invoke","isProp","partition","reduce","reduceRight","sortByAll","getTime","bindAll","bindKey","curry","curryRight","flow","flowRight","modArgs","partial","partialRight","rearg","assign","defaultsDeep","findKey","findLastKey","forIn","forInRight","forOwn","forOwnRight","mapKeys","mapValues","omit","word","kebabCase","padLeft","padRight","snakeCase","startCase","methodOf","backflow","collect","compose","eachRight","methods","tail","any","detect","foldl","foldr","include","inject","VERSION","filtered","isFilter","takeName","dropName","operationName","createCallback","checkIteratee","retUnwrapped","lodashFunc","isHybrid","isLazy","useLazy","onlyLazy","chainName","names","commit","toJSON","valueOf","mapTag","setTag","weakMapTag","upper","lower","À","Á","Â","Ã","Ä","Å","à","á","â","ã","ä","å","Ç","ç","Ð","ð","È","É","Ê","Ë","è","é","ê","ë","Ì","Í","Î","Ï","ì","í","î","ï","Ñ","ñ","Ò","Ó","Ô","Õ","Ö","Ø","ò","ó","ô","õ","ö","ø","Ù","Ú","Û","Ü","ù","ú","û","ü","Ý","ý","ÿ","Æ","æ","Þ","þ","ß","&","<","\"","'","`","&amp;","&lt;","&gt;","&quot;","&#39;","&#96;","objectTypes","function","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F","c","d","f","r","u","x","\\","\n","\r","
","
","freeExports","freeModule","freeGlobal","freeSelf","freeWindow","moduleExports","transitionEnd","transEndEventNames","WebkitTransition","MozTransition","OTransition","transition","emulateTransitionEnd","called","$el","bsTransitionEnd","Plugin","$this","Button","setState","element","$element","DEFAULTS","isLoading","loadingText","resetText","changed","$parent","$input","Constructor","$btn","getParent","clearMenus","backdrop","tagName","Dropdown","isActive","keydown","desc","$items","dropdown","getTargetFromTrigger","$trigger","Collapse","transitioning","addAriaAndCollapsedClass","TRANSITION_DURATION","dimension","hasWidth","activesData","actives","startEvent","scrollSize","isOpen","collapse","$target","Alert","dismiss","removeElement","alert","Popover","tooltip","placement","getDefaults","setContent","$tip","tip","title","getTitle","getContent","$e","o","arrow","$arrow","popover","_relatedTarget","Modal","$body","$dialog","$backdrop","isShown","originalBodyPad","scrollbarWidth","ignoreBackdropClick","remote","BACKDROP_TRANSITION_DURATION","keyboard","that","checkScrollbar","setScrollbar","resize","adjustDialog","enforceFocus","hideModal","handleUpdate","resetAdjustments","resetScrollbar","removeBackdrop","doAnimate","callbackRemove","modalIsOverflowing","scrollHeight","clientHeight","paddingLeft","bodyIsOverflowing","paddingRight","fullWindowWidth","innerWidth","documentElementRect","right","abs","clientWidth","measureScrollbar","bodyPad","scrollDiv","modal","showEvent","ScrollSpy","$scrollElement","offsets","activeTarget","process","refresh","getScrollHeight","offsetMethod","offsetBase","$href","maxScroll","activate","clear","scrollspy","$spy","Carousel","slide","pause","cycle","$indicators","paused","sliding","$active","getItemIndex","item","getItemForDirection","direction","activeIndex","willWrap","delta","itemIndex","$next","isCycling","slideEvent","$nextIndicator","slidEvent","carousel","clickHandler","slideIndex","$carousel","Tab","$ul","$previous","hideEvent","tab","Affix","checkPosition","checkPositionWithEventLoop","affixed","unpin","pinnedOffset","RESET","getState","offsetTop","offsetBottom","targetHeight","initializing","colliderTop","colliderHeight","getPinnedOffset","bottom","affix","affixType","Tooltip","hoverState","inState","viewport","getOptions","$viewport","triggers","eventIn","eventOut","enter","leave","_options","fixTitle","getDelegateOptions","isInStateTrue","inDom","tipId","getUID","autoToken","autoPlace","getPosition","actualWidth","actualHeight","orgPlacement","viewportDim","calculatedOffset","getCalculatedOffset","applyPlacement","prevHoverState","marginTop","getViewportAdjustedDelta","isVertical","arrowDelta","arrowOffsetPosition","replaceArrow","isBody","elRect","elOffset","scroll","outerDims","viewportPadding","viewportDimensions","topEdgeOffset","bottomEdgeOffset","leftEdgeOffset","rightEdgeOffset","enable","toggleEnabled","destroy"],"mappings":"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","file":"bundle.js","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","(function() {\n    \"use strict\";\n    \n    var $ = require('jquery'),\n        _ = require('lodash'),\n        Bootstrap = require('bootstrap');\n    \n    $(init);\n    \n    function init() {\n        console.log(\"page initialized\");\n    }\n})();","; var __browserify_shim_require__=require;(function browserifyShim(module, exports, require, define, browserify_shim__define__module__export__) {\n/*!\n * jQuery JavaScript Library v2.2.2\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-03-17T17:51Z\n */\n\n(function( global, factory ) {\n\n\tif ( typeof module === \"object\" && typeof module.exports === \"object\" ) {\n\t\t// For CommonJS and CommonJS-like environments where a proper `window`\n\t\t// is present, execute the factory and get jQuery.\n\t\t// For environments that do not have a `window` with a `document`\n\t\t// (such as Node.js), expose a factory as module.exports.\n\t\t// This accentuates the need for the creation of a real `window`.\n\t\t// e.g. var jQuery = require(\"jquery\")(window);\n\t\t// See ticket #14549 for more info.\n\t\tmodule.exports = global.document ?\n\t\t\tfactory( global, true ) :\n\t\t\tfunction( w ) {\n\t\t\t\tif ( !w.document ) {\n\t\t\t\t\tthrow new Error( \"jQuery requires a window with a document\" );\n\t\t\t\t}\n\t\t\t\treturn factory( w );\n\t\t\t};\n\t} else {\n\t\tfactory( global );\n\t}\n\n// Pass this if window is not defined yet\n}(typeof window !== \"undefined\" ? window : this, function( window, noGlobal ) {\n\n// Support: Firefox 18+\n// Can't be in strict mode, several libs including ASP.NET trace\n// the stack via arguments.caller.callee and Firefox dies if\n// you try to trace through \"use strict\" call chains. (#13335)\n//\"use strict\";\nvar arr = [];\n\nvar document = window.document;\n\nvar slice = arr.slice;\n\nvar concat = arr.concat;\n\nvar push = arr.push;\n\nvar indexOf = arr.indexOf;\n\nvar class2type = {};\n\nvar toString = class2type.toString;\n\nvar hasOwn = class2type.hasOwnProperty;\n\nvar support = {};\n\n\n\nvar\n\tversion = \"2.2.2\",\n\n\t// Define a local copy of jQuery\n\tjQuery = function( selector, context ) {\n\n\t\t// The jQuery object is actually just the init constructor 'enhanced'\n\t\t// Need init if jQuery is called (just allow error to be thrown if not included)\n\t\treturn new jQuery.fn.init( selector, context );\n\t},\n\n\t// Support: Android<4.1\n\t// Make sure we trim BOM and NBSP\n\trtrim = /^[\\s\\uFEFF\\xA0]+|[\\s\\uFEFF\\xA0]+$/g,\n\n\t// Matches dashed string for camelizing\n\trmsPrefix = /^-ms-/,\n\trdashAlpha = /-([\\da-z])/gi,\n\n\t// Used by jQuery.camelCase as callback to replace()\n\tfcamelCase = function( all, letter ) {\n\t\treturn letter.toUpperCase();\n\t};\n\njQuery.fn = jQuery.prototype = {\n\n\t// The current version of jQuery being used\n\tjquery: version,\n\n\tconstructor: jQuery,\n\n\t// Start with an empty selector\n\tselector: \"\",\n\n\t// The default length of a jQuery object is 0\n\tlength: 0,\n\n\ttoArray: function() {\n\t\treturn slice.call( this );\n\t},\n\n\t// Get the Nth element in the matched element set OR\n\t// Get the whole matched element set as a clean array\n\tget: function( num ) {\n\t\treturn num != null ?\n\n\t\t\t// Return just the one element from the set\n\t\t\t( num < 0 ? this[ num + this.length ] : this[ num ] ) :\n\n\t\t\t// Return all the elements in a clean array\n\t\t\tslice.call( this );\n\t},\n\n\t// Take an array of elements and push it onto the stack\n\t// (returning the new matched element set)\n\tpushStack: function( elems ) {\n\n\t\t// Build a new jQuery matched element set\n\t\tvar ret = jQuery.merge( this.constructor(), elems );\n\n\t\t// Add the old object onto the stack (as a reference)\n\t\tret.prevObject = this;\n\t\tret.context = this.context;\n\n\t\t// Return the newly-formed element set\n\t\treturn ret;\n\t},\n\n\t// Execute a callback for every element in the matched set.\n\teach: function( callback ) {\n\t\treturn jQuery.each( this, callback );\n\t},\n\n\tmap: function( callback ) {\n\t\treturn this.pushStack( jQuery.map( this, function( elem, i ) {\n\t\t\treturn callback.call( elem, i, elem );\n\t\t} ) );\n\t},\n\n\tslice: function() {\n\t\treturn this.pushStack( slice.apply( this, arguments ) );\n\t},\n\n\tfirst: function() {\n\t\treturn this.eq( 0 );\n\t},\n\n\tlast: function() {\n\t\treturn this.eq( -1 );\n\t},\n\n\teq: function( i ) {\n\t\tvar len = this.length,\n\t\t\tj = +i + ( i < 0 ? len : 0 );\n\t\treturn this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );\n\t},\n\n\tend: function() {\n\t\treturn this.prevObject || this.constructor();\n\t},\n\n\t// For internal use only.\n\t// Behaves like an Array's method, not like a jQuery method.\n\tpush: push,\n\tsort: arr.sort,\n\tsplice: arr.splice\n};\n\njQuery.extend = jQuery.fn.extend = function() {\n\tvar options, name, src, copy, copyIsArray, clone,\n\t\ttarget = arguments[ 0 ] || {},\n\t\ti = 1,\n\t\tlength = arguments.length,\n\t\tdeep = false;\n\n\t// Handle a deep copy situation\n\tif ( typeof target === \"boolean\" ) {\n\t\tdeep = target;\n\n\t\t// Skip the boolean and the target\n\t\ttarget = arguments[ i ] || {};\n\t\ti++;\n\t}\n\n\t// Handle case when target is a string or something (possible in deep copy)\n\tif ( typeof target !== \"object\" && !jQuery.isFunction( target ) ) {\n\t\ttarget = {};\n\t}\n\n\t// Extend jQuery itself if only one argument is passed\n\tif ( i === length ) {\n\t\ttarget = this;\n\t\ti--;\n\t}\n\n\tfor ( ; i < length; i++ ) {\n\n\t\t// Only deal with non-null/undefined values\n\t\tif ( ( options = arguments[ i ] ) != null ) {\n\n\t\t\t// Extend the base object\n\t\t\tfor ( name in options ) {\n\t\t\t\tsrc = target[ name ];\n\t\t\t\tcopy = options[ name ];\n\n\t\t\t\t// Prevent never-ending loop\n\t\t\t\tif ( target === copy ) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\t// Recurse if we're merging plain objects or arrays\n\t\t\t\tif ( deep && copy && ( jQuery.isPlainObject( copy ) ||\n\t\t\t\t\t( copyIsArray = jQuery.isArray( copy ) ) ) ) {\n\n\t\t\t\t\tif ( copyIsArray ) {\n\t\t\t\t\t\tcopyIsArray = false;\n\t\t\t\t\t\tclone = src && jQuery.isArray( src ) ? src : [];\n\n\t\t\t\t\t} else {\n\t\t\t\t\t\tclone = src && jQuery.isPlainObject( src ) ? src : {};\n\t\t\t\t\t}\n\n\t\t\t\t\t// Never move original objects, clone them\n\t\t\t\t\ttarget[ name ] = jQuery.extend( deep, clone, copy );\n\n\t\t\t\t// Don't bring in undefined values\n\t\t\t\t} else if ( copy !== undefined ) {\n\t\t\t\t\ttarget[ name ] = copy;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Return the modified object\n\treturn target;\n};\n\njQuery.extend( {\n\n\t// Unique for each copy of jQuery on the page\n\texpando: \"jQuery\" + ( version + Math.random() ).replace( /\\D/g, \"\" ),\n\n\t// Assume jQuery is ready without the ready module\n\tisReady: true,\n\n\terror: function( msg ) {\n\t\tthrow new Error( msg );\n\t},\n\n\tnoop: function() {},\n\n\tisFunction: function( obj ) {\n\t\treturn jQuery.type( obj ) === \"function\";\n\t},\n\n\tisArray: Array.isArray,\n\n\tisWindow: function( obj ) {\n\t\treturn obj != null && obj === obj.window;\n\t},\n\n\tisNumeric: function( obj ) {\n\n\t\t// parseFloat NaNs numeric-cast false positives (null|true|false|\"\")\n\t\t// ...but misinterprets leading-number strings, particularly hex literals (\"0x...\")\n\t\t// subtraction forces infinities to NaN\n\t\t// adding 1 corrects loss of precision from parseFloat (#15100)\n\t\tvar realStringObj = obj && obj.toString();\n\t\treturn !jQuery.isArray( obj ) && ( realStringObj - parseFloat( realStringObj ) + 1 ) >= 0;\n\t},\n\n\tisPlainObject: function( obj ) {\n\t\tvar key;\n\n\t\t// Not plain objects:\n\t\t// - Any object or value whose internal [[Class]] property is not \"[object Object]\"\n\t\t// - DOM nodes\n\t\t// - window\n\t\tif ( jQuery.type( obj ) !== \"object\" || obj.nodeType || jQuery.isWindow( obj ) ) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Not own constructor property must be Object\n\t\tif ( obj.constructor &&\n\t\t\t\t!hasOwn.call( obj, \"constructor\" ) &&\n\t\t\t\t!hasOwn.call( obj.constructor.prototype || {}, \"isPrototypeOf\" ) ) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Own properties are enumerated firstly, so to speed up,\n\t\t// if last one is own, then all properties are own\n\t\tfor ( key in obj ) {}\n\n\t\treturn key === undefined || hasOwn.call( obj, key );\n\t},\n\n\tisEmptyObject: function( obj ) {\n\t\tvar name;\n\t\tfor ( name in obj ) {\n\t\t\treturn false;\n\t\t}\n\t\treturn true;\n\t},\n\n\ttype: function( obj ) {\n\t\tif ( obj == null ) {\n\t\t\treturn obj + \"\";\n\t\t}\n\n\t\t// Support: Android<4.0, iOS<6 (functionish RegExp)\n\t\treturn typeof obj === \"object\" || typeof obj === \"function\" ?\n\t\t\tclass2type[ toString.call( obj ) ] || \"object\" :\n\t\t\ttypeof obj;\n\t},\n\n\t// Evaluates a script in a global context\n\tglobalEval: function( code ) {\n\t\tvar script,\n\t\t\tindirect = eval;\n\n\t\tcode = jQuery.trim( code );\n\n\t\tif ( code ) {\n\n\t\t\t// If the code includes a valid, prologue position\n\t\t\t// strict mode pragma, execute code by injecting a\n\t\t\t// script tag into the document.\n\t\t\tif ( code.indexOf( \"use strict\" ) === 1 ) {\n\t\t\t\tscript = document.createElement( \"script\" );\n\t\t\t\tscript.text = code;\n\t\t\t\tdocument.head.appendChild( script ).parentNode.removeChild( script );\n\t\t\t} else {\n\n\t\t\t\t// Otherwise, avoid the DOM node creation, insertion\n\t\t\t\t// and removal by using an indirect global eval\n\n\t\t\t\tindirect( code );\n\t\t\t}\n\t\t}\n\t},\n\n\t// Convert dashed to camelCase; used by the css and data modules\n\t// Support: IE9-11+\n\t// Microsoft forgot to hump their vendor prefix (#9572)\n\tcamelCase: function( string ) {\n\t\treturn string.replace( rmsPrefix, \"ms-\" ).replace( rdashAlpha, fcamelCase );\n\t},\n\n\tnodeName: function( elem, name ) {\n\t\treturn elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();\n\t},\n\n\teach: function( obj, callback ) {\n\t\tvar length, i = 0;\n\n\t\tif ( isArrayLike( obj ) ) {\n\t\t\tlength = obj.length;\n\t\t\tfor ( ; i < length; i++ ) {\n\t\t\t\tif ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tfor ( i in obj ) {\n\t\t\t\tif ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn obj;\n\t},\n\n\t// Support: Android<4.1\n\ttrim: function( text ) {\n\t\treturn text == null ?\n\t\t\t\"\" :\n\t\t\t( text + \"\" ).replace( rtrim, \"\" );\n\t},\n\n\t// results is for internal usage only\n\tmakeArray: function( arr, results ) {\n\t\tvar ret = results || [];\n\n\t\tif ( arr != null ) {\n\t\t\tif ( isArrayLike( Object( arr ) ) ) {\n\t\t\t\tjQuery.merge( ret,\n\t\t\t\t\ttypeof arr === \"string\" ?\n\t\t\t\t\t[ arr ] : arr\n\t\t\t\t);\n\t\t\t} else {\n\t\t\t\tpush.call( ret, arr );\n\t\t\t}\n\t\t}\n\n\t\treturn ret;\n\t},\n\n\tinArray: function( elem, arr, i ) {\n\t\treturn arr == null ? -1 : indexOf.call( arr, elem, i );\n\t},\n\n\tmerge: function( first, second ) {\n\t\tvar len = +second.length,\n\t\t\tj = 0,\n\t\t\ti = first.length;\n\n\t\tfor ( ; j < len; j++ ) {\n\t\t\tfirst[ i++ ] = second[ j ];\n\t\t}\n\n\t\tfirst.length = i;\n\n\t\treturn first;\n\t},\n\n\tgrep: function( elems, callback, invert ) {\n\t\tvar callbackInverse,\n\t\t\tmatches = [],\n\t\t\ti = 0,\n\t\t\tlength = elems.length,\n\t\t\tcallbackExpect = !invert;\n\n\t\t// Go through the array, only saving the items\n\t\t// that pass the validator function\n\t\tfor ( ; i < length; i++ ) {\n\t\t\tcallbackInverse = !callback( elems[ i ], i );\n\t\t\tif ( callbackInverse !== callbackExpect ) {\n\t\t\t\tmatches.push( elems[ i ] );\n\t\t\t}\n\t\t}\n\n\t\treturn matches;\n\t},\n\n\t// arg is for internal usage only\n\tmap: function( elems, callback, arg ) {\n\t\tvar length, value,\n\t\t\ti = 0,\n\t\t\tret = [];\n\n\t\t// Go through the array, translating each of the items to their new values\n\t\tif ( isArrayLike( elems ) ) {\n\t\t\tlength = elems.length;\n\t\t\tfor ( ; i < length; i++ ) {\n\t\t\t\tvalue = callback( elems[ i ], i, arg );\n\n\t\t\t\tif ( value != null ) {\n\t\t\t\t\tret.push( value );\n\t\t\t\t}\n\t\t\t}\n\n\t\t// Go through every key on the object,\n\t\t} else {\n\t\t\tfor ( i in elems ) {\n\t\t\t\tvalue = callback( elems[ i ], i, arg );\n\n\t\t\t\tif ( value != null ) {\n\t\t\t\t\tret.push( value );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Flatten any nested arrays\n\t\treturn concat.apply( [], ret );\n\t},\n\n\t// A global GUID counter for objects\n\tguid: 1,\n\n\t// Bind a function to a context, optionally partially applying any\n\t// arguments.\n\tproxy: function( fn, context ) {\n\t\tvar tmp, args, proxy;\n\n\t\tif ( typeof context === \"string\" ) {\n\t\t\ttmp = fn[ context ];\n\t\t\tcontext = fn;\n\t\t\tfn = tmp;\n\t\t}\n\n\t\t// Quick check to determine if target is callable, in the spec\n\t\t// this throws a TypeError, but we will just return undefined.\n\t\tif ( !jQuery.isFunction( fn ) ) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\t// Simulated bind\n\t\targs = slice.call( arguments, 2 );\n\t\tproxy = function() {\n\t\t\treturn fn.apply( context || this, args.concat( slice.call( arguments ) ) );\n\t\t};\n\n\t\t// Set the guid of unique handler to the same of original handler, so it can be removed\n\t\tproxy.guid = fn.guid = fn.guid || jQuery.guid++;\n\n\t\treturn proxy;\n\t},\n\n\tnow: Date.now,\n\n\t// jQuery.support is not used in Core but other projects attach their\n\t// properties to it so it needs to exist.\n\tsupport: support\n} );\n\n// JSHint would error on this code due to the Symbol not being defined in ES5.\n// Defining this global in .jshintrc would create a danger of using the global\n// unguarded in another place, it seems safer to just disable JSHint for these\n// three lines.\n/* jshint ignore: start */\nif ( typeof Symbol === \"function\" ) {\n\tjQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];\n}\n/* jshint ignore: end */\n\n// Populate the class2type map\njQuery.each( \"Boolean Number String Function Array Date RegExp Object Error Symbol\".split( \" \" ),\nfunction( i, name ) {\n\tclass2type[ \"[object \" + name + \"]\" ] = name.toLowerCase();\n} );\n\nfunction isArrayLike( obj ) {\n\n\t// Support: iOS 8.2 (not reproducible in simulator)\n\t// `in` check used to prevent JIT error (gh-2145)\n\t// hasOwn isn't used here due to false negatives\n\t// regarding Nodelist length in IE\n\tvar length = !!obj && \"length\" in obj && obj.length,\n\t\ttype = jQuery.type( obj );\n\n\tif ( type === \"function\" || jQuery.isWindow( obj ) ) {\n\t\treturn false;\n\t}\n\n\treturn type === \"array\" || length === 0 ||\n\t\ttypeof length === \"number\" && length > 0 && ( length - 1 ) in obj;\n}\nvar Sizzle =\n/*!\n * Sizzle CSS Selector Engine v2.2.1\n * http://sizzlejs.com/\n *\n * Copyright jQuery Foundation and other contributors\n * Released under the MIT license\n * http://jquery.org/license\n *\n * Date: 2015-10-17\n */\n(function( window ) {\n\nvar i,\n\tsupport,\n\tExpr,\n\tgetText,\n\tisXML,\n\ttokenize,\n\tcompile,\n\tselect,\n\toutermostContext,\n\tsortInput,\n\thasDuplicate,\n\n\t// Local document vars\n\tsetDocument,\n\tdocument,\n\tdocElem,\n\tdocumentIsHTML,\n\trbuggyQSA,\n\trbuggyMatches,\n\tmatches,\n\tcontains,\n\n\t// Instance-specific data\n\texpando = \"sizzle\" + 1 * new Date(),\n\tpreferredDoc = window.document,\n\tdirruns = 0,\n\tdone = 0,\n\tclassCache = createCache(),\n\ttokenCache = createCache(),\n\tcompilerCache = createCache(),\n\tsortOrder = function( a, b ) {\n\t\tif ( a === b ) {\n\t\t\thasDuplicate = true;\n\t\t}\n\t\treturn 0;\n\t},\n\n\t// General-purpose constants\n\tMAX_NEGATIVE = 1 << 31,\n\n\t// Instance methods\n\thasOwn = ({}).hasOwnProperty,\n\tarr = [],\n\tpop = arr.pop,\n\tpush_native = arr.push,\n\tpush = arr.push,\n\tslice = arr.slice,\n\t// Use a stripped-down indexOf as it's faster than native\n\t// http://jsperf.com/thor-indexof-vs-for/5\n\tindexOf = function( list, elem ) {\n\t\tvar i = 0,\n\t\t\tlen = list.length;\n\t\tfor ( ; i < len; i++ ) {\n\t\t\tif ( list[i] === elem ) {\n\t\t\t\treturn i;\n\t\t\t}\n\t\t}\n\t\treturn -1;\n\t},\n\n\tbooleans = \"checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped\",\n\n\t// Regular expressions\n\n\t// http://www.w3.org/TR/css3-selectors/#whitespace\n\twhitespace = \"[\\\\x20\\\\t\\\\r\\\\n\\\\f]\",\n\n\t// http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier\n\tidentifier = \"(?:\\\\\\\\.|[\\\\w-]|[^\\\\x00-\\\\xa0])+\",\n\n\t// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors\n\tattributes = \"\\\\[\" + whitespace + \"*(\" + identifier + \")(?:\" + whitespace +\n\t\t// Operator (capture 2)\n\t\t\"*([*^$|!~]?=)\" + whitespace +\n\t\t// \"Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]\"\n\t\t\"*(?:'((?:\\\\\\\\.|[^\\\\\\\\'])*)'|\\\"((?:\\\\\\\\.|[^\\\\\\\\\\\"])*)\\\"|(\" + identifier + \"))|)\" + whitespace +\n\t\t\"*\\\\]\",\n\n\tpseudos = \":(\" + identifier + \")(?:\\\\((\" +\n\t\t// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:\n\t\t// 1. quoted (capture 3; capture 4 or capture 5)\n\t\t\"('((?:\\\\\\\\.|[^\\\\\\\\'])*)'|\\\"((?:\\\\\\\\.|[^\\\\\\\\\\\"])*)\\\")|\" +\n\t\t// 2. simple (capture 6)\n\t\t\"((?:\\\\\\\\.|[^\\\\\\\\()[\\\\]]|\" + attributes + \")*)|\" +\n\t\t// 3. anything else (capture 2)\n\t\t\".*\" +\n\t\t\")\\\\)|)\",\n\n\t// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter\n\trwhitespace = new RegExp( whitespace + \"+\", \"g\" ),\n\trtrim = new RegExp( \"^\" + whitespace + \"+|((?:^|[^\\\\\\\\])(?:\\\\\\\\.)*)\" + whitespace + \"+$\", \"g\" ),\n\n\trcomma = new RegExp( \"^\" + whitespace + \"*,\" + whitespace + \"*\" ),\n\trcombinators = new RegExp( \"^\" + whitespace + \"*([>+~]|\" + whitespace + \")\" + whitespace + \"*\" ),\n\n\trattributeQuotes = new RegExp( \"=\" + whitespace + \"*([^\\\\]'\\\"]*?)\" + whitespace + \"*\\\\]\", \"g\" ),\n\n\trpseudo = new RegExp( pseudos ),\n\tridentifier = new RegExp( \"^\" + identifier + \"$\" ),\n\n\tmatchExpr = {\n\t\t\"ID\": new RegExp( \"^#(\" + identifier + \")\" ),\n\t\t\"CLASS\": new RegExp( \"^\\\\.(\" + identifier + \")\" ),\n\t\t\"TAG\": new RegExp( \"^(\" + identifier + \"|[*])\" ),\n\t\t\"ATTR\": new RegExp( \"^\" + attributes ),\n\t\t\"PSEUDO\": new RegExp( \"^\" + pseudos ),\n\t\t\"CHILD\": new RegExp( \"^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\\\(\" + whitespace +\n\t\t\t\"*(even|odd|(([+-]|)(\\\\d*)n|)\" + whitespace + \"*(?:([+-]|)\" + whitespace +\n\t\t\t\"*(\\\\d+)|))\" + whitespace + \"*\\\\)|)\", \"i\" ),\n\t\t\"bool\": new RegExp( \"^(?:\" + booleans + \")$\", \"i\" ),\n\t\t// For use in libraries implementing .is()\n\t\t// We use this for POS matching in `select`\n\t\t\"needsContext\": new RegExp( \"^\" + whitespace + \"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\\\(\" +\n\t\t\twhitespace + \"*((?:-\\\\d)?\\\\d*)\" + whitespace + \"*\\\\)|)(?=[^-]|$)\", \"i\" )\n\t},\n\n\trinputs = /^(?:input|select|textarea|button)$/i,\n\trheader = /^h\\d$/i,\n\n\trnative = /^[^{]+\\{\\s*\\[native \\w/,\n\n\t// Easily-parseable/retrievable ID or TAG or CLASS selectors\n\trquickExpr = /^(?:#([\\w-]+)|(\\w+)|\\.([\\w-]+))$/,\n\n\trsibling = /[+~]/,\n\trescape = /'|\\\\/g,\n\n\t// CSS escapes http://www.w3.org/TR/CSS21/syndata.html#escaped-characters\n\trunescape = new RegExp( \"\\\\\\\\([\\\\da-f]{1,6}\" + whitespace + \"?|(\" + whitespace + \")|.)\", \"ig\" ),\n\tfunescape = function( _, escaped, escapedWhitespace ) {\n\t\tvar high = \"0x\" + escaped - 0x10000;\n\t\t// NaN means non-codepoint\n\t\t// Support: Firefox<24\n\t\t// Workaround erroneous numeric interpretation of +\"0x\"\n\t\treturn high !== high || escapedWhitespace ?\n\t\t\tescaped :\n\t\t\thigh < 0 ?\n\t\t\t\t// BMP codepoint\n\t\t\t\tString.fromCharCode( high + 0x10000 ) :\n\t\t\t\t// Supplemental Plane codepoint (surrogate pair)\n\t\t\t\tString.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );\n\t},\n\n\t// Used for iframes\n\t// See setDocument()\n\t// Removing the function wrapper causes a \"Permission Denied\"\n\t// error in IE\n\tunloadHandler = function() {\n\t\tsetDocument();\n\t};\n\n// Optimize for push.apply( _, NodeList )\ntry {\n\tpush.apply(\n\t\t(arr = slice.call( preferredDoc.childNodes )),\n\t\tpreferredDoc.childNodes\n\t);\n\t// Support: Android<4.0\n\t// Detect silently failing push.apply\n\tarr[ preferredDoc.childNodes.length ].nodeType;\n} catch ( e ) {\n\tpush = { apply: arr.length ?\n\n\t\t// Leverage slice if possible\n\t\tfunction( target, els ) {\n\t\t\tpush_native.apply( target, slice.call(els) );\n\t\t} :\n\n\t\t// Support: IE<9\n\t\t// Otherwise append directly\n\t\tfunction( target, els ) {\n\t\t\tvar j = target.length,\n\t\t\t\ti = 0;\n\t\t\t// Can't trust NodeList.length\n\t\t\twhile ( (target[j++] = els[i++]) ) {}\n\t\t\ttarget.length = j - 1;\n\t\t}\n\t};\n}\n\nfunction Sizzle( selector, context, results, seed ) {\n\tvar m, i, elem, nid, nidselect, match, groups, newSelector,\n\t\tnewContext = context && context.ownerDocument,\n\n\t\t// nodeType defaults to 9, since context defaults to document\n\t\tnodeType = context ? context.nodeType : 9;\n\n\tresults = results || [];\n\n\t// Return early from calls with invalid selector or context\n\tif ( typeof selector !== \"string\" || !selector ||\n\t\tnodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {\n\n\t\treturn results;\n\t}\n\n\t// Try to shortcut find operations (as opposed to filters) in HTML documents\n\tif ( !seed ) {\n\n\t\tif ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {\n\t\t\tsetDocument( context );\n\t\t}\n\t\tcontext = context || document;\n\n\t\tif ( documentIsHTML ) {\n\n\t\t\t// If the selector is sufficiently simple, try using a \"get*By*\" DOM method\n\t\t\t// (excepting DocumentFragment context, where the methods don't exist)\n\t\t\tif ( nodeType !== 11 && (match = rquickExpr.exec( selector )) ) {\n\n\t\t\t\t// ID selector\n\t\t\t\tif ( (m = match[1]) ) {\n\n\t\t\t\t\t// Document context\n\t\t\t\t\tif ( nodeType === 9 ) {\n\t\t\t\t\t\tif ( (elem = context.getElementById( m )) ) {\n\n\t\t\t\t\t\t\t// Support: IE, Opera, Webkit\n\t\t\t\t\t\t\t// TODO: identify versions\n\t\t\t\t\t\t\t// getElementById can match elements by name instead of ID\n\t\t\t\t\t\t\tif ( elem.id === m ) {\n\t\t\t\t\t\t\t\tresults.push( elem );\n\t\t\t\t\t\t\t\treturn results;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\treturn results;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t// Element context\n\t\t\t\t\t} else {\n\n\t\t\t\t\t\t// Support: IE, Opera, Webkit\n\t\t\t\t\t\t// TODO: identify versions\n\t\t\t\t\t\t// getElementById can match elements by name instead of ID\n\t\t\t\t\t\tif ( newContext && (elem = newContext.getElementById( m )) &&\n\t\t\t\t\t\t\tcontains( context, elem ) &&\n\t\t\t\t\t\t\telem.id === m ) {\n\n\t\t\t\t\t\t\tresults.push( elem );\n\t\t\t\t\t\t\treturn results;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t// Type selector\n\t\t\t\t} else if ( match[2] ) {\n\t\t\t\t\tpush.apply( results, context.getElementsByTagName( selector ) );\n\t\t\t\t\treturn results;\n\n\t\t\t\t// Class selector\n\t\t\t\t} else if ( (m = match[3]) && support.getElementsByClassName &&\n\t\t\t\t\tcontext.getElementsByClassName ) {\n\n\t\t\t\t\tpush.apply( results, context.getElementsByClassName( m ) );\n\t\t\t\t\treturn results;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Take advantage of querySelectorAll\n\t\t\tif ( support.qsa &&\n\t\t\t\t!compilerCache[ selector + \" \" ] &&\n\t\t\t\t(!rbuggyQSA || !rbuggyQSA.test( selector )) ) {\n\n\t\t\t\tif ( nodeType !== 1 ) {\n\t\t\t\t\tnewContext = context;\n\t\t\t\t\tnewSelector = selector;\n\n\t\t\t\t// qSA looks outside Element context, which is not what we want\n\t\t\t\t// Thanks to Andrew Dupont for this workaround technique\n\t\t\t\t// Support: IE <=8\n\t\t\t\t// Exclude object elements\n\t\t\t\t} else if ( context.nodeName.toLowerCase() !== \"object\" ) {\n\n\t\t\t\t\t// Capture the context ID, setting it first if necessary\n\t\t\t\t\tif ( (nid = context.getAttribute( \"id\" )) ) {\n\t\t\t\t\t\tnid = nid.replace( rescape, \"\\\\$&\" );\n\t\t\t\t\t} else {\n\t\t\t\t\t\tcontext.setAttribute( \"id\", (nid = expando) );\n\t\t\t\t\t}\n\n\t\t\t\t\t// Prefix every selector in the list\n\t\t\t\t\tgroups = tokenize( selector );\n\t\t\t\t\ti = groups.length;\n\t\t\t\t\tnidselect = ridentifier.test( nid ) ? \"#\" + nid : \"[id='\" + nid + \"']\";\n\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\tgroups[i] = nidselect + \" \" + toSelector( groups[i] );\n\t\t\t\t\t}\n\t\t\t\t\tnewSelector = groups.join( \",\" );\n\n\t\t\t\t\t// Expand context for sibling selectors\n\t\t\t\t\tnewContext = rsibling.test( selector ) && testContext( context.parentNode ) ||\n\t\t\t\t\t\tcontext;\n\t\t\t\t}\n\n\t\t\t\tif ( newSelector ) {\n\t\t\t\t\ttry {\n\t\t\t\t\t\tpush.apply( results,\n\t\t\t\t\t\t\tnewContext.querySelectorAll( newSelector )\n\t\t\t\t\t\t);\n\t\t\t\t\t\treturn results;\n\t\t\t\t\t} catch ( qsaError ) {\n\t\t\t\t\t} finally {\n\t\t\t\t\t\tif ( nid === expando ) {\n\t\t\t\t\t\t\tcontext.removeAttribute( \"id\" );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// All others\n\treturn select( selector.replace( rtrim, \"$1\" ), context, results, seed );\n}\n\n/**\n * Create key-value caches of limited size\n * @returns {function(string, object)} Returns the Object data after storing it on itself with\n *\tproperty name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)\n *\tdeleting the oldest entry\n */\nfunction createCache() {\n\tvar keys = [];\n\n\tfunction cache( key, value ) {\n\t\t// Use (key + \" \") to avoid collision with native prototype properties (see Issue #157)\n\t\tif ( keys.push( key + \" \" ) > Expr.cacheLength ) {\n\t\t\t// Only keep the most recent entries\n\t\t\tdelete cache[ keys.shift() ];\n\t\t}\n\t\treturn (cache[ key + \" \" ] = value);\n\t}\n\treturn cache;\n}\n\n/**\n * Mark a function for special use by Sizzle\n * @param {Function} fn The function to mark\n */\nfunction markFunction( fn ) {\n\tfn[ expando ] = true;\n\treturn fn;\n}\n\n/**\n * Support testing using an element\n * @param {Function} fn Passed the created div and expects a boolean result\n */\nfunction assert( fn ) {\n\tvar div = document.createElement(\"div\");\n\n\ttry {\n\t\treturn !!fn( div );\n\t} catch (e) {\n\t\treturn false;\n\t} finally {\n\t\t// Remove from its parent by default\n\t\tif ( div.parentNode ) {\n\t\t\tdiv.parentNode.removeChild( div );\n\t\t}\n\t\t// release memory in IE\n\t\tdiv = null;\n\t}\n}\n\n/**\n * Adds the same handler for all of the specified attrs\n * @param {String} attrs Pipe-separated list of attributes\n * @param {Function} handler The method that will be applied\n */\nfunction addHandle( attrs, handler ) {\n\tvar arr = attrs.split(\"|\"),\n\t\ti = arr.length;\n\n\twhile ( i-- ) {\n\t\tExpr.attrHandle[ arr[i] ] = handler;\n\t}\n}\n\n/**\n * Checks document order of two siblings\n * @param {Element} a\n * @param {Element} b\n * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b\n */\nfunction siblingCheck( a, b ) {\n\tvar cur = b && a,\n\t\tdiff = cur && a.nodeType === 1 && b.nodeType === 1 &&\n\t\t\t( ~b.sourceIndex || MAX_NEGATIVE ) -\n\t\t\t( ~a.sourceIndex || MAX_NEGATIVE );\n\n\t// Use IE sourceIndex if available on both nodes\n\tif ( diff ) {\n\t\treturn diff;\n\t}\n\n\t// Check if b follows a\n\tif ( cur ) {\n\t\twhile ( (cur = cur.nextSibling) ) {\n\t\t\tif ( cur === b ) {\n\t\t\t\treturn -1;\n\t\t\t}\n\t\t}\n\t}\n\n\treturn a ? 1 : -1;\n}\n\n/**\n * Returns a function to use in pseudos for input types\n * @param {String} type\n */\nfunction createInputPseudo( type ) {\n\treturn function( elem ) {\n\t\tvar name = elem.nodeName.toLowerCase();\n\t\treturn name === \"input\" && elem.type === type;\n\t};\n}\n\n/**\n * Returns a function to use in pseudos for buttons\n * @param {String} type\n */\nfunction createButtonPseudo( type ) {\n\treturn function( elem ) {\n\t\tvar name = elem.nodeName.toLowerCase();\n\t\treturn (name === \"input\" || name === \"button\") && elem.type === type;\n\t};\n}\n\n/**\n * Returns a function to use in pseudos for positionals\n * @param {Function} fn\n */\nfunction createPositionalPseudo( fn ) {\n\treturn markFunction(function( argument ) {\n\t\targument = +argument;\n\t\treturn markFunction(function( seed, matches ) {\n\t\t\tvar j,\n\t\t\t\tmatchIndexes = fn( [], seed.length, argument ),\n\t\t\t\ti = matchIndexes.length;\n\n\t\t\t// Match elements found at the specified indexes\n\t\t\twhile ( i-- ) {\n\t\t\t\tif ( seed[ (j = matchIndexes[i]) ] ) {\n\t\t\t\t\tseed[j] = !(matches[j] = seed[j]);\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\t});\n}\n\n/**\n * Checks a node for validity as a Sizzle context\n * @param {Element|Object=} context\n * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value\n */\nfunction testContext( context ) {\n\treturn context && typeof context.getElementsByTagName !== \"undefined\" && context;\n}\n\n// Expose support vars for convenience\nsupport = Sizzle.support = {};\n\n/**\n * Detects XML nodes\n * @param {Element|Object} elem An element or a document\n * @returns {Boolean} True iff elem is a non-HTML XML node\n */\nisXML = Sizzle.isXML = function( elem ) {\n\t// documentElement is verified for cases where it doesn't yet exist\n\t// (such as loading iframes in IE - #4833)\n\tvar documentElement = elem && (elem.ownerDocument || elem).documentElement;\n\treturn documentElement ? documentElement.nodeName !== \"HTML\" : false;\n};\n\n/**\n * Sets document-related variables once based on the current document\n * @param {Element|Object} [doc] An element or document object to use to set the document\n * @returns {Object} Returns the current document\n */\nsetDocument = Sizzle.setDocument = function( node ) {\n\tvar hasCompare, parent,\n\t\tdoc = node ? node.ownerDocument || node : preferredDoc;\n\n\t// Return early if doc is invalid or already selected\n\tif ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {\n\t\treturn document;\n\t}\n\n\t// Update global variables\n\tdocument = doc;\n\tdocElem = document.documentElement;\n\tdocumentIsHTML = !isXML( document );\n\n\t// Support: IE 9-11, Edge\n\t// Accessing iframe documents after unload throws \"permission denied\" errors (jQuery #13936)\n\tif ( (parent = document.defaultView) && parent.top !== parent ) {\n\t\t// Support: IE 11\n\t\tif ( parent.addEventListener ) {\n\t\t\tparent.addEventListener( \"unload\", unloadHandler, false );\n\n\t\t// Support: IE 9 - 10 only\n\t\t} else if ( parent.attachEvent ) {\n\t\t\tparent.attachEvent( \"onunload\", unloadHandler );\n\t\t}\n\t}\n\n\t/* Attributes\n\t---------------------------------------------------------------------- */\n\n\t// Support: IE<8\n\t// Verify that getAttribute really returns attributes and not properties\n\t// (excepting IE8 booleans)\n\tsupport.attributes = assert(function( div ) {\n\t\tdiv.className = \"i\";\n\t\treturn !div.getAttribute(\"className\");\n\t});\n\n\t/* getElement(s)By*\n\t---------------------------------------------------------------------- */\n\n\t// Check if getElementsByTagName(\"*\") returns only elements\n\tsupport.getElementsByTagName = assert(function( div ) {\n\t\tdiv.appendChild( document.createComment(\"\") );\n\t\treturn !div.getElementsByTagName(\"*\").length;\n\t});\n\n\t// Support: IE<9\n\tsupport.getElementsByClassName = rnative.test( document.getElementsByClassName );\n\n\t// Support: IE<10\n\t// Check if getElementById returns elements by name\n\t// The broken getElementById methods don't pick up programatically-set names,\n\t// so use a roundabout getElementsByName test\n\tsupport.getById = assert(function( div ) {\n\t\tdocElem.appendChild( div ).id = expando;\n\t\treturn !document.getElementsByName || !document.getElementsByName( expando ).length;\n\t});\n\n\t// ID find and filter\n\tif ( support.getById ) {\n\t\tExpr.find[\"ID\"] = function( id, context ) {\n\t\t\tif ( typeof context.getElementById !== \"undefined\" && documentIsHTML ) {\n\t\t\t\tvar m = context.getElementById( id );\n\t\t\t\treturn m ? [ m ] : [];\n\t\t\t}\n\t\t};\n\t\tExpr.filter[\"ID\"] = function( id ) {\n\t\t\tvar attrId = id.replace( runescape, funescape );\n\t\t\treturn function( elem ) {\n\t\t\t\treturn elem.getAttribute(\"id\") === attrId;\n\t\t\t};\n\t\t};\n\t} else {\n\t\t// Support: IE6/7\n\t\t// getElementById is not reliable as a find shortcut\n\t\tdelete Expr.find[\"ID\"];\n\n\t\tExpr.filter[\"ID\"] =  function( id ) {\n\t\t\tvar attrId = id.replace( runescape, funescape );\n\t\t\treturn function( elem ) {\n\t\t\t\tvar node = typeof elem.getAttributeNode !== \"undefined\" &&\n\t\t\t\t\telem.getAttributeNode(\"id\");\n\t\t\t\treturn node && node.value === attrId;\n\t\t\t};\n\t\t};\n\t}\n\n\t// Tag\n\tExpr.find[\"TAG\"] = support.getElementsByTagName ?\n\t\tfunction( tag, context ) {\n\t\t\tif ( typeof context.getElementsByTagName !== \"undefined\" ) {\n\t\t\t\treturn context.getElementsByTagName( tag );\n\n\t\t\t// DocumentFragment nodes don't have gEBTN\n\t\t\t} else if ( support.qsa ) {\n\t\t\t\treturn context.querySelectorAll( tag );\n\t\t\t}\n\t\t} :\n\n\t\tfunction( tag, context ) {\n\t\t\tvar elem,\n\t\t\t\ttmp = [],\n\t\t\t\ti = 0,\n\t\t\t\t// By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too\n\t\t\t\tresults = context.getElementsByTagName( tag );\n\n\t\t\t// Filter out possible comments\n\t\t\tif ( tag === \"*\" ) {\n\t\t\t\twhile ( (elem = results[i++]) ) {\n\t\t\t\t\tif ( elem.nodeType === 1 ) {\n\t\t\t\t\t\ttmp.push( elem );\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\treturn tmp;\n\t\t\t}\n\t\t\treturn results;\n\t\t};\n\n\t// Class\n\tExpr.find[\"CLASS\"] = support.getElementsByClassName && function( className, context ) {\n\t\tif ( typeof context.getElementsByClassName !== \"undefined\" && documentIsHTML ) {\n\t\t\treturn context.getElementsByClassName( className );\n\t\t}\n\t};\n\n\t/* QSA/matchesSelector\n\t---------------------------------------------------------------------- */\n\n\t// QSA and matchesSelector support\n\n\t// matchesSelector(:active) reports false when true (IE9/Opera 11.5)\n\trbuggyMatches = [];\n\n\t// qSa(:focus) reports false when true (Chrome 21)\n\t// We allow this because of a bug in IE8/9 that throws an error\n\t// whenever `document.activeElement` is accessed on an iframe\n\t// So, we allow :focus to pass through QSA all the time to avoid the IE error\n\t// See http://bugs.jquery.com/ticket/13378\n\trbuggyQSA = [];\n\n\tif ( (support.qsa = rnative.test( document.querySelectorAll )) ) {\n\t\t// Build QSA regex\n\t\t// Regex strategy adopted from Diego Perini\n\t\tassert(function( div ) {\n\t\t\t// Select is set to empty string on purpose\n\t\t\t// This is to test IE's treatment of not explicitly\n\t\t\t// setting a boolean content attribute,\n\t\t\t// since its presence should be enough\n\t\t\t// http://bugs.jquery.com/ticket/12359\n\t\t\tdocElem.appendChild( div ).innerHTML = \"<a id='\" + expando + \"'></a>\" +\n\t\t\t\t\"<select id='\" + expando + \"-\\r\\\\' msallowcapture=''>\" +\n\t\t\t\t\"<option selected=''></option></select>\";\n\n\t\t\t// Support: IE8, Opera 11-12.16\n\t\t\t// Nothing should be selected when empty strings follow ^= or $= or *=\n\t\t\t// The test attribute must be unknown in Opera but \"safe\" for WinRT\n\t\t\t// http://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section\n\t\t\tif ( div.querySelectorAll(\"[msallowcapture^='']\").length ) {\n\t\t\t\trbuggyQSA.push( \"[*^$]=\" + whitespace + \"*(?:''|\\\"\\\")\" );\n\t\t\t}\n\n\t\t\t// Support: IE8\n\t\t\t// Boolean attributes and \"value\" are not treated correctly\n\t\t\tif ( !div.querySelectorAll(\"[selected]\").length ) {\n\t\t\t\trbuggyQSA.push( \"\\\\[\" + whitespace + \"*(?:value|\" + booleans + \")\" );\n\t\t\t}\n\n\t\t\t// Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+\n\t\t\tif ( !div.querySelectorAll( \"[id~=\" + expando + \"-]\" ).length ) {\n\t\t\t\trbuggyQSA.push(\"~=\");\n\t\t\t}\n\n\t\t\t// Webkit/Opera - :checked should return selected option elements\n\t\t\t// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked\n\t\t\t// IE8 throws error here and will not see later tests\n\t\t\tif ( !div.querySelectorAll(\":checked\").length ) {\n\t\t\t\trbuggyQSA.push(\":checked\");\n\t\t\t}\n\n\t\t\t// Support: Safari 8+, iOS 8+\n\t\t\t// https://bugs.webkit.org/show_bug.cgi?id=136851\n\t\t\t// In-page `selector#id sibing-combinator selector` fails\n\t\t\tif ( !div.querySelectorAll( \"a#\" + expando + \"+*\" ).length ) {\n\t\t\t\trbuggyQSA.push(\".#.+[+~]\");\n\t\t\t}\n\t\t});\n\n\t\tassert(function( div ) {\n\t\t\t// Support: Windows 8 Native Apps\n\t\t\t// The type and name attributes are restricted during .innerHTML assignment\n\t\t\tvar input = document.createElement(\"input\");\n\t\t\tinput.setAttribute( \"type\", \"hidden\" );\n\t\t\tdiv.appendChild( input ).setAttribute( \"name\", \"D\" );\n\n\t\t\t// Support: IE8\n\t\t\t// Enforce case-sensitivity of name attribute\n\t\t\tif ( div.querySelectorAll(\"[name=d]\").length ) {\n\t\t\t\trbuggyQSA.push( \"name\" + whitespace + \"*[*^$|!~]?=\" );\n\t\t\t}\n\n\t\t\t// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)\n\t\t\t// IE8 throws error here and will not see later tests\n\t\t\tif ( !div.querySelectorAll(\":enabled\").length ) {\n\t\t\t\trbuggyQSA.push( \":enabled\", \":disabled\" );\n\t\t\t}\n\n\t\t\t// Opera 10-11 does not throw on post-comma invalid pseudos\n\t\t\tdiv.querySelectorAll(\"*,:x\");\n\t\t\trbuggyQSA.push(\",.*:\");\n\t\t});\n\t}\n\n\tif ( (support.matchesSelector = rnative.test( (matches = docElem.matches ||\n\t\tdocElem.webkitMatchesSelector ||\n\t\tdocElem.mozMatchesSelector ||\n\t\tdocElem.oMatchesSelector ||\n\t\tdocElem.msMatchesSelector) )) ) {\n\n\t\tassert(function( div ) {\n\t\t\t// Check to see if it's possible to do matchesSelector\n\t\t\t// on a disconnected node (IE 9)\n\t\t\tsupport.disconnectedMatch = matches.call( div, \"div\" );\n\n\t\t\t// This should fail with an exception\n\t\t\t// Gecko does not error, returns false instead\n\t\t\tmatches.call( div, \"[s!='']:x\" );\n\t\t\trbuggyMatches.push( \"!=\", pseudos );\n\t\t});\n\t}\n\n\trbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join(\"|\") );\n\trbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join(\"|\") );\n\n\t/* Contains\n\t---------------------------------------------------------------------- */\n\thasCompare = rnative.test( docElem.compareDocumentPosition );\n\n\t// Element contains another\n\t// Purposefully self-exclusive\n\t// As in, an element does not contain itself\n\tcontains = hasCompare || rnative.test( docElem.contains ) ?\n\t\tfunction( a, b ) {\n\t\t\tvar adown = a.nodeType === 9 ? a.documentElement : a,\n\t\t\t\tbup = b && b.parentNode;\n\t\t\treturn a === bup || !!( bup && bup.nodeType === 1 && (\n\t\t\t\tadown.contains ?\n\t\t\t\t\tadown.contains( bup ) :\n\t\t\t\t\ta.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16\n\t\t\t));\n\t\t} :\n\t\tfunction( a, b ) {\n\t\t\tif ( b ) {\n\t\t\t\twhile ( (b = b.parentNode) ) {\n\t\t\t\t\tif ( b === a ) {\n\t\t\t\t\t\treturn true;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn false;\n\t\t};\n\n\t/* Sorting\n\t---------------------------------------------------------------------- */\n\n\t// Document order sorting\n\tsortOrder = hasCompare ?\n\tfunction( a, b ) {\n\n\t\t// Flag for duplicate removal\n\t\tif ( a === b ) {\n\t\t\thasDuplicate = true;\n\t\t\treturn 0;\n\t\t}\n\n\t\t// Sort on method existence if only one input has compareDocumentPosition\n\t\tvar compare = !a.compareDocumentPosition - !b.compareDocumentPosition;\n\t\tif ( compare ) {\n\t\t\treturn compare;\n\t\t}\n\n\t\t// Calculate position if both inputs belong to the same document\n\t\tcompare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?\n\t\t\ta.compareDocumentPosition( b ) :\n\n\t\t\t// Otherwise we know they are disconnected\n\t\t\t1;\n\n\t\t// Disconnected nodes\n\t\tif ( compare & 1 ||\n\t\t\t(!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {\n\n\t\t\t// Choose the first element that is related to our preferred document\n\t\t\tif ( a === document || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) {\n\t\t\t\treturn -1;\n\t\t\t}\n\t\t\tif ( b === document || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) {\n\t\t\t\treturn 1;\n\t\t\t}\n\n\t\t\t// Maintain original order\n\t\t\treturn sortInput ?\n\t\t\t\t( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :\n\t\t\t\t0;\n\t\t}\n\n\t\treturn compare & 4 ? -1 : 1;\n\t} :\n\tfunction( a, b ) {\n\t\t// Exit early if the nodes are identical\n\t\tif ( a === b ) {\n\t\t\thasDuplicate = true;\n\t\t\treturn 0;\n\t\t}\n\n\t\tvar cur,\n\t\t\ti = 0,\n\t\t\taup = a.parentNode,\n\t\t\tbup = b.parentNode,\n\t\t\tap = [ a ],\n\t\t\tbp = [ b ];\n\n\t\t// Parentless nodes are either documents or disconnected\n\t\tif ( !aup || !bup ) {\n\t\t\treturn a === document ? -1 :\n\t\t\t\tb === document ? 1 :\n\t\t\t\taup ? -1 :\n\t\t\t\tbup ? 1 :\n\t\t\t\tsortInput ?\n\t\t\t\t( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :\n\t\t\t\t0;\n\n\t\t// If the nodes are siblings, we can do a quick check\n\t\t} else if ( aup === bup ) {\n\t\t\treturn siblingCheck( a, b );\n\t\t}\n\n\t\t// Otherwise we need full lists of their ancestors for comparison\n\t\tcur = a;\n\t\twhile ( (cur = cur.parentNode) ) {\n\t\t\tap.unshift( cur );\n\t\t}\n\t\tcur = b;\n\t\twhile ( (cur = cur.parentNode) ) {\n\t\t\tbp.unshift( cur );\n\t\t}\n\n\t\t// Walk down the tree looking for a discrepancy\n\t\twhile ( ap[i] === bp[i] ) {\n\t\t\ti++;\n\t\t}\n\n\t\treturn i ?\n\t\t\t// Do a sibling check if the nodes have a common ancestor\n\t\t\tsiblingCheck( ap[i], bp[i] ) :\n\n\t\t\t// Otherwise nodes in our document sort first\n\t\t\tap[i] === preferredDoc ? -1 :\n\t\t\tbp[i] === preferredDoc ? 1 :\n\t\t\t0;\n\t};\n\n\treturn document;\n};\n\nSizzle.matches = function( expr, elements ) {\n\treturn Sizzle( expr, null, null, elements );\n};\n\nSizzle.matchesSelector = function( elem, expr ) {\n\t// Set document vars if needed\n\tif ( ( elem.ownerDocument || elem ) !== document ) {\n\t\tsetDocument( elem );\n\t}\n\n\t// Make sure that attribute selectors are quoted\n\texpr = expr.replace( rattributeQuotes, \"='$1']\" );\n\n\tif ( support.matchesSelector && documentIsHTML &&\n\t\t!compilerCache[ expr + \" \" ] &&\n\t\t( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&\n\t\t( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {\n\n\t\ttry {\n\t\t\tvar ret = matches.call( elem, expr );\n\n\t\t\t// IE 9's matchesSelector returns false on disconnected nodes\n\t\t\tif ( ret || support.disconnectedMatch ||\n\t\t\t\t\t// As well, disconnected nodes are said to be in a document\n\t\t\t\t\t// fragment in IE 9\n\t\t\t\t\telem.document && elem.document.nodeType !== 11 ) {\n\t\t\t\treturn ret;\n\t\t\t}\n\t\t} catch (e) {}\n\t}\n\n\treturn Sizzle( expr, document, null, [ elem ] ).length > 0;\n};\n\nSizzle.contains = function( context, elem ) {\n\t// Set document vars if needed\n\tif ( ( context.ownerDocument || context ) !== document ) {\n\t\tsetDocument( context );\n\t}\n\treturn contains( context, elem );\n};\n\nSizzle.attr = function( elem, name ) {\n\t// Set document vars if needed\n\tif ( ( elem.ownerDocument || elem ) !== document ) {\n\t\tsetDocument( elem );\n\t}\n\n\tvar fn = Expr.attrHandle[ name.toLowerCase() ],\n\t\t// Don't get fooled by Object.prototype properties (jQuery #13807)\n\t\tval = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?\n\t\t\tfn( elem, name, !documentIsHTML ) :\n\t\t\tundefined;\n\n\treturn val !== undefined ?\n\t\tval :\n\t\tsupport.attributes || !documentIsHTML ?\n\t\t\telem.getAttribute( name ) :\n\t\t\t(val = elem.getAttributeNode(name)) && val.specified ?\n\t\t\t\tval.value :\n\t\t\t\tnull;\n};\n\nSizzle.error = function( msg ) {\n\tthrow new Error( \"Syntax error, unrecognized expression: \" + msg );\n};\n\n/**\n * Document sorting and removing duplicates\n * @param {ArrayLike} results\n */\nSizzle.uniqueSort = function( results ) {\n\tvar elem,\n\t\tduplicates = [],\n\t\tj = 0,\n\t\ti = 0;\n\n\t// Unless we *know* we can detect duplicates, assume their presence\n\thasDuplicate = !support.detectDuplicates;\n\tsortInput = !support.sortStable && results.slice( 0 );\n\tresults.sort( sortOrder );\n\n\tif ( hasDuplicate ) {\n\t\twhile ( (elem = results[i++]) ) {\n\t\t\tif ( elem === results[ i ] ) {\n\t\t\t\tj = duplicates.push( i );\n\t\t\t}\n\t\t}\n\t\twhile ( j-- ) {\n\t\t\tresults.splice( duplicates[ j ], 1 );\n\t\t}\n\t}\n\n\t// Clear input after sorting to release objects\n\t// See https://github.com/jquery/sizzle/pull/225\n\tsortInput = null;\n\n\treturn results;\n};\n\n/**\n * Utility function for retrieving the text value of an array of DOM nodes\n * @param {Array|Element} elem\n */\ngetText = Sizzle.getText = function( elem ) {\n\tvar node,\n\t\tret = \"\",\n\t\ti = 0,\n\t\tnodeType = elem.nodeType;\n\n\tif ( !nodeType ) {\n\t\t// If no nodeType, this is expected to be an array\n\t\twhile ( (node = elem[i++]) ) {\n\t\t\t// Do not traverse comment nodes\n\t\t\tret += getText( node );\n\t\t}\n\t} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {\n\t\t// Use textContent for elements\n\t\t// innerText usage removed for consistency of new lines (jQuery #11153)\n\t\tif ( typeof elem.textContent === \"string\" ) {\n\t\t\treturn elem.textContent;\n\t\t} else {\n\t\t\t// Traverse its children\n\t\t\tfor ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {\n\t\t\t\tret += getText( elem );\n\t\t\t}\n\t\t}\n\t} else if ( nodeType === 3 || nodeType === 4 ) {\n\t\treturn elem.nodeValue;\n\t}\n\t// Do not include comment or processing instruction nodes\n\n\treturn ret;\n};\n\nExpr = Sizzle.selectors = {\n\n\t// Can be adjusted by the user\n\tcacheLength: 50,\n\n\tcreatePseudo: markFunction,\n\n\tmatch: matchExpr,\n\n\tattrHandle: {},\n\n\tfind: {},\n\n\trelative: {\n\t\t\">\": { dir: \"parentNode\", first: true },\n\t\t\" \": { dir: \"parentNode\" },\n\t\t\"+\": { dir: \"previousSibling\", first: true },\n\t\t\"~\": { dir: \"previousSibling\" }\n\t},\n\n\tpreFilter: {\n\t\t\"ATTR\": function( match ) {\n\t\t\tmatch[1] = match[1].replace( runescape, funescape );\n\n\t\t\t// Move the given value to match[3] whether quoted or unquoted\n\t\t\tmatch[3] = ( match[3] || match[4] || match[5] || \"\" ).replace( runescape, funescape );\n\n\t\t\tif ( match[2] === \"~=\" ) {\n\t\t\t\tmatch[3] = \" \" + match[3] + \" \";\n\t\t\t}\n\n\t\t\treturn match.slice( 0, 4 );\n\t\t},\n\n\t\t\"CHILD\": function( match ) {\n\t\t\t/* matches from matchExpr[\"CHILD\"]\n\t\t\t\t1 type (only|nth|...)\n\t\t\t\t2 what (child|of-type)\n\t\t\t\t3 argument (even|odd|\\d*|\\d*n([+-]\\d+)?|...)\n\t\t\t\t4 xn-component of xn+y argument ([+-]?\\d*n|)\n\t\t\t\t5 sign of xn-component\n\t\t\t\t6 x of xn-component\n\t\t\t\t7 sign of y-component\n\t\t\t\t8 y of y-component\n\t\t\t*/\n\t\t\tmatch[1] = match[1].toLowerCase();\n\n\t\t\tif ( match[1].slice( 0, 3 ) === \"nth\" ) {\n\t\t\t\t// nth-* requires argument\n\t\t\t\tif ( !match[3] ) {\n\t\t\t\t\tSizzle.error( match[0] );\n\t\t\t\t}\n\n\t\t\t\t// numeric x and y parameters for Expr.filter.CHILD\n\t\t\t\t// remember that false/true cast respectively to 0/1\n\t\t\t\tmatch[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === \"even\" || match[3] === \"odd\" ) );\n\t\t\t\tmatch[5] = +( ( match[7] + match[8] ) || match[3] === \"odd\" );\n\n\t\t\t// other types prohibit arguments\n\t\t\t} else if ( match[3] ) {\n\t\t\t\tSizzle.error( match[0] );\n\t\t\t}\n\n\t\t\treturn match;\n\t\t},\n\n\t\t\"PSEUDO\": function( match ) {\n\t\t\tvar excess,\n\t\t\t\tunquoted = !match[6] && match[2];\n\n\t\t\tif ( matchExpr[\"CHILD\"].test( match[0] ) ) {\n\t\t\t\treturn null;\n\t\t\t}\n\n\t\t\t// Accept quoted arguments as-is\n\t\t\tif ( match[3] ) {\n\t\t\t\tmatch[2] = match[4] || match[5] || \"\";\n\n\t\t\t// Strip excess characters from unquoted arguments\n\t\t\t} else if ( unquoted && rpseudo.test( unquoted ) &&\n\t\t\t\t// Get excess from tokenize (recursively)\n\t\t\t\t(excess = tokenize( unquoted, true )) &&\n\t\t\t\t// advance to the next closing parenthesis\n\t\t\t\t(excess = unquoted.indexOf( \")\", unquoted.length - excess ) - unquoted.length) ) {\n\n\t\t\t\t// excess is a negative index\n\t\t\t\tmatch[0] = match[0].slice( 0, excess );\n\t\t\t\tmatch[2] = unquoted.slice( 0, excess );\n\t\t\t}\n\n\t\t\t// Return only captures needed by the pseudo filter method (type and argument)\n\t\t\treturn match.slice( 0, 3 );\n\t\t}\n\t},\n\n\tfilter: {\n\n\t\t\"TAG\": function( nodeNameSelector ) {\n\t\t\tvar nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();\n\t\t\treturn nodeNameSelector === \"*\" ?\n\t\t\t\tfunction() { return true; } :\n\t\t\t\tfunction( elem ) {\n\t\t\t\t\treturn elem.nodeName && elem.nodeName.toLowerCase() === nodeName;\n\t\t\t\t};\n\t\t},\n\n\t\t\"CLASS\": function( className ) {\n\t\t\tvar pattern = classCache[ className + \" \" ];\n\n\t\t\treturn pattern ||\n\t\t\t\t(pattern = new RegExp( \"(^|\" + whitespace + \")\" + className + \"(\" + whitespace + \"|$)\" )) &&\n\t\t\t\tclassCache( className, function( elem ) {\n\t\t\t\t\treturn pattern.test( typeof elem.className === \"string\" && elem.className || typeof elem.getAttribute !== \"undefined\" && elem.getAttribute(\"class\") || \"\" );\n\t\t\t\t});\n\t\t},\n\n\t\t\"ATTR\": function( name, operator, check ) {\n\t\t\treturn function( elem ) {\n\t\t\t\tvar result = Sizzle.attr( elem, name );\n\n\t\t\t\tif ( result == null ) {\n\t\t\t\t\treturn operator === \"!=\";\n\t\t\t\t}\n\t\t\t\tif ( !operator ) {\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\n\t\t\t\tresult += \"\";\n\n\t\t\t\treturn operator === \"=\" ? result === check :\n\t\t\t\t\toperator === \"!=\" ? result !== check :\n\t\t\t\t\toperator === \"^=\" ? check && result.indexOf( check ) === 0 :\n\t\t\t\t\toperator === \"*=\" ? check && result.indexOf( check ) > -1 :\n\t\t\t\t\toperator === \"$=\" ? check && result.slice( -check.length ) === check :\n\t\t\t\t\toperator === \"~=\" ? ( \" \" + result.replace( rwhitespace, \" \" ) + \" \" ).indexOf( check ) > -1 :\n\t\t\t\t\toperator === \"|=\" ? result === check || result.slice( 0, check.length + 1 ) === check + \"-\" :\n\t\t\t\t\tfalse;\n\t\t\t};\n\t\t},\n\n\t\t\"CHILD\": function( type, what, argument, first, last ) {\n\t\t\tvar simple = type.slice( 0, 3 ) !== \"nth\",\n\t\t\t\tforward = type.slice( -4 ) !== \"last\",\n\t\t\t\tofType = what === \"of-type\";\n\n\t\t\treturn first === 1 && last === 0 ?\n\n\t\t\t\t// Shortcut for :nth-*(n)\n\t\t\t\tfunction( elem ) {\n\t\t\t\t\treturn !!elem.parentNode;\n\t\t\t\t} :\n\n\t\t\t\tfunction( elem, context, xml ) {\n\t\t\t\t\tvar cache, uniqueCache, outerCache, node, nodeIndex, start,\n\t\t\t\t\t\tdir = simple !== forward ? \"nextSibling\" : \"previousSibling\",\n\t\t\t\t\t\tparent = elem.parentNode,\n\t\t\t\t\t\tname = ofType && elem.nodeName.toLowerCase(),\n\t\t\t\t\t\tuseCache = !xml && !ofType,\n\t\t\t\t\t\tdiff = false;\n\n\t\t\t\t\tif ( parent ) {\n\n\t\t\t\t\t\t// :(first|last|only)-(child|of-type)\n\t\t\t\t\t\tif ( simple ) {\n\t\t\t\t\t\t\twhile ( dir ) {\n\t\t\t\t\t\t\t\tnode = elem;\n\t\t\t\t\t\t\t\twhile ( (node = node[ dir ]) ) {\n\t\t\t\t\t\t\t\t\tif ( ofType ?\n\t\t\t\t\t\t\t\t\t\tnode.nodeName.toLowerCase() === name :\n\t\t\t\t\t\t\t\t\t\tnode.nodeType === 1 ) {\n\n\t\t\t\t\t\t\t\t\t\treturn false;\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t// Reverse direction for :only-* (if we haven't yet done so)\n\t\t\t\t\t\t\t\tstart = dir = type === \"only\" && !start && \"nextSibling\";\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tstart = [ forward ? parent.firstChild : parent.lastChild ];\n\n\t\t\t\t\t\t// non-xml :nth-child(...) stores cache data on `parent`\n\t\t\t\t\t\tif ( forward && useCache ) {\n\n\t\t\t\t\t\t\t// Seek `elem` from a previously-cached index\n\n\t\t\t\t\t\t\t// ...in a gzip-friendly way\n\t\t\t\t\t\t\tnode = parent;\n\t\t\t\t\t\t\touterCache = node[ expando ] || (node[ expando ] = {});\n\n\t\t\t\t\t\t\t// Support: IE <9 only\n\t\t\t\t\t\t\t// Defend against cloned attroperties (jQuery gh-1709)\n\t\t\t\t\t\t\tuniqueCache = outerCache[ node.uniqueID ] ||\n\t\t\t\t\t\t\t\t(outerCache[ node.uniqueID ] = {});\n\n\t\t\t\t\t\t\tcache = uniqueCache[ type ] || [];\n\t\t\t\t\t\t\tnodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];\n\t\t\t\t\t\t\tdiff = nodeIndex && cache[ 2 ];\n\t\t\t\t\t\t\tnode = nodeIndex && parent.childNodes[ nodeIndex ];\n\n\t\t\t\t\t\t\twhile ( (node = ++nodeIndex && node && node[ dir ] ||\n\n\t\t\t\t\t\t\t\t// Fallback to seeking `elem` from the start\n\t\t\t\t\t\t\t\t(diff = nodeIndex = 0) || start.pop()) ) {\n\n\t\t\t\t\t\t\t\t// When found, cache indexes on `parent` and break\n\t\t\t\t\t\t\t\tif ( node.nodeType === 1 && ++diff && node === elem ) {\n\t\t\t\t\t\t\t\t\tuniqueCache[ type ] = [ dirruns, nodeIndex, diff ];\n\t\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t// Use previously-cached element index if available\n\t\t\t\t\t\t\tif ( useCache ) {\n\t\t\t\t\t\t\t\t// ...in a gzip-friendly way\n\t\t\t\t\t\t\t\tnode = elem;\n\t\t\t\t\t\t\t\touterCache = node[ expando ] || (node[ expando ] = {});\n\n\t\t\t\t\t\t\t\t// Support: IE <9 only\n\t\t\t\t\t\t\t\t// Defend against cloned attroperties (jQuery gh-1709)\n\t\t\t\t\t\t\t\tuniqueCache = outerCache[ node.uniqueID ] ||\n\t\t\t\t\t\t\t\t\t(outerCache[ node.uniqueID ] = {});\n\n\t\t\t\t\t\t\t\tcache = uniqueCache[ type ] || [];\n\t\t\t\t\t\t\t\tnodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];\n\t\t\t\t\t\t\t\tdiff = nodeIndex;\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t// xml :nth-child(...)\n\t\t\t\t\t\t\t// or :nth-last-child(...) or :nth(-last)?-of-type(...)\n\t\t\t\t\t\t\tif ( diff === false ) {\n\t\t\t\t\t\t\t\t// Use the same loop as above to seek `elem` from the start\n\t\t\t\t\t\t\t\twhile ( (node = ++nodeIndex && node && node[ dir ] ||\n\t\t\t\t\t\t\t\t\t(diff = nodeIndex = 0) || start.pop()) ) {\n\n\t\t\t\t\t\t\t\t\tif ( ( ofType ?\n\t\t\t\t\t\t\t\t\t\tnode.nodeName.toLowerCase() === name :\n\t\t\t\t\t\t\t\t\t\tnode.nodeType === 1 ) &&\n\t\t\t\t\t\t\t\t\t\t++diff ) {\n\n\t\t\t\t\t\t\t\t\t\t// Cache the index of each encountered element\n\t\t\t\t\t\t\t\t\t\tif ( useCache ) {\n\t\t\t\t\t\t\t\t\t\t\touterCache = node[ expando ] || (node[ expando ] = {});\n\n\t\t\t\t\t\t\t\t\t\t\t// Support: IE <9 only\n\t\t\t\t\t\t\t\t\t\t\t// Defend against cloned attroperties (jQuery gh-1709)\n\t\t\t\t\t\t\t\t\t\t\tuniqueCache = outerCache[ node.uniqueID ] ||\n\t\t\t\t\t\t\t\t\t\t\t\t(outerCache[ node.uniqueID ] = {});\n\n\t\t\t\t\t\t\t\t\t\t\tuniqueCache[ type ] = [ dirruns, diff ];\n\t\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\t\tif ( node === elem ) {\n\t\t\t\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Incorporate the offset, then check against cycle size\n\t\t\t\t\t\tdiff -= last;\n\t\t\t\t\t\treturn diff === first || ( diff % first === 0 && diff / first >= 0 );\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t},\n\n\t\t\"PSEUDO\": function( pseudo, argument ) {\n\t\t\t// pseudo-class names are case-insensitive\n\t\t\t// http://www.w3.org/TR/selectors/#pseudo-classes\n\t\t\t// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters\n\t\t\t// Remember that setFilters inherits from pseudos\n\t\t\tvar args,\n\t\t\t\tfn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||\n\t\t\t\t\tSizzle.error( \"unsupported pseudo: \" + pseudo );\n\n\t\t\t// The user may use createPseudo to indicate that\n\t\t\t// arguments are needed to create the filter function\n\t\t\t// just as Sizzle does\n\t\t\tif ( fn[ expando ] ) {\n\t\t\t\treturn fn( argument );\n\t\t\t}\n\n\t\t\t// But maintain support for old signatures\n\t\t\tif ( fn.length > 1 ) {\n\t\t\t\targs = [ pseudo, pseudo, \"\", argument ];\n\t\t\t\treturn Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?\n\t\t\t\t\tmarkFunction(function( seed, matches ) {\n\t\t\t\t\t\tvar idx,\n\t\t\t\t\t\t\tmatched = fn( seed, argument ),\n\t\t\t\t\t\t\ti = matched.length;\n\t\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\t\tidx = indexOf( seed, matched[i] );\n\t\t\t\t\t\t\tseed[ idx ] = !( matches[ idx ] = matched[i] );\n\t\t\t\t\t\t}\n\t\t\t\t\t}) :\n\t\t\t\t\tfunction( elem ) {\n\t\t\t\t\t\treturn fn( elem, 0, args );\n\t\t\t\t\t};\n\t\t\t}\n\n\t\t\treturn fn;\n\t\t}\n\t},\n\n\tpseudos: {\n\t\t// Potentially complex pseudos\n\t\t\"not\": markFunction(function( selector ) {\n\t\t\t// Trim the selector passed to compile\n\t\t\t// to avoid treating leading and trailing\n\t\t\t// spaces as combinators\n\t\t\tvar input = [],\n\t\t\t\tresults = [],\n\t\t\t\tmatcher = compile( selector.replace( rtrim, \"$1\" ) );\n\n\t\t\treturn matcher[ expando ] ?\n\t\t\t\tmarkFunction(function( seed, matches, context, xml ) {\n\t\t\t\t\tvar elem,\n\t\t\t\t\t\tunmatched = matcher( seed, null, xml, [] ),\n\t\t\t\t\t\ti = seed.length;\n\n\t\t\t\t\t// Match elements unmatched by `matcher`\n\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\tif ( (elem = unmatched[i]) ) {\n\t\t\t\t\t\t\tseed[i] = !(matches[i] = elem);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}) :\n\t\t\t\tfunction( elem, context, xml ) {\n\t\t\t\t\tinput[0] = elem;\n\t\t\t\t\tmatcher( input, null, xml, results );\n\t\t\t\t\t// Don't keep the element (issue #299)\n\t\t\t\t\tinput[0] = null;\n\t\t\t\t\treturn !results.pop();\n\t\t\t\t};\n\t\t}),\n\n\t\t\"has\": markFunction(function( selector ) {\n\t\t\treturn function( elem ) {\n\t\t\t\treturn Sizzle( selector, elem ).length > 0;\n\t\t\t};\n\t\t}),\n\n\t\t\"contains\": markFunction(function( text ) {\n\t\t\ttext = text.replace( runescape, funescape );\n\t\t\treturn function( elem ) {\n\t\t\t\treturn ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1;\n\t\t\t};\n\t\t}),\n\n\t\t// \"Whether an element is represented by a :lang() selector\n\t\t// is based solely on the element's language value\n\t\t// being equal to the identifier C,\n\t\t// or beginning with the identifier C immediately followed by \"-\".\n\t\t// The matching of C against the element's language value is performed case-insensitively.\n\t\t// The identifier C does not have to be a valid language name.\"\n\t\t// http://www.w3.org/TR/selectors/#lang-pseudo\n\t\t\"lang\": markFunction( function( lang ) {\n\t\t\t// lang value must be a valid identifier\n\t\t\tif ( !ridentifier.test(lang || \"\") ) {\n\t\t\t\tSizzle.error( \"unsupported lang: \" + lang );\n\t\t\t}\n\t\t\tlang = lang.replace( runescape, funescape ).toLowerCase();\n\t\t\treturn function( elem ) {\n\t\t\t\tvar elemLang;\n\t\t\t\tdo {\n\t\t\t\t\tif ( (elemLang = documentIsHTML ?\n\t\t\t\t\t\telem.lang :\n\t\t\t\t\t\telem.getAttribute(\"xml:lang\") || elem.getAttribute(\"lang\")) ) {\n\n\t\t\t\t\t\telemLang = elemLang.toLowerCase();\n\t\t\t\t\t\treturn elemLang === lang || elemLang.indexOf( lang + \"-\" ) === 0;\n\t\t\t\t\t}\n\t\t\t\t} while ( (elem = elem.parentNode) && elem.nodeType === 1 );\n\t\t\t\treturn false;\n\t\t\t};\n\t\t}),\n\n\t\t// Miscellaneous\n\t\t\"target\": function( elem ) {\n\t\t\tvar hash = window.location && window.location.hash;\n\t\t\treturn hash && hash.slice( 1 ) === elem.id;\n\t\t},\n\n\t\t\"root\": function( elem ) {\n\t\t\treturn elem === docElem;\n\t\t},\n\n\t\t\"focus\": function( elem ) {\n\t\t\treturn elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);\n\t\t},\n\n\t\t// Boolean properties\n\t\t\"enabled\": function( elem ) {\n\t\t\treturn elem.disabled === false;\n\t\t},\n\n\t\t\"disabled\": function( elem ) {\n\t\t\treturn elem.disabled === true;\n\t\t},\n\n\t\t\"checked\": function( elem ) {\n\t\t\t// In CSS3, :checked should return both checked and selected elements\n\t\t\t// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked\n\t\t\tvar nodeName = elem.nodeName.toLowerCase();\n\t\t\treturn (nodeName === \"input\" && !!elem.checked) || (nodeName === \"option\" && !!elem.selected);\n\t\t},\n\n\t\t\"selected\": function( elem ) {\n\t\t\t// Accessing this property makes selected-by-default\n\t\t\t// options in Safari work properly\n\t\t\tif ( elem.parentNode ) {\n\t\t\t\telem.parentNode.selectedIndex;\n\t\t\t}\n\n\t\t\treturn elem.selected === true;\n\t\t},\n\n\t\t// Contents\n\t\t\"empty\": function( elem ) {\n\t\t\t// http://www.w3.org/TR/selectors/#empty-pseudo\n\t\t\t// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),\n\t\t\t//   but not by others (comment: 8; processing instruction: 7; etc.)\n\t\t\t// nodeType < 6 works because attributes (2) do not appear as children\n\t\t\tfor ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {\n\t\t\t\tif ( elem.nodeType < 6 ) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn true;\n\t\t},\n\n\t\t\"parent\": function( elem ) {\n\t\t\treturn !Expr.pseudos[\"empty\"]( elem );\n\t\t},\n\n\t\t// Element/input types\n\t\t\"header\": function( elem ) {\n\t\t\treturn rheader.test( elem.nodeName );\n\t\t},\n\n\t\t\"input\": function( elem ) {\n\t\t\treturn rinputs.test( elem.nodeName );\n\t\t},\n\n\t\t\"button\": function( elem ) {\n\t\t\tvar name = elem.nodeName.toLowerCase();\n\t\t\treturn name === \"input\" && elem.type === \"button\" || name === \"button\";\n\t\t},\n\n\t\t\"text\": function( elem ) {\n\t\t\tvar attr;\n\t\t\treturn elem.nodeName.toLowerCase() === \"input\" &&\n\t\t\t\telem.type === \"text\" &&\n\n\t\t\t\t// Support: IE<8\n\t\t\t\t// New HTML5 attribute values (e.g., \"search\") appear with elem.type === \"text\"\n\t\t\t\t( (attr = elem.getAttribute(\"type\")) == null || attr.toLowerCase() === \"text\" );\n\t\t},\n\n\t\t// Position-in-collection\n\t\t\"first\": createPositionalPseudo(function() {\n\t\t\treturn [ 0 ];\n\t\t}),\n\n\t\t\"last\": createPositionalPseudo(function( matchIndexes, length ) {\n\t\t\treturn [ length - 1 ];\n\t\t}),\n\n\t\t\"eq\": createPositionalPseudo(function( matchIndexes, length, argument ) {\n\t\t\treturn [ argument < 0 ? argument + length : argument ];\n\t\t}),\n\n\t\t\"even\": createPositionalPseudo(function( matchIndexes, length ) {\n\t\t\tvar i = 0;\n\t\t\tfor ( ; i < length; i += 2 ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t}),\n\n\t\t\"odd\": createPositionalPseudo(function( matchIndexes, length ) {\n\t\t\tvar i = 1;\n\t\t\tfor ( ; i < length; i += 2 ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t}),\n\n\t\t\"lt\": createPositionalPseudo(function( matchIndexes, length, argument ) {\n\t\t\tvar i = argument < 0 ? argument + length : argument;\n\t\t\tfor ( ; --i >= 0; ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t}),\n\n\t\t\"gt\": createPositionalPseudo(function( matchIndexes, length, argument ) {\n\t\t\tvar i = argument < 0 ? argument + length : argument;\n\t\t\tfor ( ; ++i < length; ) {\n\t\t\t\tmatchIndexes.push( i );\n\t\t\t}\n\t\t\treturn matchIndexes;\n\t\t})\n\t}\n};\n\nExpr.pseudos[\"nth\"] = Expr.pseudos[\"eq\"];\n\n// Add button/input type pseudos\nfor ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {\n\tExpr.pseudos[ i ] = createInputPseudo( i );\n}\nfor ( i in { submit: true, reset: true } ) {\n\tExpr.pseudos[ i ] = createButtonPseudo( i );\n}\n\n// Easy API for creating new setFilters\nfunction setFilters() {}\nsetFilters.prototype = Expr.filters = Expr.pseudos;\nExpr.setFilters = new setFilters();\n\ntokenize = Sizzle.tokenize = function( selector, parseOnly ) {\n\tvar matched, match, tokens, type,\n\t\tsoFar, groups, preFilters,\n\t\tcached = tokenCache[ selector + \" \" ];\n\n\tif ( cached ) {\n\t\treturn parseOnly ? 0 : cached.slice( 0 );\n\t}\n\n\tsoFar = selector;\n\tgroups = [];\n\tpreFilters = Expr.preFilter;\n\n\twhile ( soFar ) {\n\n\t\t// Comma and first run\n\t\tif ( !matched || (match = rcomma.exec( soFar )) ) {\n\t\t\tif ( match ) {\n\t\t\t\t// Don't consume trailing commas as valid\n\t\t\t\tsoFar = soFar.slice( match[0].length ) || soFar;\n\t\t\t}\n\t\t\tgroups.push( (tokens = []) );\n\t\t}\n\n\t\tmatched = false;\n\n\t\t// Combinators\n\t\tif ( (match = rcombinators.exec( soFar )) ) {\n\t\t\tmatched = match.shift();\n\t\t\ttokens.push({\n\t\t\t\tvalue: matched,\n\t\t\t\t// Cast descendant combinators to space\n\t\t\t\ttype: match[0].replace( rtrim, \" \" )\n\t\t\t});\n\t\t\tsoFar = soFar.slice( matched.length );\n\t\t}\n\n\t\t// Filters\n\t\tfor ( type in Expr.filter ) {\n\t\t\tif ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||\n\t\t\t\t(match = preFilters[ type ]( match ))) ) {\n\t\t\t\tmatched = match.shift();\n\t\t\t\ttokens.push({\n\t\t\t\t\tvalue: matched,\n\t\t\t\t\ttype: type,\n\t\t\t\t\tmatches: match\n\t\t\t\t});\n\t\t\t\tsoFar = soFar.slice( matched.length );\n\t\t\t}\n\t\t}\n\n\t\tif ( !matched ) {\n\t\t\tbreak;\n\t\t}\n\t}\n\n\t// Return the length of the invalid excess\n\t// if we're just parsing\n\t// Otherwise, throw an error or return tokens\n\treturn parseOnly ?\n\t\tsoFar.length :\n\t\tsoFar ?\n\t\t\tSizzle.error( selector ) :\n\t\t\t// Cache the tokens\n\t\t\ttokenCache( selector, groups ).slice( 0 );\n};\n\nfunction toSelector( tokens ) {\n\tvar i = 0,\n\t\tlen = tokens.length,\n\t\tselector = \"\";\n\tfor ( ; i < len; i++ ) {\n\t\tselector += tokens[i].value;\n\t}\n\treturn selector;\n}\n\nfunction addCombinator( matcher, combinator, base ) {\n\tvar dir = combinator.dir,\n\t\tcheckNonElements = base && dir === \"parentNode\",\n\t\tdoneName = done++;\n\n\treturn combinator.first ?\n\t\t// Check against closest ancestor/preceding element\n\t\tfunction( elem, context, xml ) {\n\t\t\twhile ( (elem = elem[ dir ]) ) {\n\t\t\t\tif ( elem.nodeType === 1 || checkNonElements ) {\n\t\t\t\t\treturn matcher( elem, context, xml );\n\t\t\t\t}\n\t\t\t}\n\t\t} :\n\n\t\t// Check against all ancestor/preceding elements\n\t\tfunction( elem, context, xml ) {\n\t\t\tvar oldCache, uniqueCache, outerCache,\n\t\t\t\tnewCache = [ dirruns, doneName ];\n\n\t\t\t// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching\n\t\t\tif ( xml ) {\n\t\t\t\twhile ( (elem = elem[ dir ]) ) {\n\t\t\t\t\tif ( elem.nodeType === 1 || checkNonElements ) {\n\t\t\t\t\t\tif ( matcher( elem, context, xml ) ) {\n\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\twhile ( (elem = elem[ dir ]) ) {\n\t\t\t\t\tif ( elem.nodeType === 1 || checkNonElements ) {\n\t\t\t\t\t\touterCache = elem[ expando ] || (elem[ expando ] = {});\n\n\t\t\t\t\t\t// Support: IE <9 only\n\t\t\t\t\t\t// Defend against cloned attroperties (jQuery gh-1709)\n\t\t\t\t\t\tuniqueCache = outerCache[ elem.uniqueID ] || (outerCache[ elem.uniqueID ] = {});\n\n\t\t\t\t\t\tif ( (oldCache = uniqueCache[ dir ]) &&\n\t\t\t\t\t\t\toldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {\n\n\t\t\t\t\t\t\t// Assign to newCache so results back-propagate to previous elements\n\t\t\t\t\t\t\treturn (newCache[ 2 ] = oldCache[ 2 ]);\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t// Reuse newcache so results back-propagate to previous elements\n\t\t\t\t\t\t\tuniqueCache[ dir ] = newCache;\n\n\t\t\t\t\t\t\t// A match means we're done; a fail means we have to keep checking\n\t\t\t\t\t\t\tif ( (newCache[ 2 ] = matcher( elem, context, xml )) ) {\n\t\t\t\t\t\t\t\treturn true;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t};\n}\n\nfunction elementMatcher( matchers ) {\n\treturn matchers.length > 1 ?\n\t\tfunction( elem, context, xml ) {\n\t\t\tvar i = matchers.length;\n\t\t\twhile ( i-- ) {\n\t\t\t\tif ( !matchers[i]( elem, context, xml ) ) {\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn true;\n\t\t} :\n\t\tmatchers[0];\n}\n\nfunction multipleContexts( selector, contexts, results ) {\n\tvar i = 0,\n\t\tlen = contexts.length;\n\tfor ( ; i < len; i++ ) {\n\t\tSizzle( selector, contexts[i], results );\n\t}\n\treturn results;\n}\n\nfunction condense( unmatched, map, filter, context, xml ) {\n\tvar elem,\n\t\tnewUnmatched = [],\n\t\ti = 0,\n\t\tlen = unmatched.length,\n\t\tmapped = map != null;\n\n\tfor ( ; i < len; i++ ) {\n\t\tif ( (elem = unmatched[i]) ) {\n\t\t\tif ( !filter || filter( elem, context, xml ) ) {\n\t\t\t\tnewUnmatched.push( elem );\n\t\t\t\tif ( mapped ) {\n\t\t\t\t\tmap.push( i );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn newUnmatched;\n}\n\nfunction setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {\n\tif ( postFilter && !postFilter[ expando ] ) {\n\t\tpostFilter = setMatcher( postFilter );\n\t}\n\tif ( postFinder && !postFinder[ expando ] ) {\n\t\tpostFinder = setMatcher( postFinder, postSelector );\n\t}\n\treturn markFunction(function( seed, results, context, xml ) {\n\t\tvar temp, i, elem,\n\t\t\tpreMap = [],\n\t\t\tpostMap = [],\n\t\t\tpreexisting = results.length,\n\n\t\t\t// Get initial elements from seed or context\n\t\t\telems = seed || multipleContexts( selector || \"*\", context.nodeType ? [ context ] : context, [] ),\n\n\t\t\t// Prefilter to get matcher input, preserving a map for seed-results synchronization\n\t\t\tmatcherIn = preFilter && ( seed || !selector ) ?\n\t\t\t\tcondense( elems, preMap, preFilter, context, xml ) :\n\t\t\t\telems,\n\n\t\t\tmatcherOut = matcher ?\n\t\t\t\t// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,\n\t\t\t\tpostFinder || ( seed ? preFilter : preexisting || postFilter ) ?\n\n\t\t\t\t\t// ...intermediate processing is necessary\n\t\t\t\t\t[] :\n\n\t\t\t\t\t// ...otherwise use results directly\n\t\t\t\t\tresults :\n\t\t\t\tmatcherIn;\n\n\t\t// Find primary matches\n\t\tif ( matcher ) {\n\t\t\tmatcher( matcherIn, matcherOut, context, xml );\n\t\t}\n\n\t\t// Apply postFilter\n\t\tif ( postFilter ) {\n\t\t\ttemp = condense( matcherOut, postMap );\n\t\t\tpostFilter( temp, [], context, xml );\n\n\t\t\t// Un-match failing elements by moving them back to matcherIn\n\t\t\ti = temp.length;\n\t\t\twhile ( i-- ) {\n\t\t\t\tif ( (elem = temp[i]) ) {\n\t\t\t\t\tmatcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif ( seed ) {\n\t\t\tif ( postFinder || preFilter ) {\n\t\t\t\tif ( postFinder ) {\n\t\t\t\t\t// Get the final matcherOut by condensing this intermediate into postFinder contexts\n\t\t\t\t\ttemp = [];\n\t\t\t\t\ti = matcherOut.length;\n\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\tif ( (elem = matcherOut[i]) ) {\n\t\t\t\t\t\t\t// Restore matcherIn since elem is not yet a final match\n\t\t\t\t\t\t\ttemp.push( (matcherIn[i] = elem) );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tpostFinder( null, (matcherOut = []), temp, xml );\n\t\t\t\t}\n\n\t\t\t\t// Move matched elements from seed to results to keep them synchronized\n\t\t\t\ti = matcherOut.length;\n\t\t\t\twhile ( i-- ) {\n\t\t\t\t\tif ( (elem = matcherOut[i]) &&\n\t\t\t\t\t\t(temp = postFinder ? indexOf( seed, elem ) : preMap[i]) > -1 ) {\n\n\t\t\t\t\t\tseed[temp] = !(results[temp] = elem);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t// Add elements to results, through postFinder if defined\n\t\t} else {\n\t\t\tmatcherOut = condense(\n\t\t\t\tmatcherOut === results ?\n\t\t\t\t\tmatcherOut.splice( preexisting, matcherOut.length ) :\n\t\t\t\t\tmatcherOut\n\t\t\t);\n\t\t\tif ( postFinder ) {\n\t\t\t\tpostFinder( null, results, matcherOut, xml );\n\t\t\t} else {\n\t\t\t\tpush.apply( results, matcherOut );\n\t\t\t}\n\t\t}\n\t});\n}\n\nfunction matcherFromTokens( tokens ) {\n\tvar checkContext, matcher, j,\n\t\tlen = tokens.length,\n\t\tleadingRelative = Expr.relative[ tokens[0].type ],\n\t\timplicitRelative = leadingRelative || Expr.relative[\" \"],\n\t\ti = leadingRelative ? 1 : 0,\n\n\t\t// The foundational matcher ensures that elements are reachable from top-level context(s)\n\t\tmatchContext = addCombinator( function( elem ) {\n\t\t\treturn elem === checkContext;\n\t\t}, implicitRelative, true ),\n\t\tmatchAnyContext = addCombinator( function( elem ) {\n\t\t\treturn indexOf( checkContext, elem ) > -1;\n\t\t}, implicitRelative, true ),\n\t\tmatchers = [ function( elem, context, xml ) {\n\t\t\tvar ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (\n\t\t\t\t(checkContext = context).nodeType ?\n\t\t\t\t\tmatchContext( elem, context, xml ) :\n\t\t\t\t\tmatchAnyContext( elem, context, xml ) );\n\t\t\t// Avoid hanging onto element (issue #299)\n\t\t\tcheckContext = null;\n\t\t\treturn ret;\n\t\t} ];\n\n\tfor ( ; i < len; i++ ) {\n\t\tif ( (matcher = Expr.relative[ tokens[i].type ]) ) {\n\t\t\tmatchers = [ addCombinator(elementMatcher( matchers ), matcher) ];\n\t\t} else {\n\t\t\tmatcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );\n\n\t\t\t// Return special upon seeing a positional matcher\n\t\t\tif ( matcher[ expando ] ) {\n\t\t\t\t// Find the next relative operator (if any) for proper handling\n\t\t\t\tj = ++i;\n\t\t\t\tfor ( ; j < len; j++ ) {\n\t\t\t\t\tif ( Expr.relative[ tokens[j].type ] ) {\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn setMatcher(\n\t\t\t\t\ti > 1 && elementMatcher( matchers ),\n\t\t\t\t\ti > 1 && toSelector(\n\t\t\t\t\t\t// If the preceding token was a descendant combinator, insert an implicit any-element `*`\n\t\t\t\t\t\ttokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === \" \" ? \"*\" : \"\" })\n\t\t\t\t\t).replace( rtrim, \"$1\" ),\n\t\t\t\t\tmatcher,\n\t\t\t\t\ti < j && matcherFromTokens( tokens.slice( i, j ) ),\n\t\t\t\t\tj < len && matcherFromTokens( (tokens = tokens.slice( j )) ),\n\t\t\t\t\tj < len && toSelector( tokens )\n\t\t\t\t);\n\t\t\t}\n\t\t\tmatchers.push( matcher );\n\t\t}\n\t}\n\n\treturn elementMatcher( matchers );\n}\n\nfunction matcherFromGroupMatchers( elementMatchers, setMatchers ) {\n\tvar bySet = setMatchers.length > 0,\n\t\tbyElement = elementMatchers.length > 0,\n\t\tsuperMatcher = function( seed, context, xml, results, outermost ) {\n\t\t\tvar elem, j, matcher,\n\t\t\t\tmatchedCount = 0,\n\t\t\t\ti = \"0\",\n\t\t\t\tunmatched = seed && [],\n\t\t\t\tsetMatched = [],\n\t\t\t\tcontextBackup = outermostContext,\n\t\t\t\t// We must always have either seed elements or outermost context\n\t\t\t\telems = seed || byElement && Expr.find[\"TAG\"]( \"*\", outermost ),\n\t\t\t\t// Use integer dirruns iff this is the outermost matcher\n\t\t\t\tdirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1),\n\t\t\t\tlen = elems.length;\n\n\t\t\tif ( outermost ) {\n\t\t\t\toutermostContext = context === document || context || outermost;\n\t\t\t}\n\n\t\t\t// Add elements passing elementMatchers directly to results\n\t\t\t// Support: IE<9, Safari\n\t\t\t// Tolerate NodeList properties (IE: \"length\"; Safari: <number>) matching elements by id\n\t\t\tfor ( ; i !== len && (elem = elems[i]) != null; i++ ) {\n\t\t\t\tif ( byElement && elem ) {\n\t\t\t\t\tj = 0;\n\t\t\t\t\tif ( !context && elem.ownerDocument !== document ) {\n\t\t\t\t\t\tsetDocument( elem );\n\t\t\t\t\t\txml = !documentIsHTML;\n\t\t\t\t\t}\n\t\t\t\t\twhile ( (matcher = elementMatchers[j++]) ) {\n\t\t\t\t\t\tif ( matcher( elem, context || document, xml) ) {\n\t\t\t\t\t\t\tresults.push( elem );\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tif ( outermost ) {\n\t\t\t\t\t\tdirruns = dirrunsUnique;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Track unmatched elements for set filters\n\t\t\t\tif ( bySet ) {\n\t\t\t\t\t// They will have gone through all possible matchers\n\t\t\t\t\tif ( (elem = !matcher && elem) ) {\n\t\t\t\t\t\tmatchedCount--;\n\t\t\t\t\t}\n\n\t\t\t\t\t// Lengthen the array for every element, matched or not\n\t\t\t\t\tif ( seed ) {\n\t\t\t\t\t\tunmatched.push( elem );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// `i` is now the count of elements visited above, and adding it to `matchedCount`\n\t\t\t// makes the latter nonnegative.\n\t\t\tmatchedCount += i;\n\n\t\t\t// Apply set filters to unmatched elements\n\t\t\t// NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`\n\t\t\t// equals `i`), unless we didn't visit _any_ elements in the above loop because we have\n\t\t\t// no element matchers and no seed.\n\t\t\t// Incrementing an initially-string \"0\" `i` allows `i` to remain a string only in that\n\t\t\t// case, which will result in a \"00\" `matchedCount` that differs from `i` but is also\n\t\t\t// numerically zero.\n\t\t\tif ( bySet && i !== matchedCount ) {\n\t\t\t\tj = 0;\n\t\t\t\twhile ( (matcher = setMatchers[j++]) ) {\n\t\t\t\t\tmatcher( unmatched, setMatched, context, xml );\n\t\t\t\t}\n\n\t\t\t\tif ( seed ) {\n\t\t\t\t\t// Reintegrate element matches to eliminate the need for sorting\n\t\t\t\t\tif ( matchedCount > 0 ) {\n\t\t\t\t\t\twhile ( i-- ) {\n\t\t\t\t\t\t\tif ( !(unmatched[i] || setMatched[i]) ) {\n\t\t\t\t\t\t\t\tsetMatched[i] = pop.call( results );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Discard index placeholder values to get only actual matches\n\t\t\t\t\tsetMatched = condense( setMatched );\n\t\t\t\t}\n\n\t\t\t\t// Add matches to results\n\t\t\t\tpush.apply( results, setMatched );\n\n\t\t\t\t// Seedless set matches succeeding multiple successful matchers stipulate sorting\n\t\t\t\tif ( outermost && !seed && setMatched.length > 0 &&\n\t\t\t\t\t( matchedCount + setMatchers.length ) > 1 ) {\n\n\t\t\t\t\tSizzle.uniqueSort( results );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Override manipulation of globals by nested matchers\n\t\t\tif ( outermost ) {\n\t\t\t\tdirruns = dirrunsUnique;\n\t\t\t\toutermostContext = contextBackup;\n\t\t\t}\n\n\t\t\treturn unmatched;\n\t\t};\n\n\treturn bySet ?\n\t\tmarkFunction( superMatcher ) :\n\t\tsuperMatcher;\n}\n\ncompile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {\n\tvar i,\n\t\tsetMatchers = [],\n\t\telementMatchers = [],\n\t\tcached = compilerCache[ selector + \" \" ];\n\n\tif ( !cached ) {\n\t\t// Generate a function of recursive functions that can be used to check each element\n\t\tif ( !match ) {\n\t\t\tmatch = tokenize( selector );\n\t\t}\n\t\ti = match.length;\n\t\twhile ( i-- ) {\n\t\t\tcached = matcherFromTokens( match[i] );\n\t\t\tif ( cached[ expando ] ) {\n\t\t\t\tsetMatchers.push( cached );\n\t\t\t} else {\n\t\t\t\telementMatchers.push( cached );\n\t\t\t}\n\t\t}\n\n\t\t// Cache the compiled function\n\t\tcached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );\n\n\t\t// Save selector and tokenization\n\t\tcached.selector = selector;\n\t}\n\treturn cached;\n};\n\n/**\n * A low-level selection function that works with Sizzle's compiled\n *  selector functions\n * @param {String|Function} selector A selector or a pre-compiled\n *  selector function built with Sizzle.compile\n * @param {Element} context\n * @param {Array} [results]\n * @param {Array} [seed] A set of elements to match against\n */\nselect = Sizzle.select = function( selector, context, results, seed ) {\n\tvar i, tokens, token, type, find,\n\t\tcompiled = typeof selector === \"function\" && selector,\n\t\tmatch = !seed && tokenize( (selector = compiled.selector || selector) );\n\n\tresults = results || [];\n\n\t// Try to minimize operations if there is only one selector in the list and no seed\n\t// (the latter of which guarantees us context)\n\tif ( match.length === 1 ) {\n\n\t\t// Reduce context if the leading compound selector is an ID\n\t\ttokens = match[0] = match[0].slice( 0 );\n\t\tif ( tokens.length > 2 && (token = tokens[0]).type === \"ID\" &&\n\t\t\t\tsupport.getById && context.nodeType === 9 && documentIsHTML &&\n\t\t\t\tExpr.relative[ tokens[1].type ] ) {\n\n\t\t\tcontext = ( Expr.find[\"ID\"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0];\n\t\t\tif ( !context ) {\n\t\t\t\treturn results;\n\n\t\t\t// Precompiled matchers will still verify ancestry, so step up a level\n\t\t\t} else if ( compiled ) {\n\t\t\t\tcontext = context.parentNode;\n\t\t\t}\n\n\t\t\tselector = selector.slice( tokens.shift().value.length );\n\t\t}\n\n\t\t// Fetch a seed set for right-to-left matching\n\t\ti = matchExpr[\"needsContext\"].test( selector ) ? 0 : tokens.length;\n\t\twhile ( i-- ) {\n\t\t\ttoken = tokens[i];\n\n\t\t\t// Abort if we hit a combinator\n\t\t\tif ( Expr.relative[ (type = token.type) ] ) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tif ( (find = Expr.find[ type ]) ) {\n\t\t\t\t// Search, expanding context for leading sibling combinators\n\t\t\t\tif ( (seed = find(\n\t\t\t\t\ttoken.matches[0].replace( runescape, funescape ),\n\t\t\t\t\trsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context\n\t\t\t\t)) ) {\n\n\t\t\t\t\t// If seed is empty or no tokens remain, we can return early\n\t\t\t\t\ttokens.splice( i, 1 );\n\t\t\t\t\tselector = seed.length && toSelector( tokens );\n\t\t\t\t\tif ( !selector ) {\n\t\t\t\t\t\tpush.apply( results, seed );\n\t\t\t\t\t\treturn results;\n\t\t\t\t\t}\n\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// Compile and execute a filtering function if one is not provided\n\t// Provide `match` to avoid retokenization if we modified the selector above\n\t( compiled || compile( selector, match ) )(\n\t\tseed,\n\t\tcontext,\n\t\t!documentIsHTML,\n\t\tresults,\n\t\t!context || rsibling.test( selector ) && testContext( context.parentNode ) || context\n\t);\n\treturn results;\n};\n\n// One-time assignments\n\n// Sort stability\nsupport.sortStable = expando.split(\"\").sort( sortOrder ).join(\"\") === expando;\n\n// Support: Chrome 14-35+\n// Always assume duplicates if they aren't passed to the comparison function\nsupport.detectDuplicates = !!hasDuplicate;\n\n// Initialize against the default document\nsetDocument();\n\n// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)\n// Detached nodes confoundingly follow *each other*\nsupport.sortDetached = assert(function( div1 ) {\n\t// Should return 1, but returns 4 (following)\n\treturn div1.compareDocumentPosition( document.createElement(\"div\") ) & 1;\n});\n\n// Support: IE<8\n// Prevent attribute/property \"interpolation\"\n// http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx\nif ( !assert(function( div ) {\n\tdiv.innerHTML = \"<a href='#'></a>\";\n\treturn div.firstChild.getAttribute(\"href\") === \"#\" ;\n}) ) {\n\taddHandle( \"type|href|height|width\", function( elem, name, isXML ) {\n\t\tif ( !isXML ) {\n\t\t\treturn elem.getAttribute( name, name.toLowerCase() === \"type\" ? 1 : 2 );\n\t\t}\n\t});\n}\n\n// Support: IE<9\n// Use defaultValue in place of getAttribute(\"value\")\nif ( !support.attributes || !assert(function( div ) {\n\tdiv.innerHTML = \"<input/>\";\n\tdiv.firstChild.setAttribute( \"value\", \"\" );\n\treturn div.firstChild.getAttribute( \"value\" ) === \"\";\n}) ) {\n\taddHandle( \"value\", function( elem, name, isXML ) {\n\t\tif ( !isXML && elem.nodeName.toLowerCase() === \"input\" ) {\n\t\t\treturn elem.defaultValue;\n\t\t}\n\t});\n}\n\n// Support: IE<9\n// Use getAttributeNode to fetch booleans when getAttribute lies\nif ( !assert(function( div ) {\n\treturn div.getAttribute(\"disabled\") == null;\n}) ) {\n\taddHandle( booleans, function( elem, name, isXML ) {\n\t\tvar val;\n\t\tif ( !isXML ) {\n\t\t\treturn elem[ name ] === true ? name.toLowerCase() :\n\t\t\t\t\t(val = elem.getAttributeNode( name )) && val.specified ?\n\t\t\t\t\tval.value :\n\t\t\t\tnull;\n\t\t}\n\t});\n}\n\nreturn Sizzle;\n\n})( window );\n\n\n\njQuery.find = Sizzle;\njQuery.expr = Sizzle.selectors;\njQuery.expr[ \":\" ] = jQuery.expr.pseudos;\njQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;\njQuery.text = Sizzle.getText;\njQuery.isXMLDoc = Sizzle.isXML;\njQuery.contains = Sizzle.contains;\n\n\n\nvar dir = function( elem, dir, until ) {\n\tvar matched = [],\n\t\ttruncate = until !== undefined;\n\n\twhile ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) {\n\t\tif ( elem.nodeType === 1 ) {\n\t\t\tif ( truncate && jQuery( elem ).is( until ) ) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tmatched.push( elem );\n\t\t}\n\t}\n\treturn matched;\n};\n\n\nvar siblings = function( n, elem ) {\n\tvar matched = [];\n\n\tfor ( ; n; n = n.nextSibling ) {\n\t\tif ( n.nodeType === 1 && n !== elem ) {\n\t\t\tmatched.push( n );\n\t\t}\n\t}\n\n\treturn matched;\n};\n\n\nvar rneedsContext = jQuery.expr.match.needsContext;\n\nvar rsingleTag = ( /^<([\\w-]+)\\s*\\/?>(?:<\\/\\1>|)$/ );\n\n\n\nvar risSimple = /^.[^:#\\[\\.,]*$/;\n\n// Implement the identical functionality for filter and not\nfunction winnow( elements, qualifier, not ) {\n\tif ( jQuery.isFunction( qualifier ) ) {\n\t\treturn jQuery.grep( elements, function( elem, i ) {\n\t\t\t/* jshint -W018 */\n\t\t\treturn !!qualifier.call( elem, i, elem ) !== not;\n\t\t} );\n\n\t}\n\n\tif ( qualifier.nodeType ) {\n\t\treturn jQuery.grep( elements, function( elem ) {\n\t\t\treturn ( elem === qualifier ) !== not;\n\t\t} );\n\n\t}\n\n\tif ( typeof qualifier === \"string\" ) {\n\t\tif ( risSimple.test( qualifier ) ) {\n\t\t\treturn jQuery.filter( qualifier, elements, not );\n\t\t}\n\n\t\tqualifier = jQuery.filter( qualifier, elements );\n\t}\n\n\treturn jQuery.grep( elements, function( elem ) {\n\t\treturn ( indexOf.call( qualifier, elem ) > -1 ) !== not;\n\t} );\n}\n\njQuery.filter = function( expr, elems, not ) {\n\tvar elem = elems[ 0 ];\n\n\tif ( not ) {\n\t\texpr = \":not(\" + expr + \")\";\n\t}\n\n\treturn elems.length === 1 && elem.nodeType === 1 ?\n\t\tjQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [] :\n\t\tjQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {\n\t\t\treturn elem.nodeType === 1;\n\t\t} ) );\n};\n\njQuery.fn.extend( {\n\tfind: function( selector ) {\n\t\tvar i,\n\t\t\tlen = this.length,\n\t\t\tret = [],\n\t\t\tself = this;\n\n\t\tif ( typeof selector !== \"string\" ) {\n\t\t\treturn this.pushStack( jQuery( selector ).filter( function() {\n\t\t\t\tfor ( i = 0; i < len; i++ ) {\n\t\t\t\t\tif ( jQuery.contains( self[ i ], this ) ) {\n\t\t\t\t\t\treturn true;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} ) );\n\t\t}\n\n\t\tfor ( i = 0; i < len; i++ ) {\n\t\t\tjQuery.find( selector, self[ i ], ret );\n\t\t}\n\n\t\t// Needed because $( selector, context ) becomes $( context ).find( selector )\n\t\tret = this.pushStack( len > 1 ? jQuery.unique( ret ) : ret );\n\t\tret.selector = this.selector ? this.selector + \" \" + selector : selector;\n\t\treturn ret;\n\t},\n\tfilter: function( selector ) {\n\t\treturn this.pushStack( winnow( this, selector || [], false ) );\n\t},\n\tnot: function( selector ) {\n\t\treturn this.pushStack( winnow( this, selector || [], true ) );\n\t},\n\tis: function( selector ) {\n\t\treturn !!winnow(\n\t\t\tthis,\n\n\t\t\t// If this is a positional/relative selector, check membership in the returned set\n\t\t\t// so $(\"p:first\").is(\"p:last\") won't return true for a doc with two \"p\".\n\t\t\ttypeof selector === \"string\" && rneedsContext.test( selector ) ?\n\t\t\t\tjQuery( selector ) :\n\t\t\t\tselector || [],\n\t\t\tfalse\n\t\t).length;\n\t}\n} );\n\n\n// Initialize a jQuery object\n\n\n// A central reference to the root jQuery(document)\nvar rootjQuery,\n\n\t// A simple way to check for HTML strings\n\t// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)\n\t// Strict HTML recognition (#11290: must start with <)\n\trquickExpr = /^(?:\\s*(<[\\w\\W]+>)[^>]*|#([\\w-]*))$/,\n\n\tinit = jQuery.fn.init = function( selector, context, root ) {\n\t\tvar match, elem;\n\n\t\t// HANDLE: $(\"\"), $(null), $(undefined), $(false)\n\t\tif ( !selector ) {\n\t\t\treturn this;\n\t\t}\n\n\t\t// Method init() accepts an alternate rootjQuery\n\t\t// so migrate can support jQuery.sub (gh-2101)\n\t\troot = root || rootjQuery;\n\n\t\t// Handle HTML strings\n\t\tif ( typeof selector === \"string\" ) {\n\t\t\tif ( selector[ 0 ] === \"<\" &&\n\t\t\t\tselector[ selector.length - 1 ] === \">\" &&\n\t\t\t\tselector.length >= 3 ) {\n\n\t\t\t\t// Assume that strings that start and end with <> are HTML and skip the regex check\n\t\t\t\tmatch = [ null, selector, null ];\n\n\t\t\t} else {\n\t\t\t\tmatch = rquickExpr.exec( selector );\n\t\t\t}\n\n\t\t\t// Match html or make sure no context is specified for #id\n\t\t\tif ( match && ( match[ 1 ] || !context ) ) {\n\n\t\t\t\t// HANDLE: $(html) -> $(array)\n\t\t\t\tif ( match[ 1 ] ) {\n\t\t\t\t\tcontext = context instanceof jQuery ? context[ 0 ] : context;\n\n\t\t\t\t\t// Option to run scripts is true for back-compat\n\t\t\t\t\t// Intentionally let the error be thrown if parseHTML is not present\n\t\t\t\t\tjQuery.merge( this, jQuery.parseHTML(\n\t\t\t\t\t\tmatch[ 1 ],\n\t\t\t\t\t\tcontext && context.nodeType ? context.ownerDocument || context : document,\n\t\t\t\t\t\ttrue\n\t\t\t\t\t) );\n\n\t\t\t\t\t// HANDLE: $(html, props)\n\t\t\t\t\tif ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) {\n\t\t\t\t\t\tfor ( match in context ) {\n\n\t\t\t\t\t\t\t// Properties of context are called as methods if possible\n\t\t\t\t\t\t\tif ( jQuery.isFunction( this[ match ] ) ) {\n\t\t\t\t\t\t\t\tthis[ match ]( context[ match ] );\n\n\t\t\t\t\t\t\t// ...and otherwise set as attributes\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tthis.attr( match, context[ match ] );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\treturn this;\n\n\t\t\t\t// HANDLE: $(#id)\n\t\t\t\t} else {\n\t\t\t\t\telem = document.getElementById( match[ 2 ] );\n\n\t\t\t\t\t// Support: Blackberry 4.6\n\t\t\t\t\t// gEBID returns nodes no longer in the document (#6963)\n\t\t\t\t\tif ( elem && elem.parentNode ) {\n\n\t\t\t\t\t\t// Inject the element directly into the jQuery object\n\t\t\t\t\t\tthis.length = 1;\n\t\t\t\t\t\tthis[ 0 ] = elem;\n\t\t\t\t\t}\n\n\t\t\t\t\tthis.context = document;\n\t\t\t\t\tthis.selector = selector;\n\t\t\t\t\treturn this;\n\t\t\t\t}\n\n\t\t\t// HANDLE: $(expr, $(...))\n\t\t\t} else if ( !context || context.jquery ) {\n\t\t\t\treturn ( context || root ).find( selector );\n\n\t\t\t// HANDLE: $(expr, context)\n\t\t\t// (which is just equivalent to: $(context).find(expr)\n\t\t\t} else {\n\t\t\t\treturn this.constructor( context ).find( selector );\n\t\t\t}\n\n\t\t// HANDLE: $(DOMElement)\n\t\t} else if ( selector.nodeType ) {\n\t\t\tthis.context = this[ 0 ] = selector;\n\t\t\tthis.length = 1;\n\t\t\treturn this;\n\n\t\t// HANDLE: $(function)\n\t\t// Shortcut for document ready\n\t\t} else if ( jQuery.isFunction( selector ) ) {\n\t\t\treturn root.ready !== undefined ?\n\t\t\t\troot.ready( selector ) :\n\n\t\t\t\t// Execute immediately if ready is not present\n\t\t\t\tselector( jQuery );\n\t\t}\n\n\t\tif ( selector.selector !== undefined ) {\n\t\t\tthis.selector = selector.selector;\n\t\t\tthis.context = selector.context;\n\t\t}\n\n\t\treturn jQuery.makeArray( selector, this );\n\t};\n\n// Give the init function the jQuery prototype for later instantiation\ninit.prototype = jQuery.fn;\n\n// Initialize central reference\nrootjQuery = jQuery( document );\n\n\nvar rparentsprev = /^(?:parents|prev(?:Until|All))/,\n\n\t// Methods guaranteed to produce a unique set when starting from a unique set\n\tguaranteedUnique = {\n\t\tchildren: true,\n\t\tcontents: true,\n\t\tnext: true,\n\t\tprev: true\n\t};\n\njQuery.fn.extend( {\n\thas: function( target ) {\n\t\tvar targets = jQuery( target, this ),\n\t\t\tl = targets.length;\n\n\t\treturn this.filter( function() {\n\t\t\tvar i = 0;\n\t\t\tfor ( ; i < l; i++ ) {\n\t\t\t\tif ( jQuery.contains( this, targets[ i ] ) ) {\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t}\n\t\t} );\n\t},\n\n\tclosest: function( selectors, context ) {\n\t\tvar cur,\n\t\t\ti = 0,\n\t\t\tl = this.length,\n\t\t\tmatched = [],\n\t\t\tpos = rneedsContext.test( selectors ) || typeof selectors !== \"string\" ?\n\t\t\t\tjQuery( selectors, context || this.context ) :\n\t\t\t\t0;\n\n\t\tfor ( ; i < l; i++ ) {\n\t\t\tfor ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) {\n\n\t\t\t\t// Always skip document fragments\n\t\t\t\tif ( cur.nodeType < 11 && ( pos ?\n\t\t\t\t\tpos.index( cur ) > -1 :\n\n\t\t\t\t\t// Don't pass non-elements to Sizzle\n\t\t\t\t\tcur.nodeType === 1 &&\n\t\t\t\t\t\tjQuery.find.matchesSelector( cur, selectors ) ) ) {\n\n\t\t\t\t\tmatched.push( cur );\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched );\n\t},\n\n\t// Determine the position of an element within the set\n\tindex: function( elem ) {\n\n\t\t// No argument, return index in parent\n\t\tif ( !elem ) {\n\t\t\treturn ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;\n\t\t}\n\n\t\t// Index in selector\n\t\tif ( typeof elem === \"string\" ) {\n\t\t\treturn indexOf.call( jQuery( elem ), this[ 0 ] );\n\t\t}\n\n\t\t// Locate the position of the desired element\n\t\treturn indexOf.call( this,\n\n\t\t\t// If it receives a jQuery object, the first element is used\n\t\t\telem.jquery ? elem[ 0 ] : elem\n\t\t);\n\t},\n\n\tadd: function( selector, context ) {\n\t\treturn this.pushStack(\n\t\t\tjQuery.uniqueSort(\n\t\t\t\tjQuery.merge( this.get(), jQuery( selector, context ) )\n\t\t\t)\n\t\t);\n\t},\n\n\taddBack: function( selector ) {\n\t\treturn this.add( selector == null ?\n\t\t\tthis.prevObject : this.prevObject.filter( selector )\n\t\t);\n\t}\n} );\n\nfunction sibling( cur, dir ) {\n\twhile ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {}\n\treturn cur;\n}\n\njQuery.each( {\n\tparent: function( elem ) {\n\t\tvar parent = elem.parentNode;\n\t\treturn parent && parent.nodeType !== 11 ? parent : null;\n\t},\n\tparents: function( elem ) {\n\t\treturn dir( elem, \"parentNode\" );\n\t},\n\tparentsUntil: function( elem, i, until ) {\n\t\treturn dir( elem, \"parentNode\", until );\n\t},\n\tnext: function( elem ) {\n\t\treturn sibling( elem, \"nextSibling\" );\n\t},\n\tprev: function( elem ) {\n\t\treturn sibling( elem, \"previousSibling\" );\n\t},\n\tnextAll: function( elem ) {\n\t\treturn dir( elem, \"nextSibling\" );\n\t},\n\tprevAll: function( elem ) {\n\t\treturn dir( elem, \"previousSibling\" );\n\t},\n\tnextUntil: function( elem, i, until ) {\n\t\treturn dir( elem, \"nextSibling\", until );\n\t},\n\tprevUntil: function( elem, i, until ) {\n\t\treturn dir( elem, \"previousSibling\", until );\n\t},\n\tsiblings: function( elem ) {\n\t\treturn siblings( ( elem.parentNode || {} ).firstChild, elem );\n\t},\n\tchildren: function( elem ) {\n\t\treturn siblings( elem.firstChild );\n\t},\n\tcontents: function( elem ) {\n\t\treturn elem.contentDocument || jQuery.merge( [], elem.childNodes );\n\t}\n}, function( name, fn ) {\n\tjQuery.fn[ name ] = function( until, selector ) {\n\t\tvar matched = jQuery.map( this, fn, until );\n\n\t\tif ( name.slice( -5 ) !== \"Until\" ) {\n\t\t\tselector = until;\n\t\t}\n\n\t\tif ( selector && typeof selector === \"string\" ) {\n\t\t\tmatched = jQuery.filter( selector, matched );\n\t\t}\n\n\t\tif ( this.length > 1 ) {\n\n\t\t\t// Remove duplicates\n\t\t\tif ( !guaranteedUnique[ name ] ) {\n\t\t\t\tjQuery.uniqueSort( matched );\n\t\t\t}\n\n\t\t\t// Reverse order for parents* and prev-derivatives\n\t\t\tif ( rparentsprev.test( name ) ) {\n\t\t\t\tmatched.reverse();\n\t\t\t}\n\t\t}\n\n\t\treturn this.pushStack( matched );\n\t};\n} );\nvar rnotwhite = ( /\\S+/g );\n\n\n\n// Convert String-formatted options into Object-formatted ones\nfunction createOptions( options ) {\n\tvar object = {};\n\tjQuery.each( options.match( rnotwhite ) || [], function( _, flag ) {\n\t\tobject[ flag ] = true;\n\t} );\n\treturn object;\n}\n\n/*\n * Create a callback list using the following parameters:\n *\n *\toptions: an optional list of space-separated options that will change how\n *\t\t\tthe callback list behaves or a more traditional option object\n *\n * By default a callback list will act like an event callback list and can be\n * \"fired\" multiple times.\n *\n * Possible options:\n *\n *\tonce:\t\t\twill ensure the callback list can only be fired once (like a Deferred)\n *\n *\tmemory:\t\t\twill keep track of previous values and will call any callback added\n *\t\t\t\t\tafter the list has been fired right away with the latest \"memorized\"\n *\t\t\t\t\tvalues (like a Deferred)\n *\n *\tunique:\t\t\twill ensure a callback can only be added once (no duplicate in the list)\n *\n *\tstopOnFalse:\tinterrupt callings when a callback returns false\n *\n */\njQuery.Callbacks = function( options ) {\n\n\t// Convert options from String-formatted to Object-formatted if needed\n\t// (we check in cache first)\n\toptions = typeof options === \"string\" ?\n\t\tcreateOptions( options ) :\n\t\tjQuery.extend( {}, options );\n\n\tvar // Flag to know if list is currently firing\n\t\tfiring,\n\n\t\t// Last fire value for non-forgettable lists\n\t\tmemory,\n\n\t\t// Flag to know if list was already fired\n\t\tfired,\n\n\t\t// Flag to prevent firing\n\t\tlocked,\n\n\t\t// Actual callback list\n\t\tlist = [],\n\n\t\t// Queue of execution data for repeatable lists\n\t\tqueue = [],\n\n\t\t// Index of currently firing callback (modified by add/remove as needed)\n\t\tfiringIndex = -1,\n\n\t\t// Fire callbacks\n\t\tfire = function() {\n\n\t\t\t// Enforce single-firing\n\t\t\tlocked = options.once;\n\n\t\t\t// Execute callbacks for all pending executions,\n\t\t\t// respecting firingIndex overrides and runtime changes\n\t\t\tfired = firing = true;\n\t\t\tfor ( ; queue.length; firingIndex = -1 ) {\n\t\t\t\tmemory = queue.shift();\n\t\t\t\twhile ( ++firingIndex < list.length ) {\n\n\t\t\t\t\t// Run callback and check for early termination\n\t\t\t\t\tif ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false &&\n\t\t\t\t\t\toptions.stopOnFalse ) {\n\n\t\t\t\t\t\t// Jump to end and forget the data so .add doesn't re-fire\n\t\t\t\t\t\tfiringIndex = list.length;\n\t\t\t\t\t\tmemory = false;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Forget the data if we're done with it\n\t\t\tif ( !options.memory ) {\n\t\t\t\tmemory = false;\n\t\t\t}\n\n\t\t\tfiring = false;\n\n\t\t\t// Clean up if we're done firing for good\n\t\t\tif ( locked ) {\n\n\t\t\t\t// Keep an empty list if we have data for future add calls\n\t\t\t\tif ( memory ) {\n\t\t\t\t\tlist = [];\n\n\t\t\t\t// Otherwise, this object is spent\n\t\t\t\t} else {\n\t\t\t\t\tlist = \"\";\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\n\t\t// Actual Callbacks object\n\t\tself = {\n\n\t\t\t// Add a callback or a collection of callbacks to the list\n\t\t\tadd: function() {\n\t\t\t\tif ( list ) {\n\n\t\t\t\t\t// If we have memory from a past run, we should fire after adding\n\t\t\t\t\tif ( memory && !firing ) {\n\t\t\t\t\t\tfiringIndex = list.length - 1;\n\t\t\t\t\t\tqueue.push( memory );\n\t\t\t\t\t}\n\n\t\t\t\t\t( function add( args ) {\n\t\t\t\t\t\tjQuery.each( args, function( _, arg ) {\n\t\t\t\t\t\t\tif ( jQuery.isFunction( arg ) ) {\n\t\t\t\t\t\t\t\tif ( !options.unique || !self.has( arg ) ) {\n\t\t\t\t\t\t\t\t\tlist.push( arg );\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} else if ( arg && arg.length && jQuery.type( arg ) !== \"string\" ) {\n\n\t\t\t\t\t\t\t\t// Inspect recursively\n\t\t\t\t\t\t\t\tadd( arg );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} );\n\t\t\t\t\t} )( arguments );\n\n\t\t\t\t\tif ( memory && !firing ) {\n\t\t\t\t\t\tfire();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// Remove a callback from the list\n\t\t\tremove: function() {\n\t\t\t\tjQuery.each( arguments, function( _, arg ) {\n\t\t\t\t\tvar index;\n\t\t\t\t\twhile ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {\n\t\t\t\t\t\tlist.splice( index, 1 );\n\n\t\t\t\t\t\t// Handle firing indexes\n\t\t\t\t\t\tif ( index <= firingIndex ) {\n\t\t\t\t\t\t\tfiringIndex--;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} );\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// Check if a given callback is in the list.\n\t\t\t// If no argument is given, return whether or not list has callbacks attached.\n\t\t\thas: function( fn ) {\n\t\t\t\treturn fn ?\n\t\t\t\t\tjQuery.inArray( fn, list ) > -1 :\n\t\t\t\t\tlist.length > 0;\n\t\t\t},\n\n\t\t\t// Remove all callbacks from the list\n\t\t\tempty: function() {\n\t\t\t\tif ( list ) {\n\t\t\t\t\tlist = [];\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// Disable .fire and .add\n\t\t\t// Abort any current/pending executions\n\t\t\t// Clear all callbacks and values\n\t\t\tdisable: function() {\n\t\t\t\tlocked = queue = [];\n\t\t\t\tlist = memory = \"\";\n\t\t\t\treturn this;\n\t\t\t},\n\t\t\tdisabled: function() {\n\t\t\t\treturn !list;\n\t\t\t},\n\n\t\t\t// Disable .fire\n\t\t\t// Also disable .add unless we have memory (since it would have no effect)\n\t\t\t// Abort any pending executions\n\t\t\tlock: function() {\n\t\t\t\tlocked = queue = [];\n\t\t\t\tif ( !memory ) {\n\t\t\t\t\tlist = memory = \"\";\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t},\n\t\t\tlocked: function() {\n\t\t\t\treturn !!locked;\n\t\t\t},\n\n\t\t\t// Call all callbacks with the given context and arguments\n\t\t\tfireWith: function( context, args ) {\n\t\t\t\tif ( !locked ) {\n\t\t\t\t\targs = args || [];\n\t\t\t\t\targs = [ context, args.slice ? args.slice() : args ];\n\t\t\t\t\tqueue.push( args );\n\t\t\t\t\tif ( !firing ) {\n\t\t\t\t\t\tfire();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// Call all the callbacks with the given arguments\n\t\t\tfire: function() {\n\t\t\t\tself.fireWith( this, arguments );\n\t\t\t\treturn this;\n\t\t\t},\n\n\t\t\t// To know if the callbacks have already been called at least once\n\t\t\tfired: function() {\n\t\t\t\treturn !!fired;\n\t\t\t}\n\t\t};\n\n\treturn self;\n};\n\n\njQuery.extend( {\n\n\tDeferred: function( func ) {\n\t\tvar tuples = [\n\n\t\t\t\t// action, add listener, listener list, final state\n\t\t\t\t[ \"resolve\", \"done\", jQuery.Callbacks( \"once memory\" ), \"resolved\" ],\n\t\t\t\t[ \"reject\", \"fail\", jQuery.Callbacks( \"once memory\" ), \"rejected\" ],\n\t\t\t\t[ \"notify\", \"progress\", jQuery.Callbacks( \"memory\" ) ]\n\t\t\t],\n\t\t\tstate = \"pending\",\n\t\t\tpromise = {\n\t\t\t\tstate: function() {\n\t\t\t\t\treturn state;\n\t\t\t\t},\n\t\t\t\talways: function() {\n\t\t\t\t\tdeferred.done( arguments ).fail( arguments );\n\t\t\t\t\treturn this;\n\t\t\t\t},\n\t\t\t\tthen: function( /* fnDone, fnFail, fnProgress */ ) {\n\t\t\t\t\tvar fns = arguments;\n\t\t\t\t\treturn jQuery.Deferred( function( newDefer ) {\n\t\t\t\t\t\tjQuery.each( tuples, function( i, tuple ) {\n\t\t\t\t\t\t\tvar fn = jQuery.isFunction( fns[ i ] ) && fns[ i ];\n\n\t\t\t\t\t\t\t// deferred[ done | fail | progress ] for forwarding actions to newDefer\n\t\t\t\t\t\t\tdeferred[ tuple[ 1 ] ]( function() {\n\t\t\t\t\t\t\t\tvar returned = fn && fn.apply( this, arguments );\n\t\t\t\t\t\t\t\tif ( returned && jQuery.isFunction( returned.promise ) ) {\n\t\t\t\t\t\t\t\t\treturned.promise()\n\t\t\t\t\t\t\t\t\t\t.progress( newDefer.notify )\n\t\t\t\t\t\t\t\t\t\t.done( newDefer.resolve )\n\t\t\t\t\t\t\t\t\t\t.fail( newDefer.reject );\n\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\tnewDefer[ tuple[ 0 ] + \"With\" ](\n\t\t\t\t\t\t\t\t\t\tthis === promise ? newDefer.promise() : this,\n\t\t\t\t\t\t\t\t\t\tfn ? [ returned ] : arguments\n\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} );\n\t\t\t\t\t\t} );\n\t\t\t\t\t\tfns = null;\n\t\t\t\t\t} ).promise();\n\t\t\t\t},\n\n\t\t\t\t// Get a promise for this deferred\n\t\t\t\t// If obj is provided, the promise aspect is added to the object\n\t\t\t\tpromise: function( obj ) {\n\t\t\t\t\treturn obj != null ? jQuery.extend( obj, promise ) : promise;\n\t\t\t\t}\n\t\t\t},\n\t\t\tdeferred = {};\n\n\t\t// Keep pipe for back-compat\n\t\tpromise.pipe = promise.then;\n\n\t\t// Add list-specific methods\n\t\tjQuery.each( tuples, function( i, tuple ) {\n\t\t\tvar list = tuple[ 2 ],\n\t\t\t\tstateString = tuple[ 3 ];\n\n\t\t\t// promise[ done | fail | progress ] = list.add\n\t\t\tpromise[ tuple[ 1 ] ] = list.add;\n\n\t\t\t// Handle state\n\t\t\tif ( stateString ) {\n\t\t\t\tlist.add( function() {\n\n\t\t\t\t\t// state = [ resolved | rejected ]\n\t\t\t\t\tstate = stateString;\n\n\t\t\t\t// [ reject_list | resolve_list ].disable; progress_list.lock\n\t\t\t\t}, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock );\n\t\t\t}\n\n\t\t\t// deferred[ resolve | reject | notify ]\n\t\t\tdeferred[ tuple[ 0 ] ] = function() {\n\t\t\t\tdeferred[ tuple[ 0 ] + \"With\" ]( this === deferred ? promise : this, arguments );\n\t\t\t\treturn this;\n\t\t\t};\n\t\t\tdeferred[ tuple[ 0 ] + \"With\" ] = list.fireWith;\n\t\t} );\n\n\t\t// Make the deferred a promise\n\t\tpromise.promise( deferred );\n\n\t\t// Call given func if any\n\t\tif ( func ) {\n\t\t\tfunc.call( deferred, deferred );\n\t\t}\n\n\t\t// All done!\n\t\treturn deferred;\n\t},\n\n\t// Deferred helper\n\twhen: function( subordinate /* , ..., subordinateN */ ) {\n\t\tvar i = 0,\n\t\t\tresolveValues = slice.call( arguments ),\n\t\t\tlength = resolveValues.length,\n\n\t\t\t// the count of uncompleted subordinates\n\t\t\tremaining = length !== 1 ||\n\t\t\t\t( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0,\n\n\t\t\t// the master Deferred.\n\t\t\t// If resolveValues consist of only a single Deferred, just use that.\n\t\t\tdeferred = remaining === 1 ? subordinate : jQuery.Deferred(),\n\n\t\t\t// Update function for both resolve and progress values\n\t\t\tupdateFunc = function( i, contexts, values ) {\n\t\t\t\treturn function( value ) {\n\t\t\t\t\tcontexts[ i ] = this;\n\t\t\t\t\tvalues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;\n\t\t\t\t\tif ( values === progressValues ) {\n\t\t\t\t\t\tdeferred.notifyWith( contexts, values );\n\t\t\t\t\t} else if ( !( --remaining ) ) {\n\t\t\t\t\t\tdeferred.resolveWith( contexts, values );\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t\t},\n\n\t\t\tprogressValues, progressContexts, resolveContexts;\n\n\t\t// Add listeners to Deferred subordinates; treat others as resolved\n\t\tif ( length > 1 ) {\n\t\t\tprogressValues = new Array( length );\n\t\t\tprogressContexts = new Array( length );\n\t\t\tresolveContexts = new Array( length );\n\t\t\tfor ( ; i < length; i++ ) {\n\t\t\t\tif ( resolveValues[ i ] && jQuery.isFunction( resolveValues[ i ].promise ) ) {\n\t\t\t\t\tresolveValues[ i ].promise()\n\t\t\t\t\t\t.progress( updateFunc( i, progressContexts, progressValues ) )\n\t\t\t\t\t\t.done( updateFunc( i, resolveContexts, resolveValues ) )\n\t\t\t\t\t\t.fail( deferred.reject );\n\t\t\t\t} else {\n\t\t\t\t\t--remaining;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// If we're not waiting on anything, resolve the master\n\t\tif ( !remaining ) {\n\t\t\tdeferred.resolveWith( resolveContexts, resolveValues );\n\t\t}\n\n\t\treturn deferred.promise();\n\t}\n} );\n\n\n// The deferred used on DOM ready\nvar readyList;\n\njQuery.fn.ready = function( fn ) {\n\n\t// Add the callback\n\tjQuery.ready.promise().done( fn );\n\n\treturn this;\n};\n\njQuery.extend( {\n\n\t// Is the DOM ready to be used? Set to true once it occurs.\n\tisReady: false,\n\n\t// A counter to track how many items to wait for before\n\t// the ready event fires. See #6781\n\treadyWait: 1,\n\n\t// Hold (or release) the ready event\n\tholdReady: function( hold ) {\n\t\tif ( hold ) {\n\t\t\tjQuery.readyWait++;\n\t\t} else {\n\t\t\tjQuery.ready( true );\n\t\t}\n\t},\n\n\t// Handle when the DOM is ready\n\tready: function( wait ) {\n\n\t\t// Abort if there are pending holds or we're already ready\n\t\tif ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Remember that the DOM is ready\n\t\tjQuery.isReady = true;\n\n\t\t// If a normal DOM Ready event fired, decrement, and wait if need be\n\t\tif ( wait !== true && --jQuery.readyWait > 0 ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// If there are functions bound, to execute\n\t\treadyList.resolveWith( document, [ jQuery ] );\n\n\t\t// Trigger any bound ready events\n\t\tif ( jQuery.fn.triggerHandler ) {\n\t\t\tjQuery( document ).triggerHandler( \"ready\" );\n\t\t\tjQuery( document ).off( \"ready\" );\n\t\t}\n\t}\n} );\n\n/**\n * The ready event handler and self cleanup method\n */\nfunction completed() {\n\tdocument.removeEventListener( \"DOMContentLoaded\", completed );\n\twindow.removeEventListener( \"load\", completed );\n\tjQuery.ready();\n}\n\njQuery.ready.promise = function( obj ) {\n\tif ( !readyList ) {\n\n\t\treadyList = jQuery.Deferred();\n\n\t\t// Catch cases where $(document).ready() is called\n\t\t// after the browser event has already occurred.\n\t\t// Support: IE9-10 only\n\t\t// Older IE sometimes signals \"interactive\" too soon\n\t\tif ( document.readyState === \"complete\" ||\n\t\t\t( document.readyState !== \"loading\" && !document.documentElement.doScroll ) ) {\n\n\t\t\t// Handle it asynchronously to allow scripts the opportunity to delay ready\n\t\t\twindow.setTimeout( jQuery.ready );\n\n\t\t} else {\n\n\t\t\t// Use the handy event callback\n\t\t\tdocument.addEventListener( \"DOMContentLoaded\", completed );\n\n\t\t\t// A fallback to window.onload, that will always work\n\t\t\twindow.addEventListener( \"load\", completed );\n\t\t}\n\t}\n\treturn readyList.promise( obj );\n};\n\n// Kick off the DOM ready check even if the user does not\njQuery.ready.promise();\n\n\n\n\n// Multifunctional method to get and set values of a collection\n// The value/s can optionally be executed if it's a function\nvar access = function( elems, fn, key, value, chainable, emptyGet, raw ) {\n\tvar i = 0,\n\t\tlen = elems.length,\n\t\tbulk = key == null;\n\n\t// Sets many values\n\tif ( jQuery.type( key ) === \"object\" ) {\n\t\tchainable = true;\n\t\tfor ( i in key ) {\n\t\t\taccess( elems, fn, i, key[ i ], true, emptyGet, raw );\n\t\t}\n\n\t// Sets one value\n\t} else if ( value !== undefined ) {\n\t\tchainable = true;\n\n\t\tif ( !jQuery.isFunction( value ) ) {\n\t\t\traw = true;\n\t\t}\n\n\t\tif ( bulk ) {\n\n\t\t\t// Bulk operations run against the entire set\n\t\t\tif ( raw ) {\n\t\t\t\tfn.call( elems, value );\n\t\t\t\tfn = null;\n\n\t\t\t// ...except when executing function values\n\t\t\t} else {\n\t\t\t\tbulk = fn;\n\t\t\t\tfn = function( elem, key, value ) {\n\t\t\t\t\treturn bulk.call( jQuery( elem ), value );\n\t\t\t\t};\n\t\t\t}\n\t\t}\n\n\t\tif ( fn ) {\n\t\t\tfor ( ; i < len; i++ ) {\n\t\t\t\tfn(\n\t\t\t\t\telems[ i ], key, raw ?\n\t\t\t\t\tvalue :\n\t\t\t\t\tvalue.call( elems[ i ], i, fn( elems[ i ], key ) )\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\t}\n\n\treturn chainable ?\n\t\telems :\n\n\t\t// Gets\n\t\tbulk ?\n\t\t\tfn.call( elems ) :\n\t\t\tlen ? fn( elems[ 0 ], key ) : emptyGet;\n};\nvar acceptData = function( owner ) {\n\n\t// Accepts only:\n\t//  - Node\n\t//    - Node.ELEMENT_NODE\n\t//    - Node.DOCUMENT_NODE\n\t//  - Object\n\t//    - Any\n\t/* jshint -W018 */\n\treturn owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType );\n};\n\n\n\n\nfunction Data() {\n\tthis.expando = jQuery.expando + Data.uid++;\n}\n\nData.uid = 1;\n\nData.prototype = {\n\n\tregister: function( owner, initial ) {\n\t\tvar value = initial || {};\n\n\t\t// If it is a node unlikely to be stringify-ed or looped over\n\t\t// use plain assignment\n\t\tif ( owner.nodeType ) {\n\t\t\towner[ this.expando ] = value;\n\n\t\t// Otherwise secure it in a non-enumerable, non-writable property\n\t\t// configurability must be true to allow the property to be\n\t\t// deleted with the delete operator\n\t\t} else {\n\t\t\tObject.defineProperty( owner, this.expando, {\n\t\t\t\tvalue: value,\n\t\t\t\twritable: true,\n\t\t\t\tconfigurable: true\n\t\t\t} );\n\t\t}\n\t\treturn owner[ this.expando ];\n\t},\n\tcache: function( owner ) {\n\n\t\t// We can accept data for non-element nodes in modern browsers,\n\t\t// but we should not, see #8335.\n\t\t// Always return an empty object.\n\t\tif ( !acceptData( owner ) ) {\n\t\t\treturn {};\n\t\t}\n\n\t\t// Check if the owner object already has a cache\n\t\tvar value = owner[ this.expando ];\n\n\t\t// If not, create one\n\t\tif ( !value ) {\n\t\t\tvalue = {};\n\n\t\t\t// We can accept data for non-element nodes in modern browsers,\n\t\t\t// but we should not, see #8335.\n\t\t\t// Always return an empty object.\n\t\t\tif ( acceptData( owner ) ) {\n\n\t\t\t\t// If it is a node unlikely to be stringify-ed or looped over\n\t\t\t\t// use plain assignment\n\t\t\t\tif ( owner.nodeType ) {\n\t\t\t\t\towner[ this.expando ] = value;\n\n\t\t\t\t// Otherwise secure it in a non-enumerable property\n\t\t\t\t// configurable must be true to allow the property to be\n\t\t\t\t// deleted when data is removed\n\t\t\t\t} else {\n\t\t\t\t\tObject.defineProperty( owner, this.expando, {\n\t\t\t\t\t\tvalue: value,\n\t\t\t\t\t\tconfigurable: true\n\t\t\t\t\t} );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn value;\n\t},\n\tset: function( owner, data, value ) {\n\t\tvar prop,\n\t\t\tcache = this.cache( owner );\n\n\t\t// Handle: [ owner, key, value ] args\n\t\tif ( typeof data === \"string\" ) {\n\t\t\tcache[ data ] = value;\n\n\t\t// Handle: [ owner, { properties } ] args\n\t\t} else {\n\n\t\t\t// Copy the properties one-by-one to the cache object\n\t\t\tfor ( prop in data ) {\n\t\t\t\tcache[ prop ] = data[ prop ];\n\t\t\t}\n\t\t}\n\t\treturn cache;\n\t},\n\tget: function( owner, key ) {\n\t\treturn key === undefined ?\n\t\t\tthis.cache( owner ) :\n\t\t\towner[ this.expando ] && owner[ this.expando ][ key ];\n\t},\n\taccess: function( owner, key, value ) {\n\t\tvar stored;\n\n\t\t// In cases where either:\n\t\t//\n\t\t//   1. No key was specified\n\t\t//   2. A string key was specified, but no value provided\n\t\t//\n\t\t// Take the \"read\" path and allow the get method to determine\n\t\t// which value to return, respectively either:\n\t\t//\n\t\t//   1. The entire cache object\n\t\t//   2. The data stored at the key\n\t\t//\n\t\tif ( key === undefined ||\n\t\t\t\t( ( key && typeof key === \"string\" ) && value === undefined ) ) {\n\n\t\t\tstored = this.get( owner, key );\n\n\t\t\treturn stored !== undefined ?\n\t\t\t\tstored : this.get( owner, jQuery.camelCase( key ) );\n\t\t}\n\n\t\t// When the key is not a string, or both a key and value\n\t\t// are specified, set or extend (existing objects) with either:\n\t\t//\n\t\t//   1. An object of properties\n\t\t//   2. A key and value\n\t\t//\n\t\tthis.set( owner, key, value );\n\n\t\t// Since the \"set\" path can have two possible entry points\n\t\t// return the expected data based on which path was taken[*]\n\t\treturn value !== undefined ? value : key;\n\t},\n\tremove: function( owner, key ) {\n\t\tvar i, name, camel,\n\t\t\tcache = owner[ this.expando ];\n\n\t\tif ( cache === undefined ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( key === undefined ) {\n\t\t\tthis.register( owner );\n\n\t\t} else {\n\n\t\t\t// Support array or space separated string of keys\n\t\t\tif ( jQuery.isArray( key ) ) {\n\n\t\t\t\t// If \"name\" is an array of keys...\n\t\t\t\t// When data is initially created, via (\"key\", \"val\") signature,\n\t\t\t\t// keys will be converted to camelCase.\n\t\t\t\t// Since there is no way to tell _how_ a key was added, remove\n\t\t\t\t// both plain key and camelCase key. #12786\n\t\t\t\t// This will only penalize the array argument path.\n\t\t\t\tname = key.concat( key.map( jQuery.camelCase ) );\n\t\t\t} else {\n\t\t\t\tcamel = jQuery.camelCase( key );\n\n\t\t\t\t// Try the string as a key before any manipulation\n\t\t\t\tif ( key in cache ) {\n\t\t\t\t\tname = [ key, camel ];\n\t\t\t\t} else {\n\n\t\t\t\t\t// If a key with the spaces exists, use it.\n\t\t\t\t\t// Otherwise, create an array by matching non-whitespace\n\t\t\t\t\tname = camel;\n\t\t\t\t\tname = name in cache ?\n\t\t\t\t\t\t[ name ] : ( name.match( rnotwhite ) || [] );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\ti = name.length;\n\n\t\t\twhile ( i-- ) {\n\t\t\t\tdelete cache[ name[ i ] ];\n\t\t\t}\n\t\t}\n\n\t\t// Remove the expando if there's no more data\n\t\tif ( key === undefined || jQuery.isEmptyObject( cache ) ) {\n\n\t\t\t// Support: Chrome <= 35-45+\n\t\t\t// Webkit & Blink performance suffers when deleting properties\n\t\t\t// from DOM nodes, so set to undefined instead\n\t\t\t// https://code.google.com/p/chromium/issues/detail?id=378607\n\t\t\tif ( owner.nodeType ) {\n\t\t\t\towner[ this.expando ] = undefined;\n\t\t\t} else {\n\t\t\t\tdelete owner[ this.expando ];\n\t\t\t}\n\t\t}\n\t},\n\thasData: function( owner ) {\n\t\tvar cache = owner[ this.expando ];\n\t\treturn cache !== undefined && !jQuery.isEmptyObject( cache );\n\t}\n};\nvar dataPriv = new Data();\n\nvar dataUser = new Data();\n\n\n\n//\tImplementation Summary\n//\n//\t1. Enforce API surface and semantic compatibility with 1.9.x branch\n//\t2. Improve the module's maintainability by reducing the storage\n//\t\tpaths to a single mechanism.\n//\t3. Use the same single mechanism to support \"private\" and \"user\" data.\n//\t4. _Never_ expose \"private\" data to user code (TODO: Drop _data, _removeData)\n//\t5. Avoid exposing implementation details on user objects (eg. expando properties)\n//\t6. Provide a clear path for implementation upgrade to WeakMap in 2014\n\nvar rbrace = /^(?:\\{[\\w\\W]*\\}|\\[[\\w\\W]*\\])$/,\n\trmultiDash = /[A-Z]/g;\n\nfunction dataAttr( elem, key, data ) {\n\tvar name;\n\n\t// If nothing was found internally, try to fetch any\n\t// data from the HTML5 data-* attribute\n\tif ( data === undefined && elem.nodeType === 1 ) {\n\t\tname = \"data-\" + key.replace( rmultiDash, \"-$&\" ).toLowerCase();\n\t\tdata = elem.getAttribute( name );\n\n\t\tif ( typeof data === \"string\" ) {\n\t\t\ttry {\n\t\t\t\tdata = data === \"true\" ? true :\n\t\t\t\t\tdata === \"false\" ? false :\n\t\t\t\t\tdata === \"null\" ? null :\n\n\t\t\t\t\t// Only convert to a number if it doesn't change the string\n\t\t\t\t\t+data + \"\" === data ? +data :\n\t\t\t\t\trbrace.test( data ) ? jQuery.parseJSON( data ) :\n\t\t\t\t\tdata;\n\t\t\t} catch ( e ) {}\n\n\t\t\t// Make sure we set the data so it isn't changed later\n\t\t\tdataUser.set( elem, key, data );\n\t\t} else {\n\t\t\tdata = undefined;\n\t\t}\n\t}\n\treturn data;\n}\n\njQuery.extend( {\n\thasData: function( elem ) {\n\t\treturn dataUser.hasData( elem ) || dataPriv.hasData( elem );\n\t},\n\n\tdata: function( elem, name, data ) {\n\t\treturn dataUser.access( elem, name, data );\n\t},\n\n\tremoveData: function( elem, name ) {\n\t\tdataUser.remove( elem, name );\n\t},\n\n\t// TODO: Now that all calls to _data and _removeData have been replaced\n\t// with direct calls to dataPriv methods, these can be deprecated.\n\t_data: function( elem, name, data ) {\n\t\treturn dataPriv.access( elem, name, data );\n\t},\n\n\t_removeData: function( elem, name ) {\n\t\tdataPriv.remove( elem, name );\n\t}\n} );\n\njQuery.fn.extend( {\n\tdata: function( key, value ) {\n\t\tvar i, name, data,\n\t\t\telem = this[ 0 ],\n\t\t\tattrs = elem && elem.attributes;\n\n\t\t// Gets all values\n\t\tif ( key === undefined ) {\n\t\t\tif ( this.length ) {\n\t\t\t\tdata = dataUser.get( elem );\n\n\t\t\t\tif ( elem.nodeType === 1 && !dataPriv.get( elem, \"hasDataAttrs\" ) ) {\n\t\t\t\t\ti = attrs.length;\n\t\t\t\t\twhile ( i-- ) {\n\n\t\t\t\t\t\t// Support: IE11+\n\t\t\t\t\t\t// The attrs elements can be null (#14894)\n\t\t\t\t\t\tif ( attrs[ i ] ) {\n\t\t\t\t\t\t\tname = attrs[ i ].name;\n\t\t\t\t\t\t\tif ( name.indexOf( \"data-\" ) === 0 ) {\n\t\t\t\t\t\t\t\tname = jQuery.camelCase( name.slice( 5 ) );\n\t\t\t\t\t\t\t\tdataAttr( elem, name, data[ name ] );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tdataPriv.set( elem, \"hasDataAttrs\", true );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn data;\n\t\t}\n\n\t\t// Sets multiple values\n\t\tif ( typeof key === \"object\" ) {\n\t\t\treturn this.each( function() {\n\t\t\t\tdataUser.set( this, key );\n\t\t\t} );\n\t\t}\n\n\t\treturn access( this, function( value ) {\n\t\t\tvar data, camelKey;\n\n\t\t\t// The calling jQuery object (element matches) is not empty\n\t\t\t// (and therefore has an element appears at this[ 0 ]) and the\n\t\t\t// `value` parameter was not undefined. An empty jQuery object\n\t\t\t// will result in `undefined` for elem = this[ 0 ] which will\n\t\t\t// throw an exception if an attempt to read a data cache is made.\n\t\t\tif ( elem && value === undefined ) {\n\n\t\t\t\t// Attempt to get data from the cache\n\t\t\t\t// with the key as-is\n\t\t\t\tdata = dataUser.get( elem, key ) ||\n\n\t\t\t\t\t// Try to find dashed key if it exists (gh-2779)\n\t\t\t\t\t// This is for 2.2.x only\n\t\t\t\t\tdataUser.get( elem, key.replace( rmultiDash, \"-$&\" ).toLowerCase() );\n\n\t\t\t\tif ( data !== undefined ) {\n\t\t\t\t\treturn data;\n\t\t\t\t}\n\n\t\t\t\tcamelKey = jQuery.camelCase( key );\n\n\t\t\t\t// Attempt to get data from the cache\n\t\t\t\t// with the key camelized\n\t\t\t\tdata = dataUser.get( elem, camelKey );\n\t\t\t\tif ( data !== undefined ) {\n\t\t\t\t\treturn data;\n\t\t\t\t}\n\n\t\t\t\t// Attempt to \"discover\" the data in\n\t\t\t\t// HTML5 custom data-* attrs\n\t\t\t\tdata = dataAttr( elem, camelKey, undefined );\n\t\t\t\tif ( data !== undefined ) {\n\t\t\t\t\treturn data;\n\t\t\t\t}\n\n\t\t\t\t// We tried really hard, but the data doesn't exist.\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// Set the data...\n\t\t\tcamelKey = jQuery.camelCase( key );\n\t\t\tthis.each( function() {\n\n\t\t\t\t// First, attempt to store a copy or reference of any\n\t\t\t\t// data that might've been store with a camelCased key.\n\t\t\t\tvar data = dataUser.get( this, camelKey );\n\n\t\t\t\t// For HTML5 data-* attribute interop, we have to\n\t\t\t\t// store property names with dashes in a camelCase form.\n\t\t\t\t// This might not apply to all properties...*\n\t\t\t\tdataUser.set( this, camelKey, value );\n\n\t\t\t\t// *... In the case of properties that might _actually_\n\t\t\t\t// have dashes, we need to also store a copy of that\n\t\t\t\t// unchanged property.\n\t\t\t\tif ( key.indexOf( \"-\" ) > -1 && data !== undefined ) {\n\t\t\t\t\tdataUser.set( this, key, value );\n\t\t\t\t}\n\t\t\t} );\n\t\t}, null, value, arguments.length > 1, null, true );\n\t},\n\n\tremoveData: function( key ) {\n\t\treturn this.each( function() {\n\t\t\tdataUser.remove( this, key );\n\t\t} );\n\t}\n} );\n\n\njQuery.extend( {\n\tqueue: function( elem, type, data ) {\n\t\tvar queue;\n\n\t\tif ( elem ) {\n\t\t\ttype = ( type || \"fx\" ) + \"queue\";\n\t\t\tqueue = dataPriv.get( elem, type );\n\n\t\t\t// Speed up dequeue by getting out quickly if this is just a lookup\n\t\t\tif ( data ) {\n\t\t\t\tif ( !queue || jQuery.isArray( data ) ) {\n\t\t\t\t\tqueue = dataPriv.access( elem, type, jQuery.makeArray( data ) );\n\t\t\t\t} else {\n\t\t\t\t\tqueue.push( data );\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn queue || [];\n\t\t}\n\t},\n\n\tdequeue: function( elem, type ) {\n\t\ttype = type || \"fx\";\n\n\t\tvar queue = jQuery.queue( elem, type ),\n\t\t\tstartLength = queue.length,\n\t\t\tfn = queue.shift(),\n\t\t\thooks = jQuery._queueHooks( elem, type ),\n\t\t\tnext = function() {\n\t\t\t\tjQuery.dequeue( elem, type );\n\t\t\t};\n\n\t\t// If the fx queue is dequeued, always remove the progress sentinel\n\t\tif ( fn === \"inprogress\" ) {\n\t\t\tfn = queue.shift();\n\t\t\tstartLength--;\n\t\t}\n\n\t\tif ( fn ) {\n\n\t\t\t// Add a progress sentinel to prevent the fx queue from being\n\t\t\t// automatically dequeued\n\t\t\tif ( type === \"fx\" ) {\n\t\t\t\tqueue.unshift( \"inprogress\" );\n\t\t\t}\n\n\t\t\t// Clear up the last queue stop function\n\t\t\tdelete hooks.stop;\n\t\t\tfn.call( elem, next, hooks );\n\t\t}\n\n\t\tif ( !startLength && hooks ) {\n\t\t\thooks.empty.fire();\n\t\t}\n\t},\n\n\t// Not public - generate a queueHooks object, or return the current one\n\t_queueHooks: function( elem, type ) {\n\t\tvar key = type + \"queueHooks\";\n\t\treturn dataPriv.get( elem, key ) || dataPriv.access( elem, key, {\n\t\t\tempty: jQuery.Callbacks( \"once memory\" ).add( function() {\n\t\t\t\tdataPriv.remove( elem, [ type + \"queue\", key ] );\n\t\t\t} )\n\t\t} );\n\t}\n} );\n\njQuery.fn.extend( {\n\tqueue: function( type, data ) {\n\t\tvar setter = 2;\n\n\t\tif ( typeof type !== \"string\" ) {\n\t\t\tdata = type;\n\t\t\ttype = \"fx\";\n\t\t\tsetter--;\n\t\t}\n\n\t\tif ( arguments.length < setter ) {\n\t\t\treturn jQuery.queue( this[ 0 ], type );\n\t\t}\n\n\t\treturn data === undefined ?\n\t\t\tthis :\n\t\t\tthis.each( function() {\n\t\t\t\tvar queue = jQuery.queue( this, type, data );\n\n\t\t\t\t// Ensure a hooks for this queue\n\t\t\t\tjQuery._queueHooks( this, type );\n\n\t\t\t\tif ( type === \"fx\" && queue[ 0 ] !== \"inprogress\" ) {\n\t\t\t\t\tjQuery.dequeue( this, type );\n\t\t\t\t}\n\t\t\t} );\n\t},\n\tdequeue: function( type ) {\n\t\treturn this.each( function() {\n\t\t\tjQuery.dequeue( this, type );\n\t\t} );\n\t},\n\tclearQueue: function( type ) {\n\t\treturn this.queue( type || \"fx\", [] );\n\t},\n\n\t// Get a promise resolved when queues of a certain type\n\t// are emptied (fx is the type by default)\n\tpromise: function( type, obj ) {\n\t\tvar tmp,\n\t\t\tcount = 1,\n\t\t\tdefer = jQuery.Deferred(),\n\t\t\telements = this,\n\t\t\ti = this.length,\n\t\t\tresolve = function() {\n\t\t\t\tif ( !( --count ) ) {\n\t\t\t\t\tdefer.resolveWith( elements, [ elements ] );\n\t\t\t\t}\n\t\t\t};\n\n\t\tif ( typeof type !== \"string\" ) {\n\t\t\tobj = type;\n\t\t\ttype = undefined;\n\t\t}\n\t\ttype = type || \"fx\";\n\n\t\twhile ( i-- ) {\n\t\t\ttmp = dataPriv.get( elements[ i ], type + \"queueHooks\" );\n\t\t\tif ( tmp && tmp.empty ) {\n\t\t\t\tcount++;\n\t\t\t\ttmp.empty.add( resolve );\n\t\t\t}\n\t\t}\n\t\tresolve();\n\t\treturn defer.promise( obj );\n\t}\n} );\nvar pnum = ( /[+-]?(?:\\d*\\.|)\\d+(?:[eE][+-]?\\d+|)/ ).source;\n\nvar rcssNum = new RegExp( \"^(?:([+-])=|)(\" + pnum + \")([a-z%]*)$\", \"i\" );\n\n\nvar cssExpand = [ \"Top\", \"Right\", \"Bottom\", \"Left\" ];\n\nvar isHidden = function( elem, el ) {\n\n\t\t// isHidden might be called from jQuery#filter function;\n\t\t// in that case, element will be second argument\n\t\telem = el || elem;\n\t\treturn jQuery.css( elem, \"display\" ) === \"none\" ||\n\t\t\t!jQuery.contains( elem.ownerDocument, elem );\n\t};\n\n\n\nfunction adjustCSS( elem, prop, valueParts, tween ) {\n\tvar adjusted,\n\t\tscale = 1,\n\t\tmaxIterations = 20,\n\t\tcurrentValue = tween ?\n\t\t\tfunction() { return tween.cur(); } :\n\t\t\tfunction() { return jQuery.css( elem, prop, \"\" ); },\n\t\tinitial = currentValue(),\n\t\tunit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? \"\" : \"px\" ),\n\n\t\t// Starting value computation is required for potential unit mismatches\n\t\tinitialInUnit = ( jQuery.cssNumber[ prop ] || unit !== \"px\" && +initial ) &&\n\t\t\trcssNum.exec( jQuery.css( elem, prop ) );\n\n\tif ( initialInUnit && initialInUnit[ 3 ] !== unit ) {\n\n\t\t// Trust units reported by jQuery.css\n\t\tunit = unit || initialInUnit[ 3 ];\n\n\t\t// Make sure we update the tween properties later on\n\t\tvalueParts = valueParts || [];\n\n\t\t// Iteratively approximate from a nonzero starting point\n\t\tinitialInUnit = +initial || 1;\n\n\t\tdo {\n\n\t\t\t// If previous iteration zeroed out, double until we get *something*.\n\t\t\t// Use string for doubling so we don't accidentally see scale as unchanged below\n\t\t\tscale = scale || \".5\";\n\n\t\t\t// Adjust and apply\n\t\t\tinitialInUnit = initialInUnit / scale;\n\t\t\tjQuery.style( elem, prop, initialInUnit + unit );\n\n\t\t// Update scale, tolerating zero or NaN from tween.cur()\n\t\t// Break the loop if scale is unchanged or perfect, or if we've just had enough.\n\t\t} while (\n\t\t\tscale !== ( scale = currentValue() / initial ) && scale !== 1 && --maxIterations\n\t\t);\n\t}\n\n\tif ( valueParts ) {\n\t\tinitialInUnit = +initialInUnit || +initial || 0;\n\n\t\t// Apply relative offset (+=/-=) if specified\n\t\tadjusted = valueParts[ 1 ] ?\n\t\t\tinitialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] :\n\t\t\t+valueParts[ 2 ];\n\t\tif ( tween ) {\n\t\t\ttween.unit = unit;\n\t\t\ttween.start = initialInUnit;\n\t\t\ttween.end = adjusted;\n\t\t}\n\t}\n\treturn adjusted;\n}\nvar rcheckableType = ( /^(?:checkbox|radio)$/i );\n\nvar rtagName = ( /<([\\w:-]+)/ );\n\nvar rscriptType = ( /^$|\\/(?:java|ecma)script/i );\n\n\n\n// We have to close these tags to support XHTML (#13200)\nvar wrapMap = {\n\n\t// Support: IE9\n\toption: [ 1, \"<select multiple='multiple'>\", \"</select>\" ],\n\n\t// XHTML parsers do not magically insert elements in the\n\t// same way that tag soup parsers do. So we cannot shorten\n\t// this by omitting <tbody> or other required elements.\n\tthead: [ 1, \"<table>\", \"</table>\" ],\n\tcol: [ 2, \"<table><colgroup>\", \"</colgroup></table>\" ],\n\ttr: [ 2, \"<table><tbody>\", \"</tbody></table>\" ],\n\ttd: [ 3, \"<table><tbody><tr>\", \"</tr></tbody></table>\" ],\n\n\t_default: [ 0, \"\", \"\" ]\n};\n\n// Support: IE9\nwrapMap.optgroup = wrapMap.option;\n\nwrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;\nwrapMap.th = wrapMap.td;\n\n\nfunction getAll( context, tag ) {\n\n\t// Support: IE9-11+\n\t// Use typeof to avoid zero-argument method invocation on host objects (#15151)\n\tvar ret = typeof context.getElementsByTagName !== \"undefined\" ?\n\t\t\tcontext.getElementsByTagName( tag || \"*\" ) :\n\t\t\ttypeof context.querySelectorAll !== \"undefined\" ?\n\t\t\t\tcontext.querySelectorAll( tag || \"*\" ) :\n\t\t\t[];\n\n\treturn tag === undefined || tag && jQuery.nodeName( context, tag ) ?\n\t\tjQuery.merge( [ context ], ret ) :\n\t\tret;\n}\n\n\n// Mark scripts as having already been evaluated\nfunction setGlobalEval( elems, refElements ) {\n\tvar i = 0,\n\t\tl = elems.length;\n\n\tfor ( ; i < l; i++ ) {\n\t\tdataPriv.set(\n\t\t\telems[ i ],\n\t\t\t\"globalEval\",\n\t\t\t!refElements || dataPriv.get( refElements[ i ], \"globalEval\" )\n\t\t);\n\t}\n}\n\n\nvar rhtml = /<|&#?\\w+;/;\n\nfunction buildFragment( elems, context, scripts, selection, ignored ) {\n\tvar elem, tmp, tag, wrap, contains, j,\n\t\tfragment = context.createDocumentFragment(),\n\t\tnodes = [],\n\t\ti = 0,\n\t\tl = elems.length;\n\n\tfor ( ; i < l; i++ ) {\n\t\telem = elems[ i ];\n\n\t\tif ( elem || elem === 0 ) {\n\n\t\t\t// Add nodes directly\n\t\t\tif ( jQuery.type( elem ) === \"object\" ) {\n\n\t\t\t\t// Support: Android<4.1, PhantomJS<2\n\t\t\t\t// push.apply(_, arraylike) throws on ancient WebKit\n\t\t\t\tjQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );\n\n\t\t\t// Convert non-html into a text node\n\t\t\t} else if ( !rhtml.test( elem ) ) {\n\t\t\t\tnodes.push( context.createTextNode( elem ) );\n\n\t\t\t// Convert html into DOM nodes\n\t\t\t} else {\n\t\t\t\ttmp = tmp || fragment.appendChild( context.createElement( \"div\" ) );\n\n\t\t\t\t// Deserialize a standard representation\n\t\t\t\ttag = ( rtagName.exec( elem ) || [ \"\", \"\" ] )[ 1 ].toLowerCase();\n\t\t\t\twrap = wrapMap[ tag ] || wrapMap._default;\n\t\t\t\ttmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ];\n\n\t\t\t\t// Descend through wrappers to the right content\n\t\t\t\tj = wrap[ 0 ];\n\t\t\t\twhile ( j-- ) {\n\t\t\t\t\ttmp = tmp.lastChild;\n\t\t\t\t}\n\n\t\t\t\t// Support: Android<4.1, PhantomJS<2\n\t\t\t\t// push.apply(_, arraylike) throws on ancient WebKit\n\t\t\t\tjQuery.merge( nodes, tmp.childNodes );\n\n\t\t\t\t// Remember the top-level container\n\t\t\t\ttmp = fragment.firstChild;\n\n\t\t\t\t// Ensure the created nodes are orphaned (#12392)\n\t\t\t\ttmp.textContent = \"\";\n\t\t\t}\n\t\t}\n\t}\n\n\t// Remove wrapper from fragment\n\tfragment.textContent = \"\";\n\n\ti = 0;\n\twhile ( ( elem = nodes[ i++ ] ) ) {\n\n\t\t// Skip elements already in the context collection (trac-4087)\n\t\tif ( selection && jQuery.inArray( elem, selection ) > -1 ) {\n\t\t\tif ( ignored ) {\n\t\t\t\tignored.push( elem );\n\t\t\t}\n\t\t\tcontinue;\n\t\t}\n\n\t\tcontains = jQuery.contains( elem.ownerDocument, elem );\n\n\t\t// Append to fragment\n\t\ttmp = getAll( fragment.appendChild( elem ), \"script\" );\n\n\t\t// Preserve script evaluation history\n\t\tif ( contains ) {\n\t\t\tsetGlobalEval( tmp );\n\t\t}\n\n\t\t// Capture executables\n\t\tif ( scripts ) {\n\t\t\tj = 0;\n\t\t\twhile ( ( elem = tmp[ j++ ] ) ) {\n\t\t\t\tif ( rscriptType.test( elem.type || \"\" ) ) {\n\t\t\t\t\tscripts.push( elem );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn fragment;\n}\n\n\n( function() {\n\tvar fragment = document.createDocumentFragment(),\n\t\tdiv = fragment.appendChild( document.createElement( \"div\" ) ),\n\t\tinput = document.createElement( \"input\" );\n\n\t// Support: Android 4.0-4.3, Safari<=5.1\n\t// Check state lost if the name is set (#11217)\n\t// Support: Windows Web Apps (WWA)\n\t// `name` and `type` must use .setAttribute for WWA (#14901)\n\tinput.setAttribute( \"type\", \"radio\" );\n\tinput.setAttribute( \"checked\", \"checked\" );\n\tinput.setAttribute( \"name\", \"t\" );\n\n\tdiv.appendChild( input );\n\n\t// Support: Safari<=5.1, Android<4.2\n\t// Older WebKit doesn't clone checked state correctly in fragments\n\tsupport.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;\n\n\t// Support: IE<=11+\n\t// Make sure textarea (and checkbox) defaultValue is properly cloned\n\tdiv.innerHTML = \"<textarea>x</textarea>\";\n\tsupport.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;\n} )();\n\n\nvar\n\trkeyEvent = /^key/,\n\trmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/,\n\trtypenamespace = /^([^.]*)(?:\\.(.+)|)/;\n\nfunction returnTrue() {\n\treturn true;\n}\n\nfunction returnFalse() {\n\treturn false;\n}\n\n// Support: IE9\n// See #13393 for more info\nfunction safeActiveElement() {\n\ttry {\n\t\treturn document.activeElement;\n\t} catch ( err ) { }\n}\n\nfunction on( elem, types, selector, data, fn, one ) {\n\tvar origFn, type;\n\n\t// Types can be a map of types/handlers\n\tif ( typeof types === \"object\" ) {\n\n\t\t// ( types-Object, selector, data )\n\t\tif ( typeof selector !== \"string\" ) {\n\n\t\t\t// ( types-Object, data )\n\t\t\tdata = data || selector;\n\t\t\tselector = undefined;\n\t\t}\n\t\tfor ( type in types ) {\n\t\t\ton( elem, type, selector, data, types[ type ], one );\n\t\t}\n\t\treturn elem;\n\t}\n\n\tif ( data == null && fn == null ) {\n\n\t\t// ( types, fn )\n\t\tfn = selector;\n\t\tdata = selector = undefined;\n\t} else if ( fn == null ) {\n\t\tif ( typeof selector === \"string\" ) {\n\n\t\t\t// ( types, selector, fn )\n\t\t\tfn = data;\n\t\t\tdata = undefined;\n\t\t} else {\n\n\t\t\t// ( types, data, fn )\n\t\t\tfn = data;\n\t\t\tdata = selector;\n\t\t\tselector = undefined;\n\t\t}\n\t}\n\tif ( fn === false ) {\n\t\tfn = returnFalse;\n\t} else if ( !fn ) {\n\t\treturn elem;\n\t}\n\n\tif ( one === 1 ) {\n\t\torigFn = fn;\n\t\tfn = function( event ) {\n\n\t\t\t// Can use an empty set, since event contains the info\n\t\t\tjQuery().off( event );\n\t\t\treturn origFn.apply( this, arguments );\n\t\t};\n\n\t\t// Use same guid so caller can remove using origFn\n\t\tfn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );\n\t}\n\treturn elem.each( function() {\n\t\tjQuery.event.add( this, types, fn, data, selector );\n\t} );\n}\n\n/*\n * Helper functions for managing events -- not part of the public interface.\n * Props to Dean Edwards' addEvent library for many of the ideas.\n */\njQuery.event = {\n\n\tglobal: {},\n\n\tadd: function( elem, types, handler, data, selector ) {\n\n\t\tvar handleObjIn, eventHandle, tmp,\n\t\t\tevents, t, handleObj,\n\t\t\tspecial, handlers, type, namespaces, origType,\n\t\t\telemData = dataPriv.get( elem );\n\n\t\t// Don't attach events to noData or text/comment nodes (but allow plain objects)\n\t\tif ( !elemData ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Caller can pass in an object of custom data in lieu of the handler\n\t\tif ( handler.handler ) {\n\t\t\thandleObjIn = handler;\n\t\t\thandler = handleObjIn.handler;\n\t\t\tselector = handleObjIn.selector;\n\t\t}\n\n\t\t// Make sure that the handler has a unique ID, used to find/remove it later\n\t\tif ( !handler.guid ) {\n\t\t\thandler.guid = jQuery.guid++;\n\t\t}\n\n\t\t// Init the element's event structure and main handler, if this is the first\n\t\tif ( !( events = elemData.events ) ) {\n\t\t\tevents = elemData.events = {};\n\t\t}\n\t\tif ( !( eventHandle = elemData.handle ) ) {\n\t\t\teventHandle = elemData.handle = function( e ) {\n\n\t\t\t\t// Discard the second event of a jQuery.event.trigger() and\n\t\t\t\t// when an event is called after a page has unloaded\n\t\t\t\treturn typeof jQuery !== \"undefined\" && jQuery.event.triggered !== e.type ?\n\t\t\t\t\tjQuery.event.dispatch.apply( elem, arguments ) : undefined;\n\t\t\t};\n\t\t}\n\n\t\t// Handle multiple events separated by a space\n\t\ttypes = ( types || \"\" ).match( rnotwhite ) || [ \"\" ];\n\t\tt = types.length;\n\t\twhile ( t-- ) {\n\t\t\ttmp = rtypenamespace.exec( types[ t ] ) || [];\n\t\t\ttype = origType = tmp[ 1 ];\n\t\t\tnamespaces = ( tmp[ 2 ] || \"\" ).split( \".\" ).sort();\n\n\t\t\t// There *must* be a type, no attaching namespace-only handlers\n\t\t\tif ( !type ) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// If event changes its type, use the special event handlers for the changed type\n\t\t\tspecial = jQuery.event.special[ type ] || {};\n\n\t\t\t// If selector defined, determine special event api type, otherwise given type\n\t\t\ttype = ( selector ? special.delegateType : special.bindType ) || type;\n\n\t\t\t// Update special based on newly reset type\n\t\t\tspecial = jQuery.event.special[ type ] || {};\n\n\t\t\t// handleObj is passed to all event handlers\n\t\t\thandleObj = jQuery.extend( {\n\t\t\t\ttype: type,\n\t\t\t\torigType: origType,\n\t\t\t\tdata: data,\n\t\t\t\thandler: handler,\n\t\t\t\tguid: handler.guid,\n\t\t\t\tselector: selector,\n\t\t\t\tneedsContext: selector && jQuery.expr.match.needsContext.test( selector ),\n\t\t\t\tnamespace: namespaces.join( \".\" )\n\t\t\t}, handleObjIn );\n\n\t\t\t// Init the event handler queue if we're the first\n\t\t\tif ( !( handlers = events[ type ] ) ) {\n\t\t\t\thandlers = events[ type ] = [];\n\t\t\t\thandlers.delegateCount = 0;\n\n\t\t\t\t// Only use addEventListener if the special events handler returns false\n\t\t\t\tif ( !special.setup ||\n\t\t\t\t\tspecial.setup.call( elem, data, namespaces, eventHandle ) === false ) {\n\n\t\t\t\t\tif ( elem.addEventListener ) {\n\t\t\t\t\t\telem.addEventListener( type, eventHandle );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif ( special.add ) {\n\t\t\t\tspecial.add.call( elem, handleObj );\n\n\t\t\t\tif ( !handleObj.handler.guid ) {\n\t\t\t\t\thandleObj.handler.guid = handler.guid;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Add to the element's handler list, delegates in front\n\t\t\tif ( selector ) {\n\t\t\t\thandlers.splice( handlers.delegateCount++, 0, handleObj );\n\t\t\t} else {\n\t\t\t\thandlers.push( handleObj );\n\t\t\t}\n\n\t\t\t// Keep track of which events have ever been used, for event optimization\n\t\t\tjQuery.event.global[ type ] = true;\n\t\t}\n\n\t},\n\n\t// Detach an event or set of events from an element\n\tremove: function( elem, types, handler, selector, mappedTypes ) {\n\n\t\tvar j, origCount, tmp,\n\t\t\tevents, t, handleObj,\n\t\t\tspecial, handlers, type, namespaces, origType,\n\t\t\telemData = dataPriv.hasData( elem ) && dataPriv.get( elem );\n\n\t\tif ( !elemData || !( events = elemData.events ) ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Once for each type.namespace in types; type may be omitted\n\t\ttypes = ( types || \"\" ).match( rnotwhite ) || [ \"\" ];\n\t\tt = types.length;\n\t\twhile ( t-- ) {\n\t\t\ttmp = rtypenamespace.exec( types[ t ] ) || [];\n\t\t\ttype = origType = tmp[ 1 ];\n\t\t\tnamespaces = ( tmp[ 2 ] || \"\" ).split( \".\" ).sort();\n\n\t\t\t// Unbind all events (on this namespace, if provided) for the element\n\t\t\tif ( !type ) {\n\t\t\t\tfor ( type in events ) {\n\t\t\t\t\tjQuery.event.remove( elem, type + types[ t ], handler, selector, true );\n\t\t\t\t}\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tspecial = jQuery.event.special[ type ] || {};\n\t\t\ttype = ( selector ? special.delegateType : special.bindType ) || type;\n\t\t\thandlers = events[ type ] || [];\n\t\t\ttmp = tmp[ 2 ] &&\n\t\t\t\tnew RegExp( \"(^|\\\\.)\" + namespaces.join( \"\\\\.(?:.*\\\\.|)\" ) + \"(\\\\.|$)\" );\n\n\t\t\t// Remove matching events\n\t\t\torigCount = j = handlers.length;\n\t\t\twhile ( j-- ) {\n\t\t\t\thandleObj = handlers[ j ];\n\n\t\t\t\tif ( ( mappedTypes || origType === handleObj.origType ) &&\n\t\t\t\t\t( !handler || handler.guid === handleObj.guid ) &&\n\t\t\t\t\t( !tmp || tmp.test( handleObj.namespace ) ) &&\n\t\t\t\t\t( !selector || selector === handleObj.selector ||\n\t\t\t\t\t\tselector === \"**\" && handleObj.selector ) ) {\n\t\t\t\t\thandlers.splice( j, 1 );\n\n\t\t\t\t\tif ( handleObj.selector ) {\n\t\t\t\t\t\thandlers.delegateCount--;\n\t\t\t\t\t}\n\t\t\t\t\tif ( special.remove ) {\n\t\t\t\t\t\tspecial.remove.call( elem, handleObj );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Remove generic event handler if we removed something and no more handlers exist\n\t\t\t// (avoids potential for endless recursion during removal of special event handlers)\n\t\t\tif ( origCount && !handlers.length ) {\n\t\t\t\tif ( !special.teardown ||\n\t\t\t\t\tspecial.teardown.call( elem, namespaces, elemData.handle ) === false ) {\n\n\t\t\t\t\tjQuery.removeEvent( elem, type, elemData.handle );\n\t\t\t\t}\n\n\t\t\t\tdelete events[ type ];\n\t\t\t}\n\t\t}\n\n\t\t// Remove data and the expando if it's no longer used\n\t\tif ( jQuery.isEmptyObject( events ) ) {\n\t\t\tdataPriv.remove( elem, \"handle events\" );\n\t\t}\n\t},\n\n\tdispatch: function( event ) {\n\n\t\t// Make a writable jQuery.Event from the native event object\n\t\tevent = jQuery.event.fix( event );\n\n\t\tvar i, j, ret, matched, handleObj,\n\t\t\thandlerQueue = [],\n\t\t\targs = slice.call( arguments ),\n\t\t\thandlers = ( dataPriv.get( this, \"events\" ) || {} )[ event.type ] || [],\n\t\t\tspecial = jQuery.event.special[ event.type ] || {};\n\n\t\t// Use the fix-ed jQuery.Event rather than the (read-only) native event\n\t\targs[ 0 ] = event;\n\t\tevent.delegateTarget = this;\n\n\t\t// Call the preDispatch hook for the mapped type, and let it bail if desired\n\t\tif ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Determine handlers\n\t\thandlerQueue = jQuery.event.handlers.call( this, event, handlers );\n\n\t\t// Run delegates first; they may want to stop propagation beneath us\n\t\ti = 0;\n\t\twhile ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) {\n\t\t\tevent.currentTarget = matched.elem;\n\n\t\t\tj = 0;\n\t\t\twhile ( ( handleObj = matched.handlers[ j++ ] ) &&\n\t\t\t\t!event.isImmediatePropagationStopped() ) {\n\n\t\t\t\t// Triggered event must either 1) have no namespace, or 2) have namespace(s)\n\t\t\t\t// a subset or equal to those in the bound event (both can have no namespace).\n\t\t\t\tif ( !event.rnamespace || event.rnamespace.test( handleObj.namespace ) ) {\n\n\t\t\t\t\tevent.handleObj = handleObj;\n\t\t\t\t\tevent.data = handleObj.data;\n\n\t\t\t\t\tret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle ||\n\t\t\t\t\t\thandleObj.handler ).apply( matched.elem, args );\n\n\t\t\t\t\tif ( ret !== undefined ) {\n\t\t\t\t\t\tif ( ( event.result = ret ) === false ) {\n\t\t\t\t\t\t\tevent.preventDefault();\n\t\t\t\t\t\t\tevent.stopPropagation();\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Call the postDispatch hook for the mapped type\n\t\tif ( special.postDispatch ) {\n\t\t\tspecial.postDispatch.call( this, event );\n\t\t}\n\n\t\treturn event.result;\n\t},\n\n\thandlers: function( event, handlers ) {\n\t\tvar i, matches, sel, handleObj,\n\t\t\thandlerQueue = [],\n\t\t\tdelegateCount = handlers.delegateCount,\n\t\t\tcur = event.target;\n\n\t\t// Support (at least): Chrome, IE9\n\t\t// Find delegate handlers\n\t\t// Black-hole SVG <use> instance trees (#13180)\n\t\t//\n\t\t// Support: Firefox<=42+\n\t\t// Avoid non-left-click in FF but don't block IE radio events (#3861, gh-2343)\n\t\tif ( delegateCount && cur.nodeType &&\n\t\t\t( event.type !== \"click\" || isNaN( event.button ) || event.button < 1 ) ) {\n\n\t\t\tfor ( ; cur !== this; cur = cur.parentNode || this ) {\n\n\t\t\t\t// Don't check non-elements (#13208)\n\t\t\t\t// Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)\n\t\t\t\tif ( cur.nodeType === 1 && ( cur.disabled !== true || event.type !== \"click\" ) ) {\n\t\t\t\t\tmatches = [];\n\t\t\t\t\tfor ( i = 0; i < delegateCount; i++ ) {\n\t\t\t\t\t\thandleObj = handlers[ i ];\n\n\t\t\t\t\t\t// Don't conflict with Object.prototype properties (#13203)\n\t\t\t\t\t\tsel = handleObj.selector + \" \";\n\n\t\t\t\t\t\tif ( matches[ sel ] === undefined ) {\n\t\t\t\t\t\t\tmatches[ sel ] = handleObj.needsContext ?\n\t\t\t\t\t\t\t\tjQuery( sel, this ).index( cur ) > -1 :\n\t\t\t\t\t\t\t\tjQuery.find( sel, this, null, [ cur ] ).length;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif ( matches[ sel ] ) {\n\t\t\t\t\t\t\tmatches.push( handleObj );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tif ( matches.length ) {\n\t\t\t\t\t\thandlerQueue.push( { elem: cur, handlers: matches } );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Add the remaining (directly-bound) handlers\n\t\tif ( delegateCount < handlers.length ) {\n\t\t\thandlerQueue.push( { elem: this, handlers: handlers.slice( delegateCount ) } );\n\t\t}\n\n\t\treturn handlerQueue;\n\t},\n\n\t// Includes some event props shared by KeyEvent and MouseEvent\n\tprops: ( \"altKey bubbles cancelable ctrlKey currentTarget detail eventPhase \" +\n\t\t\"metaKey relatedTarget shiftKey target timeStamp view which\" ).split( \" \" ),\n\n\tfixHooks: {},\n\n\tkeyHooks: {\n\t\tprops: \"char charCode key keyCode\".split( \" \" ),\n\t\tfilter: function( event, original ) {\n\n\t\t\t// Add which for key events\n\t\t\tif ( event.which == null ) {\n\t\t\t\tevent.which = original.charCode != null ? original.charCode : original.keyCode;\n\t\t\t}\n\n\t\t\treturn event;\n\t\t}\n\t},\n\n\tmouseHooks: {\n\t\tprops: ( \"button buttons clientX clientY offsetX offsetY pageX pageY \" +\n\t\t\t\"screenX screenY toElement\" ).split( \" \" ),\n\t\tfilter: function( event, original ) {\n\t\t\tvar eventDoc, doc, body,\n\t\t\t\tbutton = original.button;\n\n\t\t\t// Calculate pageX/Y if missing and clientX/Y available\n\t\t\tif ( event.pageX == null && original.clientX != null ) {\n\t\t\t\teventDoc = event.target.ownerDocument || document;\n\t\t\t\tdoc = eventDoc.documentElement;\n\t\t\t\tbody = eventDoc.body;\n\n\t\t\t\tevent.pageX = original.clientX +\n\t\t\t\t\t( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) -\n\t\t\t\t\t( doc && doc.clientLeft || body && body.clientLeft || 0 );\n\t\t\t\tevent.pageY = original.clientY +\n\t\t\t\t\t( doc && doc.scrollTop  || body && body.scrollTop  || 0 ) -\n\t\t\t\t\t( doc && doc.clientTop  || body && body.clientTop  || 0 );\n\t\t\t}\n\n\t\t\t// Add which for click: 1 === left; 2 === middle; 3 === right\n\t\t\t// Note: button is not normalized, so don't use it\n\t\t\tif ( !event.which && button !== undefined ) {\n\t\t\t\tevent.which = ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) );\n\t\t\t}\n\n\t\t\treturn event;\n\t\t}\n\t},\n\n\tfix: function( event ) {\n\t\tif ( event[ jQuery.expando ] ) {\n\t\t\treturn event;\n\t\t}\n\n\t\t// Create a writable copy of the event object and normalize some properties\n\t\tvar i, prop, copy,\n\t\t\ttype = event.type,\n\t\t\toriginalEvent = event,\n\t\t\tfixHook = this.fixHooks[ type ];\n\n\t\tif ( !fixHook ) {\n\t\t\tthis.fixHooks[ type ] = fixHook =\n\t\t\t\trmouseEvent.test( type ) ? this.mouseHooks :\n\t\t\t\trkeyEvent.test( type ) ? this.keyHooks :\n\t\t\t\t{};\n\t\t}\n\t\tcopy = fixHook.props ? this.props.concat( fixHook.props ) : this.props;\n\n\t\tevent = new jQuery.Event( originalEvent );\n\n\t\ti = copy.length;\n\t\twhile ( i-- ) {\n\t\t\tprop = copy[ i ];\n\t\t\tevent[ prop ] = originalEvent[ prop ];\n\t\t}\n\n\t\t// Support: Cordova 2.5 (WebKit) (#13255)\n\t\t// All events should have a target; Cordova deviceready doesn't\n\t\tif ( !event.target ) {\n\t\t\tevent.target = document;\n\t\t}\n\n\t\t// Support: Safari 6.0+, Chrome<28\n\t\t// Target should not be a text node (#504, #13143)\n\t\tif ( event.target.nodeType === 3 ) {\n\t\t\tevent.target = event.target.parentNode;\n\t\t}\n\n\t\treturn fixHook.filter ? fixHook.filter( event, originalEvent ) : event;\n\t},\n\n\tspecial: {\n\t\tload: {\n\n\t\t\t// Prevent triggered image.load events from bubbling to window.load\n\t\t\tnoBubble: true\n\t\t},\n\t\tfocus: {\n\n\t\t\t// Fire native event if possible so blur/focus sequence is correct\n\t\t\ttrigger: function() {\n\t\t\t\tif ( this !== safeActiveElement() && this.focus ) {\n\t\t\t\t\tthis.focus();\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t},\n\t\t\tdelegateType: \"focusin\"\n\t\t},\n\t\tblur: {\n\t\t\ttrigger: function() {\n\t\t\t\tif ( this === safeActiveElement() && this.blur ) {\n\t\t\t\t\tthis.blur();\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t},\n\t\t\tdelegateType: \"focusout\"\n\t\t},\n\t\tclick: {\n\n\t\t\t// For checkbox, fire native event so checked state will be right\n\t\t\ttrigger: function() {\n\t\t\t\tif ( this.type === \"checkbox\" && this.click && jQuery.nodeName( this, \"input\" ) ) {\n\t\t\t\t\tthis.click();\n\t\t\t\t\treturn false;\n\t\t\t\t}\n\t\t\t},\n\n\t\t\t// For cross-browser consistency, don't fire native .click() on links\n\t\t\t_default: function( event ) {\n\t\t\t\treturn jQuery.nodeName( event.target, \"a\" );\n\t\t\t}\n\t\t},\n\n\t\tbeforeunload: {\n\t\t\tpostDispatch: function( event ) {\n\n\t\t\t\t// Support: Firefox 20+\n\t\t\t\t// Firefox doesn't alert if the returnValue field is not set.\n\t\t\t\tif ( event.result !== undefined && event.originalEvent ) {\n\t\t\t\t\tevent.originalEvent.returnValue = event.result;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n};\n\njQuery.removeEvent = function( elem, type, handle ) {\n\n\t// This \"if\" is needed for plain objects\n\tif ( elem.removeEventListener ) {\n\t\telem.removeEventListener( type, handle );\n\t}\n};\n\njQuery.Event = function( src, props ) {\n\n\t// Allow instantiation without the 'new' keyword\n\tif ( !( this instanceof jQuery.Event ) ) {\n\t\treturn new jQuery.Event( src, props );\n\t}\n\n\t// Event object\n\tif ( src && src.type ) {\n\t\tthis.originalEvent = src;\n\t\tthis.type = src.type;\n\n\t\t// Events bubbling up the document may have been marked as prevented\n\t\t// by a handler lower down the tree; reflect the correct value.\n\t\tthis.isDefaultPrevented = src.defaultPrevented ||\n\t\t\t\tsrc.defaultPrevented === undefined &&\n\n\t\t\t\t// Support: Android<4.0\n\t\t\t\tsrc.returnValue === false ?\n\t\t\treturnTrue :\n\t\t\treturnFalse;\n\n\t// Event type\n\t} else {\n\t\tthis.type = src;\n\t}\n\n\t// Put explicitly provided properties onto the event object\n\tif ( props ) {\n\t\tjQuery.extend( this, props );\n\t}\n\n\t// Create a timestamp if incoming event doesn't have one\n\tthis.timeStamp = src && src.timeStamp || jQuery.now();\n\n\t// Mark it as fixed\n\tthis[ jQuery.expando ] = true;\n};\n\n// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding\n// http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html\njQuery.Event.prototype = {\n\tconstructor: jQuery.Event,\n\tisDefaultPrevented: returnFalse,\n\tisPropagationStopped: returnFalse,\n\tisImmediatePropagationStopped: returnFalse,\n\n\tpreventDefault: function() {\n\t\tvar e = this.originalEvent;\n\n\t\tthis.isDefaultPrevented = returnTrue;\n\n\t\tif ( e ) {\n\t\t\te.preventDefault();\n\t\t}\n\t},\n\tstopPropagation: function() {\n\t\tvar e = this.originalEvent;\n\n\t\tthis.isPropagationStopped = returnTrue;\n\n\t\tif ( e ) {\n\t\t\te.stopPropagation();\n\t\t}\n\t},\n\tstopImmediatePropagation: function() {\n\t\tvar e = this.originalEvent;\n\n\t\tthis.isImmediatePropagationStopped = returnTrue;\n\n\t\tif ( e ) {\n\t\t\te.stopImmediatePropagation();\n\t\t}\n\n\t\tthis.stopPropagation();\n\t}\n};\n\n// Create mouseenter/leave events using mouseover/out and event-time checks\n// so that event delegation works in jQuery.\n// Do the same for pointerenter/pointerleave and pointerover/pointerout\n//\n// Support: Safari 7 only\n// Safari sends mouseenter too often; see:\n// https://code.google.com/p/chromium/issues/detail?id=470258\n// for the description of the bug (it existed in older Chrome versions as well).\njQuery.each( {\n\tmouseenter: \"mouseover\",\n\tmouseleave: \"mouseout\",\n\tpointerenter: \"pointerover\",\n\tpointerleave: \"pointerout\"\n}, function( orig, fix ) {\n\tjQuery.event.special[ orig ] = {\n\t\tdelegateType: fix,\n\t\tbindType: fix,\n\n\t\thandle: function( event ) {\n\t\t\tvar ret,\n\t\t\t\ttarget = this,\n\t\t\t\trelated = event.relatedTarget,\n\t\t\t\thandleObj = event.handleObj;\n\n\t\t\t// For mouseenter/leave call the handler if related is outside the target.\n\t\t\t// NB: No relatedTarget if the mouse left/entered the browser window\n\t\t\tif ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) {\n\t\t\t\tevent.type = handleObj.origType;\n\t\t\t\tret = handleObj.handler.apply( this, arguments );\n\t\t\t\tevent.type = fix;\n\t\t\t}\n\t\t\treturn ret;\n\t\t}\n\t};\n} );\n\njQuery.fn.extend( {\n\ton: function( types, selector, data, fn ) {\n\t\treturn on( this, types, selector, data, fn );\n\t},\n\tone: function( types, selector, data, fn ) {\n\t\treturn on( this, types, selector, data, fn, 1 );\n\t},\n\toff: function( types, selector, fn ) {\n\t\tvar handleObj, type;\n\t\tif ( types && types.preventDefault && types.handleObj ) {\n\n\t\t\t// ( event )  dispatched jQuery.Event\n\t\t\thandleObj = types.handleObj;\n\t\t\tjQuery( types.delegateTarget ).off(\n\t\t\t\thandleObj.namespace ?\n\t\t\t\t\thandleObj.origType + \".\" + handleObj.namespace :\n\t\t\t\t\thandleObj.origType,\n\t\t\t\thandleObj.selector,\n\t\t\t\thandleObj.handler\n\t\t\t);\n\t\t\treturn this;\n\t\t}\n\t\tif ( typeof types === \"object\" ) {\n\n\t\t\t// ( types-object [, selector] )\n\t\t\tfor ( type in types ) {\n\t\t\t\tthis.off( type, selector, types[ type ] );\n\t\t\t}\n\t\t\treturn this;\n\t\t}\n\t\tif ( selector === false || typeof selector === \"function\" ) {\n\n\t\t\t// ( types [, fn] )\n\t\t\tfn = selector;\n\t\t\tselector = undefined;\n\t\t}\n\t\tif ( fn === false ) {\n\t\t\tfn = returnFalse;\n\t\t}\n\t\treturn this.each( function() {\n\t\t\tjQuery.event.remove( this, types, fn, selector );\n\t\t} );\n\t}\n} );\n\n\nvar\n\trxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\\w:-]+)[^>]*)\\/>/gi,\n\n\t// Support: IE 10-11, Edge 10240+\n\t// In IE/Edge using regex groups here causes severe slowdowns.\n\t// See https://connect.microsoft.com/IE/feedback/details/1736512/\n\trnoInnerhtml = /<script|<style|<link/i,\n\n\t// checked=\"checked\" or checked\n\trchecked = /checked\\s*(?:[^=]|=\\s*.checked.)/i,\n\trscriptTypeMasked = /^true\\/(.*)/,\n\trcleanScript = /^\\s*<!(?:\\[CDATA\\[|--)|(?:\\]\\]|--)>\\s*$/g;\n\n// Manipulating tables requires a tbody\nfunction manipulationTarget( elem, content ) {\n\treturn jQuery.nodeName( elem, \"table\" ) &&\n\t\tjQuery.nodeName( content.nodeType !== 11 ? content : content.firstChild, \"tr\" ) ?\n\n\t\telem.getElementsByTagName( \"tbody\" )[ 0 ] ||\n\t\t\telem.appendChild( elem.ownerDocument.createElement( \"tbody\" ) ) :\n\t\telem;\n}\n\n// Replace/restore the type attribute of script elements for safe DOM manipulation\nfunction disableScript( elem ) {\n\telem.type = ( elem.getAttribute( \"type\" ) !== null ) + \"/\" + elem.type;\n\treturn elem;\n}\nfunction restoreScript( elem ) {\n\tvar match = rscriptTypeMasked.exec( elem.type );\n\n\tif ( match ) {\n\t\telem.type = match[ 1 ];\n\t} else {\n\t\telem.removeAttribute( \"type\" );\n\t}\n\n\treturn elem;\n}\n\nfunction cloneCopyEvent( src, dest ) {\n\tvar i, l, type, pdataOld, pdataCur, udataOld, udataCur, events;\n\n\tif ( dest.nodeType !== 1 ) {\n\t\treturn;\n\t}\n\n\t// 1. Copy private data: events, handlers, etc.\n\tif ( dataPriv.hasData( src ) ) {\n\t\tpdataOld = dataPriv.access( src );\n\t\tpdataCur = dataPriv.set( dest, pdataOld );\n\t\tevents = pdataOld.events;\n\n\t\tif ( events ) {\n\t\t\tdelete pdataCur.handle;\n\t\t\tpdataCur.events = {};\n\n\t\t\tfor ( type in events ) {\n\t\t\t\tfor ( i = 0, l = events[ type ].length; i < l; i++ ) {\n\t\t\t\t\tjQuery.event.add( dest, type, events[ type ][ i ] );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t// 2. Copy user data\n\tif ( dataUser.hasData( src ) ) {\n\t\tudataOld = dataUser.access( src );\n\t\tudataCur = jQuery.extend( {}, udataOld );\n\n\t\tdataUser.set( dest, udataCur );\n\t}\n}\n\n// Fix IE bugs, see support tests\nfunction fixInput( src, dest ) {\n\tvar nodeName = dest.nodeName.toLowerCase();\n\n\t// Fails to persist the checked state of a cloned checkbox or radio button.\n\tif ( nodeName === \"input\" && rcheckableType.test( src.type ) ) {\n\t\tdest.checked = src.checked;\n\n\t// Fails to return the selected option to the default selected state when cloning options\n\t} else if ( nodeName === \"input\" || nodeName === \"textarea\" ) {\n\t\tdest.defaultValue = src.defaultValue;\n\t}\n}\n\nfunction domManip( collection, args, callback, ignored ) {\n\n\t// Flatten any nested arrays\n\targs = concat.apply( [], args );\n\n\tvar fragment, first, scripts, hasScripts, node, doc,\n\t\ti = 0,\n\t\tl = collection.length,\n\t\tiNoClone = l - 1,\n\t\tvalue = args[ 0 ],\n\t\tisFunction = jQuery.isFunction( value );\n\n\t// We can't cloneNode fragments that contain checked, in WebKit\n\tif ( isFunction ||\n\t\t\t( l > 1 && typeof value === \"string\" &&\n\t\t\t\t!support.checkClone && rchecked.test( value ) ) ) {\n\t\treturn collection.each( function( index ) {\n\t\t\tvar self = collection.eq( index );\n\t\t\tif ( isFunction ) {\n\t\t\t\targs[ 0 ] = value.call( this, index, self.html() );\n\t\t\t}\n\t\t\tdomManip( self, args, callback, ignored );\n\t\t} );\n\t}\n\n\tif ( l ) {\n\t\tfragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored );\n\t\tfirst = fragment.firstChild;\n\n\t\tif ( fragment.childNodes.length === 1 ) {\n\t\t\tfragment = first;\n\t\t}\n\n\t\t// Require either new content or an interest in ignored elements to invoke the callback\n\t\tif ( first || ignored ) {\n\t\t\tscripts = jQuery.map( getAll( fragment, \"script\" ), disableScript );\n\t\t\thasScripts = scripts.length;\n\n\t\t\t// Use the original fragment for the last item\n\t\t\t// instead of the first because it can end up\n\t\t\t// being emptied incorrectly in certain situations (#8070).\n\t\t\tfor ( ; i < l; i++ ) {\n\t\t\t\tnode = fragment;\n\n\t\t\t\tif ( i !== iNoClone ) {\n\t\t\t\t\tnode = jQuery.clone( node, true, true );\n\n\t\t\t\t\t// Keep references to cloned scripts for later restoration\n\t\t\t\t\tif ( hasScripts ) {\n\n\t\t\t\t\t\t// Support: Android<4.1, PhantomJS<2\n\t\t\t\t\t\t// push.apply(_, arraylike) throws on ancient WebKit\n\t\t\t\t\t\tjQuery.merge( scripts, getAll( node, \"script\" ) );\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tcallback.call( collection[ i ], node, i );\n\t\t\t}\n\n\t\t\tif ( hasScripts ) {\n\t\t\t\tdoc = scripts[ scripts.length - 1 ].ownerDocument;\n\n\t\t\t\t// Reenable scripts\n\t\t\t\tjQuery.map( scripts, restoreScript );\n\n\t\t\t\t// Evaluate executable scripts on first document insertion\n\t\t\t\tfor ( i = 0; i < hasScripts; i++ ) {\n\t\t\t\t\tnode = scripts[ i ];\n\t\t\t\t\tif ( rscriptType.test( node.type || \"\" ) &&\n\t\t\t\t\t\t!dataPriv.access( node, \"globalEval\" ) &&\n\t\t\t\t\t\tjQuery.contains( doc, node ) ) {\n\n\t\t\t\t\t\tif ( node.src ) {\n\n\t\t\t\t\t\t\t// Optional AJAX dependency, but won't run scripts if not present\n\t\t\t\t\t\t\tif ( jQuery._evalUrl ) {\n\t\t\t\t\t\t\t\tjQuery._evalUrl( node.src );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tjQuery.globalEval( node.textContent.replace( rcleanScript, \"\" ) );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn collection;\n}\n\nfunction remove( elem, selector, keepData ) {\n\tvar node,\n\t\tnodes = selector ? jQuery.filter( selector, elem ) : elem,\n\t\ti = 0;\n\n\tfor ( ; ( node = nodes[ i ] ) != null; i++ ) {\n\t\tif ( !keepData && node.nodeType === 1 ) {\n\t\t\tjQuery.cleanData( getAll( node ) );\n\t\t}\n\n\t\tif ( node.parentNode ) {\n\t\t\tif ( keepData && jQuery.contains( node.ownerDocument, node ) ) {\n\t\t\t\tsetGlobalEval( getAll( node, \"script\" ) );\n\t\t\t}\n\t\t\tnode.parentNode.removeChild( node );\n\t\t}\n\t}\n\n\treturn elem;\n}\n\njQuery.extend( {\n\thtmlPrefilter: function( html ) {\n\t\treturn html.replace( rxhtmlTag, \"<$1></$2>\" );\n\t},\n\n\tclone: function( elem, dataAndEvents, deepDataAndEvents ) {\n\t\tvar i, l, srcElements, destElements,\n\t\t\tclone = elem.cloneNode( true ),\n\t\t\tinPage = jQuery.contains( elem.ownerDocument, elem );\n\n\t\t// Fix IE cloning issues\n\t\tif ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) &&\n\t\t\t\t!jQuery.isXMLDoc( elem ) ) {\n\n\t\t\t// We eschew Sizzle here for performance reasons: http://jsperf.com/getall-vs-sizzle/2\n\t\t\tdestElements = getAll( clone );\n\t\t\tsrcElements = getAll( elem );\n\n\t\t\tfor ( i = 0, l = srcElements.length; i < l; i++ ) {\n\t\t\t\tfixInput( srcElements[ i ], destElements[ i ] );\n\t\t\t}\n\t\t}\n\n\t\t// Copy the events from the original to the clone\n\t\tif ( dataAndEvents ) {\n\t\t\tif ( deepDataAndEvents ) {\n\t\t\t\tsrcElements = srcElements || getAll( elem );\n\t\t\t\tdestElements = destElements || getAll( clone );\n\n\t\t\t\tfor ( i = 0, l = srcElements.length; i < l; i++ ) {\n\t\t\t\t\tcloneCopyEvent( srcElements[ i ], destElements[ i ] );\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tcloneCopyEvent( elem, clone );\n\t\t\t}\n\t\t}\n\n\t\t// Preserve script evaluation history\n\t\tdestElements = getAll( clone, \"script\" );\n\t\tif ( destElements.length > 0 ) {\n\t\t\tsetGlobalEval( destElements, !inPage && getAll( elem, \"script\" ) );\n\t\t}\n\n\t\t// Return the cloned set\n\t\treturn clone;\n\t},\n\n\tcleanData: function( elems ) {\n\t\tvar data, elem, type,\n\t\t\tspecial = jQuery.event.special,\n\t\t\ti = 0;\n\n\t\tfor ( ; ( elem = elems[ i ] ) !== undefined; i++ ) {\n\t\t\tif ( acceptData( elem ) ) {\n\t\t\t\tif ( ( data = elem[ dataPriv.expando ] ) ) {\n\t\t\t\t\tif ( data.events ) {\n\t\t\t\t\t\tfor ( type in data.events ) {\n\t\t\t\t\t\t\tif ( special[ type ] ) {\n\t\t\t\t\t\t\t\tjQuery.event.remove( elem, type );\n\n\t\t\t\t\t\t\t// This is a shortcut to avoid jQuery.event.remove's overhead\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tjQuery.removeEvent( elem, type, data.handle );\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Support: Chrome <= 35-45+\n\t\t\t\t\t// Assign undefined instead of using delete, see Data#remove\n\t\t\t\t\telem[ dataPriv.expando ] = undefined;\n\t\t\t\t}\n\t\t\t\tif ( elem[ dataUser.expando ] ) {\n\n\t\t\t\t\t// Support: Chrome <= 35-45+\n\t\t\t\t\t// Assign undefined instead of using delete, see Data#remove\n\t\t\t\t\telem[ dataUser.expando ] = undefined;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n} );\n\njQuery.fn.extend( {\n\n\t// Keep domManip exposed until 3.0 (gh-2225)\n\tdomManip: domManip,\n\n\tdetach: function( selector ) {\n\t\treturn remove( this, selector, true );\n\t},\n\n\tremove: function( selector ) {\n\t\treturn remove( this, selector );\n\t},\n\n\ttext: function( value ) {\n\t\treturn access( this, function( value ) {\n\t\t\treturn value === undefined ?\n\t\t\t\tjQuery.text( this ) :\n\t\t\t\tthis.empty().each( function() {\n\t\t\t\t\tif ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {\n\t\t\t\t\t\tthis.textContent = value;\n\t\t\t\t\t}\n\t\t\t\t} );\n\t\t}, null, value, arguments.length );\n\t},\n\n\tappend: function() {\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tif ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {\n\t\t\t\tvar target = manipulationTarget( this, elem );\n\t\t\t\ttarget.appendChild( elem );\n\t\t\t}\n\t\t} );\n\t},\n\n\tprepend: function() {\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tif ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {\n\t\t\t\tvar target = manipulationTarget( this, elem );\n\t\t\t\ttarget.insertBefore( elem, target.firstChild );\n\t\t\t}\n\t\t} );\n\t},\n\n\tbefore: function() {\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tif ( this.parentNode ) {\n\t\t\t\tthis.parentNode.insertBefore( elem, this );\n\t\t\t}\n\t\t} );\n\t},\n\n\tafter: function() {\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tif ( this.parentNode ) {\n\t\t\t\tthis.parentNode.insertBefore( elem, this.nextSibling );\n\t\t\t}\n\t\t} );\n\t},\n\n\tempty: function() {\n\t\tvar elem,\n\t\t\ti = 0;\n\n\t\tfor ( ; ( elem = this[ i ] ) != null; i++ ) {\n\t\t\tif ( elem.nodeType === 1 ) {\n\n\t\t\t\t// Prevent memory leaks\n\t\t\t\tjQuery.cleanData( getAll( elem, false ) );\n\n\t\t\t\t// Remove any remaining nodes\n\t\t\t\telem.textContent = \"\";\n\t\t\t}\n\t\t}\n\n\t\treturn this;\n\t},\n\n\tclone: function( dataAndEvents, deepDataAndEvents ) {\n\t\tdataAndEvents = dataAndEvents == null ? false : dataAndEvents;\n\t\tdeepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;\n\n\t\treturn this.map( function() {\n\t\t\treturn jQuery.clone( this, dataAndEvents, deepDataAndEvents );\n\t\t} );\n\t},\n\n\thtml: function( value ) {\n\t\treturn access( this, function( value ) {\n\t\t\tvar elem = this[ 0 ] || {},\n\t\t\t\ti = 0,\n\t\t\t\tl = this.length;\n\n\t\t\tif ( value === undefined && elem.nodeType === 1 ) {\n\t\t\t\treturn elem.innerHTML;\n\t\t\t}\n\n\t\t\t// See if we can take a shortcut and just use innerHTML\n\t\t\tif ( typeof value === \"string\" && !rnoInnerhtml.test( value ) &&\n\t\t\t\t!wrapMap[ ( rtagName.exec( value ) || [ \"\", \"\" ] )[ 1 ].toLowerCase() ] ) {\n\n\t\t\t\tvalue = jQuery.htmlPrefilter( value );\n\n\t\t\t\ttry {\n\t\t\t\t\tfor ( ; i < l; i++ ) {\n\t\t\t\t\t\telem = this[ i ] || {};\n\n\t\t\t\t\t\t// Remove element nodes and prevent memory leaks\n\t\t\t\t\t\tif ( elem.nodeType === 1 ) {\n\t\t\t\t\t\t\tjQuery.cleanData( getAll( elem, false ) );\n\t\t\t\t\t\t\telem.innerHTML = value;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\telem = 0;\n\n\t\t\t\t// If using innerHTML throws an exception, use the fallback method\n\t\t\t\t} catch ( e ) {}\n\t\t\t}\n\n\t\t\tif ( elem ) {\n\t\t\t\tthis.empty().append( value );\n\t\t\t}\n\t\t}, null, value, arguments.length );\n\t},\n\n\treplaceWith: function() {\n\t\tvar ignored = [];\n\n\t\t// Make the changes, replacing each non-ignored context element with the new content\n\t\treturn domManip( this, arguments, function( elem ) {\n\t\t\tvar parent = this.parentNode;\n\n\t\t\tif ( jQuery.inArray( this, ignored ) < 0 ) {\n\t\t\t\tjQuery.cleanData( getAll( this ) );\n\t\t\t\tif ( parent ) {\n\t\t\t\t\tparent.replaceChild( elem, this );\n\t\t\t\t}\n\t\t\t}\n\n\t\t// Force callback invocation\n\t\t}, ignored );\n\t}\n} );\n\njQuery.each( {\n\tappendTo: \"append\",\n\tprependTo: \"prepend\",\n\tinsertBefore: \"before\",\n\tinsertAfter: \"after\",\n\treplaceAll: \"replaceWith\"\n}, function( name, original ) {\n\tjQuery.fn[ name ] = function( selector ) {\n\t\tvar elems,\n\t\t\tret = [],\n\t\t\tinsert = jQuery( selector ),\n\t\t\tlast = insert.length - 1,\n\t\t\ti = 0;\n\n\t\tfor ( ; i <= last; i++ ) {\n\t\t\telems = i === last ? this : this.clone( true );\n\t\t\tjQuery( insert[ i ] )[ original ]( elems );\n\n\t\t\t// Support: QtWebKit\n\t\t\t// .get() because push.apply(_, arraylike) throws\n\t\t\tpush.apply( ret, elems.get() );\n\t\t}\n\n\t\treturn this.pushStack( ret );\n\t};\n} );\n\n\nvar iframe,\n\telemdisplay = {\n\n\t\t// Support: Firefox\n\t\t// We have to pre-define these values for FF (#10227)\n\t\tHTML: \"block\",\n\t\tBODY: \"block\"\n\t};\n\n/**\n * Retrieve the actual display of a element\n * @param {String} name nodeName of the element\n * @param {Object} doc Document object\n */\n\n// Called only from within defaultDisplay\nfunction actualDisplay( name, doc ) {\n\tvar elem = jQuery( doc.createElement( name ) ).appendTo( doc.body ),\n\n\t\tdisplay = jQuery.css( elem[ 0 ], \"display\" );\n\n\t// We don't have any data stored on the element,\n\t// so use \"detach\" method as fast way to get rid of the element\n\telem.detach();\n\n\treturn display;\n}\n\n/**\n * Try to determine the default display value of an element\n * @param {String} nodeName\n */\nfunction defaultDisplay( nodeName ) {\n\tvar doc = document,\n\t\tdisplay = elemdisplay[ nodeName ];\n\n\tif ( !display ) {\n\t\tdisplay = actualDisplay( nodeName, doc );\n\n\t\t// If the simple way fails, read from inside an iframe\n\t\tif ( display === \"none\" || !display ) {\n\n\t\t\t// Use the already-created iframe if possible\n\t\t\tiframe = ( iframe || jQuery( \"<iframe frameborder='0' width='0' height='0'/>\" ) )\n\t\t\t\t.appendTo( doc.documentElement );\n\n\t\t\t// Always write a new HTML skeleton so Webkit and Firefox don't choke on reuse\n\t\t\tdoc = iframe[ 0 ].contentDocument;\n\n\t\t\t// Support: IE\n\t\t\tdoc.write();\n\t\t\tdoc.close();\n\n\t\t\tdisplay = actualDisplay( nodeName, doc );\n\t\t\tiframe.detach();\n\t\t}\n\n\t\t// Store the correct default display\n\t\telemdisplay[ nodeName ] = display;\n\t}\n\n\treturn display;\n}\nvar rmargin = ( /^margin/ );\n\nvar rnumnonpx = new RegExp( \"^(\" + pnum + \")(?!px)[a-z%]+$\", \"i\" );\n\nvar getStyles = function( elem ) {\n\n\t\t// Support: IE<=11+, Firefox<=30+ (#15098, #14150)\n\t\t// IE throws on elements created in popups\n\t\t// FF meanwhile throws on frame elements through \"defaultView.getComputedStyle\"\n\t\tvar view = elem.ownerDocument.defaultView;\n\n\t\tif ( !view || !view.opener ) {\n\t\t\tview = window;\n\t\t}\n\n\t\treturn view.getComputedStyle( elem );\n\t};\n\nvar swap = function( elem, options, callback, args ) {\n\tvar ret, name,\n\t\told = {};\n\n\t// Remember the old values, and insert the new ones\n\tfor ( name in options ) {\n\t\told[ name ] = elem.style[ name ];\n\t\telem.style[ name ] = options[ name ];\n\t}\n\n\tret = callback.apply( elem, args || [] );\n\n\t// Revert the old values\n\tfor ( name in options ) {\n\t\telem.style[ name ] = old[ name ];\n\t}\n\n\treturn ret;\n};\n\n\nvar documentElement = document.documentElement;\n\n\n\n( function() {\n\tvar pixelPositionVal, boxSizingReliableVal, pixelMarginRightVal, reliableMarginLeftVal,\n\t\tcontainer = document.createElement( \"div\" ),\n\t\tdiv = document.createElement( \"div\" );\n\n\t// Finish early in limited (non-browser) environments\n\tif ( !div.style ) {\n\t\treturn;\n\t}\n\n\t// Support: IE9-11+\n\t// Style of cloned element affects source element cloned (#8908)\n\tdiv.style.backgroundClip = \"content-box\";\n\tdiv.cloneNode( true ).style.backgroundClip = \"\";\n\tsupport.clearCloneStyle = div.style.backgroundClip === \"content-box\";\n\n\tcontainer.style.cssText = \"border:0;width:8px;height:0;top:0;left:-9999px;\" +\n\t\t\"padding:0;margin-top:1px;position:absolute\";\n\tcontainer.appendChild( div );\n\n\t// Executing both pixelPosition & boxSizingReliable tests require only one layout\n\t// so they're executed at the same time to save the second computation.\n\tfunction computeStyleTests() {\n\t\tdiv.style.cssText =\n\n\t\t\t// Support: Firefox<29, Android 2.3\n\t\t\t// Vendor-prefix box-sizing\n\t\t\t\"-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;\" +\n\t\t\t\"position:relative;display:block;\" +\n\t\t\t\"margin:auto;border:1px;padding:1px;\" +\n\t\t\t\"top:1%;width:50%\";\n\t\tdiv.innerHTML = \"\";\n\t\tdocumentElement.appendChild( container );\n\n\t\tvar divStyle = window.getComputedStyle( div );\n\t\tpixelPositionVal = divStyle.top !== \"1%\";\n\t\treliableMarginLeftVal = divStyle.marginLeft === \"2px\";\n\t\tboxSizingReliableVal = divStyle.width === \"4px\";\n\n\t\t// Support: Android 4.0 - 4.3 only\n\t\t// Some styles come back with percentage values, even though they shouldn't\n\t\tdiv.style.marginRight = \"50%\";\n\t\tpixelMarginRightVal = divStyle.marginRight === \"4px\";\n\n\t\tdocumentElement.removeChild( container );\n\t}\n\n\tjQuery.extend( support, {\n\t\tpixelPosition: function() {\n\n\t\t\t// This test is executed only once but we still do memoizing\n\t\t\t// since we can use the boxSizingReliable pre-computing.\n\t\t\t// No need to check if the test was already performed, though.\n\t\t\tcomputeStyleTests();\n\t\t\treturn pixelPositionVal;\n\t\t},\n\t\tboxSizingReliable: function() {\n\t\t\tif ( boxSizingReliableVal == null ) {\n\t\t\t\tcomputeStyleTests();\n\t\t\t}\n\t\t\treturn boxSizingReliableVal;\n\t\t},\n\t\tpixelMarginRight: function() {\n\n\t\t\t// Support: Android 4.0-4.3\n\t\t\t// We're checking for boxSizingReliableVal here instead of pixelMarginRightVal\n\t\t\t// since that compresses better and they're computed together anyway.\n\t\t\tif ( boxSizingReliableVal == null ) {\n\t\t\t\tcomputeStyleTests();\n\t\t\t}\n\t\t\treturn pixelMarginRightVal;\n\t\t},\n\t\treliableMarginLeft: function() {\n\n\t\t\t// Support: IE <=8 only, Android 4.0 - 4.3 only, Firefox <=3 - 37\n\t\t\tif ( boxSizingReliableVal == null ) {\n\t\t\t\tcomputeStyleTests();\n\t\t\t}\n\t\t\treturn reliableMarginLeftVal;\n\t\t},\n\t\treliableMarginRight: function() {\n\n\t\t\t// Support: Android 2.3\n\t\t\t// Check if div with explicit width and no margin-right incorrectly\n\t\t\t// gets computed margin-right based on width of container. (#3333)\n\t\t\t// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right\n\t\t\t// This support function is only executed once so no memoizing is needed.\n\t\t\tvar ret,\n\t\t\t\tmarginDiv = div.appendChild( document.createElement( \"div\" ) );\n\n\t\t\t// Reset CSS: box-sizing; display; margin; border; padding\n\t\t\tmarginDiv.style.cssText = div.style.cssText =\n\n\t\t\t\t// Support: Android 2.3\n\t\t\t\t// Vendor-prefix box-sizing\n\t\t\t\t\"-webkit-box-sizing:content-box;box-sizing:content-box;\" +\n\t\t\t\t\"display:block;margin:0;border:0;padding:0\";\n\t\t\tmarginDiv.style.marginRight = marginDiv.style.width = \"0\";\n\t\t\tdiv.style.width = \"1px\";\n\t\t\tdocumentElement.appendChild( container );\n\n\t\t\tret = !parseFloat( window.getComputedStyle( marginDiv ).marginRight );\n\n\t\t\tdocumentElement.removeChild( container );\n\t\t\tdiv.removeChild( marginDiv );\n\n\t\t\treturn ret;\n\t\t}\n\t} );\n} )();\n\n\nfunction curCSS( elem, name, computed ) {\n\tvar width, minWidth, maxWidth, ret,\n\t\tstyle = elem.style;\n\n\tcomputed = computed || getStyles( elem );\n\tret = computed ? computed.getPropertyValue( name ) || computed[ name ] : undefined;\n\n\t// Support: Opera 12.1x only\n\t// Fall back to style even without computed\n\t// computed is undefined for elems on document fragments\n\tif ( ( ret === \"\" || ret === undefined ) && !jQuery.contains( elem.ownerDocument, elem ) ) {\n\t\tret = jQuery.style( elem, name );\n\t}\n\n\t// Support: IE9\n\t// getPropertyValue is only needed for .css('filter') (#12537)\n\tif ( computed ) {\n\n\t\t// A tribute to the \"awesome hack by Dean Edwards\"\n\t\t// Android Browser returns percentage for some values,\n\t\t// but width seems to be reliably pixels.\n\t\t// This is against the CSSOM draft spec:\n\t\t// http://dev.w3.org/csswg/cssom/#resolved-values\n\t\tif ( !support.pixelMarginRight() && rnumnonpx.test( ret ) && rmargin.test( name ) ) {\n\n\t\t\t// Remember the original values\n\t\t\twidth = style.width;\n\t\t\tminWidth = style.minWidth;\n\t\t\tmaxWidth = style.maxWidth;\n\n\t\t\t// Put in the new values to get a computed value out\n\t\t\tstyle.minWidth = style.maxWidth = style.width = ret;\n\t\t\tret = computed.width;\n\n\t\t\t// Revert the changed values\n\t\t\tstyle.width = width;\n\t\t\tstyle.minWidth = minWidth;\n\t\t\tstyle.maxWidth = maxWidth;\n\t\t}\n\t}\n\n\treturn ret !== undefined ?\n\n\t\t// Support: IE9-11+\n\t\t// IE returns zIndex value as an integer.\n\t\tret + \"\" :\n\t\tret;\n}\n\n\nfunction addGetHookIf( conditionFn, hookFn ) {\n\n\t// Define the hook, we'll check on the first run if it's really needed.\n\treturn {\n\t\tget: function() {\n\t\t\tif ( conditionFn() ) {\n\n\t\t\t\t// Hook not needed (or it's not possible to use it due\n\t\t\t\t// to missing dependency), remove it.\n\t\t\t\tdelete this.get;\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// Hook needed; redefine it so that the support test is not executed again.\n\t\t\treturn ( this.get = hookFn ).apply( this, arguments );\n\t\t}\n\t};\n}\n\n\nvar\n\n\t// Swappable if display is none or starts with table\n\t// except \"table\", \"table-cell\", or \"table-caption\"\n\t// See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display\n\trdisplayswap = /^(none|table(?!-c[ea]).+)/,\n\n\tcssShow = { position: \"absolute\", visibility: \"hidden\", display: \"block\" },\n\tcssNormalTransform = {\n\t\tletterSpacing: \"0\",\n\t\tfontWeight: \"400\"\n\t},\n\n\tcssPrefixes = [ \"Webkit\", \"O\", \"Moz\", \"ms\" ],\n\temptyStyle = document.createElement( \"div\" ).style;\n\n// Return a css property mapped to a potentially vendor prefixed property\nfunction vendorPropName( name ) {\n\n\t// Shortcut for names that are not vendor prefixed\n\tif ( name in emptyStyle ) {\n\t\treturn name;\n\t}\n\n\t// Check for vendor prefixed names\n\tvar capName = name[ 0 ].toUpperCase() + name.slice( 1 ),\n\t\ti = cssPrefixes.length;\n\n\twhile ( i-- ) {\n\t\tname = cssPrefixes[ i ] + capName;\n\t\tif ( name in emptyStyle ) {\n\t\t\treturn name;\n\t\t}\n\t}\n}\n\nfunction setPositiveNumber( elem, value, subtract ) {\n\n\t// Any relative (+/-) values have already been\n\t// normalized at this point\n\tvar matches = rcssNum.exec( value );\n\treturn matches ?\n\n\t\t// Guard against undefined \"subtract\", e.g., when used as in cssHooks\n\t\tMath.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || \"px\" ) :\n\t\tvalue;\n}\n\nfunction augmentWidthOrHeight( elem, name, extra, isBorderBox, styles ) {\n\tvar i = extra === ( isBorderBox ? \"border\" : \"content\" ) ?\n\n\t\t// If we already have the right measurement, avoid augmentation\n\t\t4 :\n\n\t\t// Otherwise initialize for horizontal or vertical properties\n\t\tname === \"width\" ? 1 : 0,\n\n\t\tval = 0;\n\n\tfor ( ; i < 4; i += 2 ) {\n\n\t\t// Both box models exclude margin, so add it if we want it\n\t\tif ( extra === \"margin\" ) {\n\t\t\tval += jQuery.css( elem, extra + cssExpand[ i ], true, styles );\n\t\t}\n\n\t\tif ( isBorderBox ) {\n\n\t\t\t// border-box includes padding, so remove it if we want content\n\t\t\tif ( extra === \"content\" ) {\n\t\t\t\tval -= jQuery.css( elem, \"padding\" + cssExpand[ i ], true, styles );\n\t\t\t}\n\n\t\t\t// At this point, extra isn't border nor margin, so remove border\n\t\t\tif ( extra !== \"margin\" ) {\n\t\t\t\tval -= jQuery.css( elem, \"border\" + cssExpand[ i ] + \"Width\", true, styles );\n\t\t\t}\n\t\t} else {\n\n\t\t\t// At this point, extra isn't content, so add padding\n\t\t\tval += jQuery.css( elem, \"padding\" + cssExpand[ i ], true, styles );\n\n\t\t\t// At this point, extra isn't content nor padding, so add border\n\t\t\tif ( extra !== \"padding\" ) {\n\t\t\t\tval += jQuery.css( elem, \"border\" + cssExpand[ i ] + \"Width\", true, styles );\n\t\t\t}\n\t\t}\n\t}\n\n\treturn val;\n}\n\nfunction getWidthOrHeight( elem, name, extra ) {\n\n\t// Start with offset property, which is equivalent to the border-box value\n\tvar valueIsBorderBox = true,\n\t\tval = name === \"width\" ? elem.offsetWidth : elem.offsetHeight,\n\t\tstyles = getStyles( elem ),\n\t\tisBorderBox = jQuery.css( elem, \"boxSizing\", false, styles ) === \"border-box\";\n\n\t// Support: IE11 only\n\t// In IE 11 fullscreen elements inside of an iframe have\n\t// 100x too small dimensions (gh-1764).\n\tif ( document.msFullscreenElement && window.top !== window ) {\n\n\t\t// Support: IE11 only\n\t\t// Running getBoundingClientRect on a disconnected node\n\t\t// in IE throws an error.\n\t\tif ( elem.getClientRects().length ) {\n\t\t\tval = Math.round( elem.getBoundingClientRect()[ name ] * 100 );\n\t\t}\n\t}\n\n\t// Some non-html elements return undefined for offsetWidth, so check for null/undefined\n\t// svg - https://bugzilla.mozilla.org/show_bug.cgi?id=649285\n\t// MathML - https://bugzilla.mozilla.org/show_bug.cgi?id=491668\n\tif ( val <= 0 || val == null ) {\n\n\t\t// Fall back to computed then uncomputed css if necessary\n\t\tval = curCSS( elem, name, styles );\n\t\tif ( val < 0 || val == null ) {\n\t\t\tval = elem.style[ name ];\n\t\t}\n\n\t\t// Computed unit is not pixels. Stop here and return.\n\t\tif ( rnumnonpx.test( val ) ) {\n\t\t\treturn val;\n\t\t}\n\n\t\t// Check for style in case a browser which returns unreliable values\n\t\t// for getComputedStyle silently falls back to the reliable elem.style\n\t\tvalueIsBorderBox = isBorderBox &&\n\t\t\t( support.boxSizingReliable() || val === elem.style[ name ] );\n\n\t\t// Normalize \"\", auto, and prepare for extra\n\t\tval = parseFloat( val ) || 0;\n\t}\n\n\t// Use the active box-sizing model to add/subtract irrelevant styles\n\treturn ( val +\n\t\taugmentWidthOrHeight(\n\t\t\telem,\n\t\t\tname,\n\t\t\textra || ( isBorderBox ? \"border\" : \"content\" ),\n\t\t\tvalueIsBorderBox,\n\t\t\tstyles\n\t\t)\n\t) + \"px\";\n}\n\nfunction showHide( elements, show ) {\n\tvar display, elem, hidden,\n\t\tvalues = [],\n\t\tindex = 0,\n\t\tlength = elements.length;\n\n\tfor ( ; index < length; index++ ) {\n\t\telem = elements[ index ];\n\t\tif ( !elem.style ) {\n\t\t\tcontinue;\n\t\t}\n\n\t\tvalues[ index ] = dataPriv.get( elem, \"olddisplay\" );\n\t\tdisplay = elem.style.display;\n\t\tif ( show ) {\n\n\t\t\t// Reset the inline display of this element to learn if it is\n\t\t\t// being hidden by cascaded rules or not\n\t\t\tif ( !values[ index ] && display === \"none\" ) {\n\t\t\t\telem.style.display = \"\";\n\t\t\t}\n\n\t\t\t// Set elements which have been overridden with display: none\n\t\t\t// in a stylesheet to whatever the default browser style is\n\t\t\t// for such an element\n\t\t\tif ( elem.style.display === \"\" && isHidden( elem ) ) {\n\t\t\t\tvalues[ index ] = dataPriv.access(\n\t\t\t\t\telem,\n\t\t\t\t\t\"olddisplay\",\n\t\t\t\t\tdefaultDisplay( elem.nodeName )\n\t\t\t\t);\n\t\t\t}\n\t\t} else {\n\t\t\thidden = isHidden( elem );\n\n\t\t\tif ( display !== \"none\" || !hidden ) {\n\t\t\t\tdataPriv.set(\n\t\t\t\t\telem,\n\t\t\t\t\t\"olddisplay\",\n\t\t\t\t\thidden ? display : jQuery.css( elem, \"display\" )\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\t}\n\n\t// Set the display of most of the elements in a second loop\n\t// to avoid the constant reflow\n\tfor ( index = 0; index < length; index++ ) {\n\t\telem = elements[ index ];\n\t\tif ( !elem.style ) {\n\t\t\tcontinue;\n\t\t}\n\t\tif ( !show || elem.style.display === \"none\" || elem.style.display === \"\" ) {\n\t\t\telem.style.display = show ? values[ index ] || \"\" : \"none\";\n\t\t}\n\t}\n\n\treturn elements;\n}\n\njQuery.extend( {\n\n\t// Add in style property hooks for overriding the default\n\t// behavior of getting and setting a style property\n\tcssHooks: {\n\t\topacity: {\n\t\t\tget: function( elem, computed ) {\n\t\t\t\tif ( computed ) {\n\n\t\t\t\t\t// We should always get a number back from opacity\n\t\t\t\t\tvar ret = curCSS( elem, \"opacity\" );\n\t\t\t\t\treturn ret === \"\" ? \"1\" : ret;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t},\n\n\t// Don't automatically add \"px\" to these possibly-unitless properties\n\tcssNumber: {\n\t\t\"animationIterationCount\": true,\n\t\t\"columnCount\": true,\n\t\t\"fillOpacity\": true,\n\t\t\"flexGrow\": true,\n\t\t\"flexShrink\": true,\n\t\t\"fontWeight\": true,\n\t\t\"lineHeight\": true,\n\t\t\"opacity\": true,\n\t\t\"order\": true,\n\t\t\"orphans\": true,\n\t\t\"widows\": true,\n\t\t\"zIndex\": true,\n\t\t\"zoom\": true\n\t},\n\n\t// Add in properties whose names you wish to fix before\n\t// setting or getting the value\n\tcssProps: {\n\t\t\"float\": \"cssFloat\"\n\t},\n\n\t// Get and set the style property on a DOM Node\n\tstyle: function( elem, name, value, extra ) {\n\n\t\t// Don't set styles on text and comment nodes\n\t\tif ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Make sure that we're working with the right name\n\t\tvar ret, type, hooks,\n\t\t\torigName = jQuery.camelCase( name ),\n\t\t\tstyle = elem.style;\n\n\t\tname = jQuery.cssProps[ origName ] ||\n\t\t\t( jQuery.cssProps[ origName ] = vendorPropName( origName ) || origName );\n\n\t\t// Gets hook for the prefixed version, then unprefixed version\n\t\thooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];\n\n\t\t// Check if we're setting a value\n\t\tif ( value !== undefined ) {\n\t\t\ttype = typeof value;\n\n\t\t\t// Convert \"+=\" or \"-=\" to relative numbers (#7345)\n\t\t\tif ( type === \"string\" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) {\n\t\t\t\tvalue = adjustCSS( elem, name, ret );\n\n\t\t\t\t// Fixes bug #9237\n\t\t\t\ttype = \"number\";\n\t\t\t}\n\n\t\t\t// Make sure that null and NaN values aren't set (#7116)\n\t\t\tif ( value == null || value !== value ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// If a number was passed in, add the unit (except for certain CSS properties)\n\t\t\tif ( type === \"number\" ) {\n\t\t\t\tvalue += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? \"\" : \"px\" );\n\t\t\t}\n\n\t\t\t// Support: IE9-11+\n\t\t\t// background-* props affect original clone's values\n\t\t\tif ( !support.clearCloneStyle && value === \"\" && name.indexOf( \"background\" ) === 0 ) {\n\t\t\t\tstyle[ name ] = \"inherit\";\n\t\t\t}\n\n\t\t\t// If a hook was provided, use that value, otherwise just set the specified value\n\t\t\tif ( !hooks || !( \"set\" in hooks ) ||\n\t\t\t\t( value = hooks.set( elem, value, extra ) ) !== undefined ) {\n\n\t\t\t\tstyle[ name ] = value;\n\t\t\t}\n\n\t\t} else {\n\n\t\t\t// If a hook was provided get the non-computed value from there\n\t\t\tif ( hooks && \"get\" in hooks &&\n\t\t\t\t( ret = hooks.get( elem, false, extra ) ) !== undefined ) {\n\n\t\t\t\treturn ret;\n\t\t\t}\n\n\t\t\t// Otherwise just get the value from the style object\n\t\t\treturn style[ name ];\n\t\t}\n\t},\n\n\tcss: function( elem, name, extra, styles ) {\n\t\tvar val, num, hooks,\n\t\t\torigName = jQuery.camelCase( name );\n\n\t\t// Make sure that we're working with the right name\n\t\tname = jQuery.cssProps[ origName ] ||\n\t\t\t( jQuery.cssProps[ origName ] = vendorPropName( origName ) || origName );\n\n\t\t// Try prefixed name followed by the unprefixed name\n\t\thooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];\n\n\t\t// If a hook was provided get the computed value from there\n\t\tif ( hooks && \"get\" in hooks ) {\n\t\t\tval = hooks.get( elem, true, extra );\n\t\t}\n\n\t\t// Otherwise, if a way to get the computed value exists, use that\n\t\tif ( val === undefined ) {\n\t\t\tval = curCSS( elem, name, styles );\n\t\t}\n\n\t\t// Convert \"normal\" to computed value\n\t\tif ( val === \"normal\" && name in cssNormalTransform ) {\n\t\t\tval = cssNormalTransform[ name ];\n\t\t}\n\n\t\t// Make numeric if forced or a qualifier was provided and val looks numeric\n\t\tif ( extra === \"\" || extra ) {\n\t\t\tnum = parseFloat( val );\n\t\t\treturn extra === true || isFinite( num ) ? num || 0 : val;\n\t\t}\n\t\treturn val;\n\t}\n} );\n\njQuery.each( [ \"height\", \"width\" ], function( i, name ) {\n\tjQuery.cssHooks[ name ] = {\n\t\tget: function( elem, computed, extra ) {\n\t\t\tif ( computed ) {\n\n\t\t\t\t// Certain elements can have dimension info if we invisibly show them\n\t\t\t\t// but it must have a current display style that would benefit\n\t\t\t\treturn rdisplayswap.test( jQuery.css( elem, \"display\" ) ) &&\n\t\t\t\t\telem.offsetWidth === 0 ?\n\t\t\t\t\t\tswap( elem, cssShow, function() {\n\t\t\t\t\t\t\treturn getWidthOrHeight( elem, name, extra );\n\t\t\t\t\t\t} ) :\n\t\t\t\t\t\tgetWidthOrHeight( elem, name, extra );\n\t\t\t}\n\t\t},\n\n\t\tset: function( elem, value, extra ) {\n\t\t\tvar matches,\n\t\t\t\tstyles = extra && getStyles( elem ),\n\t\t\t\tsubtract = extra && augmentWidthOrHeight(\n\t\t\t\t\telem,\n\t\t\t\t\tname,\n\t\t\t\t\textra,\n\t\t\t\t\tjQuery.css( elem, \"boxSizing\", false, styles ) === \"border-box\",\n\t\t\t\t\tstyles\n\t\t\t\t);\n\n\t\t\t// Convert to pixels if value adjustment is needed\n\t\t\tif ( subtract && ( matches = rcssNum.exec( value ) ) &&\n\t\t\t\t( matches[ 3 ] || \"px\" ) !== \"px\" ) {\n\n\t\t\t\telem.style[ name ] = value;\n\t\t\t\tvalue = jQuery.css( elem, name );\n\t\t\t}\n\n\t\t\treturn setPositiveNumber( elem, value, subtract );\n\t\t}\n\t};\n} );\n\njQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft,\n\tfunction( elem, computed ) {\n\t\tif ( computed ) {\n\t\t\treturn ( parseFloat( curCSS( elem, \"marginLeft\" ) ) ||\n\t\t\t\telem.getBoundingClientRect().left -\n\t\t\t\t\tswap( elem, { marginLeft: 0 }, function() {\n\t\t\t\t\t\treturn elem.getBoundingClientRect().left;\n\t\t\t\t\t} )\n\t\t\t\t) + \"px\";\n\t\t}\n\t}\n);\n\n// Support: Android 2.3\njQuery.cssHooks.marginRight = addGetHookIf( support.reliableMarginRight,\n\tfunction( elem, computed ) {\n\t\tif ( computed ) {\n\t\t\treturn swap( elem, { \"display\": \"inline-block\" },\n\t\t\t\tcurCSS, [ elem, \"marginRight\" ] );\n\t\t}\n\t}\n);\n\n// These hooks are used by animate to expand properties\njQuery.each( {\n\tmargin: \"\",\n\tpadding: \"\",\n\tborder: \"Width\"\n}, function( prefix, suffix ) {\n\tjQuery.cssHooks[ prefix + suffix ] = {\n\t\texpand: function( value ) {\n\t\t\tvar i = 0,\n\t\t\t\texpanded = {},\n\n\t\t\t\t// Assumes a single number if not a string\n\t\t\t\tparts = typeof value === \"string\" ? value.split( \" \" ) : [ value ];\n\n\t\t\tfor ( ; i < 4; i++ ) {\n\t\t\t\texpanded[ prefix + cssExpand[ i ] + suffix ] =\n\t\t\t\t\tparts[ i ] || parts[ i - 2 ] || parts[ 0 ];\n\t\t\t}\n\n\t\t\treturn expanded;\n\t\t}\n\t};\n\n\tif ( !rmargin.test( prefix ) ) {\n\t\tjQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;\n\t}\n} );\n\njQuery.fn.extend( {\n\tcss: function( name, value ) {\n\t\treturn access( this, function( elem, name, value ) {\n\t\t\tvar styles, len,\n\t\t\t\tmap = {},\n\t\t\t\ti = 0;\n\n\t\t\tif ( jQuery.isArray( name ) ) {\n\t\t\t\tstyles = getStyles( elem );\n\t\t\t\tlen = name.length;\n\n\t\t\t\tfor ( ; i < len; i++ ) {\n\t\t\t\t\tmap[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );\n\t\t\t\t}\n\n\t\t\t\treturn map;\n\t\t\t}\n\n\t\t\treturn value !== undefined ?\n\t\t\t\tjQuery.style( elem, name, value ) :\n\t\t\t\tjQuery.css( elem, name );\n\t\t}, name, value, arguments.length > 1 );\n\t},\n\tshow: function() {\n\t\treturn showHide( this, true );\n\t},\n\thide: function() {\n\t\treturn showHide( this );\n\t},\n\ttoggle: function( state ) {\n\t\tif ( typeof state === \"boolean\" ) {\n\t\t\treturn state ? this.show() : this.hide();\n\t\t}\n\n\t\treturn this.each( function() {\n\t\t\tif ( isHidden( this ) ) {\n\t\t\t\tjQuery( this ).show();\n\t\t\t} else {\n\t\t\t\tjQuery( this ).hide();\n\t\t\t}\n\t\t} );\n\t}\n} );\n\n\nfunction Tween( elem, options, prop, end, easing ) {\n\treturn new Tween.prototype.init( elem, options, prop, end, easing );\n}\njQuery.Tween = Tween;\n\nTween.prototype = {\n\tconstructor: Tween,\n\tinit: function( elem, options, prop, end, easing, unit ) {\n\t\tthis.elem = elem;\n\t\tthis.prop = prop;\n\t\tthis.easing = easing || jQuery.easing._default;\n\t\tthis.options = options;\n\t\tthis.start = this.now = this.cur();\n\t\tthis.end = end;\n\t\tthis.unit = unit || ( jQuery.cssNumber[ prop ] ? \"\" : \"px\" );\n\t},\n\tcur: function() {\n\t\tvar hooks = Tween.propHooks[ this.prop ];\n\n\t\treturn hooks && hooks.get ?\n\t\t\thooks.get( this ) :\n\t\t\tTween.propHooks._default.get( this );\n\t},\n\trun: function( percent ) {\n\t\tvar eased,\n\t\t\thooks = Tween.propHooks[ this.prop ];\n\n\t\tif ( this.options.duration ) {\n\t\t\tthis.pos = eased = jQuery.easing[ this.easing ](\n\t\t\t\tpercent, this.options.duration * percent, 0, 1, this.options.duration\n\t\t\t);\n\t\t} else {\n\t\t\tthis.pos = eased = percent;\n\t\t}\n\t\tthis.now = ( this.end - this.start ) * eased + this.start;\n\n\t\tif ( this.options.step ) {\n\t\t\tthis.options.step.call( this.elem, this.now, this );\n\t\t}\n\n\t\tif ( hooks && hooks.set ) {\n\t\t\thooks.set( this );\n\t\t} else {\n\t\t\tTween.propHooks._default.set( this );\n\t\t}\n\t\treturn this;\n\t}\n};\n\nTween.prototype.init.prototype = Tween.prototype;\n\nTween.propHooks = {\n\t_default: {\n\t\tget: function( tween ) {\n\t\t\tvar result;\n\n\t\t\t// Use a property on the element directly when it is not a DOM element,\n\t\t\t// or when there is no matching style property that exists.\n\t\t\tif ( tween.elem.nodeType !== 1 ||\n\t\t\t\ttween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) {\n\t\t\t\treturn tween.elem[ tween.prop ];\n\t\t\t}\n\n\t\t\t// Passing an empty string as a 3rd parameter to .css will automatically\n\t\t\t// attempt a parseFloat and fallback to a string if the parse fails.\n\t\t\t// Simple values such as \"10px\" are parsed to Float;\n\t\t\t// complex values such as \"rotate(1rad)\" are returned as-is.\n\t\t\tresult = jQuery.css( tween.elem, tween.prop, \"\" );\n\n\t\t\t// Empty strings, null, undefined and \"auto\" are converted to 0.\n\t\t\treturn !result || result === \"auto\" ? 0 : result;\n\t\t},\n\t\tset: function( tween ) {\n\n\t\t\t// Use step hook for back compat.\n\t\t\t// Use cssHook if its there.\n\t\t\t// Use .style if available and use plain properties where available.\n\t\t\tif ( jQuery.fx.step[ tween.prop ] ) {\n\t\t\t\tjQuery.fx.step[ tween.prop ]( tween );\n\t\t\t} else if ( tween.elem.nodeType === 1 &&\n\t\t\t\t( tween.elem.style[ jQuery.cssProps[ tween.prop ] ] != null ||\n\t\t\t\t\tjQuery.cssHooks[ tween.prop ] ) ) {\n\t\t\t\tjQuery.style( tween.elem, tween.prop, tween.now + tween.unit );\n\t\t\t} else {\n\t\t\t\ttween.elem[ tween.prop ] = tween.now;\n\t\t\t}\n\t\t}\n\t}\n};\n\n// Support: IE9\n// Panic based approach to setting things on disconnected nodes\nTween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {\n\tset: function( tween ) {\n\t\tif ( tween.elem.nodeType && tween.elem.parentNode ) {\n\t\t\ttween.elem[ tween.prop ] = tween.now;\n\t\t}\n\t}\n};\n\njQuery.easing = {\n\tlinear: function( p ) {\n\t\treturn p;\n\t},\n\tswing: function( p ) {\n\t\treturn 0.5 - Math.cos( p * Math.PI ) / 2;\n\t},\n\t_default: \"swing\"\n};\n\njQuery.fx = Tween.prototype.init;\n\n// Back Compat <1.8 extension point\njQuery.fx.step = {};\n\n\n\n\nvar\n\tfxNow, timerId,\n\trfxtypes = /^(?:toggle|show|hide)$/,\n\trrun = /queueHooks$/;\n\n// Animations created synchronously will run synchronously\nfunction createFxNow() {\n\twindow.setTimeout( function() {\n\t\tfxNow = undefined;\n\t} );\n\treturn ( fxNow = jQuery.now() );\n}\n\n// Generate parameters to create a standard animation\nfunction genFx( type, includeWidth ) {\n\tvar which,\n\t\ti = 0,\n\t\tattrs = { height: type };\n\n\t// If we include width, step value is 1 to do all cssExpand values,\n\t// otherwise step value is 2 to skip over Left and Right\n\tincludeWidth = includeWidth ? 1 : 0;\n\tfor ( ; i < 4 ; i += 2 - includeWidth ) {\n\t\twhich = cssExpand[ i ];\n\t\tattrs[ \"margin\" + which ] = attrs[ \"padding\" + which ] = type;\n\t}\n\n\tif ( includeWidth ) {\n\t\tattrs.opacity = attrs.width = type;\n\t}\n\n\treturn attrs;\n}\n\nfunction createTween( value, prop, animation ) {\n\tvar tween,\n\t\tcollection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ \"*\" ] ),\n\t\tindex = 0,\n\t\tlength = collection.length;\n\tfor ( ; index < length; index++ ) {\n\t\tif ( ( tween = collection[ index ].call( animation, prop, value ) ) ) {\n\n\t\t\t// We're done with this property\n\t\t\treturn tween;\n\t\t}\n\t}\n}\n\nfunction defaultPrefilter( elem, props, opts ) {\n\t/* jshint validthis: true */\n\tvar prop, value, toggle, tween, hooks, oldfire, display, checkDisplay,\n\t\tanim = this,\n\t\torig = {},\n\t\tstyle = elem.style,\n\t\thidden = elem.nodeType && isHidden( elem ),\n\t\tdataShow = dataPriv.get( elem, \"fxshow\" );\n\n\t// Handle queue: false promises\n\tif ( !opts.queue ) {\n\t\thooks = jQuery._queueHooks( elem, \"fx\" );\n\t\tif ( hooks.unqueued == null ) {\n\t\t\thooks.unqueued = 0;\n\t\t\toldfire = hooks.empty.fire;\n\t\t\thooks.empty.fire = function() {\n\t\t\t\tif ( !hooks.unqueued ) {\n\t\t\t\t\toldfire();\n\t\t\t\t}\n\t\t\t};\n\t\t}\n\t\thooks.unqueued++;\n\n\t\tanim.always( function() {\n\n\t\t\t// Ensure the complete handler is called before this completes\n\t\t\tanim.always( function() {\n\t\t\t\thooks.unqueued--;\n\t\t\t\tif ( !jQuery.queue( elem, \"fx\" ).length ) {\n\t\t\t\t\thooks.empty.fire();\n\t\t\t\t}\n\t\t\t} );\n\t\t} );\n\t}\n\n\t// Height/width overflow pass\n\tif ( elem.nodeType === 1 && ( \"height\" in props || \"width\" in props ) ) {\n\n\t\t// Make sure that nothing sneaks out\n\t\t// Record all 3 overflow attributes because IE9-10 do not\n\t\t// change the overflow attribute when overflowX and\n\t\t// overflowY are set to the same value\n\t\topts.overflow = [ style.overflow, style.overflowX, style.overflowY ];\n\n\t\t// Set display property to inline-block for height/width\n\t\t// animations on inline elements that are having width/height animated\n\t\tdisplay = jQuery.css( elem, \"display\" );\n\n\t\t// Test default display if display is currently \"none\"\n\t\tcheckDisplay = display === \"none\" ?\n\t\t\tdataPriv.get( elem, \"olddisplay\" ) || defaultDisplay( elem.nodeName ) : display;\n\n\t\tif ( checkDisplay === \"inline\" && jQuery.css( elem, \"float\" ) === \"none\" ) {\n\t\t\tstyle.display = \"inline-block\";\n\t\t}\n\t}\n\n\tif ( opts.overflow ) {\n\t\tstyle.overflow = \"hidden\";\n\t\tanim.always( function() {\n\t\t\tstyle.overflow = opts.overflow[ 0 ];\n\t\t\tstyle.overflowX = opts.overflow[ 1 ];\n\t\t\tstyle.overflowY = opts.overflow[ 2 ];\n\t\t} );\n\t}\n\n\t// show/hide pass\n\tfor ( prop in props ) {\n\t\tvalue = props[ prop ];\n\t\tif ( rfxtypes.exec( value ) ) {\n\t\t\tdelete props[ prop ];\n\t\t\ttoggle = toggle || value === \"toggle\";\n\t\t\tif ( value === ( hidden ? \"hide\" : \"show\" ) ) {\n\n\t\t\t\t// If there is dataShow left over from a stopped hide or show\n\t\t\t\t// and we are going to proceed with show, we should pretend to be hidden\n\t\t\t\tif ( value === \"show\" && dataShow && dataShow[ prop ] !== undefined ) {\n\t\t\t\t\thidden = true;\n\t\t\t\t} else {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t}\n\t\t\torig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop );\n\n\t\t// Any non-fx value stops us from restoring the original display value\n\t\t} else {\n\t\t\tdisplay = undefined;\n\t\t}\n\t}\n\n\tif ( !jQuery.isEmptyObject( orig ) ) {\n\t\tif ( dataShow ) {\n\t\t\tif ( \"hidden\" in dataShow ) {\n\t\t\t\thidden = dataShow.hidden;\n\t\t\t}\n\t\t} else {\n\t\t\tdataShow = dataPriv.access( elem, \"fxshow\", {} );\n\t\t}\n\n\t\t// Store state if its toggle - enables .stop().toggle() to \"reverse\"\n\t\tif ( toggle ) {\n\t\t\tdataShow.hidden = !hidden;\n\t\t}\n\t\tif ( hidden ) {\n\t\t\tjQuery( elem ).show();\n\t\t} else {\n\t\t\tanim.done( function() {\n\t\t\t\tjQuery( elem ).hide();\n\t\t\t} );\n\t\t}\n\t\tanim.done( function() {\n\t\t\tvar prop;\n\n\t\t\tdataPriv.remove( elem, \"fxshow\" );\n\t\t\tfor ( prop in orig ) {\n\t\t\t\tjQuery.style( elem, prop, orig[ prop ] );\n\t\t\t}\n\t\t} );\n\t\tfor ( prop in orig ) {\n\t\t\ttween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim );\n\n\t\t\tif ( !( prop in dataShow ) ) {\n\t\t\t\tdataShow[ prop ] = tween.start;\n\t\t\t\tif ( hidden ) {\n\t\t\t\t\ttween.end = tween.start;\n\t\t\t\t\ttween.start = prop === \"width\" || prop === \"height\" ? 1 : 0;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t// If this is a noop like .hide().hide(), restore an overwritten display value\n\t} else if ( ( display === \"none\" ? defaultDisplay( elem.nodeName ) : display ) === \"inline\" ) {\n\t\tstyle.display = display;\n\t}\n}\n\nfunction propFilter( props, specialEasing ) {\n\tvar index, name, easing, value, hooks;\n\n\t// camelCase, specialEasing and expand cssHook pass\n\tfor ( index in props ) {\n\t\tname = jQuery.camelCase( index );\n\t\teasing = specialEasing[ name ];\n\t\tvalue = props[ index ];\n\t\tif ( jQuery.isArray( value ) ) {\n\t\t\teasing = value[ 1 ];\n\t\t\tvalue = props[ index ] = value[ 0 ];\n\t\t}\n\n\t\tif ( index !== name ) {\n\t\t\tprops[ name ] = value;\n\t\t\tdelete props[ index ];\n\t\t}\n\n\t\thooks = jQuery.cssHooks[ name ];\n\t\tif ( hooks && \"expand\" in hooks ) {\n\t\t\tvalue = hooks.expand( value );\n\t\t\tdelete props[ name ];\n\n\t\t\t// Not quite $.extend, this won't overwrite existing keys.\n\t\t\t// Reusing 'index' because we have the correct \"name\"\n\t\t\tfor ( index in value ) {\n\t\t\t\tif ( !( index in props ) ) {\n\t\t\t\t\tprops[ index ] = value[ index ];\n\t\t\t\t\tspecialEasing[ index ] = easing;\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tspecialEasing[ name ] = easing;\n\t\t}\n\t}\n}\n\nfunction Animation( elem, properties, options ) {\n\tvar result,\n\t\tstopped,\n\t\tindex = 0,\n\t\tlength = Animation.prefilters.length,\n\t\tdeferred = jQuery.Deferred().always( function() {\n\n\t\t\t// Don't match elem in the :animated selector\n\t\t\tdelete tick.elem;\n\t\t} ),\n\t\ttick = function() {\n\t\t\tif ( stopped ) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t\tvar currentTime = fxNow || createFxNow(),\n\t\t\t\tremaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),\n\n\t\t\t\t// Support: Android 2.3\n\t\t\t\t// Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497)\n\t\t\t\ttemp = remaining / animation.duration || 0,\n\t\t\t\tpercent = 1 - temp,\n\t\t\t\tindex = 0,\n\t\t\t\tlength = animation.tweens.length;\n\n\t\t\tfor ( ; index < length ; index++ ) {\n\t\t\t\tanimation.tweens[ index ].run( percent );\n\t\t\t}\n\n\t\t\tdeferred.notifyWith( elem, [ animation, percent, remaining ] );\n\n\t\t\tif ( percent < 1 && length ) {\n\t\t\t\treturn remaining;\n\t\t\t} else {\n\t\t\t\tdeferred.resolveWith( elem, [ animation ] );\n\t\t\t\treturn false;\n\t\t\t}\n\t\t},\n\t\tanimation = deferred.promise( {\n\t\t\telem: elem,\n\t\t\tprops: jQuery.extend( {}, properties ),\n\t\t\topts: jQuery.extend( true, {\n\t\t\t\tspecialEasing: {},\n\t\t\t\teasing: jQuery.easing._default\n\t\t\t}, options ),\n\t\t\toriginalProperties: properties,\n\t\t\toriginalOptions: options,\n\t\t\tstartTime: fxNow || createFxNow(),\n\t\t\tduration: options.duration,\n\t\t\ttweens: [],\n\t\t\tcreateTween: function( prop, end ) {\n\t\t\t\tvar tween = jQuery.Tween( elem, animation.opts, prop, end,\n\t\t\t\t\t\tanimation.opts.specialEasing[ prop ] || animation.opts.easing );\n\t\t\t\tanimation.tweens.push( tween );\n\t\t\t\treturn tween;\n\t\t\t},\n\t\t\tstop: function( gotoEnd ) {\n\t\t\t\tvar index = 0,\n\n\t\t\t\t\t// If we are going to the end, we want to run all the tweens\n\t\t\t\t\t// otherwise we skip this part\n\t\t\t\t\tlength = gotoEnd ? animation.tweens.length : 0;\n\t\t\t\tif ( stopped ) {\n\t\t\t\t\treturn this;\n\t\t\t\t}\n\t\t\t\tstopped = true;\n\t\t\t\tfor ( ; index < length ; index++ ) {\n\t\t\t\t\tanimation.tweens[ index ].run( 1 );\n\t\t\t\t}\n\n\t\t\t\t// Resolve when we played the last frame; otherwise, reject\n\t\t\t\tif ( gotoEnd ) {\n\t\t\t\t\tdeferred.notifyWith( elem, [ animation, 1, 0 ] );\n\t\t\t\t\tdeferred.resolveWith( elem, [ animation, gotoEnd ] );\n\t\t\t\t} else {\n\t\t\t\t\tdeferred.rejectWith( elem, [ animation, gotoEnd ] );\n\t\t\t\t}\n\t\t\t\treturn this;\n\t\t\t}\n\t\t} ),\n\t\tprops = animation.props;\n\n\tpropFilter( props, animation.opts.specialEasing );\n\n\tfor ( ; index < length ; index++ ) {\n\t\tresult = Animation.prefilters[ index ].call( animation, elem, props, animation.opts );\n\t\tif ( result ) {\n\t\t\tif ( jQuery.isFunction( result.stop ) ) {\n\t\t\t\tjQuery._queueHooks( animation.elem, animation.opts.queue ).stop =\n\t\t\t\t\tjQuery.proxy( result.stop, result );\n\t\t\t}\n\t\t\treturn result;\n\t\t}\n\t}\n\n\tjQuery.map( props, createTween, animation );\n\n\tif ( jQuery.isFunction( animation.opts.start ) ) {\n\t\tanimation.opts.start.call( elem, animation );\n\t}\n\n\tjQuery.fx.timer(\n\t\tjQuery.extend( tick, {\n\t\t\telem: elem,\n\t\t\tanim: animation,\n\t\t\tqueue: animation.opts.queue\n\t\t} )\n\t);\n\n\t// attach callbacks from options\n\treturn animation.progress( animation.opts.progress )\n\t\t.done( animation.opts.done, animation.opts.complete )\n\t\t.fail( animation.opts.fail )\n\t\t.always( animation.opts.always );\n}\n\njQuery.Animation = jQuery.extend( Animation, {\n\ttweeners: {\n\t\t\"*\": [ function( prop, value ) {\n\t\t\tvar tween = this.createTween( prop, value );\n\t\t\tadjustCSS( tween.elem, prop, rcssNum.exec( value ), tween );\n\t\t\treturn tween;\n\t\t} ]\n\t},\n\n\ttweener: function( props, callback ) {\n\t\tif ( jQuery.isFunction( props ) ) {\n\t\t\tcallback = props;\n\t\t\tprops = [ \"*\" ];\n\t\t} else {\n\t\t\tprops = props.match( rnotwhite );\n\t\t}\n\n\t\tvar prop,\n\t\t\tindex = 0,\n\t\t\tlength = props.length;\n\n\t\tfor ( ; index < length ; index++ ) {\n\t\t\tprop = props[ index ];\n\t\t\tAnimation.tweeners[ prop ] = Animation.tweeners[ prop ] || [];\n\t\t\tAnimation.tweeners[ prop ].unshift( callback );\n\t\t}\n\t},\n\n\tprefilters: [ defaultPrefilter ],\n\n\tprefilter: function( callback, prepend ) {\n\t\tif ( prepend ) {\n\t\t\tAnimation.prefilters.unshift( callback );\n\t\t} else {\n\t\t\tAnimation.prefilters.push( callback );\n\t\t}\n\t}\n} );\n\njQuery.speed = function( speed, easing, fn ) {\n\tvar opt = speed && typeof speed === \"object\" ? jQuery.extend( {}, speed ) : {\n\t\tcomplete: fn || !fn && easing ||\n\t\t\tjQuery.isFunction( speed ) && speed,\n\t\tduration: speed,\n\t\teasing: fn && easing || easing && !jQuery.isFunction( easing ) && easing\n\t};\n\n\topt.duration = jQuery.fx.off ? 0 : typeof opt.duration === \"number\" ?\n\t\topt.duration : opt.duration in jQuery.fx.speeds ?\n\t\t\tjQuery.fx.speeds[ opt.duration ] : jQuery.fx.speeds._default;\n\n\t// Normalize opt.queue - true/undefined/null -> \"fx\"\n\tif ( opt.queue == null || opt.queue === true ) {\n\t\topt.queue = \"fx\";\n\t}\n\n\t// Queueing\n\topt.old = opt.complete;\n\n\topt.complete = function() {\n\t\tif ( jQuery.isFunction( opt.old ) ) {\n\t\t\topt.old.call( this );\n\t\t}\n\n\t\tif ( opt.queue ) {\n\t\t\tjQuery.dequeue( this, opt.queue );\n\t\t}\n\t};\n\n\treturn opt;\n};\n\njQuery.fn.extend( {\n\tfadeTo: function( speed, to, easing, callback ) {\n\n\t\t// Show any hidden elements after setting opacity to 0\n\t\treturn this.filter( isHidden ).css( \"opacity\", 0 ).show()\n\n\t\t\t// Animate to the value specified\n\t\t\t.end().animate( { opacity: to }, speed, easing, callback );\n\t},\n\tanimate: function( prop, speed, easing, callback ) {\n\t\tvar empty = jQuery.isEmptyObject( prop ),\n\t\t\toptall = jQuery.speed( speed, easing, callback ),\n\t\t\tdoAnimation = function() {\n\n\t\t\t\t// Operate on a copy of prop so per-property easing won't be lost\n\t\t\t\tvar anim = Animation( this, jQuery.extend( {}, prop ), optall );\n\n\t\t\t\t// Empty animations, or finishing resolves immediately\n\t\t\t\tif ( empty || dataPriv.get( this, \"finish\" ) ) {\n\t\t\t\t\tanim.stop( true );\n\t\t\t\t}\n\t\t\t};\n\t\t\tdoAnimation.finish = doAnimation;\n\n\t\treturn empty || optall.queue === false ?\n\t\t\tthis.each( doAnimation ) :\n\t\t\tthis.queue( optall.queue, doAnimation );\n\t},\n\tstop: function( type, clearQueue, gotoEnd ) {\n\t\tvar stopQueue = function( hooks ) {\n\t\t\tvar stop = hooks.stop;\n\t\t\tdelete hooks.stop;\n\t\t\tstop( gotoEnd );\n\t\t};\n\n\t\tif ( typeof type !== \"string\" ) {\n\t\t\tgotoEnd = clearQueue;\n\t\t\tclearQueue = type;\n\t\t\ttype = undefined;\n\t\t}\n\t\tif ( clearQueue && type !== false ) {\n\t\t\tthis.queue( type || \"fx\", [] );\n\t\t}\n\n\t\treturn this.each( function() {\n\t\t\tvar dequeue = true,\n\t\t\t\tindex = type != null && type + \"queueHooks\",\n\t\t\t\ttimers = jQuery.timers,\n\t\t\t\tdata = dataPriv.get( this );\n\n\t\t\tif ( index ) {\n\t\t\t\tif ( data[ index ] && data[ index ].stop ) {\n\t\t\t\t\tstopQueue( data[ index ] );\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tfor ( index in data ) {\n\t\t\t\t\tif ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {\n\t\t\t\t\t\tstopQueue( data[ index ] );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tfor ( index = timers.length; index--; ) {\n\t\t\t\tif ( timers[ index ].elem === this &&\n\t\t\t\t\t( type == null || timers[ index ].queue === type ) ) {\n\n\t\t\t\t\ttimers[ index ].anim.stop( gotoEnd );\n\t\t\t\t\tdequeue = false;\n\t\t\t\t\ttimers.splice( index, 1 );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Start the next in the queue if the last step wasn't forced.\n\t\t\t// Timers currently will call their complete callbacks, which\n\t\t\t// will dequeue but only if they were gotoEnd.\n\t\t\tif ( dequeue || !gotoEnd ) {\n\t\t\t\tjQuery.dequeue( this, type );\n\t\t\t}\n\t\t} );\n\t},\n\tfinish: function( type ) {\n\t\tif ( type !== false ) {\n\t\t\ttype = type || \"fx\";\n\t\t}\n\t\treturn this.each( function() {\n\t\t\tvar index,\n\t\t\t\tdata = dataPriv.get( this ),\n\t\t\t\tqueue = data[ type + \"queue\" ],\n\t\t\t\thooks = data[ type + \"queueHooks\" ],\n\t\t\t\ttimers = jQuery.timers,\n\t\t\t\tlength = queue ? queue.length : 0;\n\n\t\t\t// Enable finishing flag on private data\n\t\t\tdata.finish = true;\n\n\t\t\t// Empty the queue first\n\t\t\tjQuery.queue( this, type, [] );\n\n\t\t\tif ( hooks && hooks.stop ) {\n\t\t\t\thooks.stop.call( this, true );\n\t\t\t}\n\n\t\t\t// Look for any active animations, and finish them\n\t\t\tfor ( index = timers.length; index--; ) {\n\t\t\t\tif ( timers[ index ].elem === this && timers[ index ].queue === type ) {\n\t\t\t\t\ttimers[ index ].anim.stop( true );\n\t\t\t\t\ttimers.splice( index, 1 );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Look for any animations in the old queue and finish them\n\t\t\tfor ( index = 0; index < length; index++ ) {\n\t\t\t\tif ( queue[ index ] && queue[ index ].finish ) {\n\t\t\t\t\tqueue[ index ].finish.call( this );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Turn off finishing flag\n\t\t\tdelete data.finish;\n\t\t} );\n\t}\n} );\n\njQuery.each( [ \"toggle\", \"show\", \"hide\" ], function( i, name ) {\n\tvar cssFn = jQuery.fn[ name ];\n\tjQuery.fn[ name ] = function( speed, easing, callback ) {\n\t\treturn speed == null || typeof speed === \"boolean\" ?\n\t\t\tcssFn.apply( this, arguments ) :\n\t\t\tthis.animate( genFx( name, true ), speed, easing, callback );\n\t};\n} );\n\n// Generate shortcuts for custom animations\njQuery.each( {\n\tslideDown: genFx( \"show\" ),\n\tslideUp: genFx( \"hide\" ),\n\tslideToggle: genFx( \"toggle\" ),\n\tfadeIn: { opacity: \"show\" },\n\tfadeOut: { opacity: \"hide\" },\n\tfadeToggle: { opacity: \"toggle\" }\n}, function( name, props ) {\n\tjQuery.fn[ name ] = function( speed, easing, callback ) {\n\t\treturn this.animate( props, speed, easing, callback );\n\t};\n} );\n\njQuery.timers = [];\njQuery.fx.tick = function() {\n\tvar timer,\n\t\ti = 0,\n\t\ttimers = jQuery.timers;\n\n\tfxNow = jQuery.now();\n\n\tfor ( ; i < timers.length; i++ ) {\n\t\ttimer = timers[ i ];\n\n\t\t// Checks the timer has not already been removed\n\t\tif ( !timer() && timers[ i ] === timer ) {\n\t\t\ttimers.splice( i--, 1 );\n\t\t}\n\t}\n\n\tif ( !timers.length ) {\n\t\tjQuery.fx.stop();\n\t}\n\tfxNow = undefined;\n};\n\njQuery.fx.timer = function( timer ) {\n\tjQuery.timers.push( timer );\n\tif ( timer() ) {\n\t\tjQuery.fx.start();\n\t} else {\n\t\tjQuery.timers.pop();\n\t}\n};\n\njQuery.fx.interval = 13;\njQuery.fx.start = function() {\n\tif ( !timerId ) {\n\t\ttimerId = window.setInterval( jQuery.fx.tick, jQuery.fx.interval );\n\t}\n};\n\njQuery.fx.stop = function() {\n\twindow.clearInterval( timerId );\n\n\ttimerId = null;\n};\n\njQuery.fx.speeds = {\n\tslow: 600,\n\tfast: 200,\n\n\t// Default speed\n\t_default: 400\n};\n\n\n// Based off of the plugin by Clint Helfers, with permission.\n// http://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/\njQuery.fn.delay = function( time, type ) {\n\ttime = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;\n\ttype = type || \"fx\";\n\n\treturn this.queue( type, function( next, hooks ) {\n\t\tvar timeout = window.setTimeout( next, time );\n\t\thooks.stop = function() {\n\t\t\twindow.clearTimeout( timeout );\n\t\t};\n\t} );\n};\n\n\n( function() {\n\tvar input = document.createElement( \"input\" ),\n\t\tselect = document.createElement( \"select\" ),\n\t\topt = select.appendChild( document.createElement( \"option\" ) );\n\n\tinput.type = \"checkbox\";\n\n\t// Support: iOS<=5.1, Android<=4.2+\n\t// Default value for a checkbox should be \"on\"\n\tsupport.checkOn = input.value !== \"\";\n\n\t// Support: IE<=11+\n\t// Must access selectedIndex to make default options select\n\tsupport.optSelected = opt.selected;\n\n\t// Support: Android<=2.3\n\t// Options inside disabled selects are incorrectly marked as disabled\n\tselect.disabled = true;\n\tsupport.optDisabled = !opt.disabled;\n\n\t// Support: IE<=11+\n\t// An input loses its value after becoming a radio\n\tinput = document.createElement( \"input\" );\n\tinput.value = \"t\";\n\tinput.type = \"radio\";\n\tsupport.radioValue = input.value === \"t\";\n} )();\n\n\nvar boolHook,\n\tattrHandle = jQuery.expr.attrHandle;\n\njQuery.fn.extend( {\n\tattr: function( name, value ) {\n\t\treturn access( this, jQuery.attr, name, value, arguments.length > 1 );\n\t},\n\n\tremoveAttr: function( name ) {\n\t\treturn this.each( function() {\n\t\t\tjQuery.removeAttr( this, name );\n\t\t} );\n\t}\n} );\n\njQuery.extend( {\n\tattr: function( elem, name, value ) {\n\t\tvar ret, hooks,\n\t\t\tnType = elem.nodeType;\n\n\t\t// Don't get/set attributes on text, comment and attribute nodes\n\t\tif ( nType === 3 || nType === 8 || nType === 2 ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Fallback to prop when attributes are not supported\n\t\tif ( typeof elem.getAttribute === \"undefined\" ) {\n\t\t\treturn jQuery.prop( elem, name, value );\n\t\t}\n\n\t\t// All attributes are lowercase\n\t\t// Grab necessary hook if one is defined\n\t\tif ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {\n\t\t\tname = name.toLowerCase();\n\t\t\thooks = jQuery.attrHooks[ name ] ||\n\t\t\t\t( jQuery.expr.match.bool.test( name ) ? boolHook : undefined );\n\t\t}\n\n\t\tif ( value !== undefined ) {\n\t\t\tif ( value === null ) {\n\t\t\t\tjQuery.removeAttr( elem, name );\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tif ( hooks && \"set\" in hooks &&\n\t\t\t\t( ret = hooks.set( elem, value, name ) ) !== undefined ) {\n\t\t\t\treturn ret;\n\t\t\t}\n\n\t\t\telem.setAttribute( name, value + \"\" );\n\t\t\treturn value;\n\t\t}\n\n\t\tif ( hooks && \"get\" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {\n\t\t\treturn ret;\n\t\t}\n\n\t\tret = jQuery.find.attr( elem, name );\n\n\t\t// Non-existent attributes return null, we normalize to undefined\n\t\treturn ret == null ? undefined : ret;\n\t},\n\n\tattrHooks: {\n\t\ttype: {\n\t\t\tset: function( elem, value ) {\n\t\t\t\tif ( !support.radioValue && value === \"radio\" &&\n\t\t\t\t\tjQuery.nodeName( elem, \"input\" ) ) {\n\t\t\t\t\tvar val = elem.value;\n\t\t\t\t\telem.setAttribute( \"type\", value );\n\t\t\t\t\tif ( val ) {\n\t\t\t\t\t\telem.value = val;\n\t\t\t\t\t}\n\t\t\t\t\treturn value;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t},\n\n\tremoveAttr: function( elem, value ) {\n\t\tvar name, propName,\n\t\t\ti = 0,\n\t\t\tattrNames = value && value.match( rnotwhite );\n\n\t\tif ( attrNames && elem.nodeType === 1 ) {\n\t\t\twhile ( ( name = attrNames[ i++ ] ) ) {\n\t\t\t\tpropName = jQuery.propFix[ name ] || name;\n\n\t\t\t\t// Boolean attributes get special treatment (#10870)\n\t\t\t\tif ( jQuery.expr.match.bool.test( name ) ) {\n\n\t\t\t\t\t// Set corresponding property to false\n\t\t\t\t\telem[ propName ] = false;\n\t\t\t\t}\n\n\t\t\t\telem.removeAttribute( name );\n\t\t\t}\n\t\t}\n\t}\n} );\n\n// Hooks for boolean attributes\nboolHook = {\n\tset: function( elem, value, name ) {\n\t\tif ( value === false ) {\n\n\t\t\t// Remove boolean attributes when set to false\n\t\t\tjQuery.removeAttr( elem, name );\n\t\t} else {\n\t\t\telem.setAttribute( name, name );\n\t\t}\n\t\treturn name;\n\t}\n};\njQuery.each( jQuery.expr.match.bool.source.match( /\\w+/g ), function( i, name ) {\n\tvar getter = attrHandle[ name ] || jQuery.find.attr;\n\n\tattrHandle[ name ] = function( elem, name, isXML ) {\n\t\tvar ret, handle;\n\t\tif ( !isXML ) {\n\n\t\t\t// Avoid an infinite loop by temporarily removing this function from the getter\n\t\t\thandle = attrHandle[ name ];\n\t\t\tattrHandle[ name ] = ret;\n\t\t\tret = getter( elem, name, isXML ) != null ?\n\t\t\t\tname.toLowerCase() :\n\t\t\t\tnull;\n\t\t\tattrHandle[ name ] = handle;\n\t\t}\n\t\treturn ret;\n\t};\n} );\n\n\n\n\nvar rfocusable = /^(?:input|select|textarea|button)$/i,\n\trclickable = /^(?:a|area)$/i;\n\njQuery.fn.extend( {\n\tprop: function( name, value ) {\n\t\treturn access( this, jQuery.prop, name, value, arguments.length > 1 );\n\t},\n\n\tremoveProp: function( name ) {\n\t\treturn this.each( function() {\n\t\t\tdelete this[ jQuery.propFix[ name ] || name ];\n\t\t} );\n\t}\n} );\n\njQuery.extend( {\n\tprop: function( elem, name, value ) {\n\t\tvar ret, hooks,\n\t\t\tnType = elem.nodeType;\n\n\t\t// Don't get/set properties on text, comment and attribute nodes\n\t\tif ( nType === 3 || nType === 8 || nType === 2 ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {\n\n\t\t\t// Fix name and attach hooks\n\t\t\tname = jQuery.propFix[ name ] || name;\n\t\t\thooks = jQuery.propHooks[ name ];\n\t\t}\n\n\t\tif ( value !== undefined ) {\n\t\t\tif ( hooks && \"set\" in hooks &&\n\t\t\t\t( ret = hooks.set( elem, value, name ) ) !== undefined ) {\n\t\t\t\treturn ret;\n\t\t\t}\n\n\t\t\treturn ( elem[ name ] = value );\n\t\t}\n\n\t\tif ( hooks && \"get\" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {\n\t\t\treturn ret;\n\t\t}\n\n\t\treturn elem[ name ];\n\t},\n\n\tpropHooks: {\n\t\ttabIndex: {\n\t\t\tget: function( elem ) {\n\n\t\t\t\t// elem.tabIndex doesn't always return the\n\t\t\t\t// correct value when it hasn't been explicitly set\n\t\t\t\t// http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/\n\t\t\t\t// Use proper attribute retrieval(#12072)\n\t\t\t\tvar tabindex = jQuery.find.attr( elem, \"tabindex\" );\n\n\t\t\t\treturn tabindex ?\n\t\t\t\t\tparseInt( tabindex, 10 ) :\n\t\t\t\t\trfocusable.test( elem.nodeName ) ||\n\t\t\t\t\t\trclickable.test( elem.nodeName ) && elem.href ?\n\t\t\t\t\t\t\t0 :\n\t\t\t\t\t\t\t-1;\n\t\t\t}\n\t\t}\n\t},\n\n\tpropFix: {\n\t\t\"for\": \"htmlFor\",\n\t\t\"class\": \"className\"\n\t}\n} );\n\n// Support: IE <=11 only\n// Accessing the selectedIndex property\n// forces the browser to respect setting selected\n// on the option\n// The getter ensures a default option is selected\n// when in an optgroup\nif ( !support.optSelected ) {\n\tjQuery.propHooks.selected = {\n\t\tget: function( elem ) {\n\t\t\tvar parent = elem.parentNode;\n\t\t\tif ( parent && parent.parentNode ) {\n\t\t\t\tparent.parentNode.selectedIndex;\n\t\t\t}\n\t\t\treturn null;\n\t\t},\n\t\tset: function( elem ) {\n\t\t\tvar parent = elem.parentNode;\n\t\t\tif ( parent ) {\n\t\t\t\tparent.selectedIndex;\n\n\t\t\t\tif ( parent.parentNode ) {\n\t\t\t\t\tparent.parentNode.selectedIndex;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n}\n\njQuery.each( [\n\t\"tabIndex\",\n\t\"readOnly\",\n\t\"maxLength\",\n\t\"cellSpacing\",\n\t\"cellPadding\",\n\t\"rowSpan\",\n\t\"colSpan\",\n\t\"useMap\",\n\t\"frameBorder\",\n\t\"contentEditable\"\n], function() {\n\tjQuery.propFix[ this.toLowerCase() ] = this;\n} );\n\n\n\n\nvar rclass = /[\\t\\r\\n\\f]/g;\n\nfunction getClass( elem ) {\n\treturn elem.getAttribute && elem.getAttribute( \"class\" ) || \"\";\n}\n\njQuery.fn.extend( {\n\taddClass: function( value ) {\n\t\tvar classes, elem, cur, curValue, clazz, j, finalValue,\n\t\t\ti = 0;\n\n\t\tif ( jQuery.isFunction( value ) ) {\n\t\t\treturn this.each( function( j ) {\n\t\t\t\tjQuery( this ).addClass( value.call( this, j, getClass( this ) ) );\n\t\t\t} );\n\t\t}\n\n\t\tif ( typeof value === \"string\" && value ) {\n\t\t\tclasses = value.match( rnotwhite ) || [];\n\n\t\t\twhile ( ( elem = this[ i++ ] ) ) {\n\t\t\t\tcurValue = getClass( elem );\n\t\t\t\tcur = elem.nodeType === 1 &&\n\t\t\t\t\t( \" \" + curValue + \" \" ).replace( rclass, \" \" );\n\n\t\t\t\tif ( cur ) {\n\t\t\t\t\tj = 0;\n\t\t\t\t\twhile ( ( clazz = classes[ j++ ] ) ) {\n\t\t\t\t\t\tif ( cur.indexOf( \" \" + clazz + \" \" ) < 0 ) {\n\t\t\t\t\t\t\tcur += clazz + \" \";\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Only assign if different to avoid unneeded rendering.\n\t\t\t\t\tfinalValue = jQuery.trim( cur );\n\t\t\t\t\tif ( curValue !== finalValue ) {\n\t\t\t\t\t\telem.setAttribute( \"class\", finalValue );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn this;\n\t},\n\n\tremoveClass: function( value ) {\n\t\tvar classes, elem, cur, curValue, clazz, j, finalValue,\n\t\t\ti = 0;\n\n\t\tif ( jQuery.isFunction( value ) ) {\n\t\t\treturn this.each( function( j ) {\n\t\t\t\tjQuery( this ).removeClass( value.call( this, j, getClass( this ) ) );\n\t\t\t} );\n\t\t}\n\n\t\tif ( !arguments.length ) {\n\t\t\treturn this.attr( \"class\", \"\" );\n\t\t}\n\n\t\tif ( typeof value === \"string\" && value ) {\n\t\t\tclasses = value.match( rnotwhite ) || [];\n\n\t\t\twhile ( ( elem = this[ i++ ] ) ) {\n\t\t\t\tcurValue = getClass( elem );\n\n\t\t\t\t// This expression is here for better compressibility (see addClass)\n\t\t\t\tcur = elem.nodeType === 1 &&\n\t\t\t\t\t( \" \" + curValue + \" \" ).replace( rclass, \" \" );\n\n\t\t\t\tif ( cur ) {\n\t\t\t\t\tj = 0;\n\t\t\t\t\twhile ( ( clazz = classes[ j++ ] ) ) {\n\n\t\t\t\t\t\t// Remove *all* instances\n\t\t\t\t\t\twhile ( cur.indexOf( \" \" + clazz + \" \" ) > -1 ) {\n\t\t\t\t\t\t\tcur = cur.replace( \" \" + clazz + \" \", \" \" );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// Only assign if different to avoid unneeded rendering.\n\t\t\t\t\tfinalValue = jQuery.trim( cur );\n\t\t\t\t\tif ( curValue !== finalValue ) {\n\t\t\t\t\t\telem.setAttribute( \"class\", finalValue );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn this;\n\t},\n\n\ttoggleClass: function( value, stateVal ) {\n\t\tvar type = typeof value;\n\n\t\tif ( typeof stateVal === \"boolean\" && type === \"string\" ) {\n\t\t\treturn stateVal ? this.addClass( value ) : this.removeClass( value );\n\t\t}\n\n\t\tif ( jQuery.isFunction( value ) ) {\n\t\t\treturn this.each( function( i ) {\n\t\t\t\tjQuery( this ).toggleClass(\n\t\t\t\t\tvalue.call( this, i, getClass( this ), stateVal ),\n\t\t\t\t\tstateVal\n\t\t\t\t);\n\t\t\t} );\n\t\t}\n\n\t\treturn this.each( function() {\n\t\t\tvar className, i, self, classNames;\n\n\t\t\tif ( type === \"string\" ) {\n\n\t\t\t\t// Toggle individual class names\n\t\t\t\ti = 0;\n\t\t\t\tself = jQuery( this );\n\t\t\t\tclassNames = value.match( rnotwhite ) || [];\n\n\t\t\t\twhile ( ( className = classNames[ i++ ] ) ) {\n\n\t\t\t\t\t// Check each className given, space separated list\n\t\t\t\t\tif ( self.hasClass( className ) ) {\n\t\t\t\t\t\tself.removeClass( className );\n\t\t\t\t\t} else {\n\t\t\t\t\t\tself.addClass( className );\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t// Toggle whole class name\n\t\t\t} else if ( value === undefined || type === \"boolean\" ) {\n\t\t\t\tclassName = getClass( this );\n\t\t\t\tif ( className ) {\n\n\t\t\t\t\t// Store className if set\n\t\t\t\t\tdataPriv.set( this, \"__className__\", className );\n\t\t\t\t}\n\n\t\t\t\t// If the element has a class name or if we're passed `false`,\n\t\t\t\t// then remove the whole classname (if there was one, the above saved it).\n\t\t\t\t// Otherwise bring back whatever was previously saved (if anything),\n\t\t\t\t// falling back to the empty string if nothing was stored.\n\t\t\t\tif ( this.setAttribute ) {\n\t\t\t\t\tthis.setAttribute( \"class\",\n\t\t\t\t\t\tclassName || value === false ?\n\t\t\t\t\t\t\"\" :\n\t\t\t\t\t\tdataPriv.get( this, \"__className__\" ) || \"\"\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t}\n\t\t} );\n\t},\n\n\thasClass: function( selector ) {\n\t\tvar className, elem,\n\t\t\ti = 0;\n\n\t\tclassName = \" \" + selector + \" \";\n\t\twhile ( ( elem = this[ i++ ] ) ) {\n\t\t\tif ( elem.nodeType === 1 &&\n\t\t\t\t( \" \" + getClass( elem ) + \" \" ).replace( rclass, \" \" )\n\t\t\t\t\t.indexOf( className ) > -1\n\t\t\t) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\n\t\treturn false;\n\t}\n} );\n\n\n\n\nvar rreturn = /\\r/g,\n\trspaces = /[\\x20\\t\\r\\n\\f]+/g;\n\njQuery.fn.extend( {\n\tval: function( value ) {\n\t\tvar hooks, ret, isFunction,\n\t\t\telem = this[ 0 ];\n\n\t\tif ( !arguments.length ) {\n\t\t\tif ( elem ) {\n\t\t\t\thooks = jQuery.valHooks[ elem.type ] ||\n\t\t\t\t\tjQuery.valHooks[ elem.nodeName.toLowerCase() ];\n\n\t\t\t\tif ( hooks &&\n\t\t\t\t\t\"get\" in hooks &&\n\t\t\t\t\t( ret = hooks.get( elem, \"value\" ) ) !== undefined\n\t\t\t\t) {\n\t\t\t\t\treturn ret;\n\t\t\t\t}\n\n\t\t\t\tret = elem.value;\n\n\t\t\t\treturn typeof ret === \"string\" ?\n\n\t\t\t\t\t// Handle most common string cases\n\t\t\t\t\tret.replace( rreturn, \"\" ) :\n\n\t\t\t\t\t// Handle cases where value is null/undef or number\n\t\t\t\t\tret == null ? \"\" : ret;\n\t\t\t}\n\n\t\t\treturn;\n\t\t}\n\n\t\tisFunction = jQuery.isFunction( value );\n\n\t\treturn this.each( function( i ) {\n\t\t\tvar val;\n\n\t\t\tif ( this.nodeType !== 1 ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tif ( isFunction ) {\n\t\t\t\tval = value.call( this, i, jQuery( this ).val() );\n\t\t\t} else {\n\t\t\t\tval = value;\n\t\t\t}\n\n\t\t\t// Treat null/undefined as \"\"; convert numbers to string\n\t\t\tif ( val == null ) {\n\t\t\t\tval = \"\";\n\n\t\t\t} else if ( typeof val === \"number\" ) {\n\t\t\t\tval += \"\";\n\n\t\t\t} else if ( jQuery.isArray( val ) ) {\n\t\t\t\tval = jQuery.map( val, function( value ) {\n\t\t\t\t\treturn value == null ? \"\" : value + \"\";\n\t\t\t\t} );\n\t\t\t}\n\n\t\t\thooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];\n\n\t\t\t// If set returns undefined, fall back to normal setting\n\t\t\tif ( !hooks || !( \"set\" in hooks ) || hooks.set( this, val, \"value\" ) === undefined ) {\n\t\t\t\tthis.value = val;\n\t\t\t}\n\t\t} );\n\t}\n} );\n\njQuery.extend( {\n\tvalHooks: {\n\t\toption: {\n\t\t\tget: function( elem ) {\n\n\t\t\t\tvar val = jQuery.find.attr( elem, \"value\" );\n\t\t\t\treturn val != null ?\n\t\t\t\t\tval :\n\n\t\t\t\t\t// Support: IE10-11+\n\t\t\t\t\t// option.text throws exceptions (#14686, #14858)\n\t\t\t\t\t// Strip and collapse whitespace\n\t\t\t\t\t// https://html.spec.whatwg.org/#strip-and-collapse-whitespace\n\t\t\t\t\tjQuery.trim( jQuery.text( elem ) ).replace( rspaces, \" \" );\n\t\t\t}\n\t\t},\n\t\tselect: {\n\t\t\tget: function( elem ) {\n\t\t\t\tvar value, option,\n\t\t\t\t\toptions = elem.options,\n\t\t\t\t\tindex = elem.selectedIndex,\n\t\t\t\t\tone = elem.type === \"select-one\" || index < 0,\n\t\t\t\t\tvalues = one ? null : [],\n\t\t\t\t\tmax = one ? index + 1 : options.length,\n\t\t\t\t\ti = index < 0 ?\n\t\t\t\t\t\tmax :\n\t\t\t\t\t\tone ? index : 0;\n\n\t\t\t\t// Loop through all the selected options\n\t\t\t\tfor ( ; i < max; i++ ) {\n\t\t\t\t\toption = options[ i ];\n\n\t\t\t\t\t// IE8-9 doesn't update selected after form reset (#2551)\n\t\t\t\t\tif ( ( option.selected || i === index ) &&\n\n\t\t\t\t\t\t\t// Don't return options that are disabled or in a disabled optgroup\n\t\t\t\t\t\t\t( support.optDisabled ?\n\t\t\t\t\t\t\t\t!option.disabled : option.getAttribute( \"disabled\" ) === null ) &&\n\t\t\t\t\t\t\t( !option.parentNode.disabled ||\n\t\t\t\t\t\t\t\t!jQuery.nodeName( option.parentNode, \"optgroup\" ) ) ) {\n\n\t\t\t\t\t\t// Get the specific value for the option\n\t\t\t\t\t\tvalue = jQuery( option ).val();\n\n\t\t\t\t\t\t// We don't need an array for one selects\n\t\t\t\t\t\tif ( one ) {\n\t\t\t\t\t\t\treturn value;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Multi-Selects return an array\n\t\t\t\t\t\tvalues.push( value );\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\treturn values;\n\t\t\t},\n\n\t\t\tset: function( elem, value ) {\n\t\t\t\tvar optionSet, option,\n\t\t\t\t\toptions = elem.options,\n\t\t\t\t\tvalues = jQuery.makeArray( value ),\n\t\t\t\t\ti = options.length;\n\n\t\t\t\twhile ( i-- ) {\n\t\t\t\t\toption = options[ i ];\n\t\t\t\t\tif ( option.selected =\n\t\t\t\t\t\tjQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1\n\t\t\t\t\t) {\n\t\t\t\t\t\toptionSet = true;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Force browsers to behave consistently when non-matching value is set\n\t\t\t\tif ( !optionSet ) {\n\t\t\t\t\telem.selectedIndex = -1;\n\t\t\t\t}\n\t\t\t\treturn values;\n\t\t\t}\n\t\t}\n\t}\n} );\n\n// Radios and checkboxes getter/setter\njQuery.each( [ \"radio\", \"checkbox\" ], function() {\n\tjQuery.valHooks[ this ] = {\n\t\tset: function( elem, value ) {\n\t\t\tif ( jQuery.isArray( value ) ) {\n\t\t\t\treturn ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 );\n\t\t\t}\n\t\t}\n\t};\n\tif ( !support.checkOn ) {\n\t\tjQuery.valHooks[ this ].get = function( elem ) {\n\t\t\treturn elem.getAttribute( \"value\" ) === null ? \"on\" : elem.value;\n\t\t};\n\t}\n} );\n\n\n\n\n// Return jQuery for attributes-only inclusion\n\n\nvar rfocusMorph = /^(?:focusinfocus|focusoutblur)$/;\n\njQuery.extend( jQuery.event, {\n\n\ttrigger: function( event, data, elem, onlyHandlers ) {\n\n\t\tvar i, cur, tmp, bubbleType, ontype, handle, special,\n\t\t\teventPath = [ elem || document ],\n\t\t\ttype = hasOwn.call( event, \"type\" ) ? event.type : event,\n\t\t\tnamespaces = hasOwn.call( event, \"namespace\" ) ? event.namespace.split( \".\" ) : [];\n\n\t\tcur = tmp = elem = elem || document;\n\n\t\t// Don't do events on text and comment nodes\n\t\tif ( elem.nodeType === 3 || elem.nodeType === 8 ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// focus/blur morphs to focusin/out; ensure we're not firing them right now\n\t\tif ( rfocusMorph.test( type + jQuery.event.triggered ) ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( type.indexOf( \".\" ) > -1 ) {\n\n\t\t\t// Namespaced trigger; create a regexp to match event type in handle()\n\t\t\tnamespaces = type.split( \".\" );\n\t\t\ttype = namespaces.shift();\n\t\t\tnamespaces.sort();\n\t\t}\n\t\tontype = type.indexOf( \":\" ) < 0 && \"on\" + type;\n\n\t\t// Caller can pass in a jQuery.Event object, Object, or just an event type string\n\t\tevent = event[ jQuery.expando ] ?\n\t\t\tevent :\n\t\t\tnew jQuery.Event( type, typeof event === \"object\" && event );\n\n\t\t// Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)\n\t\tevent.isTrigger = onlyHandlers ? 2 : 3;\n\t\tevent.namespace = namespaces.join( \".\" );\n\t\tevent.rnamespace = event.namespace ?\n\t\t\tnew RegExp( \"(^|\\\\.)\" + namespaces.join( \"\\\\.(?:.*\\\\.|)\" ) + \"(\\\\.|$)\" ) :\n\t\t\tnull;\n\n\t\t// Clean up the event in case it is being reused\n\t\tevent.result = undefined;\n\t\tif ( !event.target ) {\n\t\t\tevent.target = elem;\n\t\t}\n\n\t\t// Clone any incoming data and prepend the event, creating the handler arg list\n\t\tdata = data == null ?\n\t\t\t[ event ] :\n\t\t\tjQuery.makeArray( data, [ event ] );\n\n\t\t// Allow special events to draw outside the lines\n\t\tspecial = jQuery.event.special[ type ] || {};\n\t\tif ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Determine event propagation path in advance, per W3C events spec (#9951)\n\t\t// Bubble up to document, then to window; watch for a global ownerDocument var (#9724)\n\t\tif ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) {\n\n\t\t\tbubbleType = special.delegateType || type;\n\t\t\tif ( !rfocusMorph.test( bubbleType + type ) ) {\n\t\t\t\tcur = cur.parentNode;\n\t\t\t}\n\t\t\tfor ( ; cur; cur = cur.parentNode ) {\n\t\t\t\teventPath.push( cur );\n\t\t\t\ttmp = cur;\n\t\t\t}\n\n\t\t\t// Only add window if we got to document (e.g., not plain obj or detached DOM)\n\t\t\tif ( tmp === ( elem.ownerDocument || document ) ) {\n\t\t\t\teventPath.push( tmp.defaultView || tmp.parentWindow || window );\n\t\t\t}\n\t\t}\n\n\t\t// Fire handlers on the event path\n\t\ti = 0;\n\t\twhile ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) {\n\n\t\t\tevent.type = i > 1 ?\n\t\t\t\tbubbleType :\n\t\t\t\tspecial.bindType || type;\n\n\t\t\t// jQuery handler\n\t\t\thandle = ( dataPriv.get( cur, \"events\" ) || {} )[ event.type ] &&\n\t\t\t\tdataPriv.get( cur, \"handle\" );\n\t\t\tif ( handle ) {\n\t\t\t\thandle.apply( cur, data );\n\t\t\t}\n\n\t\t\t// Native handler\n\t\t\thandle = ontype && cur[ ontype ];\n\t\t\tif ( handle && handle.apply && acceptData( cur ) ) {\n\t\t\t\tevent.result = handle.apply( cur, data );\n\t\t\t\tif ( event.result === false ) {\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tevent.type = type;\n\n\t\t// If nobody prevented the default action, do it now\n\t\tif ( !onlyHandlers && !event.isDefaultPrevented() ) {\n\n\t\t\tif ( ( !special._default ||\n\t\t\t\tspecial._default.apply( eventPath.pop(), data ) === false ) &&\n\t\t\t\tacceptData( elem ) ) {\n\n\t\t\t\t// Call a native DOM method on the target with the same name name as the event.\n\t\t\t\t// Don't do default actions on window, that's where global variables be (#6170)\n\t\t\t\tif ( ontype && jQuery.isFunction( elem[ type ] ) && !jQuery.isWindow( elem ) ) {\n\n\t\t\t\t\t// Don't re-trigger an onFOO event when we call its FOO() method\n\t\t\t\t\ttmp = elem[ ontype ];\n\n\t\t\t\t\tif ( tmp ) {\n\t\t\t\t\t\telem[ ontype ] = null;\n\t\t\t\t\t}\n\n\t\t\t\t\t// Prevent re-triggering of the same event, since we already bubbled it above\n\t\t\t\t\tjQuery.event.triggered = type;\n\t\t\t\t\telem[ type ]();\n\t\t\t\t\tjQuery.event.triggered = undefined;\n\n\t\t\t\t\tif ( tmp ) {\n\t\t\t\t\t\telem[ ontype ] = tmp;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn event.result;\n\t},\n\n\t// Piggyback on a donor event to simulate a different one\n\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// But now, this \"simulate\" function is used only for events\n\t\t\t\t// for which stopPropagation() is noop, so there is no need for that anymore.\n\t\t\t\t//\n\t\t\t\t// For the 1.x branch though, guard for \"click\" and \"submit\"\n\t\t\t\t// events is still used, but was moved to jQuery.event.stopPropagation function\n\t\t\t\t// because `originalEvent` should point to the original event for the constancy\n\t\t\t\t// 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} );\n\njQuery.fn.extend( {\n\n\ttrigger: function( type, data ) {\n\t\treturn this.each( function() {\n\t\t\tjQuery.event.trigger( type, data, this );\n\t\t} );\n\t},\n\ttriggerHandler: function( type, data ) {\n\t\tvar elem = this[ 0 ];\n\t\tif ( elem ) {\n\t\t\treturn jQuery.event.trigger( type, data, elem, true );\n\t\t}\n\t}\n} );\n\n\njQuery.each( ( \"blur focus focusin focusout load resize scroll unload click dblclick \" +\n\t\"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave \" +\n\t\"change select submit keydown keypress keyup error contextmenu\" ).split( \" \" ),\n\tfunction( i, name ) {\n\n\t// Handle event binding\n\tjQuery.fn[ name ] = function( data, fn ) {\n\t\treturn arguments.length > 0 ?\n\t\t\tthis.on( name, null, data, fn ) :\n\t\t\tthis.trigger( name );\n\t};\n} );\n\njQuery.fn.extend( {\n\thover: function( fnOver, fnOut ) {\n\t\treturn this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );\n\t}\n} );\n\n\n\n\nsupport.focusin = \"onfocusin\" in window;\n\n\n// Support: Firefox\n// Firefox doesn't have focus(in | out) events\n// Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787\n//\n// Support: Chrome, Safari\n// focus(in | out) events fire after focus & blur events,\n// which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order\n// Related ticket - https://code.google.com/p/chromium/issues/detail?id=449857\nif ( !support.focusin ) {\n\tjQuery.each( { focus: \"focusin\", blur: \"focusout\" }, function( orig, fix ) {\n\n\t\t// Attach a single capturing handler on the document while someone wants focusin/focusout\n\t\tvar handler = function( event ) {\n\t\t\tjQuery.event.simulate( fix, event.target, jQuery.event.fix( event ) );\n\t\t};\n\n\t\tjQuery.event.special[ fix ] = {\n\t\t\tsetup: function() {\n\t\t\t\tvar doc = this.ownerDocument || this,\n\t\t\t\t\tattaches = dataPriv.access( doc, fix );\n\n\t\t\t\tif ( !attaches ) {\n\t\t\t\t\tdoc.addEventListener( orig, handler, true );\n\t\t\t\t}\n\t\t\t\tdataPriv.access( doc, fix, ( attaches || 0 ) + 1 );\n\t\t\t},\n\t\t\tteardown: function() {\n\t\t\t\tvar doc = this.ownerDocument || this,\n\t\t\t\t\tattaches = dataPriv.access( doc, fix ) - 1;\n\n\t\t\t\tif ( !attaches ) {\n\t\t\t\t\tdoc.removeEventListener( orig, handler, true );\n\t\t\t\t\tdataPriv.remove( doc, fix );\n\n\t\t\t\t} else {\n\t\t\t\t\tdataPriv.access( doc, fix, attaches );\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\t} );\n}\nvar location = window.location;\n\nvar nonce = jQuery.now();\n\nvar rquery = ( /\\?/ );\n\n\n\n// Support: Android 2.3\n// Workaround failure to string-cast null input\njQuery.parseJSON = function( data ) {\n\treturn JSON.parse( data + \"\" );\n};\n\n\n// Cross-browser xml parsing\njQuery.parseXML = function( data ) {\n\tvar xml;\n\tif ( !data || typeof data !== \"string\" ) {\n\t\treturn null;\n\t}\n\n\t// Support: IE9\n\ttry {\n\t\txml = ( new window.DOMParser() ).parseFromString( data, \"text/xml\" );\n\t} catch ( e ) {\n\t\txml = undefined;\n\t}\n\n\tif ( !xml || xml.getElementsByTagName( \"parsererror\" ).length ) {\n\t\tjQuery.error( \"Invalid XML: \" + data );\n\t}\n\treturn xml;\n};\n\n\nvar\n\trhash = /#.*$/,\n\trts = /([?&])_=[^&]*/,\n\trheaders = /^(.*?):[ \\t]*([^\\r\\n]*)$/mg,\n\n\t// #7653, #8125, #8152: local protocol detection\n\trlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,\n\trnoContent = /^(?:GET|HEAD)$/,\n\trprotocol = /^\\/\\//,\n\n\t/* Prefilters\n\t * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)\n\t * 2) These are called:\n\t *    - BEFORE asking for a transport\n\t *    - AFTER param serialization (s.data is a string if s.processData is true)\n\t * 3) key is the dataType\n\t * 4) the catchall symbol \"*\" can be used\n\t * 5) execution will start with transport dataType and THEN continue down to \"*\" if needed\n\t */\n\tprefilters = {},\n\n\t/* Transports bindings\n\t * 1) key is the dataType\n\t * 2) the catchall symbol \"*\" can be used\n\t * 3) selection will start with transport dataType and THEN go to \"*\" if needed\n\t */\n\ttransports = {},\n\n\t// Avoid comment-prolog char sequence (#10098); must appease lint and evade compression\n\tallTypes = \"*/\".concat( \"*\" ),\n\n\t// Anchor tag for parsing the document origin\n\toriginAnchor = document.createElement( \"a\" );\n\toriginAnchor.href = location.href;\n\n// Base \"constructor\" for jQuery.ajaxPrefilter and jQuery.ajaxTransport\nfunction addToPrefiltersOrTransports( structure ) {\n\n\t// dataTypeExpression is optional and defaults to \"*\"\n\treturn function( dataTypeExpression, func ) {\n\n\t\tif ( typeof dataTypeExpression !== \"string\" ) {\n\t\t\tfunc = dataTypeExpression;\n\t\t\tdataTypeExpression = \"*\";\n\t\t}\n\n\t\tvar dataType,\n\t\t\ti = 0,\n\t\t\tdataTypes = dataTypeExpression.toLowerCase().match( rnotwhite ) || [];\n\n\t\tif ( jQuery.isFunction( func ) ) {\n\n\t\t\t// For each dataType in the dataTypeExpression\n\t\t\twhile ( ( dataType = dataTypes[ i++ ] ) ) {\n\n\t\t\t\t// Prepend if requested\n\t\t\t\tif ( dataType[ 0 ] === \"+\" ) {\n\t\t\t\t\tdataType = dataType.slice( 1 ) || \"*\";\n\t\t\t\t\t( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func );\n\n\t\t\t\t// Otherwise append\n\t\t\t\t} else {\n\t\t\t\t\t( structure[ dataType ] = structure[ dataType ] || [] ).push( func );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n}\n\n// Base inspection function for prefilters and transports\nfunction inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {\n\n\tvar inspected = {},\n\t\tseekingTransport = ( structure === transports );\n\n\tfunction inspect( dataType ) {\n\t\tvar selected;\n\t\tinspected[ dataType ] = true;\n\t\tjQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {\n\t\t\tvar dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );\n\t\t\tif ( typeof dataTypeOrTransport === \"string\" &&\n\t\t\t\t!seekingTransport && !inspected[ dataTypeOrTransport ] ) {\n\n\t\t\t\toptions.dataTypes.unshift( dataTypeOrTransport );\n\t\t\t\tinspect( dataTypeOrTransport );\n\t\t\t\treturn false;\n\t\t\t} else if ( seekingTransport ) {\n\t\t\t\treturn !( selected = dataTypeOrTransport );\n\t\t\t}\n\t\t} );\n\t\treturn selected;\n\t}\n\n\treturn inspect( options.dataTypes[ 0 ] ) || !inspected[ \"*\" ] && inspect( \"*\" );\n}\n\n// A special extend for ajax options\n// that takes \"flat\" options (not to be deep extended)\n// Fixes #9887\nfunction ajaxExtend( target, src ) {\n\tvar key, deep,\n\t\tflatOptions = jQuery.ajaxSettings.flatOptions || {};\n\n\tfor ( key in src ) {\n\t\tif ( src[ key ] !== undefined ) {\n\t\t\t( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];\n\t\t}\n\t}\n\tif ( deep ) {\n\t\tjQuery.extend( true, target, deep );\n\t}\n\n\treturn target;\n}\n\n/* Handles responses to an ajax request:\n * - finds the right dataType (mediates between content-type and expected dataType)\n * - returns the corresponding response\n */\nfunction ajaxHandleResponses( s, jqXHR, responses ) {\n\n\tvar ct, type, finalDataType, firstDataType,\n\t\tcontents = s.contents,\n\t\tdataTypes = s.dataTypes;\n\n\t// Remove auto dataType and get content-type in the process\n\twhile ( dataTypes[ 0 ] === \"*\" ) {\n\t\tdataTypes.shift();\n\t\tif ( ct === undefined ) {\n\t\t\tct = s.mimeType || jqXHR.getResponseHeader( \"Content-Type\" );\n\t\t}\n\t}\n\n\t// Check if we're dealing with a known content-type\n\tif ( ct ) {\n\t\tfor ( type in contents ) {\n\t\t\tif ( contents[ type ] && contents[ type ].test( ct ) ) {\n\t\t\t\tdataTypes.unshift( type );\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n\n\t// Check to see if we have a response for the expected dataType\n\tif ( dataTypes[ 0 ] in responses ) {\n\t\tfinalDataType = dataTypes[ 0 ];\n\t} else {\n\n\t\t// Try convertible dataTypes\n\t\tfor ( type in responses ) {\n\t\t\tif ( !dataTypes[ 0 ] || s.converters[ type + \" \" + dataTypes[ 0 ] ] ) {\n\t\t\t\tfinalDataType = type;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tif ( !firstDataType ) {\n\t\t\t\tfirstDataType = type;\n\t\t\t}\n\t\t}\n\n\t\t// Or just use first one\n\t\tfinalDataType = finalDataType || firstDataType;\n\t}\n\n\t// If we found a dataType\n\t// We add the dataType to the list if needed\n\t// and return the corresponding response\n\tif ( finalDataType ) {\n\t\tif ( finalDataType !== dataTypes[ 0 ] ) {\n\t\t\tdataTypes.unshift( finalDataType );\n\t\t}\n\t\treturn responses[ finalDataType ];\n\t}\n}\n\n/* Chain conversions given the request and the original response\n * Also sets the responseXXX fields on the jqXHR instance\n */\nfunction ajaxConvert( s, response, jqXHR, isSuccess ) {\n\tvar conv2, current, conv, tmp, prev,\n\t\tconverters = {},\n\n\t\t// Work with a copy of dataTypes in case we need to modify it for conversion\n\t\tdataTypes = s.dataTypes.slice();\n\n\t// Create converters map with lowercased keys\n\tif ( dataTypes[ 1 ] ) {\n\t\tfor ( conv in s.converters ) {\n\t\t\tconverters[ conv.toLowerCase() ] = s.converters[ conv ];\n\t\t}\n\t}\n\n\tcurrent = dataTypes.shift();\n\n\t// Convert to each sequential dataType\n\twhile ( current ) {\n\n\t\tif ( s.responseFields[ current ] ) {\n\t\t\tjqXHR[ s.responseFields[ current ] ] = response;\n\t\t}\n\n\t\t// Apply the dataFilter if provided\n\t\tif ( !prev && isSuccess && s.dataFilter ) {\n\t\t\tresponse = s.dataFilter( response, s.dataType );\n\t\t}\n\n\t\tprev = current;\n\t\tcurrent = dataTypes.shift();\n\n\t\tif ( current ) {\n\n\t\t// There's only work to do if current dataType is non-auto\n\t\t\tif ( current === \"*\" ) {\n\n\t\t\t\tcurrent = prev;\n\n\t\t\t// Convert response if prev dataType is non-auto and differs from current\n\t\t\t} else if ( prev !== \"*\" && prev !== current ) {\n\n\t\t\t\t// Seek a direct converter\n\t\t\t\tconv = converters[ prev + \" \" + current ] || converters[ \"* \" + current ];\n\n\t\t\t\t// If none found, seek a pair\n\t\t\t\tif ( !conv ) {\n\t\t\t\t\tfor ( conv2 in converters ) {\n\n\t\t\t\t\t\t// If conv2 outputs current\n\t\t\t\t\t\ttmp = conv2.split( \" \" );\n\t\t\t\t\t\tif ( tmp[ 1 ] === current ) {\n\n\t\t\t\t\t\t\t// If prev can be converted to accepted input\n\t\t\t\t\t\t\tconv = converters[ prev + \" \" + tmp[ 0 ] ] ||\n\t\t\t\t\t\t\t\tconverters[ \"* \" + tmp[ 0 ] ];\n\t\t\t\t\t\t\tif ( conv ) {\n\n\t\t\t\t\t\t\t\t// Condense equivalence converters\n\t\t\t\t\t\t\t\tif ( conv === true ) {\n\t\t\t\t\t\t\t\t\tconv = converters[ conv2 ];\n\n\t\t\t\t\t\t\t\t// Otherwise, insert the intermediate dataType\n\t\t\t\t\t\t\t\t} else if ( converters[ conv2 ] !== true ) {\n\t\t\t\t\t\t\t\t\tcurrent = tmp[ 0 ];\n\t\t\t\t\t\t\t\t\tdataTypes.unshift( tmp[ 1 ] );\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Apply converter (if not an equivalence)\n\t\t\t\tif ( conv !== true ) {\n\n\t\t\t\t\t// Unless errors are allowed to bubble, catch and return them\n\t\t\t\t\tif ( conv && s.throws ) {\n\t\t\t\t\t\tresponse = conv( response );\n\t\t\t\t\t} else {\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\tresponse = conv( response );\n\t\t\t\t\t\t} catch ( e ) {\n\t\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\t\tstate: \"parsererror\",\n\t\t\t\t\t\t\t\terror: conv ? e : \"No conversion from \" + prev + \" to \" + current\n\t\t\t\t\t\t\t};\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\treturn { state: \"success\", data: response };\n}\n\njQuery.extend( {\n\n\t// Counter for holding the number of active queries\n\tactive: 0,\n\n\t// Last-Modified header cache for next request\n\tlastModified: {},\n\tetag: {},\n\n\tajaxSettings: {\n\t\turl: location.href,\n\t\ttype: \"GET\",\n\t\tisLocal: rlocalProtocol.test( location.protocol ),\n\t\tglobal: true,\n\t\tprocessData: true,\n\t\tasync: true,\n\t\tcontentType: \"application/x-www-form-urlencoded; charset=UTF-8\",\n\t\t/*\n\t\ttimeout: 0,\n\t\tdata: null,\n\t\tdataType: null,\n\t\tusername: null,\n\t\tpassword: null,\n\t\tcache: null,\n\t\tthrows: false,\n\t\ttraditional: false,\n\t\theaders: {},\n\t\t*/\n\n\t\taccepts: {\n\t\t\t\"*\": allTypes,\n\t\t\ttext: \"text/plain\",\n\t\t\thtml: \"text/html\",\n\t\t\txml: \"application/xml, text/xml\",\n\t\t\tjson: \"application/json, text/javascript\"\n\t\t},\n\n\t\tcontents: {\n\t\t\txml: /\\bxml\\b/,\n\t\t\thtml: /\\bhtml/,\n\t\t\tjson: /\\bjson\\b/\n\t\t},\n\n\t\tresponseFields: {\n\t\t\txml: \"responseXML\",\n\t\t\ttext: \"responseText\",\n\t\t\tjson: \"responseJSON\"\n\t\t},\n\n\t\t// Data converters\n\t\t// Keys separate source (or catchall \"*\") and destination types with a single space\n\t\tconverters: {\n\n\t\t\t// Convert anything to text\n\t\t\t\"* text\": String,\n\n\t\t\t// Text to html (true = no transformation)\n\t\t\t\"text html\": true,\n\n\t\t\t// Evaluate text as a json expression\n\t\t\t\"text json\": jQuery.parseJSON,\n\n\t\t\t// Parse text as xml\n\t\t\t\"text xml\": jQuery.parseXML\n\t\t},\n\n\t\t// For options that shouldn't be deep extended:\n\t\t// you can add your own custom options here if\n\t\t// and when you create one that shouldn't be\n\t\t// deep extended (see ajaxExtend)\n\t\tflatOptions: {\n\t\t\turl: true,\n\t\t\tcontext: true\n\t\t}\n\t},\n\n\t// Creates a full fledged settings object into target\n\t// with both ajaxSettings and settings fields.\n\t// If target is omitted, writes into ajaxSettings.\n\tajaxSetup: function( target, settings ) {\n\t\treturn settings ?\n\n\t\t\t// Building a settings object\n\t\t\tajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :\n\n\t\t\t// Extending ajaxSettings\n\t\t\tajaxExtend( jQuery.ajaxSettings, target );\n\t},\n\n\tajaxPrefilter: addToPrefiltersOrTransports( prefilters ),\n\tajaxTransport: addToPrefiltersOrTransports( transports ),\n\n\t// Main method\n\tajax: function( url, options ) {\n\n\t\t// If url is an object, simulate pre-1.5 signature\n\t\tif ( typeof url === \"object\" ) {\n\t\t\toptions = url;\n\t\t\turl = undefined;\n\t\t}\n\n\t\t// Force options to be an object\n\t\toptions = options || {};\n\n\t\tvar transport,\n\n\t\t\t// URL without anti-cache param\n\t\t\tcacheURL,\n\n\t\t\t// Response headers\n\t\t\tresponseHeadersString,\n\t\t\tresponseHeaders,\n\n\t\t\t// timeout handle\n\t\t\ttimeoutTimer,\n\n\t\t\t// Url cleanup var\n\t\t\turlAnchor,\n\n\t\t\t// To know if global events are to be dispatched\n\t\t\tfireGlobals,\n\n\t\t\t// Loop variable\n\t\t\ti,\n\n\t\t\t// Create the final options object\n\t\t\ts = jQuery.ajaxSetup( {}, options ),\n\n\t\t\t// Callbacks context\n\t\t\tcallbackContext = s.context || s,\n\n\t\t\t// Context for global events is callbackContext if it is a DOM node or jQuery collection\n\t\t\tglobalEventContext = s.context &&\n\t\t\t\t( callbackContext.nodeType || callbackContext.jquery ) ?\n\t\t\t\t\tjQuery( callbackContext ) :\n\t\t\t\t\tjQuery.event,\n\n\t\t\t// Deferreds\n\t\t\tdeferred = jQuery.Deferred(),\n\t\t\tcompleteDeferred = jQuery.Callbacks( \"once memory\" ),\n\n\t\t\t// Status-dependent callbacks\n\t\t\tstatusCode = s.statusCode || {},\n\n\t\t\t// Headers (they are sent all at once)\n\t\t\trequestHeaders = {},\n\t\t\trequestHeadersNames = {},\n\n\t\t\t// The jqXHR state\n\t\t\tstate = 0,\n\n\t\t\t// Default abort message\n\t\t\tstrAbort = \"canceled\",\n\n\t\t\t// Fake xhr\n\t\t\tjqXHR = {\n\t\t\t\treadyState: 0,\n\n\t\t\t\t// Builds headers hashtable if needed\n\t\t\t\tgetResponseHeader: function( key ) {\n\t\t\t\t\tvar match;\n\t\t\t\t\tif ( state === 2 ) {\n\t\t\t\t\t\tif ( !responseHeaders ) {\n\t\t\t\t\t\t\tresponseHeaders = {};\n\t\t\t\t\t\t\twhile ( ( match = rheaders.exec( responseHeadersString ) ) ) {\n\t\t\t\t\t\t\t\tresponseHeaders[ match[ 1 ].toLowerCase() ] = match[ 2 ];\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\tmatch = responseHeaders[ key.toLowerCase() ];\n\t\t\t\t\t}\n\t\t\t\t\treturn match == null ? null : match;\n\t\t\t\t},\n\n\t\t\t\t// Raw string\n\t\t\t\tgetAllResponseHeaders: function() {\n\t\t\t\t\treturn state === 2 ? responseHeadersString : null;\n\t\t\t\t},\n\n\t\t\t\t// Caches the header\n\t\t\t\tsetRequestHeader: function( name, value ) {\n\t\t\t\t\tvar lname = name.toLowerCase();\n\t\t\t\t\tif ( !state ) {\n\t\t\t\t\t\tname = requestHeadersNames[ lname ] = requestHeadersNames[ lname ] || name;\n\t\t\t\t\t\trequestHeaders[ name ] = value;\n\t\t\t\t\t}\n\t\t\t\t\treturn this;\n\t\t\t\t},\n\n\t\t\t\t// Overrides response content-type header\n\t\t\t\toverrideMimeType: function( type ) {\n\t\t\t\t\tif ( !state ) {\n\t\t\t\t\t\ts.mimeType = type;\n\t\t\t\t\t}\n\t\t\t\t\treturn this;\n\t\t\t\t},\n\n\t\t\t\t// Status-dependent callbacks\n\t\t\t\tstatusCode: function( map ) {\n\t\t\t\t\tvar code;\n\t\t\t\t\tif ( map ) {\n\t\t\t\t\t\tif ( state < 2 ) {\n\t\t\t\t\t\t\tfor ( code in map ) {\n\n\t\t\t\t\t\t\t\t// Lazy-add the new callback in a way that preserves old ones\n\t\t\t\t\t\t\t\tstatusCode[ code ] = [ statusCode[ code ], map[ code ] ];\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else {\n\n\t\t\t\t\t\t\t// Execute the appropriate callbacks\n\t\t\t\t\t\t\tjqXHR.always( map[ jqXHR.status ] );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\treturn this;\n\t\t\t\t},\n\n\t\t\t\t// Cancel the request\n\t\t\t\tabort: function( statusText ) {\n\t\t\t\t\tvar finalText = statusText || strAbort;\n\t\t\t\t\tif ( transport ) {\n\t\t\t\t\t\ttransport.abort( finalText );\n\t\t\t\t\t}\n\t\t\t\t\tdone( 0, finalText );\n\t\t\t\t\treturn this;\n\t\t\t\t}\n\t\t\t};\n\n\t\t// Attach deferreds\n\t\tdeferred.promise( jqXHR ).complete = completeDeferred.add;\n\t\tjqXHR.success = jqXHR.done;\n\t\tjqXHR.error = jqXHR.fail;\n\n\t\t// Remove hash character (#7531: and string promotion)\n\t\t// Add protocol if not provided (prefilters might expect it)\n\t\t// Handle falsy url in the settings object (#10093: consistency with old signature)\n\t\t// We also use the url parameter if available\n\t\ts.url = ( ( url || s.url || location.href ) + \"\" ).replace( rhash, \"\" )\n\t\t\t.replace( rprotocol, location.protocol + \"//\" );\n\n\t\t// Alias method option to type as per ticket #12004\n\t\ts.type = options.method || options.type || s.method || s.type;\n\n\t\t// Extract dataTypes list\n\t\ts.dataTypes = jQuery.trim( s.dataType || \"*\" ).toLowerCase().match( rnotwhite ) || [ \"\" ];\n\n\t\t// A cross-domain request is in order when the origin doesn't match the current origin.\n\t\tif ( s.crossDomain == null ) {\n\t\t\turlAnchor = document.createElement( \"a\" );\n\n\t\t\t// Support: IE8-11+\n\t\t\t// IE throws exception if url is malformed, e.g. http://example.com:80x/\n\t\t\ttry {\n\t\t\t\turlAnchor.href = s.url;\n\n\t\t\t\t// Support: IE8-11+\n\t\t\t\t// Anchor's host property isn't correctly set when s.url is relative\n\t\t\t\turlAnchor.href = urlAnchor.href;\n\t\t\t\ts.crossDomain = originAnchor.protocol + \"//\" + originAnchor.host !==\n\t\t\t\t\turlAnchor.protocol + \"//\" + urlAnchor.host;\n\t\t\t} catch ( e ) {\n\n\t\t\t\t// If there is an error parsing the URL, assume it is crossDomain,\n\t\t\t\t// it can be rejected by the transport if it is invalid\n\t\t\t\ts.crossDomain = true;\n\t\t\t}\n\t\t}\n\n\t\t// Convert data if not already a string\n\t\tif ( s.data && s.processData && typeof s.data !== \"string\" ) {\n\t\t\ts.data = jQuery.param( s.data, s.traditional );\n\t\t}\n\n\t\t// Apply prefilters\n\t\tinspectPrefiltersOrTransports( prefilters, s, options, jqXHR );\n\n\t\t// If request was aborted inside a prefilter, stop there\n\t\tif ( state === 2 ) {\n\t\t\treturn jqXHR;\n\t\t}\n\n\t\t// We can fire global events as of now if asked to\n\t\t// Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118)\n\t\tfireGlobals = jQuery.event && s.global;\n\n\t\t// Watch for a new set of requests\n\t\tif ( fireGlobals && jQuery.active++ === 0 ) {\n\t\t\tjQuery.event.trigger( \"ajaxStart\" );\n\t\t}\n\n\t\t// Uppercase the type\n\t\ts.type = s.type.toUpperCase();\n\n\t\t// Determine if request has content\n\t\ts.hasContent = !rnoContent.test( s.type );\n\n\t\t// Save the URL in case we're toying with the If-Modified-Since\n\t\t// and/or If-None-Match header later on\n\t\tcacheURL = s.url;\n\n\t\t// More options handling for requests with no content\n\t\tif ( !s.hasContent ) {\n\n\t\t\t// If data is available, append data to url\n\t\t\tif ( s.data ) {\n\t\t\t\tcacheURL = ( s.url += ( rquery.test( cacheURL ) ? \"&\" : \"?\" ) + s.data );\n\n\t\t\t\t// #9682: remove data so that it's not used in an eventual retry\n\t\t\t\tdelete s.data;\n\t\t\t}\n\n\t\t\t// Add anti-cache in url if needed\n\t\t\tif ( s.cache === false ) {\n\t\t\t\ts.url = rts.test( cacheURL ) ?\n\n\t\t\t\t\t// If there is already a '_' parameter, set its value\n\t\t\t\t\tcacheURL.replace( rts, \"$1_=\" + nonce++ ) :\n\n\t\t\t\t\t// Otherwise add one to the end\n\t\t\t\t\tcacheURL + ( rquery.test( cacheURL ) ? \"&\" : \"?\" ) + \"_=\" + nonce++;\n\t\t\t}\n\t\t}\n\n\t\t// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.\n\t\tif ( s.ifModified ) {\n\t\t\tif ( jQuery.lastModified[ cacheURL ] ) {\n\t\t\t\tjqXHR.setRequestHeader( \"If-Modified-Since\", jQuery.lastModified[ cacheURL ] );\n\t\t\t}\n\t\t\tif ( jQuery.etag[ cacheURL ] ) {\n\t\t\t\tjqXHR.setRequestHeader( \"If-None-Match\", jQuery.etag[ cacheURL ] );\n\t\t\t}\n\t\t}\n\n\t\t// Set the correct header, if data is being sent\n\t\tif ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {\n\t\t\tjqXHR.setRequestHeader( \"Content-Type\", s.contentType );\n\t\t}\n\n\t\t// Set the Accepts header for the server, depending on the dataType\n\t\tjqXHR.setRequestHeader(\n\t\t\t\"Accept\",\n\t\t\ts.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ?\n\t\t\t\ts.accepts[ s.dataTypes[ 0 ] ] +\n\t\t\t\t\t( s.dataTypes[ 0 ] !== \"*\" ? \", \" + allTypes + \"; q=0.01\" : \"\" ) :\n\t\t\t\ts.accepts[ \"*\" ]\n\t\t);\n\n\t\t// Check for headers option\n\t\tfor ( i in s.headers ) {\n\t\t\tjqXHR.setRequestHeader( i, s.headers[ i ] );\n\t\t}\n\n\t\t// Allow custom headers/mimetypes and early abort\n\t\tif ( s.beforeSend &&\n\t\t\t( s.beforeSend.call( callbackContext, jqXHR, s ) === false || state === 2 ) ) {\n\n\t\t\t// Abort if not done already and return\n\t\t\treturn jqXHR.abort();\n\t\t}\n\n\t\t// Aborting is no longer a cancellation\n\t\tstrAbort = \"abort\";\n\n\t\t// Install callbacks on deferreds\n\t\tfor ( i in { success: 1, error: 1, complete: 1 } ) {\n\t\t\tjqXHR[ i ]( s[ i ] );\n\t\t}\n\n\t\t// Get transport\n\t\ttransport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );\n\n\t\t// If no transport, we auto-abort\n\t\tif ( !transport ) {\n\t\t\tdone( -1, \"No Transport\" );\n\t\t} else {\n\t\t\tjqXHR.readyState = 1;\n\n\t\t\t// Send global event\n\t\t\tif ( fireGlobals ) {\n\t\t\t\tglobalEventContext.trigger( \"ajaxSend\", [ jqXHR, s ] );\n\t\t\t}\n\n\t\t\t// If request was aborted inside ajaxSend, stop there\n\t\t\tif ( state === 2 ) {\n\t\t\t\treturn jqXHR;\n\t\t\t}\n\n\t\t\t// Timeout\n\t\t\tif ( s.async && s.timeout > 0 ) {\n\t\t\t\ttimeoutTimer = window.setTimeout( function() {\n\t\t\t\t\tjqXHR.abort( \"timeout\" );\n\t\t\t\t}, s.timeout );\n\t\t\t}\n\n\t\t\ttry {\n\t\t\t\tstate = 1;\n\t\t\t\ttransport.send( requestHeaders, done );\n\t\t\t} catch ( e ) {\n\n\t\t\t\t// Propagate exception as error if not done\n\t\t\t\tif ( state < 2 ) {\n\t\t\t\t\tdone( -1, e );\n\n\t\t\t\t// Simply rethrow otherwise\n\t\t\t\t} else {\n\t\t\t\t\tthrow e;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Callback for when everything is done\n\t\tfunction done( status, nativeStatusText, responses, headers ) {\n\t\t\tvar isSuccess, success, error, response, modified,\n\t\t\t\tstatusText = nativeStatusText;\n\n\t\t\t// Called once\n\t\t\tif ( state === 2 ) {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// State is \"done\" now\n\t\t\tstate = 2;\n\n\t\t\t// Clear timeout if it exists\n\t\t\tif ( timeoutTimer ) {\n\t\t\t\twindow.clearTimeout( timeoutTimer );\n\t\t\t}\n\n\t\t\t// Dereference transport for early garbage collection\n\t\t\t// (no matter how long the jqXHR object will be used)\n\t\t\ttransport = undefined;\n\n\t\t\t// Cache response headers\n\t\t\tresponseHeadersString = headers || \"\";\n\n\t\t\t// Set readyState\n\t\t\tjqXHR.readyState = status > 0 ? 4 : 0;\n\n\t\t\t// Determine if successful\n\t\t\tisSuccess = status >= 200 && status < 300 || status === 304;\n\n\t\t\t// Get response data\n\t\t\tif ( responses ) {\n\t\t\t\tresponse = ajaxHandleResponses( s, jqXHR, responses );\n\t\t\t}\n\n\t\t\t// Convert no matter what (that way responseXXX fields are always set)\n\t\t\tresponse = ajaxConvert( s, response, jqXHR, isSuccess );\n\n\t\t\t// If successful, handle type chaining\n\t\t\tif ( isSuccess ) {\n\n\t\t\t\t// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.\n\t\t\t\tif ( s.ifModified ) {\n\t\t\t\t\tmodified = jqXHR.getResponseHeader( \"Last-Modified\" );\n\t\t\t\t\tif ( modified ) {\n\t\t\t\t\t\tjQuery.lastModified[ cacheURL ] = modified;\n\t\t\t\t\t}\n\t\t\t\t\tmodified = jqXHR.getResponseHeader( \"etag\" );\n\t\t\t\t\tif ( modified ) {\n\t\t\t\t\t\tjQuery.etag[ cacheURL ] = modified;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// if no content\n\t\t\t\tif ( status === 204 || s.type === \"HEAD\" ) {\n\t\t\t\t\tstatusText = \"nocontent\";\n\n\t\t\t\t// if not modified\n\t\t\t\t} else if ( status === 304 ) {\n\t\t\t\t\tstatusText = \"notmodified\";\n\n\t\t\t\t// If we have data, let's convert it\n\t\t\t\t} else {\n\t\t\t\t\tstatusText = response.state;\n\t\t\t\t\tsuccess = response.data;\n\t\t\t\t\terror = response.error;\n\t\t\t\t\tisSuccess = !error;\n\t\t\t\t}\n\t\t\t} else {\n\n\t\t\t\t// Extract error from statusText and normalize for non-aborts\n\t\t\t\terror = statusText;\n\t\t\t\tif ( status || !statusText ) {\n\t\t\t\t\tstatusText = \"error\";\n\t\t\t\t\tif ( status < 0 ) {\n\t\t\t\t\t\tstatus = 0;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Set data for the fake xhr object\n\t\t\tjqXHR.status = status;\n\t\t\tjqXHR.statusText = ( nativeStatusText || statusText ) + \"\";\n\n\t\t\t// Success/Error\n\t\t\tif ( isSuccess ) {\n\t\t\t\tdeferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );\n\t\t\t} else {\n\t\t\t\tdeferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );\n\t\t\t}\n\n\t\t\t// Status-dependent callbacks\n\t\t\tjqXHR.statusCode( statusCode );\n\t\t\tstatusCode = undefined;\n\n\t\t\tif ( fireGlobals ) {\n\t\t\t\tglobalEventContext.trigger( isSuccess ? \"ajaxSuccess\" : \"ajaxError\",\n\t\t\t\t\t[ jqXHR, s, isSuccess ? success : error ] );\n\t\t\t}\n\n\t\t\t// Complete\n\t\t\tcompleteDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );\n\n\t\t\tif ( fireGlobals ) {\n\t\t\t\tglobalEventContext.trigger( \"ajaxComplete\", [ jqXHR, s ] );\n\n\t\t\t\t// Handle the global AJAX counter\n\t\t\t\tif ( !( --jQuery.active ) ) {\n\t\t\t\t\tjQuery.event.trigger( \"ajaxStop\" );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn jqXHR;\n\t},\n\n\tgetJSON: function( url, data, callback ) {\n\t\treturn jQuery.get( url, data, callback, \"json\" );\n\t},\n\n\tgetScript: function( url, callback ) {\n\t\treturn jQuery.get( url, undefined, callback, \"script\" );\n\t}\n} );\n\njQuery.each( [ \"get\", \"post\" ], function( i, method ) {\n\tjQuery[ method ] = function( url, data, callback, type ) {\n\n\t\t// Shift arguments if data argument was omitted\n\t\tif ( jQuery.isFunction( data ) ) {\n\t\t\ttype = type || callback;\n\t\t\tcallback = data;\n\t\t\tdata = undefined;\n\t\t}\n\n\t\t// The url can be an options object (which then must have .url)\n\t\treturn jQuery.ajax( jQuery.extend( {\n\t\t\turl: url,\n\t\t\ttype: method,\n\t\t\tdataType: type,\n\t\t\tdata: data,\n\t\t\tsuccess: callback\n\t\t}, jQuery.isPlainObject( url ) && url ) );\n\t};\n} );\n\n\njQuery._evalUrl = function( url ) {\n\treturn jQuery.ajax( {\n\t\turl: url,\n\n\t\t// Make this explicit, since user can override this through ajaxSetup (#11264)\n\t\ttype: \"GET\",\n\t\tdataType: \"script\",\n\t\tasync: false,\n\t\tglobal: false,\n\t\t\"throws\": true\n\t} );\n};\n\n\njQuery.fn.extend( {\n\twrapAll: function( html ) {\n\t\tvar wrap;\n\n\t\tif ( jQuery.isFunction( html ) ) {\n\t\t\treturn this.each( function( i ) {\n\t\t\t\tjQuery( this ).wrapAll( html.call( this, i ) );\n\t\t\t} );\n\t\t}\n\n\t\tif ( this[ 0 ] ) {\n\n\t\t\t// The elements to wrap the target around\n\t\t\twrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true );\n\n\t\t\tif ( this[ 0 ].parentNode ) {\n\t\t\t\twrap.insertBefore( this[ 0 ] );\n\t\t\t}\n\n\t\t\twrap.map( function() {\n\t\t\t\tvar elem = this;\n\n\t\t\t\twhile ( elem.firstElementChild ) {\n\t\t\t\t\telem = elem.firstElementChild;\n\t\t\t\t}\n\n\t\t\t\treturn elem;\n\t\t\t} ).append( this );\n\t\t}\n\n\t\treturn this;\n\t},\n\n\twrapInner: function( html ) {\n\t\tif ( jQuery.isFunction( html ) ) {\n\t\t\treturn this.each( function( i ) {\n\t\t\t\tjQuery( this ).wrapInner( html.call( this, i ) );\n\t\t\t} );\n\t\t}\n\n\t\treturn this.each( function() {\n\t\t\tvar self = jQuery( this ),\n\t\t\t\tcontents = self.contents();\n\n\t\t\tif ( contents.length ) {\n\t\t\t\tcontents.wrapAll( html );\n\n\t\t\t} else {\n\t\t\t\tself.append( html );\n\t\t\t}\n\t\t} );\n\t},\n\n\twrap: function( html ) {\n\t\tvar isFunction = jQuery.isFunction( html );\n\n\t\treturn this.each( function( i ) {\n\t\t\tjQuery( this ).wrapAll( isFunction ? html.call( this, i ) : html );\n\t\t} );\n\t},\n\n\tunwrap: function() {\n\t\treturn this.parent().each( function() {\n\t\t\tif ( !jQuery.nodeName( this, \"body\" ) ) {\n\t\t\t\tjQuery( this ).replaceWith( this.childNodes );\n\t\t\t}\n\t\t} ).end();\n\t}\n} );\n\n\njQuery.expr.filters.hidden = function( elem ) {\n\treturn !jQuery.expr.filters.visible( elem );\n};\njQuery.expr.filters.visible = function( elem ) {\n\n\t// Support: Opera <= 12.12\n\t// Opera reports offsetWidths and offsetHeights less than zero on some elements\n\t// Use OR instead of AND as the element is not visible if either is true\n\t// See tickets #10406 and #13132\n\treturn elem.offsetWidth > 0 || elem.offsetHeight > 0 || elem.getClientRects().length > 0;\n};\n\n\n\n\nvar r20 = /%20/g,\n\trbracket = /\\[\\]$/,\n\trCRLF = /\\r?\\n/g,\n\trsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,\n\trsubmittable = /^(?:input|select|textarea|keygen)/i;\n\nfunction buildParams( prefix, obj, traditional, add ) {\n\tvar name;\n\n\tif ( jQuery.isArray( obj ) ) {\n\n\t\t// Serialize array item.\n\t\tjQuery.each( obj, function( i, v ) {\n\t\t\tif ( traditional || rbracket.test( prefix ) ) {\n\n\t\t\t\t// Treat each array item as a scalar.\n\t\t\t\tadd( prefix, v );\n\n\t\t\t} else {\n\n\t\t\t\t// Item is non-scalar (array or object), encode its numeric index.\n\t\t\t\tbuildParams(\n\t\t\t\t\tprefix + \"[\" + ( typeof v === \"object\" && v != null ? i : \"\" ) + \"]\",\n\t\t\t\t\tv,\n\t\t\t\t\ttraditional,\n\t\t\t\t\tadd\n\t\t\t\t);\n\t\t\t}\n\t\t} );\n\n\t} else if ( !traditional && jQuery.type( obj ) === \"object\" ) {\n\n\t\t// Serialize object item.\n\t\tfor ( name in obj ) {\n\t\t\tbuildParams( prefix + \"[\" + name + \"]\", obj[ name ], traditional, add );\n\t\t}\n\n\t} else {\n\n\t\t// Serialize scalar item.\n\t\tadd( prefix, obj );\n\t}\n}\n\n// Serialize an array of form elements or a set of\n// key/values into a query string\njQuery.param = function( a, traditional ) {\n\tvar prefix,\n\t\ts = [],\n\t\tadd = function( key, value ) {\n\n\t\t\t// If value is a function, invoke it and return its value\n\t\t\tvalue = jQuery.isFunction( value ) ? value() : ( value == null ? \"\" : value );\n\t\t\ts[ s.length ] = encodeURIComponent( key ) + \"=\" + encodeURIComponent( value );\n\t\t};\n\n\t// Set traditional to true for jQuery <= 1.3.2 behavior.\n\tif ( traditional === undefined ) {\n\t\ttraditional = jQuery.ajaxSettings && jQuery.ajaxSettings.traditional;\n\t}\n\n\t// If an array was passed in, assume that it is an array of form elements.\n\tif ( jQuery.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {\n\n\t\t// Serialize the form elements\n\t\tjQuery.each( a, function() {\n\t\t\tadd( this.name, this.value );\n\t\t} );\n\n\t} else {\n\n\t\t// If traditional, encode the \"old\" way (the way 1.3.2 or older\n\t\t// did it), otherwise encode params recursively.\n\t\tfor ( prefix in a ) {\n\t\t\tbuildParams( prefix, a[ prefix ], traditional, add );\n\t\t}\n\t}\n\n\t// Return the resulting serialization\n\treturn s.join( \"&\" ).replace( r20, \"+\" );\n};\n\njQuery.fn.extend( {\n\tserialize: function() {\n\t\treturn jQuery.param( this.serializeArray() );\n\t},\n\tserializeArray: function() {\n\t\treturn this.map( function() {\n\n\t\t\t// Can add propHook for \"elements\" to filter or add form elements\n\t\t\tvar elements = jQuery.prop( this, \"elements\" );\n\t\t\treturn elements ? jQuery.makeArray( elements ) : this;\n\t\t} )\n\t\t.filter( function() {\n\t\t\tvar type = this.type;\n\n\t\t\t// Use .is( \":disabled\" ) so that fieldset[disabled] works\n\t\t\treturn this.name && !jQuery( this ).is( \":disabled\" ) &&\n\t\t\t\trsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) &&\n\t\t\t\t( this.checked || !rcheckableType.test( type ) );\n\t\t} )\n\t\t.map( function( i, elem ) {\n\t\t\tvar val = jQuery( this ).val();\n\n\t\t\treturn val == null ?\n\t\t\t\tnull :\n\t\t\t\tjQuery.isArray( val ) ?\n\t\t\t\t\tjQuery.map( val, function( val ) {\n\t\t\t\t\t\treturn { name: elem.name, value: val.replace( rCRLF, \"\\r\\n\" ) };\n\t\t\t\t\t} ) :\n\t\t\t\t\t{ name: elem.name, value: val.replace( rCRLF, \"\\r\\n\" ) };\n\t\t} ).get();\n\t}\n} );\n\n\njQuery.ajaxSettings.xhr = function() {\n\ttry {\n\t\treturn new window.XMLHttpRequest();\n\t} catch ( e ) {}\n};\n\nvar xhrSuccessStatus = {\n\n\t\t// File protocol always yields status code 0, assume 200\n\t\t0: 200,\n\n\t\t// Support: IE9\n\t\t// #1450: sometimes IE returns 1223 when it should be 204\n\t\t1223: 204\n\t},\n\txhrSupported = jQuery.ajaxSettings.xhr();\n\nsupport.cors = !!xhrSupported && ( \"withCredentials\" in xhrSupported );\nsupport.ajax = xhrSupported = !!xhrSupported;\n\njQuery.ajaxTransport( function( options ) {\n\tvar callback, errorCallback;\n\n\t// Cross domain only allowed if supported through XMLHttpRequest\n\tif ( support.cors || xhrSupported && !options.crossDomain ) {\n\t\treturn {\n\t\t\tsend: function( headers, complete ) {\n\t\t\t\tvar i,\n\t\t\t\t\txhr = options.xhr();\n\n\t\t\t\txhr.open(\n\t\t\t\t\toptions.type,\n\t\t\t\t\toptions.url,\n\t\t\t\t\toptions.async,\n\t\t\t\t\toptions.username,\n\t\t\t\t\toptions.password\n\t\t\t\t);\n\n\t\t\t\t// Apply custom fields if provided\n\t\t\t\tif ( options.xhrFields ) {\n\t\t\t\t\tfor ( i in options.xhrFields ) {\n\t\t\t\t\t\txhr[ i ] = options.xhrFields[ i ];\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Override mime type if needed\n\t\t\t\tif ( options.mimeType && xhr.overrideMimeType ) {\n\t\t\t\t\txhr.overrideMimeType( options.mimeType );\n\t\t\t\t}\n\n\t\t\t\t// X-Requested-With header\n\t\t\t\t// For cross-domain requests, seeing as conditions for a preflight are\n\t\t\t\t// akin to a jigsaw puzzle, we simply never set it to be sure.\n\t\t\t\t// (it can always be set on a per-request basis or even using ajaxSetup)\n\t\t\t\t// For same-domain requests, won't change header if already provided.\n\t\t\t\tif ( !options.crossDomain && !headers[ \"X-Requested-With\" ] ) {\n\t\t\t\t\theaders[ \"X-Requested-With\" ] = \"XMLHttpRequest\";\n\t\t\t\t}\n\n\t\t\t\t// Set headers\n\t\t\t\tfor ( i in headers ) {\n\t\t\t\t\txhr.setRequestHeader( i, headers[ i ] );\n\t\t\t\t}\n\n\t\t\t\t// Callback\n\t\t\t\tcallback = function( type ) {\n\t\t\t\t\treturn function() {\n\t\t\t\t\t\tif ( callback ) {\n\t\t\t\t\t\t\tcallback = errorCallback = xhr.onload =\n\t\t\t\t\t\t\t\txhr.onerror = xhr.onabort = xhr.onreadystatechange = null;\n\n\t\t\t\t\t\t\tif ( type === \"abort\" ) {\n\t\t\t\t\t\t\t\txhr.abort();\n\t\t\t\t\t\t\t} else if ( type === \"error\" ) {\n\n\t\t\t\t\t\t\t\t// Support: IE9\n\t\t\t\t\t\t\t\t// On a manual native abort, IE9 throws\n\t\t\t\t\t\t\t\t// errors on any property access that is not readyState\n\t\t\t\t\t\t\t\tif ( typeof xhr.status !== \"number\" ) {\n\t\t\t\t\t\t\t\t\tcomplete( 0, \"error\" );\n\t\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t\tcomplete(\n\n\t\t\t\t\t\t\t\t\t\t// File: protocol always yields status 0; see #8605, #14207\n\t\t\t\t\t\t\t\t\t\txhr.status,\n\t\t\t\t\t\t\t\t\t\txhr.statusText\n\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tcomplete(\n\t\t\t\t\t\t\t\t\txhrSuccessStatus[ xhr.status ] || xhr.status,\n\t\t\t\t\t\t\t\t\txhr.statusText,\n\n\t\t\t\t\t\t\t\t\t// Support: IE9 only\n\t\t\t\t\t\t\t\t\t// IE9 has no XHR2 but throws on binary (trac-11426)\n\t\t\t\t\t\t\t\t\t// For XHR2 non-text, let the caller handle it (gh-2498)\n\t\t\t\t\t\t\t\t\t( xhr.responseType || \"text\" ) !== \"text\"  ||\n\t\t\t\t\t\t\t\t\ttypeof xhr.responseText !== \"string\" ?\n\t\t\t\t\t\t\t\t\t\t{ binary: xhr.response } :\n\t\t\t\t\t\t\t\t\t\t{ text: xhr.responseText },\n\t\t\t\t\t\t\t\t\txhr.getAllResponseHeaders()\n\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\t\t\t\t};\n\n\t\t\t\t// Listen to events\n\t\t\t\txhr.onload = callback();\n\t\t\t\terrorCallback = xhr.onerror = callback( \"error\" );\n\n\t\t\t\t// Support: IE9\n\t\t\t\t// Use onreadystatechange to replace onabort\n\t\t\t\t// to handle uncaught aborts\n\t\t\t\tif ( xhr.onabort !== undefined ) {\n\t\t\t\t\txhr.onabort = errorCallback;\n\t\t\t\t} else {\n\t\t\t\t\txhr.onreadystatechange = function() {\n\n\t\t\t\t\t\t// Check readyState before timeout as it changes\n\t\t\t\t\t\tif ( xhr.readyState === 4 ) {\n\n\t\t\t\t\t\t\t// Allow onerror to be called first,\n\t\t\t\t\t\t\t// but that will not handle a native abort\n\t\t\t\t\t\t\t// Also, save errorCallback to a variable\n\t\t\t\t\t\t\t// as xhr.onerror cannot be accessed\n\t\t\t\t\t\t\twindow.setTimeout( function() {\n\t\t\t\t\t\t\t\tif ( callback ) {\n\t\t\t\t\t\t\t\t\terrorCallback();\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t} );\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\t\t\t\t}\n\n\t\t\t\t// Create the abort callback\n\t\t\t\tcallback = callback( \"abort\" );\n\n\t\t\t\ttry {\n\n\t\t\t\t\t// Do send the request (this may raise an exception)\n\t\t\t\t\txhr.send( options.hasContent && options.data || null );\n\t\t\t\t} catch ( e ) {\n\n\t\t\t\t\t// #14683: Only rethrow if this hasn't been notified as an error yet\n\t\t\t\t\tif ( callback ) {\n\t\t\t\t\t\tthrow e;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t},\n\n\t\t\tabort: function() {\n\t\t\t\tif ( callback ) {\n\t\t\t\t\tcallback();\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\t}\n} );\n\n\n\n\n// Install script dataType\njQuery.ajaxSetup( {\n\taccepts: {\n\t\tscript: \"text/javascript, application/javascript, \" +\n\t\t\t\"application/ecmascript, application/x-ecmascript\"\n\t},\n\tcontents: {\n\t\tscript: /\\b(?:java|ecma)script\\b/\n\t},\n\tconverters: {\n\t\t\"text script\": function( text ) {\n\t\t\tjQuery.globalEval( text );\n\t\t\treturn text;\n\t\t}\n\t}\n} );\n\n// Handle cache's special case and crossDomain\njQuery.ajaxPrefilter( \"script\", function( s ) {\n\tif ( s.cache === undefined ) {\n\t\ts.cache = false;\n\t}\n\tif ( s.crossDomain ) {\n\t\ts.type = \"GET\";\n\t}\n} );\n\n// Bind script tag hack transport\njQuery.ajaxTransport( \"script\", function( s ) {\n\n\t// This transport only deals with cross domain requests\n\tif ( s.crossDomain ) {\n\t\tvar script, callback;\n\t\treturn {\n\t\t\tsend: function( _, complete ) {\n\t\t\t\tscript = jQuery( \"<script>\" ).prop( {\n\t\t\t\t\tcharset: s.scriptCharset,\n\t\t\t\t\tsrc: s.url\n\t\t\t\t} ).on(\n\t\t\t\t\t\"load error\",\n\t\t\t\t\tcallback = function( evt ) {\n\t\t\t\t\t\tscript.remove();\n\t\t\t\t\t\tcallback = null;\n\t\t\t\t\t\tif ( evt ) {\n\t\t\t\t\t\t\tcomplete( evt.type === \"error\" ? 404 : 200, evt.type );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t);\n\n\t\t\t\t// Use native DOM manipulation to avoid our domManip AJAX trickery\n\t\t\t\tdocument.head.appendChild( script[ 0 ] );\n\t\t\t},\n\t\t\tabort: function() {\n\t\t\t\tif ( callback ) {\n\t\t\t\t\tcallback();\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\t}\n} );\n\n\n\n\nvar oldCallbacks = [],\n\trjsonp = /(=)\\?(?=&|$)|\\?\\?/;\n\n// Default jsonp settings\njQuery.ajaxSetup( {\n\tjsonp: \"callback\",\n\tjsonpCallback: function() {\n\t\tvar callback = oldCallbacks.pop() || ( jQuery.expando + \"_\" + ( nonce++ ) );\n\t\tthis[ callback ] = true;\n\t\treturn callback;\n\t}\n} );\n\n// Detect, normalize options and install callbacks for jsonp requests\njQuery.ajaxPrefilter( \"json jsonp\", function( s, originalSettings, jqXHR ) {\n\n\tvar callbackName, overwritten, responseContainer,\n\t\tjsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ?\n\t\t\t\"url\" :\n\t\t\ttypeof s.data === \"string\" &&\n\t\t\t\t( s.contentType || \"\" )\n\t\t\t\t\t.indexOf( \"application/x-www-form-urlencoded\" ) === 0 &&\n\t\t\t\trjsonp.test( s.data ) && \"data\"\n\t\t);\n\n\t// Handle iff the expected data type is \"jsonp\" or we have a parameter to set\n\tif ( jsonProp || s.dataTypes[ 0 ] === \"jsonp\" ) {\n\n\t\t// Get callback name, remembering preexisting value associated with it\n\t\tcallbackName = s.jsonpCallback = jQuery.isFunction( s.jsonpCallback ) ?\n\t\t\ts.jsonpCallback() :\n\t\t\ts.jsonpCallback;\n\n\t\t// Insert callback into url or form data\n\t\tif ( jsonProp ) {\n\t\t\ts[ jsonProp ] = s[ jsonProp ].replace( rjsonp, \"$1\" + callbackName );\n\t\t} else if ( s.jsonp !== false ) {\n\t\t\ts.url += ( rquery.test( s.url ) ? \"&\" : \"?\" ) + s.jsonp + \"=\" + callbackName;\n\t\t}\n\n\t\t// Use data converter to retrieve json after script execution\n\t\ts.converters[ \"script json\" ] = function() {\n\t\t\tif ( !responseContainer ) {\n\t\t\t\tjQuery.error( callbackName + \" was not called\" );\n\t\t\t}\n\t\t\treturn responseContainer[ 0 ];\n\t\t};\n\n\t\t// Force json dataType\n\t\ts.dataTypes[ 0 ] = \"json\";\n\n\t\t// Install callback\n\t\toverwritten = window[ callbackName ];\n\t\twindow[ callbackName ] = function() {\n\t\t\tresponseContainer = arguments;\n\t\t};\n\n\t\t// Clean-up function (fires after converters)\n\t\tjqXHR.always( function() {\n\n\t\t\t// If previous value didn't exist - remove it\n\t\t\tif ( overwritten === undefined ) {\n\t\t\t\tjQuery( window ).removeProp( callbackName );\n\n\t\t\t// Otherwise restore preexisting value\n\t\t\t} else {\n\t\t\t\twindow[ callbackName ] = overwritten;\n\t\t\t}\n\n\t\t\t// Save back as free\n\t\t\tif ( s[ callbackName ] ) {\n\n\t\t\t\t// Make sure that re-using the options doesn't screw things around\n\t\t\t\ts.jsonpCallback = originalSettings.jsonpCallback;\n\n\t\t\t\t// Save the callback name for future use\n\t\t\t\toldCallbacks.push( callbackName );\n\t\t\t}\n\n\t\t\t// Call if it was a function and we have a response\n\t\t\tif ( responseContainer && jQuery.isFunction( overwritten ) ) {\n\t\t\t\toverwritten( responseContainer[ 0 ] );\n\t\t\t}\n\n\t\t\tresponseContainer = overwritten = undefined;\n\t\t} );\n\n\t\t// Delegate to script\n\t\treturn \"script\";\n\t}\n} );\n\n\n\n\n// Argument \"data\" should be string of html\n// context (optional): If specified, the fragment will be created in this context,\n// defaults to document\n// keepScripts (optional): If true, will include scripts passed in the html string\njQuery.parseHTML = function( data, context, keepScripts ) {\n\tif ( !data || typeof data !== \"string\" ) {\n\t\treturn null;\n\t}\n\tif ( typeof context === \"boolean\" ) {\n\t\tkeepScripts = context;\n\t\tcontext = false;\n\t}\n\tcontext = context || document;\n\n\tvar parsed = rsingleTag.exec( data ),\n\t\tscripts = !keepScripts && [];\n\n\t// Single tag\n\tif ( parsed ) {\n\t\treturn [ context.createElement( parsed[ 1 ] ) ];\n\t}\n\n\tparsed = buildFragment( [ data ], context, scripts );\n\n\tif ( scripts && scripts.length ) {\n\t\tjQuery( scripts ).remove();\n\t}\n\n\treturn jQuery.merge( [], parsed.childNodes );\n};\n\n\n// Keep a copy of the old load method\nvar _load = jQuery.fn.load;\n\n/**\n * Load a url into a page\n */\njQuery.fn.load = function( url, params, callback ) {\n\tif ( typeof url !== \"string\" && _load ) {\n\t\treturn _load.apply( this, arguments );\n\t}\n\n\tvar selector, type, response,\n\t\tself = this,\n\t\toff = url.indexOf( \" \" );\n\n\tif ( off > -1 ) {\n\t\tselector = jQuery.trim( url.slice( off ) );\n\t\turl = url.slice( 0, off );\n\t}\n\n\t// If it's a function\n\tif ( jQuery.isFunction( params ) ) {\n\n\t\t// We assume that it's the callback\n\t\tcallback = params;\n\t\tparams = undefined;\n\n\t// Otherwise, build a param string\n\t} else if ( params && typeof params === \"object\" ) {\n\t\ttype = \"POST\";\n\t}\n\n\t// If we have elements to modify, make the request\n\tif ( self.length > 0 ) {\n\t\tjQuery.ajax( {\n\t\t\turl: url,\n\n\t\t\t// If \"type\" variable is undefined, then \"GET\" method will be used.\n\t\t\t// Make value of this field explicit since\n\t\t\t// user can override it through ajaxSetup method\n\t\t\ttype: type || \"GET\",\n\t\t\tdataType: \"html\",\n\t\t\tdata: params\n\t\t} ).done( function( responseText ) {\n\n\t\t\t// Save response for use in complete callback\n\t\t\tresponse = arguments;\n\n\t\t\tself.html( selector ?\n\n\t\t\t\t// If a selector was specified, locate the right elements in a dummy div\n\t\t\t\t// Exclude scripts to avoid IE 'Permission Denied' errors\n\t\t\t\tjQuery( \"<div>\" ).append( jQuery.parseHTML( responseText ) ).find( selector ) :\n\n\t\t\t\t// Otherwise use the full result\n\t\t\t\tresponseText );\n\n\t\t// If the request succeeds, this function gets \"data\", \"status\", \"jqXHR\"\n\t\t// but they are ignored because response was set above.\n\t\t// If it fails, this function gets \"jqXHR\", \"status\", \"error\"\n\t\t} ).always( callback && function( jqXHR, status ) {\n\t\t\tself.each( function() {\n\t\t\t\tcallback.apply( self, response || [ jqXHR.responseText, status, jqXHR ] );\n\t\t\t} );\n\t\t} );\n\t}\n\n\treturn this;\n};\n\n\n\n\n// Attach a bunch of functions for handling common AJAX events\njQuery.each( [\n\t\"ajaxStart\",\n\t\"ajaxStop\",\n\t\"ajaxComplete\",\n\t\"ajaxError\",\n\t\"ajaxSuccess\",\n\t\"ajaxSend\"\n], function( i, type ) {\n\tjQuery.fn[ type ] = function( fn ) {\n\t\treturn this.on( type, fn );\n\t};\n} );\n\n\n\n\njQuery.expr.filters.animated = function( elem ) {\n\treturn jQuery.grep( jQuery.timers, function( fn ) {\n\t\treturn elem === fn.elem;\n\t} ).length;\n};\n\n\n\n\n/**\n * Gets a window from an element\n */\nfunction getWindow( elem ) {\n\treturn jQuery.isWindow( elem ) ? elem : elem.nodeType === 9 && elem.defaultView;\n}\n\njQuery.offset = {\n\tsetOffset: function( elem, options, i ) {\n\t\tvar curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition,\n\t\t\tposition = jQuery.css( elem, \"position\" ),\n\t\t\tcurElem = jQuery( elem ),\n\t\t\tprops = {};\n\n\t\t// Set position first, in-case top/left are set even on static elem\n\t\tif ( position === \"static\" ) {\n\t\t\telem.style.position = \"relative\";\n\t\t}\n\n\t\tcurOffset = curElem.offset();\n\t\tcurCSSTop = jQuery.css( elem, \"top\" );\n\t\tcurCSSLeft = jQuery.css( elem, \"left\" );\n\t\tcalculatePosition = ( position === \"absolute\" || position === \"fixed\" ) &&\n\t\t\t( curCSSTop + curCSSLeft ).indexOf( \"auto\" ) > -1;\n\n\t\t// Need to be able to calculate position if either\n\t\t// top or left is auto and position is either absolute or fixed\n\t\tif ( calculatePosition ) {\n\t\t\tcurPosition = curElem.position();\n\t\t\tcurTop = curPosition.top;\n\t\t\tcurLeft = curPosition.left;\n\n\t\t} else {\n\t\t\tcurTop = parseFloat( curCSSTop ) || 0;\n\t\t\tcurLeft = parseFloat( curCSSLeft ) || 0;\n\t\t}\n\n\t\tif ( jQuery.isFunction( options ) ) {\n\n\t\t\t// Use jQuery.extend here to allow modification of coordinates argument (gh-1848)\n\t\t\toptions = options.call( elem, i, jQuery.extend( {}, curOffset ) );\n\t\t}\n\n\t\tif ( options.top != null ) {\n\t\t\tprops.top = ( options.top - curOffset.top ) + curTop;\n\t\t}\n\t\tif ( options.left != null ) {\n\t\t\tprops.left = ( options.left - curOffset.left ) + curLeft;\n\t\t}\n\n\t\tif ( \"using\" in options ) {\n\t\t\toptions.using.call( elem, props );\n\n\t\t} else {\n\t\t\tcurElem.css( props );\n\t\t}\n\t}\n};\n\njQuery.fn.extend( {\n\toffset: function( options ) {\n\t\tif ( arguments.length ) {\n\t\t\treturn options === undefined ?\n\t\t\t\tthis :\n\t\t\t\tthis.each( function( i ) {\n\t\t\t\t\tjQuery.offset.setOffset( this, options, i );\n\t\t\t\t} );\n\t\t}\n\n\t\tvar docElem, win,\n\t\t\telem = this[ 0 ],\n\t\t\tbox = { top: 0, left: 0 },\n\t\t\tdoc = elem && elem.ownerDocument;\n\n\t\tif ( !doc ) {\n\t\t\treturn;\n\t\t}\n\n\t\tdocElem = doc.documentElement;\n\n\t\t// Make sure it's not a disconnected DOM node\n\t\tif ( !jQuery.contains( docElem, elem ) ) {\n\t\t\treturn box;\n\t\t}\n\n\t\tbox = elem.getBoundingClientRect();\n\t\twin = getWindow( doc );\n\t\treturn {\n\t\t\ttop: box.top + win.pageYOffset - docElem.clientTop,\n\t\t\tleft: box.left + win.pageXOffset - docElem.clientLeft\n\t\t};\n\t},\n\n\tposition: function() {\n\t\tif ( !this[ 0 ] ) {\n\t\t\treturn;\n\t\t}\n\n\t\tvar offsetParent, offset,\n\t\t\telem = this[ 0 ],\n\t\t\tparentOffset = { top: 0, left: 0 };\n\n\t\t// Fixed elements are offset from window (parentOffset = {top:0, left: 0},\n\t\t// because it is its only offset parent\n\t\tif ( jQuery.css( elem, \"position\" ) === \"fixed\" ) {\n\n\t\t\t// Assume getBoundingClientRect is there when computed position is fixed\n\t\t\toffset = elem.getBoundingClientRect();\n\n\t\t} else {\n\n\t\t\t// Get *real* offsetParent\n\t\t\toffsetParent = this.offsetParent();\n\n\t\t\t// Get correct offsets\n\t\t\toffset = this.offset();\n\t\t\tif ( !jQuery.nodeName( offsetParent[ 0 ], \"html\" ) ) {\n\t\t\t\tparentOffset = offsetParent.offset();\n\t\t\t}\n\n\t\t\t// Add offsetParent borders\n\t\t\tparentOffset.top += jQuery.css( offsetParent[ 0 ], \"borderTopWidth\", true );\n\t\t\tparentOffset.left += jQuery.css( offsetParent[ 0 ], \"borderLeftWidth\", true );\n\t\t}\n\n\t\t// Subtract parent offsets and element margins\n\t\treturn {\n\t\t\ttop: offset.top - parentOffset.top - jQuery.css( elem, \"marginTop\", true ),\n\t\t\tleft: offset.left - parentOffset.left - jQuery.css( elem, \"marginLeft\", true )\n\t\t};\n\t},\n\n\t// This method will return documentElement in the following cases:\n\t// 1) For the element inside the iframe without offsetParent, this method will return\n\t//    documentElement of the parent window\n\t// 2) For the hidden or detached element\n\t// 3) For body or html element, i.e. in case of the html node - it will return itself\n\t//\n\t// but those exceptions were never presented as a real life use-cases\n\t// and might be considered as more preferable results.\n\t//\n\t// This logic, however, is not guaranteed and can change at any point in the future\n\toffsetParent: function() {\n\t\treturn this.map( function() {\n\t\t\tvar offsetParent = this.offsetParent;\n\n\t\t\twhile ( offsetParent && jQuery.css( offsetParent, \"position\" ) === \"static\" ) {\n\t\t\t\toffsetParent = offsetParent.offsetParent;\n\t\t\t}\n\n\t\t\treturn offsetParent || documentElement;\n\t\t} );\n\t}\n} );\n\n// Create scrollLeft and scrollTop methods\njQuery.each( { scrollLeft: \"pageXOffset\", scrollTop: \"pageYOffset\" }, function( method, prop ) {\n\tvar top = \"pageYOffset\" === prop;\n\n\tjQuery.fn[ method ] = function( val ) {\n\t\treturn access( this, function( elem, method, val ) {\n\t\t\tvar win = getWindow( elem );\n\n\t\t\tif ( val === undefined ) {\n\t\t\t\treturn win ? win[ prop ] : elem[ method ];\n\t\t\t}\n\n\t\t\tif ( win ) {\n\t\t\t\twin.scrollTo(\n\t\t\t\t\t!top ? val : win.pageXOffset,\n\t\t\t\t\ttop ? val : win.pageYOffset\n\t\t\t\t);\n\n\t\t\t} else {\n\t\t\t\telem[ method ] = val;\n\t\t\t}\n\t\t}, method, val, arguments.length );\n\t};\n} );\n\n// Support: Safari<7-8+, Chrome<37-44+\n// Add the top/left cssHooks using jQuery.fn.position\n// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084\n// Blink bug: https://code.google.com/p/chromium/issues/detail?id=229280\n// getComputedStyle returns percent when specified for top/left/bottom/right;\n// rather than make the css module depend on the offset module, just check for it here\njQuery.each( [ \"top\", \"left\" ], function( i, prop ) {\n\tjQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition,\n\t\tfunction( elem, computed ) {\n\t\t\tif ( computed ) {\n\t\t\t\tcomputed = curCSS( elem, prop );\n\n\t\t\t\t// If curCSS returns percentage, fallback to offset\n\t\t\t\treturn rnumnonpx.test( computed ) ?\n\t\t\t\t\tjQuery( elem ).position()[ prop ] + \"px\" :\n\t\t\t\t\tcomputed;\n\t\t\t}\n\t\t}\n\t);\n} );\n\n\n// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods\njQuery.each( { Height: \"height\", Width: \"width\" }, function( name, type ) {\n\tjQuery.each( { padding: \"inner\" + name, content: type, \"\": \"outer\" + name },\n\t\tfunction( defaultExtra, funcName ) {\n\n\t\t// Margin is only for outerHeight, outerWidth\n\t\tjQuery.fn[ funcName ] = function( margin, value ) {\n\t\t\tvar chainable = arguments.length && ( defaultExtra || typeof margin !== \"boolean\" ),\n\t\t\t\textra = defaultExtra || ( margin === true || value === true ? \"margin\" : \"border\" );\n\n\t\t\treturn access( this, function( elem, type, value ) {\n\t\t\t\tvar doc;\n\n\t\t\t\tif ( jQuery.isWindow( elem ) ) {\n\n\t\t\t\t\t// As of 5/8/2012 this will yield incorrect results for Mobile Safari, but there\n\t\t\t\t\t// isn't a whole lot we can do. See pull request at this URL for discussion:\n\t\t\t\t\t// https://github.com/jquery/jquery/pull/764\n\t\t\t\t\treturn elem.document.documentElement[ \"client\" + name ];\n\t\t\t\t}\n\n\t\t\t\t// Get document width or height\n\t\t\t\tif ( elem.nodeType === 9 ) {\n\t\t\t\t\tdoc = elem.documentElement;\n\n\t\t\t\t\t// Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],\n\t\t\t\t\t// whichever is greatest\n\t\t\t\t\treturn Math.max(\n\t\t\t\t\t\telem.body[ \"scroll\" + name ], doc[ \"scroll\" + name ],\n\t\t\t\t\t\telem.body[ \"offset\" + name ], doc[ \"offset\" + name ],\n\t\t\t\t\t\tdoc[ \"client\" + name ]\n\t\t\t\t\t);\n\t\t\t\t}\n\n\t\t\t\treturn value === undefined ?\n\n\t\t\t\t\t// Get width or height on the element, requesting but not forcing parseFloat\n\t\t\t\t\tjQuery.css( elem, type, extra ) :\n\n\t\t\t\t\t// Set width or height on the element\n\t\t\t\t\tjQuery.style( elem, type, value, extra );\n\t\t\t}, type, chainable ? margin : undefined, chainable, null );\n\t\t};\n\t} );\n} );\n\n\njQuery.fn.extend( {\n\n\tbind: function( types, data, fn ) {\n\t\treturn this.on( types, null, data, fn );\n\t},\n\tunbind: function( types, fn ) {\n\t\treturn this.off( types, null, fn );\n\t},\n\n\tdelegate: function( selector, types, data, fn ) {\n\t\treturn this.on( types, selector, data, fn );\n\t},\n\tundelegate: function( selector, types, fn ) {\n\n\t\t// ( namespace ) or ( selector, types [, fn] )\n\t\treturn arguments.length === 1 ?\n\t\t\tthis.off( selector, \"**\" ) :\n\t\t\tthis.off( types, selector || \"**\", fn );\n\t},\n\tsize: function() {\n\t\treturn this.length;\n\t}\n} );\n\njQuery.fn.andSelf = jQuery.fn.addBack;\n\n\n\n\n// Register as a named AMD module, since jQuery can be concatenated with other\n// files that may use define, but not via a proper concatenation script that\n// understands anonymous AMD modules. A named AMD is safest and most robust\n// way to register. Lowercase jquery is used because AMD module names are\n// derived from file names, and jQuery is normally delivered in a lowercase\n// file name. Do this after creating the global so that if an AMD module wants\n// to call noConflict to hide this version of jQuery, it will work.\n\n// Note that for maximum portability, libraries that are not jQuery should\n// declare themselves as anonymous modules, and avoid setting a global if an\n// AMD loader is present. jQuery is a special case. For more information, see\n// https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon\n\nif ( typeof define === \"function\" && define.amd ) {\n\tdefine( \"jquery\", [], function() {\n\t\treturn jQuery;\n\t} );\n}\n\n\n\nvar\n\n\t// Map over jQuery in case of overwrite\n\t_jQuery = window.jQuery,\n\n\t// Map over the $ in case of overwrite\n\t_$ = window.$;\n\njQuery.noConflict = function( deep ) {\n\tif ( window.$ === jQuery ) {\n\t\twindow.$ = _$;\n\t}\n\n\tif ( deep && window.jQuery === jQuery ) {\n\t\twindow.jQuery = _jQuery;\n\t}\n\n\treturn jQuery;\n};\n\n// Expose jQuery and $ identifiers, even in AMD\n// (#7102#comment:10, https://github.com/jquery/jquery/pull/557)\n// and CommonJS for browser emulators (#13566)\nif ( !noGlobal ) {\n\twindow.jQuery = window.$ = jQuery;\n}\n\nreturn jQuery;\n}));\n\n; browserify_shim__define__module__export__(typeof $ != \"undefined\" ? $ : window.$);\n\n}).call(global, undefined, undefined, undefined, undefined, function defineExport(ex) { module.exports = ex; });\n","// This file is autogenerated via the `commonjs` Grunt task. You can require() this file in a CommonJS environment.\nrequire('../../js/transition.js')\nrequire('../../js/alert.js')\nrequire('../../js/button.js')\nrequire('../../js/carousel.js')\nrequire('../../js/collapse.js')\nrequire('../../js/dropdown.js')\nrequire('../../js/modal.js')\nrequire('../../js/tooltip.js')\nrequire('../../js/popover.js')\nrequire('../../js/scrollspy.js')\nrequire('../../js/tab.js')\nrequire('../../js/affix.js')","/**\n * @license\n * lodash 3.10.1 (Custom Build) <https://lodash.com/>\n * Build: `lodash modern -d -o ./index.js`\n * Copyright 2012-2015 The Dojo Foundation <http://dojofoundation.org/>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright 2009-2015 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n * Available under MIT license <https://lodash.com/license>\n */\n;(function() {\n\n  /** Used as a safe reference for `undefined` in pre-ES5 environments. */\n  var undefined;\n\n  /** Used as the semantic version number. */\n  var VERSION = '3.10.1';\n\n  /** Used to compose bitmasks for wrapper metadata. */\n  var BIND_FLAG = 1,\n      BIND_KEY_FLAG = 2,\n      CURRY_BOUND_FLAG = 4,\n      CURRY_FLAG = 8,\n      CURRY_RIGHT_FLAG = 16,\n      PARTIAL_FLAG = 32,\n      PARTIAL_RIGHT_FLAG = 64,\n      ARY_FLAG = 128,\n      REARG_FLAG = 256;\n\n  /** Used as default options for `_.trunc`. */\n  var DEFAULT_TRUNC_LENGTH = 30,\n      DEFAULT_TRUNC_OMISSION = '...';\n\n  /** Used to detect when a function becomes hot. */\n  var HOT_COUNT = 150,\n      HOT_SPAN = 16;\n\n  /** Used as the size to enable large array optimizations. */\n  var LARGE_ARRAY_SIZE = 200;\n\n  /** Used to indicate the type of lazy iteratees. */\n  var LAZY_FILTER_FLAG = 1,\n      LAZY_MAP_FLAG = 2;\n\n  /** Used as the `TypeError` message for \"Functions\" methods. */\n  var FUNC_ERROR_TEXT = 'Expected a function';\n\n  /** Used as the internal argument placeholder. */\n  var PLACEHOLDER = '__lodash_placeholder__';\n\n  /** `Object#toString` result references. */\n  var argsTag = '[object Arguments]',\n      arrayTag = '[object Array]',\n      boolTag = '[object Boolean]',\n      dateTag = '[object Date]',\n      errorTag = '[object Error]',\n      funcTag = '[object Function]',\n      mapTag = '[object Map]',\n      numberTag = '[object Number]',\n      objectTag = '[object Object]',\n      regexpTag = '[object RegExp]',\n      setTag = '[object Set]',\n      stringTag = '[object String]',\n      weakMapTag = '[object WeakMap]';\n\n  var arrayBufferTag = '[object ArrayBuffer]',\n      float32Tag = '[object Float32Array]',\n      float64Tag = '[object Float64Array]',\n      int8Tag = '[object Int8Array]',\n      int16Tag = '[object Int16Array]',\n      int32Tag = '[object Int32Array]',\n      uint8Tag = '[object Uint8Array]',\n      uint8ClampedTag = '[object Uint8ClampedArray]',\n      uint16Tag = '[object Uint16Array]',\n      uint32Tag = '[object Uint32Array]';\n\n  /** Used to match empty string literals in compiled template source. */\n  var reEmptyStringLeading = /\\b__p \\+= '';/g,\n      reEmptyStringMiddle = /\\b(__p \\+=) '' \\+/g,\n      reEmptyStringTrailing = /(__e\\(.*?\\)|\\b__t\\)) \\+\\n'';/g;\n\n  /** Used to match HTML entities and HTML characters. */\n  var reEscapedHtml = /&(?:amp|lt|gt|quot|#39|#96);/g,\n      reUnescapedHtml = /[&<>\"'`]/g,\n      reHasEscapedHtml = RegExp(reEscapedHtml.source),\n      reHasUnescapedHtml = RegExp(reUnescapedHtml.source);\n\n  /** Used to match template delimiters. */\n  var reEscape = /<%-([\\s\\S]+?)%>/g,\n      reEvaluate = /<%([\\s\\S]+?)%>/g,\n      reInterpolate = /<%=([\\s\\S]+?)%>/g;\n\n  /** Used to match property names within property paths. */\n  var reIsDeepProp = /\\.|\\[(?:[^[\\]]*|([\"'])(?:(?!\\1)[^\\n\\\\]|\\\\.)*?\\1)\\]/,\n      reIsPlainProp = /^\\w*$/,\n      rePropName = /[^.[\\]]+|\\[(?:(-?\\d+(?:\\.\\d+)?)|([\"'])((?:(?!\\2)[^\\n\\\\]|\\\\.)*?)\\2)\\]/g;\n\n  /**\n   * Used to match `RegExp` [syntax characters](http://ecma-international.org/ecma-262/6.0/#sec-patterns)\n   * and those outlined by [`EscapeRegExpPattern`](http://ecma-international.org/ecma-262/6.0/#sec-escaperegexppattern).\n   */\n  var reRegExpChars = /^[:!,]|[\\\\^$.*+?()[\\]{}|\\/]|(^[0-9a-fA-Fnrtuvx])|([\\n\\r\\u2028\\u2029])/g,\n      reHasRegExpChars = RegExp(reRegExpChars.source);\n\n  /** Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks). */\n  var reComboMark = /[\\u0300-\\u036f\\ufe20-\\ufe23]/g;\n\n  /** Used to match backslashes in property paths. */\n  var reEscapeChar = /\\\\(\\\\)?/g;\n\n  /** Used to match [ES template delimiters](http://ecma-international.org/ecma-262/6.0/#sec-template-literal-lexical-components). */\n  var reEsTemplate = /\\$\\{([^\\\\}]*(?:\\\\.[^\\\\}]*)*)\\}/g;\n\n  /** Used to match `RegExp` flags from their coerced string values. */\n  var reFlags = /\\w*$/;\n\n  /** Used to detect hexadecimal string values. */\n  var reHasHexPrefix = /^0[xX]/;\n\n  /** Used to detect host constructors (Safari > 5). */\n  var reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n  /** Used to detect unsigned integer values. */\n  var reIsUint = /^\\d+$/;\n\n  /** Used to match latin-1 supplementary letters (excluding mathematical operators). */\n  var reLatin1 = /[\\xc0-\\xd6\\xd8-\\xde\\xdf-\\xf6\\xf8-\\xff]/g;\n\n  /** Used to ensure capturing order of template delimiters. */\n  var reNoMatch = /($^)/;\n\n  /** Used to match unescaped characters in compiled string literals. */\n  var reUnescapedString = /['\\n\\r\\u2028\\u2029\\\\]/g;\n\n  /** Used to match words to create compound words. */\n  var reWords = (function() {\n    var upper = '[A-Z\\\\xc0-\\\\xd6\\\\xd8-\\\\xde]',\n        lower = '[a-z\\\\xdf-\\\\xf6\\\\xf8-\\\\xff]+';\n\n    return RegExp(upper + '+(?=' + upper + lower + ')|' + upper + '?' + lower + '|' + upper + '+|[0-9]+', 'g');\n  }());\n\n  /** Used to assign default `context` object properties. */\n  var contextProps = [\n    'Array', 'ArrayBuffer', 'Date', 'Error', 'Float32Array', 'Float64Array',\n    'Function', 'Int8Array', 'Int16Array', 'Int32Array', 'Math', 'Number',\n    'Object', 'RegExp', 'Set', 'String', '_', 'clearTimeout', 'isFinite',\n    'parseFloat', 'parseInt', 'setTimeout', 'TypeError', 'Uint8Array',\n    'Uint8ClampedArray', 'Uint16Array', 'Uint32Array', 'WeakMap'\n  ];\n\n  /** Used to make template sourceURLs easier to identify. */\n  var templateCounter = -1;\n\n  /** Used to identify `toStringTag` values of typed arrays. */\n  var typedArrayTags = {};\n  typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =\n  typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =\n  typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =\n  typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =\n  typedArrayTags[uint32Tag] = true;\n  typedArrayTags[argsTag] = typedArrayTags[arrayTag] =\n  typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =\n  typedArrayTags[dateTag] = typedArrayTags[errorTag] =\n  typedArrayTags[funcTag] = typedArrayTags[mapTag] =\n  typedArrayTags[numberTag] = typedArrayTags[objectTag] =\n  typedArrayTags[regexpTag] = typedArrayTags[setTag] =\n  typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;\n\n  /** Used to identify `toStringTag` values supported by `_.clone`. */\n  var cloneableTags = {};\n  cloneableTags[argsTag] = cloneableTags[arrayTag] =\n  cloneableTags[arrayBufferTag] = cloneableTags[boolTag] =\n  cloneableTags[dateTag] = cloneableTags[float32Tag] =\n  cloneableTags[float64Tag] = cloneableTags[int8Tag] =\n  cloneableTags[int16Tag] = cloneableTags[int32Tag] =\n  cloneableTags[numberTag] = cloneableTags[objectTag] =\n  cloneableTags[regexpTag] = cloneableTags[stringTag] =\n  cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =\n  cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;\n  cloneableTags[errorTag] = cloneableTags[funcTag] =\n  cloneableTags[mapTag] = cloneableTags[setTag] =\n  cloneableTags[weakMapTag] = false;\n\n  /** Used to map latin-1 supplementary letters to basic latin letters. */\n  var deburredLetters = {\n    '\\xc0': 'A',  '\\xc1': 'A', '\\xc2': 'A', '\\xc3': 'A', '\\xc4': 'A', '\\xc5': 'A',\n    '\\xe0': 'a',  '\\xe1': 'a', '\\xe2': 'a', '\\xe3': 'a', '\\xe4': 'a', '\\xe5': 'a',\n    '\\xc7': 'C',  '\\xe7': 'c',\n    '\\xd0': 'D',  '\\xf0': 'd',\n    '\\xc8': 'E',  '\\xc9': 'E', '\\xca': 'E', '\\xcb': 'E',\n    '\\xe8': 'e',  '\\xe9': 'e', '\\xea': 'e', '\\xeb': 'e',\n    '\\xcC': 'I',  '\\xcd': 'I', '\\xce': 'I', '\\xcf': 'I',\n    '\\xeC': 'i',  '\\xed': 'i', '\\xee': 'i', '\\xef': 'i',\n    '\\xd1': 'N',  '\\xf1': 'n',\n    '\\xd2': 'O',  '\\xd3': 'O', '\\xd4': 'O', '\\xd5': 'O', '\\xd6': 'O', '\\xd8': 'O',\n    '\\xf2': 'o',  '\\xf3': 'o', '\\xf4': 'o', '\\xf5': 'o', '\\xf6': 'o', '\\xf8': 'o',\n    '\\xd9': 'U',  '\\xda': 'U', '\\xdb': 'U', '\\xdc': 'U',\n    '\\xf9': 'u',  '\\xfa': 'u', '\\xfb': 'u', '\\xfc': 'u',\n    '\\xdd': 'Y',  '\\xfd': 'y', '\\xff': 'y',\n    '\\xc6': 'Ae', '\\xe6': 'ae',\n    '\\xde': 'Th', '\\xfe': 'th',\n    '\\xdf': 'ss'\n  };\n\n  /** Used to map characters to HTML entities. */\n  var htmlEscapes = {\n    '&': '&amp;',\n    '<': '&lt;',\n    '>': '&gt;',\n    '\"': '&quot;',\n    \"'\": '&#39;',\n    '`': '&#96;'\n  };\n\n  /** Used to map HTML entities to characters. */\n  var htmlUnescapes = {\n    '&amp;': '&',\n    '&lt;': '<',\n    '&gt;': '>',\n    '&quot;': '\"',\n    '&#39;': \"'\",\n    '&#96;': '`'\n  };\n\n  /** Used to determine if values are of the language type `Object`. */\n  var objectTypes = {\n    'function': true,\n    'object': true\n  };\n\n  /** Used to escape characters for inclusion in compiled regexes. */\n  var regexpEscapes = {\n    '0': 'x30', '1': 'x31', '2': 'x32', '3': 'x33', '4': 'x34',\n    '5': 'x35', '6': 'x36', '7': 'x37', '8': 'x38', '9': 'x39',\n    'A': 'x41', 'B': 'x42', 'C': 'x43', 'D': 'x44', 'E': 'x45', 'F': 'x46',\n    'a': 'x61', 'b': 'x62', 'c': 'x63', 'd': 'x64', 'e': 'x65', 'f': 'x66',\n    'n': 'x6e', 'r': 'x72', 't': 'x74', 'u': 'x75', 'v': 'x76', 'x': 'x78'\n  };\n\n  /** Used to escape characters for inclusion in compiled string literals. */\n  var stringEscapes = {\n    '\\\\': '\\\\',\n    \"'\": \"'\",\n    '\\n': 'n',\n    '\\r': 'r',\n    '\\u2028': 'u2028',\n    '\\u2029': 'u2029'\n  };\n\n  /** Detect free variable `exports`. */\n  var freeExports = objectTypes[typeof exports] && exports && !exports.nodeType && exports;\n\n  /** Detect free variable `module`. */\n  var freeModule = objectTypes[typeof module] && module && !module.nodeType && module;\n\n  /** Detect free variable `global` from Node.js. */\n  var freeGlobal = freeExports && freeModule && typeof global == 'object' && global && global.Object && global;\n\n  /** Detect free variable `self`. */\n  var freeSelf = objectTypes[typeof self] && self && self.Object && self;\n\n  /** Detect free variable `window`. */\n  var freeWindow = objectTypes[typeof window] && window && window.Object && window;\n\n  /** Detect the popular CommonJS extension `module.exports`. */\n  var moduleExports = freeModule && freeModule.exports === freeExports && freeExports;\n\n  /**\n   * Used as a reference to the global object.\n   *\n   * The `this` value is used if it's the global object to avoid Greasemonkey's\n   * restricted `window` object, otherwise the `window` object is used.\n   */\n  var root = freeGlobal || ((freeWindow !== (this && this.window)) && freeWindow) || freeSelf || this;\n\n  /*--------------------------------------------------------------------------*/\n\n  /**\n   * The base implementation of `compareAscending` which compares values and\n   * sorts them in ascending order without guaranteeing a stable sort.\n   *\n   * @private\n   * @param {*} value The value to compare.\n   * @param {*} other The other value to compare.\n   * @returns {number} Returns the sort order indicator for `value`.\n   */\n  function baseCompareAscending(value, other) {\n    if (value !== other) {\n      var valIsNull = value === null,\n          valIsUndef = value === undefined,\n          valIsReflexive = value === value;\n\n      var othIsNull = other === null,\n          othIsUndef = other === undefined,\n          othIsReflexive = other === other;\n\n      if ((value > other && !othIsNull) || !valIsReflexive ||\n          (valIsNull && !othIsUndef && othIsReflexive) ||\n          (valIsUndef && othIsReflexive)) {\n        return 1;\n      }\n      if ((value < other && !valIsNull) || !othIsReflexive ||\n          (othIsNull && !valIsUndef && valIsReflexive) ||\n          (othIsUndef && valIsReflexive)) {\n        return -1;\n      }\n    }\n    return 0;\n  }\n\n  /**\n   * The base implementation of `_.findIndex` and `_.findLastIndex` without\n   * support for callback shorthands and `this` binding.\n   *\n   * @private\n   * @param {Array} array The array to search.\n   * @param {Function} predicate The function invoked per iteration.\n   * @param {boolean} [fromRight] Specify iterating from right to left.\n   * @returns {number} Returns the index of the matched value, else `-1`.\n   */\n  function baseFindIndex(array, predicate, fromRight) {\n    var length = array.length,\n        index = fromRight ? length : -1;\n\n    while ((fromRight ? index-- : ++index < length)) {\n      if (predicate(array[index], index, array)) {\n        return index;\n      }\n    }\n    return -1;\n  }\n\n  /**\n   * The base implementation of `_.indexOf` without support for binary searches.\n   *\n   * @private\n   * @param {Array} array The array to search.\n   * @param {*} value The value to search for.\n   * @param {number} fromIndex The index to search from.\n   * @returns {number} Returns the index of the matched value, else `-1`.\n   */\n  function baseIndexOf(array, value, fromIndex) {\n    if (value !== value) {\n      return indexOfNaN(array, fromIndex);\n    }\n    var index = fromIndex - 1,\n        length = array.length;\n\n    while (++index < length) {\n      if (array[index] === value) {\n        return index;\n      }\n    }\n    return -1;\n  }\n\n  /**\n   * The base implementation of `_.isFunction` without support for environments\n   * with incorrect `typeof` results.\n   *\n   * @private\n   * @param {*} value The value to check.\n   * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.\n   */\n  function baseIsFunction(value) {\n    // Avoid a Chakra JIT bug in compatibility modes of IE 11.\n    // See https://github.com/jashkenas/underscore/issues/1621 for more details.\n    return typeof value == 'function' || false;\n  }\n\n  /**\n   * Converts `value` to a string if it's not one. An empty string is returned\n   * for `null` or `undefined` values.\n   *\n   * @private\n   * @param {*} value The value to process.\n   * @returns {string} Returns the string.\n   */\n  function baseToString(value) {\n    return value == null ? '' : (value + '');\n  }\n\n  /**\n   * Used by `_.trim` and `_.trimLeft` to get the index of the first character\n   * of `string` that is not found in `chars`.\n   *\n   * @private\n   * @param {string} string The string to inspect.\n   * @param {string} chars The characters to find.\n   * @returns {number} Returns the index of the first character not found in `chars`.\n   */\n  function charsLeftIndex(string, chars) {\n    var index = -1,\n        length = string.length;\n\n    while (++index < length && chars.indexOf(string.charAt(index)) > -1) {}\n    return index;\n  }\n\n  /**\n   * Used by `_.trim` and `_.trimRight` to get the index of the last character\n   * of `string` that is not found in `chars`.\n   *\n   * @private\n   * @param {string} string The string to inspect.\n   * @param {string} chars The characters to find.\n   * @returns {number} Returns the index of the last character not found in `chars`.\n   */\n  function charsRightIndex(string, chars) {\n    var index = string.length;\n\n    while (index-- && chars.indexOf(string.charAt(index)) > -1) {}\n    return index;\n  }\n\n  /**\n   * Used by `_.sortBy` to compare transformed elements of a collection and stable\n   * sort them in ascending order.\n   *\n   * @private\n   * @param {Object} object The object to compare.\n   * @param {Object} other The other object to compare.\n   * @returns {number} Returns the sort order indicator for `object`.\n   */\n  function compareAscending(object, other) {\n    return baseCompareAscending(object.criteria, other.criteria) || (object.index - other.index);\n  }\n\n  /**\n   * Used by `_.sortByOrder` to compare multiple properties of a value to another\n   * and stable sort them.\n   *\n   * If `orders` is unspecified, all valuess are sorted in ascending order. Otherwise,\n   * a value is sorted in ascending order if its corresponding order is \"asc\", and\n   * descending if \"desc\".\n   *\n   * @private\n   * @param {Object} object The object to compare.\n   * @param {Object} other The other object to compare.\n   * @param {boolean[]} orders The order to sort by for each property.\n   * @returns {number} Returns the sort order indicator for `object`.\n   */\n  function compareMultiple(object, other, orders) {\n    var index = -1,\n        objCriteria = object.criteria,\n        othCriteria = other.criteria,\n        length = objCriteria.length,\n        ordersLength = orders.length;\n\n    while (++index < length) {\n      var result = baseCompareAscending(objCriteria[index], othCriteria[index]);\n      if (result) {\n        if (index >= ordersLength) {\n          return result;\n        }\n        var order = orders[index];\n        return result * ((order === 'asc' || order === true) ? 1 : -1);\n      }\n    }\n    // Fixes an `Array#sort` bug in the JS engine embedded in Adobe applications\n    // that causes it, under certain circumstances, to provide the same value for\n    // `object` and `other`. See https://github.com/jashkenas/underscore/pull/1247\n    // for more details.\n    //\n    // This also ensures a stable sort in V8 and other engines.\n    // See https://code.google.com/p/v8/issues/detail?id=90 for more details.\n    return object.index - other.index;\n  }\n\n  /**\n   * Used by `_.deburr` to convert latin-1 supplementary letters to basic latin letters.\n   *\n   * @private\n   * @param {string} letter The matched letter to deburr.\n   * @returns {string} Returns the deburred letter.\n   */\n  function deburrLetter(letter) {\n    return deburredLetters[letter];\n  }\n\n  /**\n   * Used by `_.escape` to convert characters to HTML entities.\n   *\n   * @private\n   * @param {string} chr The matched character to escape.\n   * @returns {string} Returns the escaped character.\n   */\n  function escapeHtmlChar(chr) {\n    return htmlEscapes[chr];\n  }\n\n  /**\n   * Used by `_.escapeRegExp` to escape characters for inclusion in compiled regexes.\n   *\n   * @private\n   * @param {string} chr The matched character to escape.\n   * @param {string} leadingChar The capture group for a leading character.\n   * @param {string} whitespaceChar The capture group for a whitespace character.\n   * @returns {string} Returns the escaped character.\n   */\n  function escapeRegExpChar(chr, leadingChar, whitespaceChar) {\n    if (leadingChar) {\n      chr = regexpEscapes[chr];\n    } else if (whitespaceChar) {\n      chr = stringEscapes[chr];\n    }\n    return '\\\\' + chr;\n  }\n\n  /**\n   * Used by `_.template` to escape characters for inclusion in compiled string literals.\n   *\n   * @private\n   * @param {string} chr The matched character to escape.\n   * @returns {string} Returns the escaped character.\n   */\n  function escapeStringChar(chr) {\n    return '\\\\' + stringEscapes[chr];\n  }\n\n  /**\n   * Gets the index at which the first occurrence of `NaN` is found in `array`.\n   *\n   * @private\n   * @param {Array} array The array to search.\n   * @param {number} fromIndex The index to search from.\n   * @param {boolean} [fromRight] Specify iterating from right to left.\n   * @returns {number} Returns the index of the matched `NaN`, else `-1`.\n   */\n  function indexOfNaN(array, fromIndex, fromRight) {\n    var length = array.length,\n        index = fromIndex + (fromRight ? 0 : -1);\n\n    while ((fromRight ? index-- : ++index < length)) {\n      var other = array[index];\n      if (other !== other) {\n        return index;\n      }\n    }\n    return -1;\n  }\n\n  /**\n   * Checks if `value` is object-like.\n   *\n   * @private\n   * @param {*} value The value to check.\n   * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n   */\n  function isObjectLike(value) {\n    return !!value && typeof value == 'object';\n  }\n\n  /**\n   * Used by `trimmedLeftIndex` and `trimmedRightIndex` to determine if a\n   * character code is whitespace.\n   *\n   * @private\n   * @param {number} charCode The character code to inspect.\n   * @returns {boolean} Returns `true` if `charCode` is whitespace, else `false`.\n   */\n  function isSpace(charCode) {\n    return ((charCode <= 160 && (charCode >= 9 && charCode <= 13) || charCode == 32 || charCode == 160) || charCode == 5760 || charCode == 6158 ||\n      (charCode >= 8192 && (charCode <= 8202 || charCode == 8232 || charCode == 8233 || charCode == 8239 || charCode == 8287 || charCode == 12288 || charCode == 65279)));\n  }\n\n  /**\n   * Replaces all `placeholder` elements in `array` with an internal placeholder\n   * and returns an array of their indexes.\n   *\n   * @private\n   * @param {Array} array The array to modify.\n   * @param {*} placeholder The placeholder to replace.\n   * @returns {Array} Returns the new array of placeholder indexes.\n   */\n  function replaceHolders(array, placeholder) {\n    var index = -1,\n        length = array.length,\n        resIndex = -1,\n        result = [];\n\n    while (++index < length) {\n      if (array[index] === placeholder) {\n        array[index] = PLACEHOLDER;\n        result[++resIndex] = index;\n      }\n    }\n    return result;\n  }\n\n  /**\n   * An implementation of `_.uniq` optimized for sorted arrays without support\n   * for callback shorthands and `this` binding.\n   *\n   * @private\n   * @param {Array} array The array to inspect.\n   * @param {Function} [iteratee] The function invoked per iteration.\n   * @returns {Array} Returns the new duplicate-value-free array.\n   */\n  function sortedUniq(array, iteratee) {\n    var seen,\n        index = -1,\n        length = array.length,\n        resIndex = -1,\n        result = [];\n\n    while (++index < length) {\n      var value = array[index],\n          computed = iteratee ? iteratee(value, index, array) : value;\n\n      if (!index || seen !== computed) {\n        seen = computed;\n        result[++resIndex] = value;\n      }\n    }\n    return result;\n  }\n\n  /**\n   * Used by `_.trim` and `_.trimLeft` to get the index of the first non-whitespace\n   * character of `string`.\n   *\n   * @private\n   * @param {string} string The string to inspect.\n   * @returns {number} Returns the index of the first non-whitespace character.\n   */\n  function trimmedLeftIndex(string) {\n    var index = -1,\n        length = string.length;\n\n    while (++index < length && isSpace(string.charCodeAt(index))) {}\n    return index;\n  }\n\n  /**\n   * Used by `_.trim` and `_.trimRight` to get the index of the last non-whitespace\n   * character of `string`.\n   *\n   * @private\n   * @param {string} string The string to inspect.\n   * @returns {number} Returns the index of the last non-whitespace character.\n   */\n  function trimmedRightIndex(string) {\n    var index = string.length;\n\n    while (index-- && isSpace(string.charCodeAt(index))) {}\n    return index;\n  }\n\n  /**\n   * Used by `_.unescape` to convert HTML entities to characters.\n   *\n   * @private\n   * @param {string} chr The matched character to unescape.\n   * @returns {string} Returns the unescaped character.\n   */\n  function unescapeHtmlChar(chr) {\n    return htmlUnescapes[chr];\n  }\n\n  /*--------------------------------------------------------------------------*/\n\n  /**\n   * Create a new pristine `lodash` function using the given `context` object.\n   *\n   * @static\n   * @memberOf _\n   * @category Utility\n   * @param {Object} [context=root] The context object.\n   * @returns {Function} Returns a new `lodash` function.\n   * @example\n   *\n   * _.mixin({ 'foo': _.constant('foo') });\n   *\n   * var lodash = _.runInContext();\n   * lodash.mixin({ 'bar': lodash.constant('bar') });\n   *\n   * _.isFunction(_.foo);\n   * // => true\n   * _.isFunction(_.bar);\n   * // => false\n   *\n   * lodash.isFunction(lodash.foo);\n   * // => false\n   * lodash.isFunction(lodash.bar);\n   * // => true\n   *\n   * // using `context` to mock `Date#getTime` use in `_.now`\n   * var mock = _.runInContext({\n   *   'Date': function() {\n   *     return { 'getTime': getTimeMock };\n   *   }\n   * });\n   *\n   * // or creating a suped-up `defer` in Node.js\n   * var defer = _.runInContext({ 'setTimeout': setImmediate }).defer;\n   */\n  function runInContext(context) {\n    // Avoid issues with some ES3 environments that attempt to use values, named\n    // after built-in constructors like `Object`, for the creation of literals.\n    // ES5 clears this up by stating that literals must use built-in constructors.\n    // See https://es5.github.io/#x11.1.5 for more details.\n    context = context ? _.defaults(root.Object(), context, _.pick(root, contextProps)) : root;\n\n    /** Native constructor references. */\n    var Array = context.Array,\n        Date = context.Date,\n        Error = context.Error,\n        Function = context.Function,\n        Math = context.Math,\n        Number = context.Number,\n        Object = context.Object,\n        RegExp = context.RegExp,\n        String = context.String,\n        TypeError = context.TypeError;\n\n    /** Used for native method references. */\n    var arrayProto = Array.prototype,\n        objectProto = Object.prototype,\n        stringProto = String.prototype;\n\n    /** Used to resolve the decompiled source of functions. */\n    var fnToString = Function.prototype.toString;\n\n    /** Used to check objects for own properties. */\n    var hasOwnProperty = objectProto.hasOwnProperty;\n\n    /** Used to generate unique IDs. */\n    var idCounter = 0;\n\n    /**\n     * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring)\n     * of values.\n     */\n    var objToString = objectProto.toString;\n\n    /** Used to restore the original `_` reference in `_.noConflict`. */\n    var oldDash = root._;\n\n    /** Used to detect if a method is native. */\n    var reIsNative = RegExp('^' +\n      fnToString.call(hasOwnProperty).replace(/[\\\\^$.*+?()[\\]{}|]/g, '\\\\$&')\n      .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n    );\n\n    /** Native method references. */\n    var ArrayBuffer = context.ArrayBuffer,\n        clearTimeout = context.clearTimeout,\n        parseFloat = context.parseFloat,\n        pow = Math.pow,\n        propertyIsEnumerable = objectProto.propertyIsEnumerable,\n        Set = getNative(context, 'Set'),\n        setTimeout = context.setTimeout,\n        splice = arrayProto.splice,\n        Uint8Array = context.Uint8Array,\n        WeakMap = getNative(context, 'WeakMap');\n\n    /* Native method references for those with the same name as other `lodash` methods. */\n    var nativeCeil = Math.ceil,\n        nativeCreate = getNative(Object, 'create'),\n        nativeFloor = Math.floor,\n        nativeIsArray = getNative(Array, 'isArray'),\n        nativeIsFinite = context.isFinite,\n        nativeKeys = getNative(Object, 'keys'),\n        nativeMax = Math.max,\n        nativeMin = Math.min,\n        nativeNow = getNative(Date, 'now'),\n        nativeParseInt = context.parseInt,\n        nativeRandom = Math.random;\n\n    /** Used as references for `-Infinity` and `Infinity`. */\n    var NEGATIVE_INFINITY = Number.NEGATIVE_INFINITY,\n        POSITIVE_INFINITY = Number.POSITIVE_INFINITY;\n\n    /** Used as references for the maximum length and index of an array. */\n    var MAX_ARRAY_LENGTH = 4294967295,\n        MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1,\n        HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;\n\n    /**\n     * Used as the [maximum length](http://ecma-international.org/ecma-262/6.0/#sec-number.max_safe_integer)\n     * of an array-like value.\n     */\n    var MAX_SAFE_INTEGER = 9007199254740991;\n\n    /** Used to store function metadata. */\n    var metaMap = WeakMap && new WeakMap;\n\n    /** Used to lookup unminified function names. */\n    var realNames = {};\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates a `lodash` object which wraps `value` to enable implicit chaining.\n     * Methods that operate on and return arrays, collections, and functions can\n     * be chained together. Methods that retrieve a single value or may return a\n     * primitive value will automatically end the chain returning the unwrapped\n     * value. Explicit chaining may be enabled using `_.chain`. The execution of\n     * chained methods is lazy, that is, execution is deferred until `_#value`\n     * is implicitly or explicitly called.\n     *\n     * Lazy evaluation allows several methods to support shortcut fusion. Shortcut\n     * fusion is an optimization strategy which merge iteratee calls; this can help\n     * to avoid the creation of intermediate data structures and greatly reduce the\n     * number of iteratee executions.\n     *\n     * Chaining is supported in custom builds as long as the `_#value` method is\n     * directly or indirectly included in the build.\n     *\n     * In addition to lodash methods, wrappers have `Array` and `String` methods.\n     *\n     * The wrapper `Array` methods are:\n     * `concat`, `join`, `pop`, `push`, `reverse`, `shift`, `slice`, `sort`,\n     * `splice`, and `unshift`\n     *\n     * The wrapper `String` methods are:\n     * `replace` and `split`\n     *\n     * The wrapper methods that support shortcut fusion are:\n     * `compact`, `drop`, `dropRight`, `dropRightWhile`, `dropWhile`, `filter`,\n     * `first`, `initial`, `last`, `map`, `pluck`, `reject`, `rest`, `reverse`,\n     * `slice`, `take`, `takeRight`, `takeRightWhile`, `takeWhile`, `toArray`,\n     * and `where`\n     *\n     * The chainable wrapper methods are:\n     * `after`, `ary`, `assign`, `at`, `before`, `bind`, `bindAll`, `bindKey`,\n     * `callback`, `chain`, `chunk`, `commit`, `compact`, `concat`, `constant`,\n     * `countBy`, `create`, `curry`, `debounce`, `defaults`, `defaultsDeep`,\n     * `defer`, `delay`, `difference`, `drop`, `dropRight`, `dropRightWhile`,\n     * `dropWhile`, `fill`, `filter`, `flatten`, `flattenDeep`, `flow`, `flowRight`,\n     * `forEach`, `forEachRight`, `forIn`, `forInRight`, `forOwn`, `forOwnRight`,\n     * `functions`, `groupBy`, `indexBy`, `initial`, `intersection`, `invert`,\n     * `invoke`, `keys`, `keysIn`, `map`, `mapKeys`, `mapValues`, `matches`,\n     * `matchesProperty`, `memoize`, `merge`, `method`, `methodOf`, `mixin`,\n     * `modArgs`, `negate`, `omit`, `once`, `pairs`, `partial`, `partialRight`,\n     * `partition`, `pick`, `plant`, `pluck`, `property`, `propertyOf`, `pull`,\n     * `pullAt`, `push`, `range`, `rearg`, `reject`, `remove`, `rest`, `restParam`,\n     * `reverse`, `set`, `shuffle`, `slice`, `sort`, `sortBy`, `sortByAll`,\n     * `sortByOrder`, `splice`, `spread`, `take`, `takeRight`, `takeRightWhile`,\n     * `takeWhile`, `tap`, `throttle`, `thru`, `times`, `toArray`, `toPlainObject`,\n     * `transform`, `union`, `uniq`, `unshift`, `unzip`, `unzipWith`, `values`,\n     * `valuesIn`, `where`, `without`, `wrap`, `xor`, `zip`, `zipObject`, `zipWith`\n     *\n     * The wrapper methods that are **not** chainable by default are:\n     * `add`, `attempt`, `camelCase`, `capitalize`, `ceil`, `clone`, `cloneDeep`,\n     * `deburr`, `endsWith`, `escape`, `escapeRegExp`, `every`, `find`, `findIndex`,\n     * `findKey`, `findLast`, `findLastIndex`, `findLastKey`, `findWhere`, `first`,\n     * `floor`, `get`, `gt`, `gte`, `has`, `identity`, `includes`, `indexOf`,\n     * `inRange`, `isArguments`, `isArray`, `isBoolean`, `isDate`, `isElement`,\n     * `isEmpty`, `isEqual`, `isError`, `isFinite` `isFunction`, `isMatch`,\n     * `isNative`, `isNaN`, `isNull`, `isNumber`, `isObject`, `isPlainObject`,\n     * `isRegExp`, `isString`, `isUndefined`, `isTypedArray`, `join`, `kebabCase`,\n     * `last`, `lastIndexOf`, `lt`, `lte`, `max`, `min`, `noConflict`, `noop`,\n     * `now`, `pad`, `padLeft`, `padRight`, `parseInt`, `pop`, `random`, `reduce`,\n     * `reduceRight`, `repeat`, `result`, `round`, `runInContext`, `shift`, `size`,\n     * `snakeCase`, `some`, `sortedIndex`, `sortedLastIndex`, `startCase`,\n     * `startsWith`, `sum`, `template`, `trim`, `trimLeft`, `trimRight`, `trunc`,\n     * `unescape`, `uniqueId`, `value`, and `words`\n     *\n     * The wrapper method `sample` will return a wrapped value when `n` is provided,\n     * otherwise an unwrapped value is returned.\n     *\n     * @name _\n     * @constructor\n     * @category Chain\n     * @param {*} value The value to wrap in a `lodash` instance.\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * var wrapped = _([1, 2, 3]);\n     *\n     * // returns an unwrapped value\n     * wrapped.reduce(function(total, n) {\n     *   return total + n;\n     * });\n     * // => 6\n     *\n     * // returns a wrapped value\n     * var squares = wrapped.map(function(n) {\n     *   return n * n;\n     * });\n     *\n     * _.isArray(squares);\n     * // => false\n     *\n     * _.isArray(squares.value());\n     * // => true\n     */\n    function lodash(value) {\n      if (isObjectLike(value) && !isArray(value) && !(value instanceof LazyWrapper)) {\n        if (value instanceof LodashWrapper) {\n          return value;\n        }\n        if (hasOwnProperty.call(value, '__chain__') && hasOwnProperty.call(value, '__wrapped__')) {\n          return wrapperClone(value);\n        }\n      }\n      return new LodashWrapper(value);\n    }\n\n    /**\n     * The function whose prototype all chaining wrappers inherit from.\n     *\n     * @private\n     */\n    function baseLodash() {\n      // No operation performed.\n    }\n\n    /**\n     * The base constructor for creating `lodash` wrapper objects.\n     *\n     * @private\n     * @param {*} value The value to wrap.\n     * @param {boolean} [chainAll] Enable chaining for all wrapper methods.\n     * @param {Array} [actions=[]] Actions to peform to resolve the unwrapped value.\n     */\n    function LodashWrapper(value, chainAll, actions) {\n      this.__wrapped__ = value;\n      this.__actions__ = actions || [];\n      this.__chain__ = !!chainAll;\n    }\n\n    /**\n     * An object environment feature flags.\n     *\n     * @static\n     * @memberOf _\n     * @type Object\n     */\n    var support = lodash.support = {};\n\n    /**\n     * By default, the template delimiters used by lodash are like those in\n     * embedded Ruby (ERB). Change the following template settings to use\n     * alternative delimiters.\n     *\n     * @static\n     * @memberOf _\n     * @type Object\n     */\n    lodash.templateSettings = {\n\n      /**\n       * Used to detect `data` property values to be HTML-escaped.\n       *\n       * @memberOf _.templateSettings\n       * @type RegExp\n       */\n      'escape': reEscape,\n\n      /**\n       * Used to detect code to be evaluated.\n       *\n       * @memberOf _.templateSettings\n       * @type RegExp\n       */\n      'evaluate': reEvaluate,\n\n      /**\n       * Used to detect `data` property values to inject.\n       *\n       * @memberOf _.templateSettings\n       * @type RegExp\n       */\n      'interpolate': reInterpolate,\n\n      /**\n       * Used to reference the data object in the template text.\n       *\n       * @memberOf _.templateSettings\n       * @type string\n       */\n      'variable': '',\n\n      /**\n       * Used to import variables into the compiled template.\n       *\n       * @memberOf _.templateSettings\n       * @type Object\n       */\n      'imports': {\n\n        /**\n         * A reference to the `lodash` function.\n         *\n         * @memberOf _.templateSettings.imports\n         * @type Function\n         */\n        '_': lodash\n      }\n    };\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates a lazy wrapper object which wraps `value` to enable lazy evaluation.\n     *\n     * @private\n     * @param {*} value The value to wrap.\n     */\n    function LazyWrapper(value) {\n      this.__wrapped__ = value;\n      this.__actions__ = [];\n      this.__dir__ = 1;\n      this.__filtered__ = false;\n      this.__iteratees__ = [];\n      this.__takeCount__ = POSITIVE_INFINITY;\n      this.__views__ = [];\n    }\n\n    /**\n     * Creates a clone of the lazy wrapper object.\n     *\n     * @private\n     * @name clone\n     * @memberOf LazyWrapper\n     * @returns {Object} Returns the cloned `LazyWrapper` object.\n     */\n    function lazyClone() {\n      var result = new LazyWrapper(this.__wrapped__);\n      result.__actions__ = arrayCopy(this.__actions__);\n      result.__dir__ = this.__dir__;\n      result.__filtered__ = this.__filtered__;\n      result.__iteratees__ = arrayCopy(this.__iteratees__);\n      result.__takeCount__ = this.__takeCount__;\n      result.__views__ = arrayCopy(this.__views__);\n      return result;\n    }\n\n    /**\n     * Reverses the direction of lazy iteration.\n     *\n     * @private\n     * @name reverse\n     * @memberOf LazyWrapper\n     * @returns {Object} Returns the new reversed `LazyWrapper` object.\n     */\n    function lazyReverse() {\n      if (this.__filtered__) {\n        var result = new LazyWrapper(this);\n        result.__dir__ = -1;\n        result.__filtered__ = true;\n      } else {\n        result = this.clone();\n        result.__dir__ *= -1;\n      }\n      return result;\n    }\n\n    /**\n     * Extracts the unwrapped value from its lazy wrapper.\n     *\n     * @private\n     * @name value\n     * @memberOf LazyWrapper\n     * @returns {*} Returns the unwrapped value.\n     */\n    function lazyValue() {\n      var array = this.__wrapped__.value(),\n          dir = this.__dir__,\n          isArr = isArray(array),\n          isRight = dir < 0,\n          arrLength = isArr ? array.length : 0,\n          view = getView(0, arrLength, this.__views__),\n          start = view.start,\n          end = view.end,\n          length = end - start,\n          index = isRight ? end : (start - 1),\n          iteratees = this.__iteratees__,\n          iterLength = iteratees.length,\n          resIndex = 0,\n          takeCount = nativeMin(length, this.__takeCount__);\n\n      if (!isArr || arrLength < LARGE_ARRAY_SIZE || (arrLength == length && takeCount == length)) {\n        return baseWrapperValue((isRight && isArr) ? array.reverse() : array, this.__actions__);\n      }\n      var result = [];\n\n      outer:\n      while (length-- && resIndex < takeCount) {\n        index += dir;\n\n        var iterIndex = -1,\n            value = array[index];\n\n        while (++iterIndex < iterLength) {\n          var data = iteratees[iterIndex],\n              iteratee = data.iteratee,\n              type = data.type,\n              computed = iteratee(value);\n\n          if (type == LAZY_MAP_FLAG) {\n            value = computed;\n          } else if (!computed) {\n            if (type == LAZY_FILTER_FLAG) {\n              continue outer;\n            } else {\n              break outer;\n            }\n          }\n        }\n        result[resIndex++] = value;\n      }\n      return result;\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates a cache object to store key/value pairs.\n     *\n     * @private\n     * @static\n     * @name Cache\n     * @memberOf _.memoize\n     */\n    function MapCache() {\n      this.__data__ = {};\n    }\n\n    /**\n     * Removes `key` and its value from the cache.\n     *\n     * @private\n     * @name delete\n     * @memberOf _.memoize.Cache\n     * @param {string} key The key of the value to remove.\n     * @returns {boolean} Returns `true` if the entry was removed successfully, else `false`.\n     */\n    function mapDelete(key) {\n      return this.has(key) && delete this.__data__[key];\n    }\n\n    /**\n     * Gets the cached value for `key`.\n     *\n     * @private\n     * @name get\n     * @memberOf _.memoize.Cache\n     * @param {string} key The key of the value to get.\n     * @returns {*} Returns the cached value.\n     */\n    function mapGet(key) {\n      return key == '__proto__' ? undefined : this.__data__[key];\n    }\n\n    /**\n     * Checks if a cached value for `key` exists.\n     *\n     * @private\n     * @name has\n     * @memberOf _.memoize.Cache\n     * @param {string} key The key of the entry to check.\n     * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n     */\n    function mapHas(key) {\n      return key != '__proto__' && hasOwnProperty.call(this.__data__, key);\n    }\n\n    /**\n     * Sets `value` to `key` of the cache.\n     *\n     * @private\n     * @name set\n     * @memberOf _.memoize.Cache\n     * @param {string} key The key of the value to cache.\n     * @param {*} value The value to cache.\n     * @returns {Object} Returns the cache object.\n     */\n    function mapSet(key, value) {\n      if (key != '__proto__') {\n        this.__data__[key] = value;\n      }\n      return this;\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     *\n     * Creates a cache object to store unique values.\n     *\n     * @private\n     * @param {Array} [values] The values to cache.\n     */\n    function SetCache(values) {\n      var length = values ? values.length : 0;\n\n      this.data = { 'hash': nativeCreate(null), 'set': new Set };\n      while (length--) {\n        this.push(values[length]);\n      }\n    }\n\n    /**\n     * Checks if `value` is in `cache` mimicking the return signature of\n     * `_.indexOf` by returning `0` if the value is found, else `-1`.\n     *\n     * @private\n     * @param {Object} cache The cache to search.\n     * @param {*} value The value to search for.\n     * @returns {number} Returns `0` if `value` is found, else `-1`.\n     */\n    function cacheIndexOf(cache, value) {\n      var data = cache.data,\n          result = (typeof value == 'string' || isObject(value)) ? data.set.has(value) : data.hash[value];\n\n      return result ? 0 : -1;\n    }\n\n    /**\n     * Adds `value` to the cache.\n     *\n     * @private\n     * @name push\n     * @memberOf SetCache\n     * @param {*} value The value to cache.\n     */\n    function cachePush(value) {\n      var data = this.data;\n      if (typeof value == 'string' || isObject(value)) {\n        data.set.add(value);\n      } else {\n        data.hash[value] = true;\n      }\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates a new array joining `array` with `other`.\n     *\n     * @private\n     * @param {Array} array The array to join.\n     * @param {Array} other The other array to join.\n     * @returns {Array} Returns the new concatenated array.\n     */\n    function arrayConcat(array, other) {\n      var index = -1,\n          length = array.length,\n          othIndex = -1,\n          othLength = other.length,\n          result = Array(length + othLength);\n\n      while (++index < length) {\n        result[index] = array[index];\n      }\n      while (++othIndex < othLength) {\n        result[index++] = other[othIndex];\n      }\n      return result;\n    }\n\n    /**\n     * Copies the values of `source` to `array`.\n     *\n     * @private\n     * @param {Array} source The array to copy values from.\n     * @param {Array} [array=[]] The array to copy values to.\n     * @returns {Array} Returns `array`.\n     */\n    function arrayCopy(source, array) {\n      var index = -1,\n          length = source.length;\n\n      array || (array = Array(length));\n      while (++index < length) {\n        array[index] = source[index];\n      }\n      return array;\n    }\n\n    /**\n     * A specialized version of `_.forEach` for arrays without support for callback\n     * shorthands and `this` binding.\n     *\n     * @private\n     * @param {Array} array The array to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @returns {Array} Returns `array`.\n     */\n    function arrayEach(array, iteratee) {\n      var index = -1,\n          length = array.length;\n\n      while (++index < length) {\n        if (iteratee(array[index], index, array) === false) {\n          break;\n        }\n      }\n      return array;\n    }\n\n    /**\n     * A specialized version of `_.forEachRight` for arrays without support for\n     * callback shorthands and `this` binding.\n     *\n     * @private\n     * @param {Array} array The array to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @returns {Array} Returns `array`.\n     */\n    function arrayEachRight(array, iteratee) {\n      var length = array.length;\n\n      while (length--) {\n        if (iteratee(array[length], length, array) === false) {\n          break;\n        }\n      }\n      return array;\n    }\n\n    /**\n     * A specialized version of `_.every` for arrays without support for callback\n     * shorthands and `this` binding.\n     *\n     * @private\n     * @param {Array} array The array to iterate over.\n     * @param {Function} predicate The function invoked per iteration.\n     * @returns {boolean} Returns `true` if all elements pass the predicate check,\n     *  else `false`.\n     */\n    function arrayEvery(array, predicate) {\n      var index = -1,\n          length = array.length;\n\n      while (++index < length) {\n        if (!predicate(array[index], index, array)) {\n          return false;\n        }\n      }\n      return true;\n    }\n\n    /**\n     * A specialized version of `baseExtremum` for arrays which invokes `iteratee`\n     * with one argument: (value).\n     *\n     * @private\n     * @param {Array} array The array to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @param {Function} comparator The function used to compare values.\n     * @param {*} exValue The initial extremum value.\n     * @returns {*} Returns the extremum value.\n     */\n    function arrayExtremum(array, iteratee, comparator, exValue) {\n      var index = -1,\n          length = array.length,\n          computed = exValue,\n          result = computed;\n\n      while (++index < length) {\n        var value = array[index],\n            current = +iteratee(value);\n\n        if (comparator(current, computed)) {\n          computed = current;\n          result = value;\n        }\n      }\n      return result;\n    }\n\n    /**\n     * A specialized version of `_.filter` for arrays without support for callback\n     * shorthands and `this` binding.\n     *\n     * @private\n     * @param {Array} array The array to iterate over.\n     * @param {Function} predicate The function invoked per iteration.\n     * @returns {Array} Returns the new filtered array.\n     */\n    function arrayFilter(array, predicate) {\n      var index = -1,\n          length = array.length,\n          resIndex = -1,\n          result = [];\n\n      while (++index < length) {\n        var value = array[index];\n        if (predicate(value, index, array)) {\n          result[++resIndex] = value;\n        }\n      }\n      return result;\n    }\n\n    /**\n     * A specialized version of `_.map` for arrays without support for callback\n     * shorthands and `this` binding.\n     *\n     * @private\n     * @param {Array} array The array to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @returns {Array} Returns the new mapped array.\n     */\n    function arrayMap(array, iteratee) {\n      var index = -1,\n          length = array.length,\n          result = Array(length);\n\n      while (++index < length) {\n        result[index] = iteratee(array[index], index, array);\n      }\n      return result;\n    }\n\n    /**\n     * Appends the elements of `values` to `array`.\n     *\n     * @private\n     * @param {Array} array The array to modify.\n     * @param {Array} values The values to append.\n     * @returns {Array} Returns `array`.\n     */\n    function arrayPush(array, values) {\n      var index = -1,\n          length = values.length,\n          offset = array.length;\n\n      while (++index < length) {\n        array[offset + index] = values[index];\n      }\n      return array;\n    }\n\n    /**\n     * A specialized version of `_.reduce` for arrays without support for callback\n     * shorthands and `this` binding.\n     *\n     * @private\n     * @param {Array} array The array to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @param {*} [accumulator] The initial value.\n     * @param {boolean} [initFromArray] Specify using the first element of `array`\n     *  as the initial value.\n     * @returns {*} Returns the accumulated value.\n     */\n    function arrayReduce(array, iteratee, accumulator, initFromArray) {\n      var index = -1,\n          length = array.length;\n\n      if (initFromArray && length) {\n        accumulator = array[++index];\n      }\n      while (++index < length) {\n        accumulator = iteratee(accumulator, array[index], index, array);\n      }\n      return accumulator;\n    }\n\n    /**\n     * A specialized version of `_.reduceRight` for arrays without support for\n     * callback shorthands and `this` binding.\n     *\n     * @private\n     * @param {Array} array The array to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @param {*} [accumulator] The initial value.\n     * @param {boolean} [initFromArray] Specify using the last element of `array`\n     *  as the initial value.\n     * @returns {*} Returns the accumulated value.\n     */\n    function arrayReduceRight(array, iteratee, accumulator, initFromArray) {\n      var length = array.length;\n      if (initFromArray && length) {\n        accumulator = array[--length];\n      }\n      while (length--) {\n        accumulator = iteratee(accumulator, array[length], length, array);\n      }\n      return accumulator;\n    }\n\n    /**\n     * A specialized version of `_.some` for arrays without support for callback\n     * shorthands and `this` binding.\n     *\n     * @private\n     * @param {Array} array The array to iterate over.\n     * @param {Function} predicate The function invoked per iteration.\n     * @returns {boolean} Returns `true` if any element passes the predicate check,\n     *  else `false`.\n     */\n    function arraySome(array, predicate) {\n      var index = -1,\n          length = array.length;\n\n      while (++index < length) {\n        if (predicate(array[index], index, array)) {\n          return true;\n        }\n      }\n      return false;\n    }\n\n    /**\n     * A specialized version of `_.sum` for arrays without support for callback\n     * shorthands and `this` binding..\n     *\n     * @private\n     * @param {Array} array The array to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @returns {number} Returns the sum.\n     */\n    function arraySum(array, iteratee) {\n      var length = array.length,\n          result = 0;\n\n      while (length--) {\n        result += +iteratee(array[length]) || 0;\n      }\n      return result;\n    }\n\n    /**\n     * Used by `_.defaults` to customize its `_.assign` use.\n     *\n     * @private\n     * @param {*} objectValue The destination object property value.\n     * @param {*} sourceValue The source object property value.\n     * @returns {*} Returns the value to assign to the destination object.\n     */\n    function assignDefaults(objectValue, sourceValue) {\n      return objectValue === undefined ? sourceValue : objectValue;\n    }\n\n    /**\n     * Used by `_.template` to customize its `_.assign` use.\n     *\n     * **Note:** This function is like `assignDefaults` except that it ignores\n     * inherited property values when checking if a property is `undefined`.\n     *\n     * @private\n     * @param {*} objectValue The destination object property value.\n     * @param {*} sourceValue The source object property value.\n     * @param {string} key The key associated with the object and source values.\n     * @param {Object} object The destination object.\n     * @returns {*} Returns the value to assign to the destination object.\n     */\n    function assignOwnDefaults(objectValue, sourceValue, key, object) {\n      return (objectValue === undefined || !hasOwnProperty.call(object, key))\n        ? sourceValue\n        : objectValue;\n    }\n\n    /**\n     * A specialized version of `_.assign` for customizing assigned values without\n     * support for argument juggling, multiple sources, and `this` binding `customizer`\n     * functions.\n     *\n     * @private\n     * @param {Object} object The destination object.\n     * @param {Object} source The source object.\n     * @param {Function} customizer The function to customize assigned values.\n     * @returns {Object} Returns `object`.\n     */\n    function assignWith(object, source, customizer) {\n      var index = -1,\n          props = keys(source),\n          length = props.length;\n\n      while (++index < length) {\n        var key = props[index],\n            value = object[key],\n            result = customizer(value, source[key], key, object, source);\n\n        if ((result === result ? (result !== value) : (value === value)) ||\n            (value === undefined && !(key in object))) {\n          object[key] = result;\n        }\n      }\n      return object;\n    }\n\n    /**\n     * The base implementation of `_.assign` without support for argument juggling,\n     * multiple sources, and `customizer` functions.\n     *\n     * @private\n     * @param {Object} object The destination object.\n     * @param {Object} source The source object.\n     * @returns {Object} Returns `object`.\n     */\n    function baseAssign(object, source) {\n      return source == null\n        ? object\n        : baseCopy(source, keys(source), object);\n    }\n\n    /**\n     * The base implementation of `_.at` without support for string collections\n     * and individual key arguments.\n     *\n     * @private\n     * @param {Array|Object} collection The collection to iterate over.\n     * @param {number[]|string[]} props The property names or indexes of elements to pick.\n     * @returns {Array} Returns the new array of picked elements.\n     */\n    function baseAt(collection, props) {\n      var index = -1,\n          isNil = collection == null,\n          isArr = !isNil && isArrayLike(collection),\n          length = isArr ? collection.length : 0,\n          propsLength = props.length,\n          result = Array(propsLength);\n\n      while(++index < propsLength) {\n        var key = props[index];\n        if (isArr) {\n          result[index] = isIndex(key, length) ? collection[key] : undefined;\n        } else {\n          result[index] = isNil ? undefined : collection[key];\n        }\n      }\n      return result;\n    }\n\n    /**\n     * Copies properties of `source` to `object`.\n     *\n     * @private\n     * @param {Object} source The object to copy properties from.\n     * @param {Array} props The property names to copy.\n     * @param {Object} [object={}] The object to copy properties to.\n     * @returns {Object} Returns `object`.\n     */\n    function baseCopy(source, props, object) {\n      object || (object = {});\n\n      var index = -1,\n          length = props.length;\n\n      while (++index < length) {\n        var key = props[index];\n        object[key] = source[key];\n      }\n      return object;\n    }\n\n    /**\n     * The base implementation of `_.callback` which supports specifying the\n     * number of arguments to provide to `func`.\n     *\n     * @private\n     * @param {*} [func=_.identity] The value to convert to a callback.\n     * @param {*} [thisArg] The `this` binding of `func`.\n     * @param {number} [argCount] The number of arguments to provide to `func`.\n     * @returns {Function} Returns the callback.\n     */\n    function baseCallback(func, thisArg, argCount) {\n      var type = typeof func;\n      if (type == 'function') {\n        return thisArg === undefined\n          ? func\n          : bindCallback(func, thisArg, argCount);\n      }\n      if (func == null) {\n        return identity;\n      }\n      if (type == 'object') {\n        return baseMatches(func);\n      }\n      return thisArg === undefined\n        ? property(func)\n        : baseMatchesProperty(func, thisArg);\n    }\n\n    /**\n     * The base implementation of `_.clone` without support for argument juggling\n     * and `this` binding `customizer` functions.\n     *\n     * @private\n     * @param {*} value The value to clone.\n     * @param {boolean} [isDeep] Specify a deep clone.\n     * @param {Function} [customizer] The function to customize cloning values.\n     * @param {string} [key] The key of `value`.\n     * @param {Object} [object] The object `value` belongs to.\n     * @param {Array} [stackA=[]] Tracks traversed source objects.\n     * @param {Array} [stackB=[]] Associates clones with source counterparts.\n     * @returns {*} Returns the cloned value.\n     */\n    function baseClone(value, isDeep, customizer, key, object, stackA, stackB) {\n      var result;\n      if (customizer) {\n        result = object ? customizer(value, key, object) : customizer(value);\n      }\n      if (result !== undefined) {\n        return result;\n      }\n      if (!isObject(value)) {\n        return value;\n      }\n      var isArr = isArray(value);\n      if (isArr) {\n        result = initCloneArray(value);\n        if (!isDeep) {\n          return arrayCopy(value, result);\n        }\n      } else {\n        var tag = objToString.call(value),\n            isFunc = tag == funcTag;\n\n        if (tag == objectTag || tag == argsTag || (isFunc && !object)) {\n          result = initCloneObject(isFunc ? {} : value);\n          if (!isDeep) {\n            return baseAssign(result, value);\n          }\n        } else {\n          return cloneableTags[tag]\n            ? initCloneByTag(value, tag, isDeep)\n            : (object ? value : {});\n        }\n      }\n      // Check for circular references and return its corresponding clone.\n      stackA || (stackA = []);\n      stackB || (stackB = []);\n\n      var length = stackA.length;\n      while (length--) {\n        if (stackA[length] == value) {\n          return stackB[length];\n        }\n      }\n      // Add the source value to the stack of traversed objects and associate it with its clone.\n      stackA.push(value);\n      stackB.push(result);\n\n      // Recursively populate clone (susceptible to call stack limits).\n      (isArr ? arrayEach : baseForOwn)(value, function(subValue, key) {\n        result[key] = baseClone(subValue, isDeep, customizer, key, value, stackA, stackB);\n      });\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.create` without support for assigning\n     * properties to the created object.\n     *\n     * @private\n     * @param {Object} prototype The object to inherit from.\n     * @returns {Object} Returns the new object.\n     */\n    var baseCreate = (function() {\n      function object() {}\n      return function(prototype) {\n        if (isObject(prototype)) {\n          object.prototype = prototype;\n          var result = new object;\n          object.prototype = undefined;\n        }\n        return result || {};\n      };\n    }());\n\n    /**\n     * The base implementation of `_.delay` and `_.defer` which accepts an index\n     * of where to slice the arguments to provide to `func`.\n     *\n     * @private\n     * @param {Function} func The function to delay.\n     * @param {number} wait The number of milliseconds to delay invocation.\n     * @param {Object} args The arguments provide to `func`.\n     * @returns {number} Returns the timer id.\n     */\n    function baseDelay(func, wait, args) {\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      return setTimeout(function() { func.apply(undefined, args); }, wait);\n    }\n\n    /**\n     * The base implementation of `_.difference` which accepts a single array\n     * of values to exclude.\n     *\n     * @private\n     * @param {Array} array The array to inspect.\n     * @param {Array} values The values to exclude.\n     * @returns {Array} Returns the new array of filtered values.\n     */\n    function baseDifference(array, values) {\n      var length = array ? array.length : 0,\n          result = [];\n\n      if (!length) {\n        return result;\n      }\n      var index = -1,\n          indexOf = getIndexOf(),\n          isCommon = indexOf == baseIndexOf,\n          cache = (isCommon && values.length >= LARGE_ARRAY_SIZE) ? createCache(values) : null,\n          valuesLength = values.length;\n\n      if (cache) {\n        indexOf = cacheIndexOf;\n        isCommon = false;\n        values = cache;\n      }\n      outer:\n      while (++index < length) {\n        var value = array[index];\n\n        if (isCommon && value === value) {\n          var valuesIndex = valuesLength;\n          while (valuesIndex--) {\n            if (values[valuesIndex] === value) {\n              continue outer;\n            }\n          }\n          result.push(value);\n        }\n        else if (indexOf(values, value, 0) < 0) {\n          result.push(value);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.forEach` without support for callback\n     * shorthands and `this` binding.\n     *\n     * @private\n     * @param {Array|Object|string} collection The collection to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @returns {Array|Object|string} Returns `collection`.\n     */\n    var baseEach = createBaseEach(baseForOwn);\n\n    /**\n     * The base implementation of `_.forEachRight` without support for callback\n     * shorthands and `this` binding.\n     *\n     * @private\n     * @param {Array|Object|string} collection The collection to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @returns {Array|Object|string} Returns `collection`.\n     */\n    var baseEachRight = createBaseEach(baseForOwnRight, true);\n\n    /**\n     * The base implementation of `_.every` without support for callback\n     * shorthands and `this` binding.\n     *\n     * @private\n     * @param {Array|Object|string} collection The collection to iterate over.\n     * @param {Function} predicate The function invoked per iteration.\n     * @returns {boolean} Returns `true` if all elements pass the predicate check,\n     *  else `false`\n     */\n    function baseEvery(collection, predicate) {\n      var result = true;\n      baseEach(collection, function(value, index, collection) {\n        result = !!predicate(value, index, collection);\n        return result;\n      });\n      return result;\n    }\n\n    /**\n     * Gets the extremum value of `collection` invoking `iteratee` for each value\n     * in `collection` to generate the criterion by which the value is ranked.\n     * The `iteratee` is invoked with three arguments: (value, index|key, collection).\n     *\n     * @private\n     * @param {Array|Object|string} collection The collection to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @param {Function} comparator The function used to compare values.\n     * @param {*} exValue The initial extremum value.\n     * @returns {*} Returns the extremum value.\n     */\n    function baseExtremum(collection, iteratee, comparator, exValue) {\n      var computed = exValue,\n          result = computed;\n\n      baseEach(collection, function(value, index, collection) {\n        var current = +iteratee(value, index, collection);\n        if (comparator(current, computed) || (current === exValue && current === result)) {\n          computed = current;\n          result = value;\n        }\n      });\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.fill` without an iteratee call guard.\n     *\n     * @private\n     * @param {Array} array The array to fill.\n     * @param {*} value The value to fill `array` with.\n     * @param {number} [start=0] The start position.\n     * @param {number} [end=array.length] The end position.\n     * @returns {Array} Returns `array`.\n     */\n    function baseFill(array, value, start, end) {\n      var length = array.length;\n\n      start = start == null ? 0 : (+start || 0);\n      if (start < 0) {\n        start = -start > length ? 0 : (length + start);\n      }\n      end = (end === undefined || end > length) ? length : (+end || 0);\n      if (end < 0) {\n        end += length;\n      }\n      length = start > end ? 0 : (end >>> 0);\n      start >>>= 0;\n\n      while (start < length) {\n        array[start++] = value;\n      }\n      return array;\n    }\n\n    /**\n     * The base implementation of `_.filter` without support for callback\n     * shorthands and `this` binding.\n     *\n     * @private\n     * @param {Array|Object|string} collection The collection to iterate over.\n     * @param {Function} predicate The function invoked per iteration.\n     * @returns {Array} Returns the new filtered array.\n     */\n    function baseFilter(collection, predicate) {\n      var result = [];\n      baseEach(collection, function(value, index, collection) {\n        if (predicate(value, index, collection)) {\n          result.push(value);\n        }\n      });\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.find`, `_.findLast`, `_.findKey`, and `_.findLastKey`,\n     * without support for callback shorthands and `this` binding, which iterates\n     * over `collection` using the provided `eachFunc`.\n     *\n     * @private\n     * @param {Array|Object|string} collection The collection to search.\n     * @param {Function} predicate The function invoked per iteration.\n     * @param {Function} eachFunc The function to iterate over `collection`.\n     * @param {boolean} [retKey] Specify returning the key of the found element\n     *  instead of the element itself.\n     * @returns {*} Returns the found element or its key, else `undefined`.\n     */\n    function baseFind(collection, predicate, eachFunc, retKey) {\n      var result;\n      eachFunc(collection, function(value, key, collection) {\n        if (predicate(value, key, collection)) {\n          result = retKey ? key : value;\n          return false;\n        }\n      });\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.flatten` with added support for restricting\n     * flattening and specifying the start index.\n     *\n     * @private\n     * @param {Array} array The array to flatten.\n     * @param {boolean} [isDeep] Specify a deep flatten.\n     * @param {boolean} [isStrict] Restrict flattening to arrays-like objects.\n     * @param {Array} [result=[]] The initial result value.\n     * @returns {Array} Returns the new flattened array.\n     */\n    function baseFlatten(array, isDeep, isStrict, result) {\n      result || (result = []);\n\n      var index = -1,\n          length = array.length;\n\n      while (++index < length) {\n        var value = array[index];\n        if (isObjectLike(value) && isArrayLike(value) &&\n            (isStrict || isArray(value) || isArguments(value))) {\n          if (isDeep) {\n            // Recursively flatten arrays (susceptible to call stack limits).\n            baseFlatten(value, isDeep, isStrict, result);\n          } else {\n            arrayPush(result, value);\n          }\n        } else if (!isStrict) {\n          result[result.length] = value;\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `baseForIn` and `baseForOwn` which iterates\n     * over `object` properties returned by `keysFunc` invoking `iteratee` for\n     * each property. Iteratee functions may exit iteration early by explicitly\n     * returning `false`.\n     *\n     * @private\n     * @param {Object} object The object to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @param {Function} keysFunc The function to get the keys of `object`.\n     * @returns {Object} Returns `object`.\n     */\n    var baseFor = createBaseFor();\n\n    /**\n     * This function is like `baseFor` except that it iterates over properties\n     * in the opposite order.\n     *\n     * @private\n     * @param {Object} object The object to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @param {Function} keysFunc The function to get the keys of `object`.\n     * @returns {Object} Returns `object`.\n     */\n    var baseForRight = createBaseFor(true);\n\n    /**\n     * The base implementation of `_.forIn` without support for callback\n     * shorthands and `this` binding.\n     *\n     * @private\n     * @param {Object} object The object to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @returns {Object} Returns `object`.\n     */\n    function baseForIn(object, iteratee) {\n      return baseFor(object, iteratee, keysIn);\n    }\n\n    /**\n     * The base implementation of `_.forOwn` without support for callback\n     * shorthands and `this` binding.\n     *\n     * @private\n     * @param {Object} object The object to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @returns {Object} Returns `object`.\n     */\n    function baseForOwn(object, iteratee) {\n      return baseFor(object, iteratee, keys);\n    }\n\n    /**\n     * The base implementation of `_.forOwnRight` without support for callback\n     * shorthands and `this` binding.\n     *\n     * @private\n     * @param {Object} object The object to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @returns {Object} Returns `object`.\n     */\n    function baseForOwnRight(object, iteratee) {\n      return baseForRight(object, iteratee, keys);\n    }\n\n    /**\n     * The base implementation of `_.functions` which creates an array of\n     * `object` function property names filtered from those provided.\n     *\n     * @private\n     * @param {Object} object The object to inspect.\n     * @param {Array} props The property names to filter.\n     * @returns {Array} Returns the new array of filtered property names.\n     */\n    function baseFunctions(object, props) {\n      var index = -1,\n          length = props.length,\n          resIndex = -1,\n          result = [];\n\n      while (++index < length) {\n        var key = props[index];\n        if (isFunction(object[key])) {\n          result[++resIndex] = key;\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `get` without support for string paths\n     * and default values.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @param {Array} path The path of the property to get.\n     * @param {string} [pathKey] The key representation of path.\n     * @returns {*} Returns the resolved value.\n     */\n    function baseGet(object, path, pathKey) {\n      if (object == null) {\n        return;\n      }\n      if (pathKey !== undefined && pathKey in toObject(object)) {\n        path = [pathKey];\n      }\n      var index = 0,\n          length = path.length;\n\n      while (object != null && index < length) {\n        object = object[path[index++]];\n      }\n      return (index && index == length) ? object : undefined;\n    }\n\n    /**\n     * The base implementation of `_.isEqual` without support for `this` binding\n     * `customizer` functions.\n     *\n     * @private\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @param {Function} [customizer] The function to customize comparing values.\n     * @param {boolean} [isLoose] Specify performing partial comparisons.\n     * @param {Array} [stackA] Tracks traversed `value` objects.\n     * @param {Array} [stackB] Tracks traversed `other` objects.\n     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n     */\n    function baseIsEqual(value, other, customizer, isLoose, stackA, stackB) {\n      if (value === other) {\n        return true;\n      }\n      if (value == null || other == null || (!isObject(value) && !isObjectLike(other))) {\n        return value !== value && other !== other;\n      }\n      return baseIsEqualDeep(value, other, baseIsEqual, customizer, isLoose, stackA, stackB);\n    }\n\n    /**\n     * A specialized version of `baseIsEqual` for arrays and objects which performs\n     * deep comparisons and tracks traversed objects enabling objects with circular\n     * references to be compared.\n     *\n     * @private\n     * @param {Object} object The object to compare.\n     * @param {Object} other The other object to compare.\n     * @param {Function} equalFunc The function to determine equivalents of values.\n     * @param {Function} [customizer] The function to customize comparing objects.\n     * @param {boolean} [isLoose] Specify performing partial comparisons.\n     * @param {Array} [stackA=[]] Tracks traversed `value` objects.\n     * @param {Array} [stackB=[]] Tracks traversed `other` objects.\n     * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n     */\n    function baseIsEqualDeep(object, other, equalFunc, customizer, isLoose, stackA, stackB) {\n      var objIsArr = isArray(object),\n          othIsArr = isArray(other),\n          objTag = arrayTag,\n          othTag = arrayTag;\n\n      if (!objIsArr) {\n        objTag = objToString.call(object);\n        if (objTag == argsTag) {\n          objTag = objectTag;\n        } else if (objTag != objectTag) {\n          objIsArr = isTypedArray(object);\n        }\n      }\n      if (!othIsArr) {\n        othTag = objToString.call(other);\n        if (othTag == argsTag) {\n          othTag = objectTag;\n        } else if (othTag != objectTag) {\n          othIsArr = isTypedArray(other);\n        }\n      }\n      var objIsObj = objTag == objectTag,\n          othIsObj = othTag == objectTag,\n          isSameTag = objTag == othTag;\n\n      if (isSameTag && !(objIsArr || objIsObj)) {\n        return equalByTag(object, other, objTag);\n      }\n      if (!isLoose) {\n        var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),\n            othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');\n\n        if (objIsWrapped || othIsWrapped) {\n          return equalFunc(objIsWrapped ? object.value() : object, othIsWrapped ? other.value() : other, customizer, isLoose, stackA, stackB);\n        }\n      }\n      if (!isSameTag) {\n        return false;\n      }\n      // Assume cyclic values are equal.\n      // For more information on detecting circular references see https://es5.github.io/#JO.\n      stackA || (stackA = []);\n      stackB || (stackB = []);\n\n      var length = stackA.length;\n      while (length--) {\n        if (stackA[length] == object) {\n          return stackB[length] == other;\n        }\n      }\n      // Add `object` and `other` to the stack of traversed objects.\n      stackA.push(object);\n      stackB.push(other);\n\n      var result = (objIsArr ? equalArrays : equalObjects)(object, other, equalFunc, customizer, isLoose, stackA, stackB);\n\n      stackA.pop();\n      stackB.pop();\n\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.isMatch` without support for callback\n     * shorthands and `this` binding.\n     *\n     * @private\n     * @param {Object} object The object to inspect.\n     * @param {Array} matchData The propery names, values, and compare flags to match.\n     * @param {Function} [customizer] The function to customize comparing objects.\n     * @returns {boolean} Returns `true` if `object` is a match, else `false`.\n     */\n    function baseIsMatch(object, matchData, customizer) {\n      var index = matchData.length,\n          length = index,\n          noCustomizer = !customizer;\n\n      if (object == null) {\n        return !length;\n      }\n      object = toObject(object);\n      while (index--) {\n        var data = matchData[index];\n        if ((noCustomizer && data[2])\n              ? data[1] !== object[data[0]]\n              : !(data[0] in object)\n            ) {\n          return false;\n        }\n      }\n      while (++index < length) {\n        data = matchData[index];\n        var key = data[0],\n            objValue = object[key],\n            srcValue = data[1];\n\n        if (noCustomizer && data[2]) {\n          if (objValue === undefined && !(key in object)) {\n            return false;\n          }\n        } else {\n          var result = customizer ? customizer(objValue, srcValue, key) : undefined;\n          if (!(result === undefined ? baseIsEqual(srcValue, objValue, customizer, true) : result)) {\n            return false;\n          }\n        }\n      }\n      return true;\n    }\n\n    /**\n     * The base implementation of `_.map` without support for callback shorthands\n     * and `this` binding.\n     *\n     * @private\n     * @param {Array|Object|string} collection The collection to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @returns {Array} Returns the new mapped array.\n     */\n    function baseMap(collection, iteratee) {\n      var index = -1,\n          result = isArrayLike(collection) ? Array(collection.length) : [];\n\n      baseEach(collection, function(value, key, collection) {\n        result[++index] = iteratee(value, key, collection);\n      });\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.matches` which does not clone `source`.\n     *\n     * @private\n     * @param {Object} source The object of property values to match.\n     * @returns {Function} Returns the new function.\n     */\n    function baseMatches(source) {\n      var matchData = getMatchData(source);\n      if (matchData.length == 1 && matchData[0][2]) {\n        var key = matchData[0][0],\n            value = matchData[0][1];\n\n        return function(object) {\n          if (object == null) {\n            return false;\n          }\n          return object[key] === value && (value !== undefined || (key in toObject(object)));\n        };\n      }\n      return function(object) {\n        return baseIsMatch(object, matchData);\n      };\n    }\n\n    /**\n     * The base implementation of `_.matchesProperty` which does not clone `srcValue`.\n     *\n     * @private\n     * @param {string} path The path of the property to get.\n     * @param {*} srcValue The value to compare.\n     * @returns {Function} Returns the new function.\n     */\n    function baseMatchesProperty(path, srcValue) {\n      var isArr = isArray(path),\n          isCommon = isKey(path) && isStrictComparable(srcValue),\n          pathKey = (path + '');\n\n      path = toPath(path);\n      return function(object) {\n        if (object == null) {\n          return false;\n        }\n        var key = pathKey;\n        object = toObject(object);\n        if ((isArr || !isCommon) && !(key in object)) {\n          object = path.length == 1 ? object : baseGet(object, baseSlice(path, 0, -1));\n          if (object == null) {\n            return false;\n          }\n          key = last(path);\n          object = toObject(object);\n        }\n        return object[key] === srcValue\n          ? (srcValue !== undefined || (key in object))\n          : baseIsEqual(srcValue, object[key], undefined, true);\n      };\n    }\n\n    /**\n     * The base implementation of `_.merge` without support for argument juggling,\n     * multiple sources, and `this` binding `customizer` functions.\n     *\n     * @private\n     * @param {Object} object The destination object.\n     * @param {Object} source The source object.\n     * @param {Function} [customizer] The function to customize merged values.\n     * @param {Array} [stackA=[]] Tracks traversed source objects.\n     * @param {Array} [stackB=[]] Associates values with source counterparts.\n     * @returns {Object} Returns `object`.\n     */\n    function baseMerge(object, source, customizer, stackA, stackB) {\n      if (!isObject(object)) {\n        return object;\n      }\n      var isSrcArr = isArrayLike(source) && (isArray(source) || isTypedArray(source)),\n          props = isSrcArr ? undefined : keys(source);\n\n      arrayEach(props || source, function(srcValue, key) {\n        if (props) {\n          key = srcValue;\n          srcValue = source[key];\n        }\n        if (isObjectLike(srcValue)) {\n          stackA || (stackA = []);\n          stackB || (stackB = []);\n          baseMergeDeep(object, source, key, baseMerge, customizer, stackA, stackB);\n        }\n        else {\n          var value = object[key],\n              result = customizer ? customizer(value, srcValue, key, object, source) : undefined,\n              isCommon = result === undefined;\n\n          if (isCommon) {\n            result = srcValue;\n          }\n          if ((result !== undefined || (isSrcArr && !(key in object))) &&\n              (isCommon || (result === result ? (result !== value) : (value === value)))) {\n            object[key] = result;\n          }\n        }\n      });\n      return object;\n    }\n\n    /**\n     * A specialized version of `baseMerge` for arrays and objects which performs\n     * deep merges and tracks traversed objects enabling objects with circular\n     * references to be merged.\n     *\n     * @private\n     * @param {Object} object The destination object.\n     * @param {Object} source The source object.\n     * @param {string} key The key of the value to merge.\n     * @param {Function} mergeFunc The function to merge values.\n     * @param {Function} [customizer] The function to customize merged values.\n     * @param {Array} [stackA=[]] Tracks traversed source objects.\n     * @param {Array} [stackB=[]] Associates values with source counterparts.\n     * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n     */\n    function baseMergeDeep(object, source, key, mergeFunc, customizer, stackA, stackB) {\n      var length = stackA.length,\n          srcValue = source[key];\n\n      while (length--) {\n        if (stackA[length] == srcValue) {\n          object[key] = stackB[length];\n          return;\n        }\n      }\n      var value = object[key],\n          result = customizer ? customizer(value, srcValue, key, object, source) : undefined,\n          isCommon = result === undefined;\n\n      if (isCommon) {\n        result = srcValue;\n        if (isArrayLike(srcValue) && (isArray(srcValue) || isTypedArray(srcValue))) {\n          result = isArray(value)\n            ? value\n            : (isArrayLike(value) ? arrayCopy(value) : []);\n        }\n        else if (isPlainObject(srcValue) || isArguments(srcValue)) {\n          result = isArguments(value)\n            ? toPlainObject(value)\n            : (isPlainObject(value) ? value : {});\n        }\n        else {\n          isCommon = false;\n        }\n      }\n      // Add the source value to the stack of traversed objects and associate\n      // it with its merged value.\n      stackA.push(srcValue);\n      stackB.push(result);\n\n      if (isCommon) {\n        // Recursively merge objects and arrays (susceptible to call stack limits).\n        object[key] = mergeFunc(result, srcValue, customizer, stackA, stackB);\n      } else if (result === result ? (result !== value) : (value === value)) {\n        object[key] = result;\n      }\n    }\n\n    /**\n     * The base implementation of `_.property` without support for deep paths.\n     *\n     * @private\n     * @param {string} key The key of the property to get.\n     * @returns {Function} Returns the new function.\n     */\n    function baseProperty(key) {\n      return function(object) {\n        return object == null ? undefined : object[key];\n      };\n    }\n\n    /**\n     * A specialized version of `baseProperty` which supports deep paths.\n     *\n     * @private\n     * @param {Array|string} path The path of the property to get.\n     * @returns {Function} Returns the new function.\n     */\n    function basePropertyDeep(path) {\n      var pathKey = (path + '');\n      path = toPath(path);\n      return function(object) {\n        return baseGet(object, path, pathKey);\n      };\n    }\n\n    /**\n     * The base implementation of `_.pullAt` without support for individual\n     * index arguments and capturing the removed elements.\n     *\n     * @private\n     * @param {Array} array The array to modify.\n     * @param {number[]} indexes The indexes of elements to remove.\n     * @returns {Array} Returns `array`.\n     */\n    function basePullAt(array, indexes) {\n      var length = array ? indexes.length : 0;\n      while (length--) {\n        var index = indexes[length];\n        if (index != previous && isIndex(index)) {\n          var previous = index;\n          splice.call(array, index, 1);\n        }\n      }\n      return array;\n    }\n\n    /**\n     * The base implementation of `_.random` without support for argument juggling\n     * and returning floating-point numbers.\n     *\n     * @private\n     * @param {number} min The minimum possible value.\n     * @param {number} max The maximum possible value.\n     * @returns {number} Returns the random number.\n     */\n    function baseRandom(min, max) {\n      return min + nativeFloor(nativeRandom() * (max - min + 1));\n    }\n\n    /**\n     * The base implementation of `_.reduce` and `_.reduceRight` without support\n     * for callback shorthands and `this` binding, which iterates over `collection`\n     * using the provided `eachFunc`.\n     *\n     * @private\n     * @param {Array|Object|string} collection The collection to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @param {*} accumulator The initial value.\n     * @param {boolean} initFromCollection Specify using the first or last element\n     *  of `collection` as the initial value.\n     * @param {Function} eachFunc The function to iterate over `collection`.\n     * @returns {*} Returns the accumulated value.\n     */\n    function baseReduce(collection, iteratee, accumulator, initFromCollection, eachFunc) {\n      eachFunc(collection, function(value, index, collection) {\n        accumulator = initFromCollection\n          ? (initFromCollection = false, value)\n          : iteratee(accumulator, value, index, collection);\n      });\n      return accumulator;\n    }\n\n    /**\n     * The base implementation of `setData` without support for hot loop detection.\n     *\n     * @private\n     * @param {Function} func The function to associate metadata with.\n     * @param {*} data The metadata.\n     * @returns {Function} Returns `func`.\n     */\n    var baseSetData = !metaMap ? identity : function(func, data) {\n      metaMap.set(func, data);\n      return func;\n    };\n\n    /**\n     * The base implementation of `_.slice` without an iteratee call guard.\n     *\n     * @private\n     * @param {Array} array The array to slice.\n     * @param {number} [start=0] The start position.\n     * @param {number} [end=array.length] The end position.\n     * @returns {Array} Returns the slice of `array`.\n     */\n    function baseSlice(array, start, end) {\n      var index = -1,\n          length = array.length;\n\n      start = start == null ? 0 : (+start || 0);\n      if (start < 0) {\n        start = -start > length ? 0 : (length + start);\n      }\n      end = (end === undefined || end > length) ? length : (+end || 0);\n      if (end < 0) {\n        end += length;\n      }\n      length = start > end ? 0 : ((end - start) >>> 0);\n      start >>>= 0;\n\n      var result = Array(length);\n      while (++index < length) {\n        result[index] = array[index + start];\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.some` without support for callback shorthands\n     * and `this` binding.\n     *\n     * @private\n     * @param {Array|Object|string} collection The collection to iterate over.\n     * @param {Function} predicate The function invoked per iteration.\n     * @returns {boolean} Returns `true` if any element passes the predicate check,\n     *  else `false`.\n     */\n    function baseSome(collection, predicate) {\n      var result;\n\n      baseEach(collection, function(value, index, collection) {\n        result = predicate(value, index, collection);\n        return !result;\n      });\n      return !!result;\n    }\n\n    /**\n     * The base implementation of `_.sortBy` which uses `comparer` to define\n     * the sort order of `array` and replaces criteria objects with their\n     * corresponding values.\n     *\n     * @private\n     * @param {Array} array The array to sort.\n     * @param {Function} comparer The function to define sort order.\n     * @returns {Array} Returns `array`.\n     */\n    function baseSortBy(array, comparer) {\n      var length = array.length;\n\n      array.sort(comparer);\n      while (length--) {\n        array[length] = array[length].value;\n      }\n      return array;\n    }\n\n    /**\n     * The base implementation of `_.sortByOrder` without param guards.\n     *\n     * @private\n     * @param {Array|Object|string} collection The collection to iterate over.\n     * @param {Function[]|Object[]|string[]} iteratees The iteratees to sort by.\n     * @param {boolean[]} orders The sort orders of `iteratees`.\n     * @returns {Array} Returns the new sorted array.\n     */\n    function baseSortByOrder(collection, iteratees, orders) {\n      var callback = getCallback(),\n          index = -1;\n\n      iteratees = arrayMap(iteratees, function(iteratee) { return callback(iteratee); });\n\n      var result = baseMap(collection, function(value) {\n        var criteria = arrayMap(iteratees, function(iteratee) { return iteratee(value); });\n        return { 'criteria': criteria, 'index': ++index, 'value': value };\n      });\n\n      return baseSortBy(result, function(object, other) {\n        return compareMultiple(object, other, orders);\n      });\n    }\n\n    /**\n     * The base implementation of `_.sum` without support for callback shorthands\n     * and `this` binding.\n     *\n     * @private\n     * @param {Array|Object|string} collection The collection to iterate over.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @returns {number} Returns the sum.\n     */\n    function baseSum(collection, iteratee) {\n      var result = 0;\n      baseEach(collection, function(value, index, collection) {\n        result += +iteratee(value, index, collection) || 0;\n      });\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.uniq` without support for callback shorthands\n     * and `this` binding.\n     *\n     * @private\n     * @param {Array} array The array to inspect.\n     * @param {Function} [iteratee] The function invoked per iteration.\n     * @returns {Array} Returns the new duplicate-value-free array.\n     */\n    function baseUniq(array, iteratee) {\n      var index = -1,\n          indexOf = getIndexOf(),\n          length = array.length,\n          isCommon = indexOf == baseIndexOf,\n          isLarge = isCommon && length >= LARGE_ARRAY_SIZE,\n          seen = isLarge ? createCache() : null,\n          result = [];\n\n      if (seen) {\n        indexOf = cacheIndexOf;\n        isCommon = false;\n      } else {\n        isLarge = false;\n        seen = iteratee ? [] : result;\n      }\n      outer:\n      while (++index < length) {\n        var value = array[index],\n            computed = iteratee ? iteratee(value, index, array) : value;\n\n        if (isCommon && value === value) {\n          var seenIndex = seen.length;\n          while (seenIndex--) {\n            if (seen[seenIndex] === computed) {\n              continue outer;\n            }\n          }\n          if (iteratee) {\n            seen.push(computed);\n          }\n          result.push(value);\n        }\n        else if (indexOf(seen, computed, 0) < 0) {\n          if (iteratee || isLarge) {\n            seen.push(computed);\n          }\n          result.push(value);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.values` and `_.valuesIn` which creates an\n     * array of `object` property values corresponding to the property names\n     * of `props`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @param {Array} props The property names to get values for.\n     * @returns {Object} Returns the array of property values.\n     */\n    function baseValues(object, props) {\n      var index = -1,\n          length = props.length,\n          result = Array(length);\n\n      while (++index < length) {\n        result[index] = object[props[index]];\n      }\n      return result;\n    }\n\n    /**\n     * The base implementation of `_.dropRightWhile`, `_.dropWhile`, `_.takeRightWhile`,\n     * and `_.takeWhile` without support for callback shorthands and `this` binding.\n     *\n     * @private\n     * @param {Array} array The array to query.\n     * @param {Function} predicate The function invoked per iteration.\n     * @param {boolean} [isDrop] Specify dropping elements instead of taking them.\n     * @param {boolean} [fromRight] Specify iterating from right to left.\n     * @returns {Array} Returns the slice of `array`.\n     */\n    function baseWhile(array, predicate, isDrop, fromRight) {\n      var length = array.length,\n          index = fromRight ? length : -1;\n\n      while ((fromRight ? index-- : ++index < length) && predicate(array[index], index, array)) {}\n      return isDrop\n        ? baseSlice(array, (fromRight ? 0 : index), (fromRight ? index + 1 : length))\n        : baseSlice(array, (fromRight ? index + 1 : 0), (fromRight ? length : index));\n    }\n\n    /**\n     * The base implementation of `wrapperValue` which returns the result of\n     * performing a sequence of actions on the unwrapped `value`, where each\n     * successive action is supplied the return value of the previous.\n     *\n     * @private\n     * @param {*} value The unwrapped value.\n     * @param {Array} actions Actions to peform to resolve the unwrapped value.\n     * @returns {*} Returns the resolved value.\n     */\n    function baseWrapperValue(value, actions) {\n      var result = value;\n      if (result instanceof LazyWrapper) {\n        result = result.value();\n      }\n      var index = -1,\n          length = actions.length;\n\n      while (++index < length) {\n        var action = actions[index];\n        result = action.func.apply(action.thisArg, arrayPush([result], action.args));\n      }\n      return result;\n    }\n\n    /**\n     * Performs a binary search of `array` to determine the index at which `value`\n     * should be inserted into `array` in order to maintain its sort order.\n     *\n     * @private\n     * @param {Array} array The sorted array to inspect.\n     * @param {*} value The value to evaluate.\n     * @param {boolean} [retHighest] Specify returning the highest qualified index.\n     * @returns {number} Returns the index at which `value` should be inserted\n     *  into `array`.\n     */\n    function binaryIndex(array, value, retHighest) {\n      var low = 0,\n          high = array ? array.length : low;\n\n      if (typeof value == 'number' && value === value && high <= HALF_MAX_ARRAY_LENGTH) {\n        while (low < high) {\n          var mid = (low + high) >>> 1,\n              computed = array[mid];\n\n          if ((retHighest ? (computed <= value) : (computed < value)) && computed !== null) {\n            low = mid + 1;\n          } else {\n            high = mid;\n          }\n        }\n        return high;\n      }\n      return binaryIndexBy(array, value, identity, retHighest);\n    }\n\n    /**\n     * This function is like `binaryIndex` except that it invokes `iteratee` for\n     * `value` and each element of `array` to compute their sort ranking. The\n     * iteratee is invoked with one argument; (value).\n     *\n     * @private\n     * @param {Array} array The sorted array to inspect.\n     * @param {*} value The value to evaluate.\n     * @param {Function} iteratee The function invoked per iteration.\n     * @param {boolean} [retHighest] Specify returning the highest qualified index.\n     * @returns {number} Returns the index at which `value` should be inserted\n     *  into `array`.\n     */\n    function binaryIndexBy(array, value, iteratee, retHighest) {\n      value = iteratee(value);\n\n      var low = 0,\n          high = array ? array.length : 0,\n          valIsNaN = value !== value,\n          valIsNull = value === null,\n          valIsUndef = value === undefined;\n\n      while (low < high) {\n        var mid = nativeFloor((low + high) / 2),\n            computed = iteratee(array[mid]),\n            isDef = computed !== undefined,\n            isReflexive = computed === computed;\n\n        if (valIsNaN) {\n          var setLow = isReflexive || retHighest;\n        } else if (valIsNull) {\n          setLow = isReflexive && isDef && (retHighest || computed != null);\n        } else if (valIsUndef) {\n          setLow = isReflexive && (retHighest || isDef);\n        } else if (computed == null) {\n          setLow = false;\n        } else {\n          setLow = retHighest ? (computed <= value) : (computed < value);\n        }\n        if (setLow) {\n          low = mid + 1;\n        } else {\n          high = mid;\n        }\n      }\n      return nativeMin(high, MAX_ARRAY_INDEX);\n    }\n\n    /**\n     * A specialized version of `baseCallback` which only supports `this` binding\n     * and specifying the number of arguments to provide to `func`.\n     *\n     * @private\n     * @param {Function} func The function to bind.\n     * @param {*} thisArg The `this` binding of `func`.\n     * @param {number} [argCount] The number of arguments to provide to `func`.\n     * @returns {Function} Returns the callback.\n     */\n    function bindCallback(func, thisArg, argCount) {\n      if (typeof func != 'function') {\n        return identity;\n      }\n      if (thisArg === undefined) {\n        return func;\n      }\n      switch (argCount) {\n        case 1: return function(value) {\n          return func.call(thisArg, value);\n        };\n        case 3: return function(value, index, collection) {\n          return func.call(thisArg, value, index, collection);\n        };\n        case 4: return function(accumulator, value, index, collection) {\n          return func.call(thisArg, accumulator, value, index, collection);\n        };\n        case 5: return function(value, other, key, object, source) {\n          return func.call(thisArg, value, other, key, object, source);\n        };\n      }\n      return function() {\n        return func.apply(thisArg, arguments);\n      };\n    }\n\n    /**\n     * Creates a clone of the given array buffer.\n     *\n     * @private\n     * @param {ArrayBuffer} buffer The array buffer to clone.\n     * @returns {ArrayBuffer} Returns the cloned array buffer.\n     */\n    function bufferClone(buffer) {\n      var result = new ArrayBuffer(buffer.byteLength),\n          view = new Uint8Array(result);\n\n      view.set(new Uint8Array(buffer));\n      return result;\n    }\n\n    /**\n     * Creates an array that is the composition of partially applied arguments,\n     * placeholders, and provided arguments into a single array of arguments.\n     *\n     * @private\n     * @param {Array|Object} args The provided arguments.\n     * @param {Array} partials The arguments to prepend to those provided.\n     * @param {Array} holders The `partials` placeholder indexes.\n     * @returns {Array} Returns the new array of composed arguments.\n     */\n    function composeArgs(args, partials, holders) {\n      var holdersLength = holders.length,\n          argsIndex = -1,\n          argsLength = nativeMax(args.length - holdersLength, 0),\n          leftIndex = -1,\n          leftLength = partials.length,\n          result = Array(leftLength + argsLength);\n\n      while (++leftIndex < leftLength) {\n        result[leftIndex] = partials[leftIndex];\n      }\n      while (++argsIndex < holdersLength) {\n        result[holders[argsIndex]] = args[argsIndex];\n      }\n      while (argsLength--) {\n        result[leftIndex++] = args[argsIndex++];\n      }\n      return result;\n    }\n\n    /**\n     * This function is like `composeArgs` except that the arguments composition\n     * is tailored for `_.partialRight`.\n     *\n     * @private\n     * @param {Array|Object} args The provided arguments.\n     * @param {Array} partials The arguments to append to those provided.\n     * @param {Array} holders The `partials` placeholder indexes.\n     * @returns {Array} Returns the new array of composed arguments.\n     */\n    function composeArgsRight(args, partials, holders) {\n      var holdersIndex = -1,\n          holdersLength = holders.length,\n          argsIndex = -1,\n          argsLength = nativeMax(args.length - holdersLength, 0),\n          rightIndex = -1,\n          rightLength = partials.length,\n          result = Array(argsLength + rightLength);\n\n      while (++argsIndex < argsLength) {\n        result[argsIndex] = args[argsIndex];\n      }\n      var offset = argsIndex;\n      while (++rightIndex < rightLength) {\n        result[offset + rightIndex] = partials[rightIndex];\n      }\n      while (++holdersIndex < holdersLength) {\n        result[offset + holders[holdersIndex]] = args[argsIndex++];\n      }\n      return result;\n    }\n\n    /**\n     * Creates a `_.countBy`, `_.groupBy`, `_.indexBy`, or `_.partition` function.\n     *\n     * @private\n     * @param {Function} setter The function to set keys and values of the accumulator object.\n     * @param {Function} [initializer] The function to initialize the accumulator object.\n     * @returns {Function} Returns the new aggregator function.\n     */\n    function createAggregator(setter, initializer) {\n      return function(collection, iteratee, thisArg) {\n        var result = initializer ? initializer() : {};\n        iteratee = getCallback(iteratee, thisArg, 3);\n\n        if (isArray(collection)) {\n          var index = -1,\n              length = collection.length;\n\n          while (++index < length) {\n            var value = collection[index];\n            setter(result, value, iteratee(value, index, collection), collection);\n          }\n        } else {\n          baseEach(collection, function(value, key, collection) {\n            setter(result, value, iteratee(value, key, collection), collection);\n          });\n        }\n        return result;\n      };\n    }\n\n    /**\n     * Creates a `_.assign`, `_.defaults`, or `_.merge` function.\n     *\n     * @private\n     * @param {Function} assigner The function to assign values.\n     * @returns {Function} Returns the new assigner function.\n     */\n    function createAssigner(assigner) {\n      return restParam(function(object, sources) {\n        var index = -1,\n            length = object == null ? 0 : sources.length,\n            customizer = length > 2 ? sources[length - 2] : undefined,\n            guard = length > 2 ? sources[2] : undefined,\n            thisArg = length > 1 ? sources[length - 1] : undefined;\n\n        if (typeof customizer == 'function') {\n          customizer = bindCallback(customizer, thisArg, 5);\n          length -= 2;\n        } else {\n          customizer = typeof thisArg == 'function' ? thisArg : undefined;\n          length -= (customizer ? 1 : 0);\n        }\n        if (guard && isIterateeCall(sources[0], sources[1], guard)) {\n          customizer = length < 3 ? undefined : customizer;\n          length = 1;\n        }\n        while (++index < length) {\n          var source = sources[index];\n          if (source) {\n            assigner(object, source, customizer);\n          }\n        }\n        return object;\n      });\n    }\n\n    /**\n     * Creates a `baseEach` or `baseEachRight` function.\n     *\n     * @private\n     * @param {Function} eachFunc The function to iterate over a collection.\n     * @param {boolean} [fromRight] Specify iterating from right to left.\n     * @returns {Function} Returns the new base function.\n     */\n    function createBaseEach(eachFunc, fromRight) {\n      return function(collection, iteratee) {\n        var length = collection ? getLength(collection) : 0;\n        if (!isLength(length)) {\n          return eachFunc(collection, iteratee);\n        }\n        var index = fromRight ? length : -1,\n            iterable = toObject(collection);\n\n        while ((fromRight ? index-- : ++index < length)) {\n          if (iteratee(iterable[index], index, iterable) === false) {\n            break;\n          }\n        }\n        return collection;\n      };\n    }\n\n    /**\n     * Creates a base function for `_.forIn` or `_.forInRight`.\n     *\n     * @private\n     * @param {boolean} [fromRight] Specify iterating from right to left.\n     * @returns {Function} Returns the new base function.\n     */\n    function createBaseFor(fromRight) {\n      return function(object, iteratee, keysFunc) {\n        var iterable = toObject(object),\n            props = keysFunc(object),\n            length = props.length,\n            index = fromRight ? length : -1;\n\n        while ((fromRight ? index-- : ++index < length)) {\n          var key = props[index];\n          if (iteratee(iterable[key], key, iterable) === false) {\n            break;\n          }\n        }\n        return object;\n      };\n    }\n\n    /**\n     * Creates a function that wraps `func` and invokes it with the `this`\n     * binding of `thisArg`.\n     *\n     * @private\n     * @param {Function} func The function to bind.\n     * @param {*} [thisArg] The `this` binding of `func`.\n     * @returns {Function} Returns the new bound function.\n     */\n    function createBindWrapper(func, thisArg) {\n      var Ctor = createCtorWrapper(func);\n\n      function wrapper() {\n        var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;\n        return fn.apply(thisArg, arguments);\n      }\n      return wrapper;\n    }\n\n    /**\n     * Creates a `Set` cache object to optimize linear searches of large arrays.\n     *\n     * @private\n     * @param {Array} [values] The values to cache.\n     * @returns {null|Object} Returns the new cache object if `Set` is supported, else `null`.\n     */\n    function createCache(values) {\n      return (nativeCreate && Set) ? new SetCache(values) : null;\n    }\n\n    /**\n     * Creates a function that produces compound words out of the words in a\n     * given string.\n     *\n     * @private\n     * @param {Function} callback The function to combine each word.\n     * @returns {Function} Returns the new compounder function.\n     */\n    function createCompounder(callback) {\n      return function(string) {\n        var index = -1,\n            array = words(deburr(string)),\n            length = array.length,\n            result = '';\n\n        while (++index < length) {\n          result = callback(result, array[index], index);\n        }\n        return result;\n      };\n    }\n\n    /**\n     * Creates a function that produces an instance of `Ctor` regardless of\n     * whether it was invoked as part of a `new` expression or by `call` or `apply`.\n     *\n     * @private\n     * @param {Function} Ctor The constructor to wrap.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createCtorWrapper(Ctor) {\n      return function() {\n        // Use a `switch` statement to work with class constructors.\n        // See http://ecma-international.org/ecma-262/6.0/#sec-ecmascript-function-objects-call-thisargument-argumentslist\n        // for more details.\n        var args = arguments;\n        switch (args.length) {\n          case 0: return new Ctor;\n          case 1: return new Ctor(args[0]);\n          case 2: return new Ctor(args[0], args[1]);\n          case 3: return new Ctor(args[0], args[1], args[2]);\n          case 4: return new Ctor(args[0], args[1], args[2], args[3]);\n          case 5: return new Ctor(args[0], args[1], args[2], args[3], args[4]);\n          case 6: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5]);\n          case 7: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);\n        }\n        var thisBinding = baseCreate(Ctor.prototype),\n            result = Ctor.apply(thisBinding, args);\n\n        // Mimic the constructor's `return` behavior.\n        // See https://es5.github.io/#x13.2.2 for more details.\n        return isObject(result) ? result : thisBinding;\n      };\n    }\n\n    /**\n     * Creates a `_.curry` or `_.curryRight` function.\n     *\n     * @private\n     * @param {boolean} flag The curry bit flag.\n     * @returns {Function} Returns the new curry function.\n     */\n    function createCurry(flag) {\n      function curryFunc(func, arity, guard) {\n        if (guard && isIterateeCall(func, arity, guard)) {\n          arity = undefined;\n        }\n        var result = createWrapper(func, flag, undefined, undefined, undefined, undefined, undefined, arity);\n        result.placeholder = curryFunc.placeholder;\n        return result;\n      }\n      return curryFunc;\n    }\n\n    /**\n     * Creates a `_.defaults` or `_.defaultsDeep` function.\n     *\n     * @private\n     * @param {Function} assigner The function to assign values.\n     * @param {Function} customizer The function to customize assigned values.\n     * @returns {Function} Returns the new defaults function.\n     */\n    function createDefaults(assigner, customizer) {\n      return restParam(function(args) {\n        var object = args[0];\n        if (object == null) {\n          return object;\n        }\n        args.push(customizer);\n        return assigner.apply(undefined, args);\n      });\n    }\n\n    /**\n     * Creates a `_.max` or `_.min` function.\n     *\n     * @private\n     * @param {Function} comparator The function used to compare values.\n     * @param {*} exValue The initial extremum value.\n     * @returns {Function} Returns the new extremum function.\n     */\n    function createExtremum(comparator, exValue) {\n      return function(collection, iteratee, thisArg) {\n        if (thisArg && isIterateeCall(collection, iteratee, thisArg)) {\n          iteratee = undefined;\n        }\n        iteratee = getCallback(iteratee, thisArg, 3);\n        if (iteratee.length == 1) {\n          collection = isArray(collection) ? collection : toIterable(collection);\n          var result = arrayExtremum(collection, iteratee, comparator, exValue);\n          if (!(collection.length && result === exValue)) {\n            return result;\n          }\n        }\n        return baseExtremum(collection, iteratee, comparator, exValue);\n      };\n    }\n\n    /**\n     * Creates a `_.find` or `_.findLast` function.\n     *\n     * @private\n     * @param {Function} eachFunc The function to iterate over a collection.\n     * @param {boolean} [fromRight] Specify iterating from right to left.\n     * @returns {Function} Returns the new find function.\n     */\n    function createFind(eachFunc, fromRight) {\n      return function(collection, predicate, thisArg) {\n        predicate = getCallback(predicate, thisArg, 3);\n        if (isArray(collection)) {\n          var index = baseFindIndex(collection, predicate, fromRight);\n          return index > -1 ? collection[index] : undefined;\n        }\n        return baseFind(collection, predicate, eachFunc);\n      };\n    }\n\n    /**\n     * Creates a `_.findIndex` or `_.findLastIndex` function.\n     *\n     * @private\n     * @param {boolean} [fromRight] Specify iterating from right to left.\n     * @returns {Function} Returns the new find function.\n     */\n    function createFindIndex(fromRight) {\n      return function(array, predicate, thisArg) {\n        if (!(array && array.length)) {\n          return -1;\n        }\n        predicate = getCallback(predicate, thisArg, 3);\n        return baseFindIndex(array, predicate, fromRight);\n      };\n    }\n\n    /**\n     * Creates a `_.findKey` or `_.findLastKey` function.\n     *\n     * @private\n     * @param {Function} objectFunc The function to iterate over an object.\n     * @returns {Function} Returns the new find function.\n     */\n    function createFindKey(objectFunc) {\n      return function(object, predicate, thisArg) {\n        predicate = getCallback(predicate, thisArg, 3);\n        return baseFind(object, predicate, objectFunc, true);\n      };\n    }\n\n    /**\n     * Creates a `_.flow` or `_.flowRight` function.\n     *\n     * @private\n     * @param {boolean} [fromRight] Specify iterating from right to left.\n     * @returns {Function} Returns the new flow function.\n     */\n    function createFlow(fromRight) {\n      return function() {\n        var wrapper,\n            length = arguments.length,\n            index = fromRight ? length : -1,\n            leftIndex = 0,\n            funcs = Array(length);\n\n        while ((fromRight ? index-- : ++index < length)) {\n          var func = funcs[leftIndex++] = arguments[index];\n          if (typeof func != 'function') {\n            throw new TypeError(FUNC_ERROR_TEXT);\n          }\n          if (!wrapper && LodashWrapper.prototype.thru && getFuncName(func) == 'wrapper') {\n            wrapper = new LodashWrapper([], true);\n          }\n        }\n        index = wrapper ? -1 : length;\n        while (++index < length) {\n          func = funcs[index];\n\n          var funcName = getFuncName(func),\n              data = funcName == 'wrapper' ? getData(func) : undefined;\n\n          if (data && isLaziable(data[0]) && data[1] == (ARY_FLAG | CURRY_FLAG | PARTIAL_FLAG | REARG_FLAG) && !data[4].length && data[9] == 1) {\n            wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]);\n          } else {\n            wrapper = (func.length == 1 && isLaziable(func)) ? wrapper[funcName]() : wrapper.thru(func);\n          }\n        }\n        return function() {\n          var args = arguments,\n              value = args[0];\n\n          if (wrapper && args.length == 1 && isArray(value) && value.length >= LARGE_ARRAY_SIZE) {\n            return wrapper.plant(value).value();\n          }\n          var index = 0,\n              result = length ? funcs[index].apply(this, args) : value;\n\n          while (++index < length) {\n            result = funcs[index].call(this, result);\n          }\n          return result;\n        };\n      };\n    }\n\n    /**\n     * Creates a function for `_.forEach` or `_.forEachRight`.\n     *\n     * @private\n     * @param {Function} arrayFunc The function to iterate over an array.\n     * @param {Function} eachFunc The function to iterate over a collection.\n     * @returns {Function} Returns the new each function.\n     */\n    function createForEach(arrayFunc, eachFunc) {\n      return function(collection, iteratee, thisArg) {\n        return (typeof iteratee == 'function' && thisArg === undefined && isArray(collection))\n          ? arrayFunc(collection, iteratee)\n          : eachFunc(collection, bindCallback(iteratee, thisArg, 3));\n      };\n    }\n\n    /**\n     * Creates a function for `_.forIn` or `_.forInRight`.\n     *\n     * @private\n     * @param {Function} objectFunc The function to iterate over an object.\n     * @returns {Function} Returns the new each function.\n     */\n    function createForIn(objectFunc) {\n      return function(object, iteratee, thisArg) {\n        if (typeof iteratee != 'function' || thisArg !== undefined) {\n          iteratee = bindCallback(iteratee, thisArg, 3);\n        }\n        return objectFunc(object, iteratee, keysIn);\n      };\n    }\n\n    /**\n     * Creates a function for `_.forOwn` or `_.forOwnRight`.\n     *\n     * @private\n     * @param {Function} objectFunc The function to iterate over an object.\n     * @returns {Function} Returns the new each function.\n     */\n    function createForOwn(objectFunc) {\n      return function(object, iteratee, thisArg) {\n        if (typeof iteratee != 'function' || thisArg !== undefined) {\n          iteratee = bindCallback(iteratee, thisArg, 3);\n        }\n        return objectFunc(object, iteratee);\n      };\n    }\n\n    /**\n     * Creates a function for `_.mapKeys` or `_.mapValues`.\n     *\n     * @private\n     * @param {boolean} [isMapKeys] Specify mapping keys instead of values.\n     * @returns {Function} Returns the new map function.\n     */\n    function createObjectMapper(isMapKeys) {\n      return function(object, iteratee, thisArg) {\n        var result = {};\n        iteratee = getCallback(iteratee, thisArg, 3);\n\n        baseForOwn(object, function(value, key, object) {\n          var mapped = iteratee(value, key, object);\n          key = isMapKeys ? mapped : key;\n          value = isMapKeys ? value : mapped;\n          result[key] = value;\n        });\n        return result;\n      };\n    }\n\n    /**\n     * Creates a function for `_.padLeft` or `_.padRight`.\n     *\n     * @private\n     * @param {boolean} [fromRight] Specify padding from the right.\n     * @returns {Function} Returns the new pad function.\n     */\n    function createPadDir(fromRight) {\n      return function(string, length, chars) {\n        string = baseToString(string);\n        return (fromRight ? string : '') + createPadding(string, length, chars) + (fromRight ? '' : string);\n      };\n    }\n\n    /**\n     * Creates a `_.partial` or `_.partialRight` function.\n     *\n     * @private\n     * @param {boolean} flag The partial bit flag.\n     * @returns {Function} Returns the new partial function.\n     */\n    function createPartial(flag) {\n      var partialFunc = restParam(function(func, partials) {\n        var holders = replaceHolders(partials, partialFunc.placeholder);\n        return createWrapper(func, flag, undefined, partials, holders);\n      });\n      return partialFunc;\n    }\n\n    /**\n     * Creates a function for `_.reduce` or `_.reduceRight`.\n     *\n     * @private\n     * @param {Function} arrayFunc The function to iterate over an array.\n     * @param {Function} eachFunc The function to iterate over a collection.\n     * @returns {Function} Returns the new each function.\n     */\n    function createReduce(arrayFunc, eachFunc) {\n      return function(collection, iteratee, accumulator, thisArg) {\n        var initFromArray = arguments.length < 3;\n        return (typeof iteratee == 'function' && thisArg === undefined && isArray(collection))\n          ? arrayFunc(collection, iteratee, accumulator, initFromArray)\n          : baseReduce(collection, getCallback(iteratee, thisArg, 4), accumulator, initFromArray, eachFunc);\n      };\n    }\n\n    /**\n     * Creates a function that wraps `func` and invokes it with optional `this`\n     * binding of, partial application, and currying.\n     *\n     * @private\n     * @param {Function|string} func The function or method name to reference.\n     * @param {number} bitmask The bitmask of flags. See `createWrapper` for more details.\n     * @param {*} [thisArg] The `this` binding of `func`.\n     * @param {Array} [partials] The arguments to prepend to those provided to the new function.\n     * @param {Array} [holders] The `partials` placeholder indexes.\n     * @param {Array} [partialsRight] The arguments to append to those provided to the new function.\n     * @param {Array} [holdersRight] The `partialsRight` placeholder indexes.\n     * @param {Array} [argPos] The argument positions of the new function.\n     * @param {number} [ary] The arity cap of `func`.\n     * @param {number} [arity] The arity of `func`.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createHybridWrapper(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity) {\n      var isAry = bitmask & ARY_FLAG,\n          isBind = bitmask & BIND_FLAG,\n          isBindKey = bitmask & BIND_KEY_FLAG,\n          isCurry = bitmask & CURRY_FLAG,\n          isCurryBound = bitmask & CURRY_BOUND_FLAG,\n          isCurryRight = bitmask & CURRY_RIGHT_FLAG,\n          Ctor = isBindKey ? undefined : createCtorWrapper(func);\n\n      function wrapper() {\n        // Avoid `arguments` object use disqualifying optimizations by\n        // converting it to an array before providing it to other functions.\n        var length = arguments.length,\n            index = length,\n            args = Array(length);\n\n        while (index--) {\n          args[index] = arguments[index];\n        }\n        if (partials) {\n          args = composeArgs(args, partials, holders);\n        }\n        if (partialsRight) {\n          args = composeArgsRight(args, partialsRight, holdersRight);\n        }\n        if (isCurry || isCurryRight) {\n          var placeholder = wrapper.placeholder,\n              argsHolders = replaceHolders(args, placeholder);\n\n          length -= argsHolders.length;\n          if (length < arity) {\n            var newArgPos = argPos ? arrayCopy(argPos) : undefined,\n                newArity = nativeMax(arity - length, 0),\n                newsHolders = isCurry ? argsHolders : undefined,\n                newHoldersRight = isCurry ? undefined : argsHolders,\n                newPartials = isCurry ? args : undefined,\n                newPartialsRight = isCurry ? undefined : args;\n\n            bitmask |= (isCurry ? PARTIAL_FLAG : PARTIAL_RIGHT_FLAG);\n            bitmask &= ~(isCurry ? PARTIAL_RIGHT_FLAG : PARTIAL_FLAG);\n\n            if (!isCurryBound) {\n              bitmask &= ~(BIND_FLAG | BIND_KEY_FLAG);\n            }\n            var newData = [func, bitmask, thisArg, newPartials, newsHolders, newPartialsRight, newHoldersRight, newArgPos, ary, newArity],\n                result = createHybridWrapper.apply(undefined, newData);\n\n            if (isLaziable(func)) {\n              setData(result, newData);\n            }\n            result.placeholder = placeholder;\n            return result;\n          }\n        }\n        var thisBinding = isBind ? thisArg : this,\n            fn = isBindKey ? thisBinding[func] : func;\n\n        if (argPos) {\n          args = reorder(args, argPos);\n        }\n        if (isAry && ary < args.length) {\n          args.length = ary;\n        }\n        if (this && this !== root && this instanceof wrapper) {\n          fn = Ctor || createCtorWrapper(func);\n        }\n        return fn.apply(thisBinding, args);\n      }\n      return wrapper;\n    }\n\n    /**\n     * Creates the padding required for `string` based on the given `length`.\n     * The `chars` string is truncated if the number of characters exceeds `length`.\n     *\n     * @private\n     * @param {string} string The string to create padding for.\n     * @param {number} [length=0] The padding length.\n     * @param {string} [chars=' '] The string used as padding.\n     * @returns {string} Returns the pad for `string`.\n     */\n    function createPadding(string, length, chars) {\n      var strLength = string.length;\n      length = +length;\n\n      if (strLength >= length || !nativeIsFinite(length)) {\n        return '';\n      }\n      var padLength = length - strLength;\n      chars = chars == null ? ' ' : (chars + '');\n      return repeat(chars, nativeCeil(padLength / chars.length)).slice(0, padLength);\n    }\n\n    /**\n     * Creates a function that wraps `func` and invokes it with the optional `this`\n     * binding of `thisArg` and the `partials` prepended to those provided to\n     * the wrapper.\n     *\n     * @private\n     * @param {Function} func The function to partially apply arguments to.\n     * @param {number} bitmask The bitmask of flags. See `createWrapper` for more details.\n     * @param {*} thisArg The `this` binding of `func`.\n     * @param {Array} partials The arguments to prepend to those provided to the new function.\n     * @returns {Function} Returns the new bound function.\n     */\n    function createPartialWrapper(func, bitmask, thisArg, partials) {\n      var isBind = bitmask & BIND_FLAG,\n          Ctor = createCtorWrapper(func);\n\n      function wrapper() {\n        // Avoid `arguments` object use disqualifying optimizations by\n        // converting it to an array before providing it `func`.\n        var argsIndex = -1,\n            argsLength = arguments.length,\n            leftIndex = -1,\n            leftLength = partials.length,\n            args = Array(leftLength + argsLength);\n\n        while (++leftIndex < leftLength) {\n          args[leftIndex] = partials[leftIndex];\n        }\n        while (argsLength--) {\n          args[leftIndex++] = arguments[++argsIndex];\n        }\n        var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;\n        return fn.apply(isBind ? thisArg : this, args);\n      }\n      return wrapper;\n    }\n\n    /**\n     * Creates a `_.ceil`, `_.floor`, or `_.round` function.\n     *\n     * @private\n     * @param {string} methodName The name of the `Math` method to use when rounding.\n     * @returns {Function} Returns the new round function.\n     */\n    function createRound(methodName) {\n      var func = Math[methodName];\n      return function(number, precision) {\n        precision = precision === undefined ? 0 : (+precision || 0);\n        if (precision) {\n          precision = pow(10, precision);\n          return func(number * precision) / precision;\n        }\n        return func(number);\n      };\n    }\n\n    /**\n     * Creates a `_.sortedIndex` or `_.sortedLastIndex` function.\n     *\n     * @private\n     * @param {boolean} [retHighest] Specify returning the highest qualified index.\n     * @returns {Function} Returns the new index function.\n     */\n    function createSortedIndex(retHighest) {\n      return function(array, value, iteratee, thisArg) {\n        var callback = getCallback(iteratee);\n        return (iteratee == null && callback === baseCallback)\n          ? binaryIndex(array, value, retHighest)\n          : binaryIndexBy(array, value, callback(iteratee, thisArg, 1), retHighest);\n      };\n    }\n\n    /**\n     * Creates a function that either curries or invokes `func` with optional\n     * `this` binding and partially applied arguments.\n     *\n     * @private\n     * @param {Function|string} func The function or method name to reference.\n     * @param {number} bitmask The bitmask of flags.\n     *  The bitmask may be composed of the following flags:\n     *     1 - `_.bind`\n     *     2 - `_.bindKey`\n     *     4 - `_.curry` or `_.curryRight` of a bound function\n     *     8 - `_.curry`\n     *    16 - `_.curryRight`\n     *    32 - `_.partial`\n     *    64 - `_.partialRight`\n     *   128 - `_.rearg`\n     *   256 - `_.ary`\n     * @param {*} [thisArg] The `this` binding of `func`.\n     * @param {Array} [partials] The arguments to be partially applied.\n     * @param {Array} [holders] The `partials` placeholder indexes.\n     * @param {Array} [argPos] The argument positions of the new function.\n     * @param {number} [ary] The arity cap of `func`.\n     * @param {number} [arity] The arity of `func`.\n     * @returns {Function} Returns the new wrapped function.\n     */\n    function createWrapper(func, bitmask, thisArg, partials, holders, argPos, ary, arity) {\n      var isBindKey = bitmask & BIND_KEY_FLAG;\n      if (!isBindKey && typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      var length = partials ? partials.length : 0;\n      if (!length) {\n        bitmask &= ~(PARTIAL_FLAG | PARTIAL_RIGHT_FLAG);\n        partials = holders = undefined;\n      }\n      length -= (holders ? holders.length : 0);\n      if (bitmask & PARTIAL_RIGHT_FLAG) {\n        var partialsRight = partials,\n            holdersRight = holders;\n\n        partials = holders = undefined;\n      }\n      var data = isBindKey ? undefined : getData(func),\n          newData = [func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity];\n\n      if (data) {\n        mergeData(newData, data);\n        bitmask = newData[1];\n        arity = newData[9];\n      }\n      newData[9] = arity == null\n        ? (isBindKey ? 0 : func.length)\n        : (nativeMax(arity - length, 0) || 0);\n\n      if (bitmask == BIND_FLAG) {\n        var result = createBindWrapper(newData[0], newData[2]);\n      } else if ((bitmask == PARTIAL_FLAG || bitmask == (BIND_FLAG | PARTIAL_FLAG)) && !newData[4].length) {\n        result = createPartialWrapper.apply(undefined, newData);\n      } else {\n        result = createHybridWrapper.apply(undefined, newData);\n      }\n      var setter = data ? baseSetData : setData;\n      return setter(result, newData);\n    }\n\n    /**\n     * A specialized version of `baseIsEqualDeep` for arrays with support for\n     * partial deep comparisons.\n     *\n     * @private\n     * @param {Array} array The array to compare.\n     * @param {Array} other The other array to compare.\n     * @param {Function} equalFunc The function to determine equivalents of values.\n     * @param {Function} [customizer] The function to customize comparing arrays.\n     * @param {boolean} [isLoose] Specify performing partial comparisons.\n     * @param {Array} [stackA] Tracks traversed `value` objects.\n     * @param {Array} [stackB] Tracks traversed `other` objects.\n     * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.\n     */\n    function equalArrays(array, other, equalFunc, customizer, isLoose, stackA, stackB) {\n      var index = -1,\n          arrLength = array.length,\n          othLength = other.length;\n\n      if (arrLength != othLength && !(isLoose && othLength > arrLength)) {\n        return false;\n      }\n      // Ignore non-index properties.\n      while (++index < arrLength) {\n        var arrValue = array[index],\n            othValue = other[index],\n            result = customizer ? customizer(isLoose ? othValue : arrValue, isLoose ? arrValue : othValue, index) : undefined;\n\n        if (result !== undefined) {\n          if (result) {\n            continue;\n          }\n          return false;\n        }\n        // Recursively compare arrays (susceptible to call stack limits).\n        if (isLoose) {\n          if (!arraySome(other, function(othValue) {\n                return arrValue === othValue || equalFunc(arrValue, othValue, customizer, isLoose, stackA, stackB);\n              })) {\n            return false;\n          }\n        } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, customizer, isLoose, stackA, stackB))) {\n          return false;\n        }\n      }\n      return true;\n    }\n\n    /**\n     * A specialized version of `baseIsEqualDeep` for comparing objects of\n     * the same `toStringTag`.\n     *\n     * **Note:** This function only supports comparing values with tags of\n     * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.\n     *\n     * @private\n     * @param {Object} object The object to compare.\n     * @param {Object} other The other object to compare.\n     * @param {string} tag The `toStringTag` of the objects to compare.\n     * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n     */\n    function equalByTag(object, other, tag) {\n      switch (tag) {\n        case boolTag:\n        case dateTag:\n          // Coerce dates and booleans to numbers, dates to milliseconds and booleans\n          // to `1` or `0` treating invalid dates coerced to `NaN` as not equal.\n          return +object == +other;\n\n        case errorTag:\n          return object.name == other.name && object.message == other.message;\n\n        case numberTag:\n          // Treat `NaN` vs. `NaN` as equal.\n          return (object != +object)\n            ? other != +other\n            : object == +other;\n\n        case regexpTag:\n        case stringTag:\n          // Coerce regexes to strings and treat strings primitives and string\n          // objects as equal. See https://es5.github.io/#x15.10.6.4 for more details.\n          return object == (other + '');\n      }\n      return false;\n    }\n\n    /**\n     * A specialized version of `baseIsEqualDeep` for objects with support for\n     * partial deep comparisons.\n     *\n     * @private\n     * @param {Object} object The object to compare.\n     * @param {Object} other The other object to compare.\n     * @param {Function} equalFunc The function to determine equivalents of values.\n     * @param {Function} [customizer] The function to customize comparing values.\n     * @param {boolean} [isLoose] Specify performing partial comparisons.\n     * @param {Array} [stackA] Tracks traversed `value` objects.\n     * @param {Array} [stackB] Tracks traversed `other` objects.\n     * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n     */\n    function equalObjects(object, other, equalFunc, customizer, isLoose, stackA, stackB) {\n      var objProps = keys(object),\n          objLength = objProps.length,\n          othProps = keys(other),\n          othLength = othProps.length;\n\n      if (objLength != othLength && !isLoose) {\n        return false;\n      }\n      var index = objLength;\n      while (index--) {\n        var key = objProps[index];\n        if (!(isLoose ? key in other : hasOwnProperty.call(other, key))) {\n          return false;\n        }\n      }\n      var skipCtor = isLoose;\n      while (++index < objLength) {\n        key = objProps[index];\n        var objValue = object[key],\n            othValue = other[key],\n            result = customizer ? customizer(isLoose ? othValue : objValue, isLoose? objValue : othValue, key) : undefined;\n\n        // Recursively compare objects (susceptible to call stack limits).\n        if (!(result === undefined ? equalFunc(objValue, othValue, customizer, isLoose, stackA, stackB) : result)) {\n          return false;\n        }\n        skipCtor || (skipCtor = key == 'constructor');\n      }\n      if (!skipCtor) {\n        var objCtor = object.constructor,\n            othCtor = other.constructor;\n\n        // Non `Object` object instances with different constructors are not equal.\n        if (objCtor != othCtor &&\n            ('constructor' in object && 'constructor' in other) &&\n            !(typeof objCtor == 'function' && objCtor instanceof objCtor &&\n              typeof othCtor == 'function' && othCtor instanceof othCtor)) {\n          return false;\n        }\n      }\n      return true;\n    }\n\n    /**\n     * Gets the appropriate \"callback\" function. If the `_.callback` method is\n     * customized this function returns the custom method, otherwise it returns\n     * the `baseCallback` function. If arguments are provided the chosen function\n     * is invoked with them and its result is returned.\n     *\n     * @private\n     * @returns {Function} Returns the chosen function or its result.\n     */\n    function getCallback(func, thisArg, argCount) {\n      var result = lodash.callback || callback;\n      result = result === callback ? baseCallback : result;\n      return argCount ? result(func, thisArg, argCount) : result;\n    }\n\n    /**\n     * Gets metadata for `func`.\n     *\n     * @private\n     * @param {Function} func The function to query.\n     * @returns {*} Returns the metadata for `func`.\n     */\n    var getData = !metaMap ? noop : function(func) {\n      return metaMap.get(func);\n    };\n\n    /**\n     * Gets the name of `func`.\n     *\n     * @private\n     * @param {Function} func The function to query.\n     * @returns {string} Returns the function name.\n     */\n    function getFuncName(func) {\n      var result = func.name,\n          array = realNames[result],\n          length = array ? array.length : 0;\n\n      while (length--) {\n        var data = array[length],\n            otherFunc = data.func;\n        if (otherFunc == null || otherFunc == func) {\n          return data.name;\n        }\n      }\n      return result;\n    }\n\n    /**\n     * Gets the appropriate \"indexOf\" function. If the `_.indexOf` method is\n     * customized this function returns the custom method, otherwise it returns\n     * the `baseIndexOf` function. If arguments are provided the chosen function\n     * is invoked with them and its result is returned.\n     *\n     * @private\n     * @returns {Function|number} Returns the chosen function or its result.\n     */\n    function getIndexOf(collection, target, fromIndex) {\n      var result = lodash.indexOf || indexOf;\n      result = result === indexOf ? baseIndexOf : result;\n      return collection ? result(collection, target, fromIndex) : result;\n    }\n\n    /**\n     * Gets the \"length\" property value of `object`.\n     *\n     * **Note:** This function is used to avoid a [JIT bug](https://bugs.webkit.org/show_bug.cgi?id=142792)\n     * that affects Safari on at least iOS 8.1-8.3 ARM64.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {*} Returns the \"length\" value.\n     */\n    var getLength = baseProperty('length');\n\n    /**\n     * Gets the propery names, values, and compare flags of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the match data of `object`.\n     */\n    function getMatchData(object) {\n      var result = pairs(object),\n          length = result.length;\n\n      while (length--) {\n        result[length][2] = isStrictComparable(result[length][1]);\n      }\n      return result;\n    }\n\n    /**\n     * Gets the native function at `key` of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @param {string} key The key of the method to get.\n     * @returns {*} Returns the function if it's native, else `undefined`.\n     */\n    function getNative(object, key) {\n      var value = object == null ? undefined : object[key];\n      return isNative(value) ? value : undefined;\n    }\n\n    /**\n     * Gets the view, applying any `transforms` to the `start` and `end` positions.\n     *\n     * @private\n     * @param {number} start The start of the view.\n     * @param {number} end The end of the view.\n     * @param {Array} transforms The transformations to apply to the view.\n     * @returns {Object} Returns an object containing the `start` and `end`\n     *  positions of the view.\n     */\n    function getView(start, end, transforms) {\n      var index = -1,\n          length = transforms.length;\n\n      while (++index < length) {\n        var data = transforms[index],\n            size = data.size;\n\n        switch (data.type) {\n          case 'drop':      start += size; break;\n          case 'dropRight': end -= size; break;\n          case 'take':      end = nativeMin(end, start + size); break;\n          case 'takeRight': start = nativeMax(start, end - size); break;\n        }\n      }\n      return { 'start': start, 'end': end };\n    }\n\n    /**\n     * Initializes an array clone.\n     *\n     * @private\n     * @param {Array} array The array to clone.\n     * @returns {Array} Returns the initialized clone.\n     */\n    function initCloneArray(array) {\n      var length = array.length,\n          result = new array.constructor(length);\n\n      // Add array properties assigned by `RegExp#exec`.\n      if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {\n        result.index = array.index;\n        result.input = array.input;\n      }\n      return result;\n    }\n\n    /**\n     * Initializes an object clone.\n     *\n     * @private\n     * @param {Object} object The object to clone.\n     * @returns {Object} Returns the initialized clone.\n     */\n    function initCloneObject(object) {\n      var Ctor = object.constructor;\n      if (!(typeof Ctor == 'function' && Ctor instanceof Ctor)) {\n        Ctor = Object;\n      }\n      return new Ctor;\n    }\n\n    /**\n     * Initializes an object clone based on its `toStringTag`.\n     *\n     * **Note:** This function only supports cloning values with tags of\n     * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.\n     *\n     * @private\n     * @param {Object} object The object to clone.\n     * @param {string} tag The `toStringTag` of the object to clone.\n     * @param {boolean} [isDeep] Specify a deep clone.\n     * @returns {Object} Returns the initialized clone.\n     */\n    function initCloneByTag(object, tag, isDeep) {\n      var Ctor = object.constructor;\n      switch (tag) {\n        case arrayBufferTag:\n          return bufferClone(object);\n\n        case boolTag:\n        case dateTag:\n          return new Ctor(+object);\n\n        case float32Tag: case float64Tag:\n        case int8Tag: case int16Tag: case int32Tag:\n        case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:\n          var buffer = object.buffer;\n          return new Ctor(isDeep ? bufferClone(buffer) : buffer, object.byteOffset, object.length);\n\n        case numberTag:\n        case stringTag:\n          return new Ctor(object);\n\n        case regexpTag:\n          var result = new Ctor(object.source, reFlags.exec(object));\n          result.lastIndex = object.lastIndex;\n      }\n      return result;\n    }\n\n    /**\n     * Invokes the method at `path` on `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path of the method to invoke.\n     * @param {Array} args The arguments to invoke the method with.\n     * @returns {*} Returns the result of the invoked method.\n     */\n    function invokePath(object, path, args) {\n      if (object != null && !isKey(path, object)) {\n        path = toPath(path);\n        object = path.length == 1 ? object : baseGet(object, baseSlice(path, 0, -1));\n        path = last(path);\n      }\n      var func = object == null ? object : object[path];\n      return func == null ? undefined : func.apply(object, args);\n    }\n\n    /**\n     * Checks if `value` is array-like.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n     */\n    function isArrayLike(value) {\n      return value != null && isLength(getLength(value));\n    }\n\n    /**\n     * Checks if `value` is a valid array-like index.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n     * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n     */\n    function isIndex(value, length) {\n      value = (typeof value == 'number' || reIsUint.test(value)) ? +value : -1;\n      length = length == null ? MAX_SAFE_INTEGER : length;\n      return value > -1 && value % 1 == 0 && value < length;\n    }\n\n    /**\n     * Checks if the provided arguments are from an iteratee call.\n     *\n     * @private\n     * @param {*} value The potential iteratee value argument.\n     * @param {*} index The potential iteratee index or key argument.\n     * @param {*} object The potential iteratee object argument.\n     * @returns {boolean} Returns `true` if the arguments are from an iteratee call, else `false`.\n     */\n    function isIterateeCall(value, index, object) {\n      if (!isObject(object)) {\n        return false;\n      }\n      var type = typeof index;\n      if (type == 'number'\n          ? (isArrayLike(object) && isIndex(index, object.length))\n          : (type == 'string' && index in object)) {\n        var other = object[index];\n        return value === value ? (value === other) : (other !== other);\n      }\n      return false;\n    }\n\n    /**\n     * Checks if `value` is a property name and not a property path.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @param {Object} [object] The object to query keys on.\n     * @returns {boolean} Returns `true` if `value` is a property name, else `false`.\n     */\n    function isKey(value, object) {\n      var type = typeof value;\n      if ((type == 'string' && reIsPlainProp.test(value)) || type == 'number') {\n        return true;\n      }\n      if (isArray(value)) {\n        return false;\n      }\n      var result = !reIsDeepProp.test(value);\n      return result || (object != null && value in toObject(object));\n    }\n\n    /**\n     * Checks if `func` has a lazy counterpart.\n     *\n     * @private\n     * @param {Function} func The function to check.\n     * @returns {boolean} Returns `true` if `func` has a lazy counterpart, else `false`.\n     */\n    function isLaziable(func) {\n      var funcName = getFuncName(func);\n      if (!(funcName in LazyWrapper.prototype)) {\n        return false;\n      }\n      var other = lodash[funcName];\n      if (func === other) {\n        return true;\n      }\n      var data = getData(other);\n      return !!data && func === data[0];\n    }\n\n    /**\n     * Checks if `value` is a valid array-like length.\n     *\n     * **Note:** This function is based on [`ToLength`](http://ecma-international.org/ecma-262/6.0/#sec-tolength).\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n     */\n    function isLength(value) {\n      return typeof value == 'number' && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n    }\n\n    /**\n     * Checks if `value` is suitable for strict equality comparisons, i.e. `===`.\n     *\n     * @private\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` if suitable for strict\n     *  equality comparisons, else `false`.\n     */\n    function isStrictComparable(value) {\n      return value === value && !isObject(value);\n    }\n\n    /**\n     * Merges the function metadata of `source` into `data`.\n     *\n     * Merging metadata reduces the number of wrappers required to invoke a function.\n     * This is possible because methods like `_.bind`, `_.curry`, and `_.partial`\n     * may be applied regardless of execution order. Methods like `_.ary` and `_.rearg`\n     * augment function arguments, making the order in which they are executed important,\n     * preventing the merging of metadata. However, we make an exception for a safe\n     * common case where curried functions have `_.ary` and or `_.rearg` applied.\n     *\n     * @private\n     * @param {Array} data The destination metadata.\n     * @param {Array} source The source metadata.\n     * @returns {Array} Returns `data`.\n     */\n    function mergeData(data, source) {\n      var bitmask = data[1],\n          srcBitmask = source[1],\n          newBitmask = bitmask | srcBitmask,\n          isCommon = newBitmask < ARY_FLAG;\n\n      var isCombo =\n        (srcBitmask == ARY_FLAG && bitmask == CURRY_FLAG) ||\n        (srcBitmask == ARY_FLAG && bitmask == REARG_FLAG && data[7].length <= source[8]) ||\n        (srcBitmask == (ARY_FLAG | REARG_FLAG) && bitmask == CURRY_FLAG);\n\n      // Exit early if metadata can't be merged.\n      if (!(isCommon || isCombo)) {\n        return data;\n      }\n      // Use source `thisArg` if available.\n      if (srcBitmask & BIND_FLAG) {\n        data[2] = source[2];\n        // Set when currying a bound function.\n        newBitmask |= (bitmask & BIND_FLAG) ? 0 : CURRY_BOUND_FLAG;\n      }\n      // Compose partial arguments.\n      var value = source[3];\n      if (value) {\n        var partials = data[3];\n        data[3] = partials ? composeArgs(partials, value, source[4]) : arrayCopy(value);\n        data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : arrayCopy(source[4]);\n      }\n      // Compose partial right arguments.\n      value = source[5];\n      if (value) {\n        partials = data[5];\n        data[5] = partials ? composeArgsRight(partials, value, source[6]) : arrayCopy(value);\n        data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : arrayCopy(source[6]);\n      }\n      // Use source `argPos` if available.\n      value = source[7];\n      if (value) {\n        data[7] = arrayCopy(value);\n      }\n      // Use source `ary` if it's smaller.\n      if (srcBitmask & ARY_FLAG) {\n        data[8] = data[8] == null ? source[8] : nativeMin(data[8], source[8]);\n      }\n      // Use source `arity` if one is not provided.\n      if (data[9] == null) {\n        data[9] = source[9];\n      }\n      // Use source `func` and merge bitmasks.\n      data[0] = source[0];\n      data[1] = newBitmask;\n\n      return data;\n    }\n\n    /**\n     * Used by `_.defaultsDeep` to customize its `_.merge` use.\n     *\n     * @private\n     * @param {*} objectValue The destination object property value.\n     * @param {*} sourceValue The source object property value.\n     * @returns {*} Returns the value to assign to the destination object.\n     */\n    function mergeDefaults(objectValue, sourceValue) {\n      return objectValue === undefined ? sourceValue : merge(objectValue, sourceValue, mergeDefaults);\n    }\n\n    /**\n     * A specialized version of `_.pick` which picks `object` properties specified\n     * by `props`.\n     *\n     * @private\n     * @param {Object} object The source object.\n     * @param {string[]} props The property names to pick.\n     * @returns {Object} Returns the new object.\n     */\n    function pickByArray(object, props) {\n      object = toObject(object);\n\n      var index = -1,\n          length = props.length,\n          result = {};\n\n      while (++index < length) {\n        var key = props[index];\n        if (key in object) {\n          result[key] = object[key];\n        }\n      }\n      return result;\n    }\n\n    /**\n     * A specialized version of `_.pick` which picks `object` properties `predicate`\n     * returns truthy for.\n     *\n     * @private\n     * @param {Object} object The source object.\n     * @param {Function} predicate The function invoked per iteration.\n     * @returns {Object} Returns the new object.\n     */\n    function pickByCallback(object, predicate) {\n      var result = {};\n      baseForIn(object, function(value, key, object) {\n        if (predicate(value, key, object)) {\n          result[key] = value;\n        }\n      });\n      return result;\n    }\n\n    /**\n     * Reorder `array` according to the specified indexes where the element at\n     * the first index is assigned as the first element, the element at\n     * the second index is assigned as the second element, and so on.\n     *\n     * @private\n     * @param {Array} array The array to reorder.\n     * @param {Array} indexes The arranged array indexes.\n     * @returns {Array} Returns `array`.\n     */\n    function reorder(array, indexes) {\n      var arrLength = array.length,\n          length = nativeMin(indexes.length, arrLength),\n          oldArray = arrayCopy(array);\n\n      while (length--) {\n        var index = indexes[length];\n        array[length] = isIndex(index, arrLength) ? oldArray[index] : undefined;\n      }\n      return array;\n    }\n\n    /**\n     * Sets metadata for `func`.\n     *\n     * **Note:** If this function becomes hot, i.e. is invoked a lot in a short\n     * period of time, it will trip its breaker and transition to an identity function\n     * to avoid garbage collection pauses in V8. See [V8 issue 2070](https://code.google.com/p/v8/issues/detail?id=2070)\n     * for more details.\n     *\n     * @private\n     * @param {Function} func The function to associate metadata with.\n     * @param {*} data The metadata.\n     * @returns {Function} Returns `func`.\n     */\n    var setData = (function() {\n      var count = 0,\n          lastCalled = 0;\n\n      return function(key, value) {\n        var stamp = now(),\n            remaining = HOT_SPAN - (stamp - lastCalled);\n\n        lastCalled = stamp;\n        if (remaining > 0) {\n          if (++count >= HOT_COUNT) {\n            return key;\n          }\n        } else {\n          count = 0;\n        }\n        return baseSetData(key, value);\n      };\n    }());\n\n    /**\n     * A fallback implementation of `Object.keys` which creates an array of the\n     * own enumerable property names of `object`.\n     *\n     * @private\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property names.\n     */\n    function shimKeys(object) {\n      var props = keysIn(object),\n          propsLength = props.length,\n          length = propsLength && object.length;\n\n      var allowIndexes = !!length && isLength(length) &&\n        (isArray(object) || isArguments(object));\n\n      var index = -1,\n          result = [];\n\n      while (++index < propsLength) {\n        var key = props[index];\n        if ((allowIndexes && isIndex(key, length)) || hasOwnProperty.call(object, key)) {\n          result.push(key);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * Converts `value` to an array-like object if it's not one.\n     *\n     * @private\n     * @param {*} value The value to process.\n     * @returns {Array|Object} Returns the array-like object.\n     */\n    function toIterable(value) {\n      if (value == null) {\n        return [];\n      }\n      if (!isArrayLike(value)) {\n        return values(value);\n      }\n      return isObject(value) ? value : Object(value);\n    }\n\n    /**\n     * Converts `value` to an object if it's not one.\n     *\n     * @private\n     * @param {*} value The value to process.\n     * @returns {Object} Returns the object.\n     */\n    function toObject(value) {\n      return isObject(value) ? value : Object(value);\n    }\n\n    /**\n     * Converts `value` to property path array if it's not one.\n     *\n     * @private\n     * @param {*} value The value to process.\n     * @returns {Array} Returns the property path array.\n     */\n    function toPath(value) {\n      if (isArray(value)) {\n        return value;\n      }\n      var result = [];\n      baseToString(value).replace(rePropName, function(match, number, quote, string) {\n        result.push(quote ? string.replace(reEscapeChar, '$1') : (number || match));\n      });\n      return result;\n    }\n\n    /**\n     * Creates a clone of `wrapper`.\n     *\n     * @private\n     * @param {Object} wrapper The wrapper to clone.\n     * @returns {Object} Returns the cloned wrapper.\n     */\n    function wrapperClone(wrapper) {\n      return wrapper instanceof LazyWrapper\n        ? wrapper.clone()\n        : new LodashWrapper(wrapper.__wrapped__, wrapper.__chain__, arrayCopy(wrapper.__actions__));\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates an array of elements split into groups the length of `size`.\n     * If `collection` can't be split evenly, the final chunk will be the remaining\n     * elements.\n     *\n     * @static\n     * @memberOf _\n     * @category Array\n     * @param {Array} array The array to process.\n     * @param {number} [size=1] The length of each chunk.\n     * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.\n     * @returns {Array} Returns the new array containing chunks.\n     * @example\n     *\n     * _.chunk(['a', 'b', 'c', 'd'], 2);\n     * // => [['a', 'b'], ['c', 'd']]\n     *\n     * _.chunk(['a', 'b', 'c', 'd'], 3);\n     * // => [['a', 'b', 'c'], ['d']]\n     */\n    function chunk(array, size, guard) {\n      if (guard ? isIterateeCall(array, size, guard) : size == null) {\n        size = 1;\n      } else {\n        size = nativeMax(nativeFloor(size) || 1, 1);\n      }\n      var index = 0,\n          length = array ? array.length : 0,\n          resIndex = -1,\n          result = Array(nativeCeil(length / size));\n\n      while (index < length) {\n        result[++resIndex] = baseSlice(array, index, (index += size));\n      }\n      return result;\n    }\n\n    /**\n     * Creates an array with all falsey values removed. The values `false`, `null`,\n     * `0`, `\"\"`, `undefined`, and `NaN` are falsey.\n     *\n     * @static\n     * @memberOf _\n     * @category Array\n     * @param {Array} array The array to compact.\n     * @returns {Array} Returns the new array of filtered values.\n     * @example\n     *\n     * _.compact([0, 1, false, 2, '', 3]);\n     * // => [1, 2, 3]\n     */\n    function compact(array) {\n      var index = -1,\n          length = array ? array.length : 0,\n          resIndex = -1,\n          result = [];\n\n      while (++index < length) {\n        var value = array[index];\n        if (value) {\n          result[++resIndex] = value;\n        }\n      }\n      return result;\n    }\n\n    /**\n     * Creates an array of unique `array` values not included in the other\n     * provided arrays using [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero)\n     * for equality comparisons.\n     *\n     * @static\n     * @memberOf _\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {...Array} [values] The arrays of values to exclude.\n     * @returns {Array} Returns the new array of filtered values.\n     * @example\n     *\n     * _.difference([1, 2, 3], [4, 2]);\n     * // => [1, 3]\n     */\n    var difference = restParam(function(array, values) {\n      return (isObjectLike(array) && isArrayLike(array))\n        ? baseDifference(array, baseFlatten(values, false, true))\n        : [];\n    });\n\n    /**\n     * Creates a slice of `array` with `n` elements dropped from the beginning.\n     *\n     * @static\n     * @memberOf _\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {number} [n=1] The number of elements to drop.\n     * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.drop([1, 2, 3]);\n     * // => [2, 3]\n     *\n     * _.drop([1, 2, 3], 2);\n     * // => [3]\n     *\n     * _.drop([1, 2, 3], 5);\n     * // => []\n     *\n     * _.drop([1, 2, 3], 0);\n     * // => [1, 2, 3]\n     */\n    function drop(array, n, guard) {\n      var length = array ? array.length : 0;\n      if (!length) {\n        return [];\n      }\n      if (guard ? isIterateeCall(array, n, guard) : n == null) {\n        n = 1;\n      }\n      return baseSlice(array, n < 0 ? 0 : n);\n    }\n\n    /**\n     * Creates a slice of `array` with `n` elements dropped from the end.\n     *\n     * @static\n     * @memberOf _\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {number} [n=1] The number of elements to drop.\n     * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.dropRight([1, 2, 3]);\n     * // => [1, 2]\n     *\n     * _.dropRight([1, 2, 3], 2);\n     * // => [1]\n     *\n     * _.dropRight([1, 2, 3], 5);\n     * // => []\n     *\n     * _.dropRight([1, 2, 3], 0);\n     * // => [1, 2, 3]\n     */\n    function dropRight(array, n, guard) {\n      var length = array ? array.length : 0;\n      if (!length) {\n        return [];\n      }\n      if (guard ? isIterateeCall(array, n, guard) : n == null) {\n        n = 1;\n      }\n      n = length - (+n || 0);\n      return baseSlice(array, 0, n < 0 ? 0 : n);\n    }\n\n    /**\n     * Creates a slice of `array` excluding elements dropped from the end.\n     * Elements are dropped until `predicate` returns falsey. The predicate is\n     * bound to `thisArg` and invoked with three arguments: (value, index, array).\n     *\n     * If a property name is provided for `predicate` the created `_.property`\n     * style callback returns the property value of the given element.\n     *\n     * If a value is also provided for `thisArg` the created `_.matchesProperty`\n     * style callback returns `true` for elements that have a matching property\n     * value, else `false`.\n     *\n     * If an object is provided for `predicate` the created `_.matches` style\n     * callback returns `true` for elements that match the properties of the given\n     * object, else `false`.\n     *\n     * @static\n     * @memberOf _\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {Function|Object|string} [predicate=_.identity] The function invoked\n     *  per iteration.\n     * @param {*} [thisArg] The `this` binding of `predicate`.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.dropRightWhile([1, 2, 3], function(n) {\n     *   return n > 1;\n     * });\n     * // => [1]\n     *\n     * var users = [\n     *   { 'user': 'barney',  'active': true },\n     *   { 'user': 'fred',    'active': false },\n     *   { 'user': 'pebbles', 'active': false }\n     * ];\n     *\n     * // using the `_.matches` callback shorthand\n     * _.pluck(_.dropRightWhile(users, { 'user': 'pebbles', 'active': false }), 'user');\n     * // => ['barney', 'fred']\n     *\n     * // using the `_.matchesProperty` callback shorthand\n     * _.pluck(_.dropRightWhile(users, 'active', false), 'user');\n     * // => ['barney']\n     *\n     * // using the `_.property` callback shorthand\n     * _.pluck(_.dropRightWhile(users, 'active'), 'user');\n     * // => ['barney', 'fred', 'pebbles']\n     */\n    function dropRightWhile(array, predicate, thisArg) {\n      return (array && array.length)\n        ? baseWhile(array, getCallback(predicate, thisArg, 3), true, true)\n        : [];\n    }\n\n    /**\n     * Creates a slice of `array` excluding elements dropped from the beginning.\n     * Elements are dropped until `predicate` returns falsey. The predicate is\n     * bound to `thisArg` and invoked with three arguments: (value, index, array).\n     *\n     * If a property name is provided for `predicate` the created `_.property`\n     * style callback returns the property value of the given element.\n     *\n     * If a value is also provided for `thisArg` the created `_.matchesProperty`\n     * style callback returns `true` for elements that have a matching property\n     * value, else `false`.\n     *\n     * If an object is provided for `predicate` the created `_.matches` style\n     * callback returns `true` for elements that have the properties of the given\n     * object, else `false`.\n     *\n     * @static\n     * @memberOf _\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {Function|Object|string} [predicate=_.identity] The function invoked\n     *  per iteration.\n     * @param {*} [thisArg] The `this` binding of `predicate`.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.dropWhile([1, 2, 3], function(n) {\n     *   return n < 3;\n     * });\n     * // => [3]\n     *\n     * var users = [\n     *   { 'user': 'barney',  'active': false },\n     *   { 'user': 'fred',    'active': false },\n     *   { 'user': 'pebbles', 'active': true }\n     * ];\n     *\n     * // using the `_.matches` callback shorthand\n     * _.pluck(_.dropWhile(users, { 'user': 'barney', 'active': false }), 'user');\n     * // => ['fred', 'pebbles']\n     *\n     * // using the `_.matchesProperty` callback shorthand\n     * _.pluck(_.dropWhile(users, 'active', false), 'user');\n     * // => ['pebbles']\n     *\n     * // using the `_.property` callback shorthand\n     * _.pluck(_.dropWhile(users, 'active'), 'user');\n     * // => ['barney', 'fred', 'pebbles']\n     */\n    function dropWhile(array, predicate, thisArg) {\n      return (array && array.length)\n        ? baseWhile(array, getCallback(predicate, thisArg, 3), true)\n        : [];\n    }\n\n    /**\n     * Fills elements of `array` with `value` from `start` up to, but not\n     * including, `end`.\n     *\n     * **Note:** This method mutates `array`.\n     *\n     * @static\n     * @memberOf _\n     * @category Array\n     * @param {Array} array The array to fill.\n     * @param {*} value The value to fill `array` with.\n     * @param {number} [start=0] The start position.\n     * @param {number} [end=array.length] The end position.\n     * @returns {Array} Returns `array`.\n     * @example\n     *\n     * var array = [1, 2, 3];\n     *\n     * _.fill(array, 'a');\n     * console.log(array);\n     * // => ['a', 'a', 'a']\n     *\n     * _.fill(Array(3), 2);\n     * // => [2, 2, 2]\n     *\n     * _.fill([4, 6, 8], '*', 1, 2);\n     * // => [4, '*', 8]\n     */\n    function fill(array, value, start, end) {\n      var length = array ? array.length : 0;\n      if (!length) {\n        return [];\n      }\n      if (start && typeof start != 'number' && isIterateeCall(array, value, start)) {\n        start = 0;\n        end = length;\n      }\n      return baseFill(array, value, start, end);\n    }\n\n    /**\n     * This method is like `_.find` except that it returns the index of the first\n     * element `predicate` returns truthy for instead of the element itself.\n     *\n     * If a property name is provided for `predicate` the created `_.property`\n     * style callback returns the property value of the given element.\n     *\n     * If a value is also provided for `thisArg` the created `_.matchesProperty`\n     * style callback returns `true` for elements that have a matching property\n     * value, else `false`.\n     *\n     * If an object is provided for `predicate` the created `_.matches` style\n     * callback returns `true` for elements that have the properties of the given\n     * object, else `false`.\n     *\n     * @static\n     * @memberOf _\n     * @category Array\n     * @param {Array} array The array to search.\n     * @param {Function|Object|string} [predicate=_.identity] The function invoked\n     *  per iteration.\n     * @param {*} [thisArg] The `this` binding of `predicate`.\n     * @returns {number} Returns the index of the found element, else `-1`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'active': false },\n     *   { 'user': 'fred',    'active': false },\n     *   { 'user': 'pebbles', 'active': true }\n     * ];\n     *\n     * _.findIndex(users, function(chr) {\n     *   return chr.user == 'barney';\n     * });\n     * // => 0\n     *\n     * // using the `_.matches` callback shorthand\n     * _.findIndex(users, { 'user': 'fred', 'active': false });\n     * // => 1\n     *\n     * // using the `_.matchesProperty` callback shorthand\n     * _.findIndex(users, 'active', false);\n     * // => 0\n     *\n     * // using the `_.property` callback shorthand\n     * _.findIndex(users, 'active');\n     * // => 2\n     */\n    var findIndex = createFindIndex();\n\n    /**\n     * This method is like `_.findIndex` except that it iterates over elements\n     * of `collection` from right to left.\n     *\n     * If a property name is provided for `predicate` the created `_.property`\n     * style callback returns the property value of the given element.\n     *\n     * If a value is also provided for `thisArg` the created `_.matchesProperty`\n     * style callback returns `true` for elements that have a matching property\n     * value, else `false`.\n     *\n     * If an object is provided for `predicate` the created `_.matches` style\n     * callback returns `true` for elements that have the properties of the given\n     * object, else `false`.\n     *\n     * @static\n     * @memberOf _\n     * @category Array\n     * @param {Array} array The array to search.\n     * @param {Function|Object|string} [predicate=_.identity] The function invoked\n     *  per iteration.\n     * @param {*} [thisArg] The `this` binding of `predicate`.\n     * @returns {number} Returns the index of the found element, else `-1`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'active': true },\n     *   { 'user': 'fred',    'active': false },\n     *   { 'user': 'pebbles', 'active': false }\n     * ];\n     *\n     * _.findLastIndex(users, function(chr) {\n     *   return chr.user == 'pebbles';\n     * });\n     * // => 2\n     *\n     * // using the `_.matches` callback shorthand\n     * _.findLastIndex(users, { 'user': 'barney', 'active': true });\n     * // => 0\n     *\n     * // using the `_.matchesProperty` callback shorthand\n     * _.findLastIndex(users, 'active', false);\n     * // => 2\n     *\n     * // using the `_.property` callback shorthand\n     * _.findLastIndex(users, 'active');\n     * // => 0\n     */\n    var findLastIndex = createFindIndex(true);\n\n    /**\n     * Gets the first element of `array`.\n     *\n     * @static\n     * @memberOf _\n     * @alias head\n     * @category Array\n     * @param {Array} array The array to query.\n     * @returns {*} Returns the first element of `array`.\n     * @example\n     *\n     * _.first([1, 2, 3]);\n     * // => 1\n     *\n     * _.first([]);\n     * // => undefined\n     */\n    function first(array) {\n      return array ? array[0] : undefined;\n    }\n\n    /**\n     * Flattens a nested array. If `isDeep` is `true` the array is recursively\n     * flattened, otherwise it is only flattened a single level.\n     *\n     * @static\n     * @memberOf _\n     * @category Array\n     * @param {Array} array The array to flatten.\n     * @param {boolean} [isDeep] Specify a deep flatten.\n     * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.\n     * @returns {Array} Returns the new flattened array.\n     * @example\n     *\n     * _.flatten([1, [2, 3, [4]]]);\n     * // => [1, 2, 3, [4]]\n     *\n     * // using `isDeep`\n     * _.flatten([1, [2, 3, [4]]], true);\n     * // => [1, 2, 3, 4]\n     */\n    function flatten(array, isDeep, guard) {\n      var length = array ? array.length : 0;\n      if (guard && isIterateeCall(array, isDeep, guard)) {\n        isDeep = false;\n      }\n      return length ? baseFlatten(array, isDeep) : [];\n    }\n\n    /**\n     * Recursively flattens a nested array.\n     *\n     * @static\n     * @memberOf _\n     * @category Array\n     * @param {Array} array The array to recursively flatten.\n     * @returns {Array} Returns the new flattened array.\n     * @example\n     *\n     * _.flattenDeep([1, [2, 3, [4]]]);\n     * // => [1, 2, 3, 4]\n     */\n    function flattenDeep(array) {\n      var length = array ? array.length : 0;\n      return length ? baseFlatten(array, true) : [];\n    }\n\n    /**\n     * Gets the index at which the first occurrence of `value` is found in `array`\n     * using [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero)\n     * for equality comparisons. If `fromIndex` is negative, it is used as the offset\n     * from the end of `array`. If `array` is sorted providing `true` for `fromIndex`\n     * performs a faster binary search.\n     *\n     * @static\n     * @memberOf _\n     * @category Array\n     * @param {Array} array The array to search.\n     * @param {*} value The value to search for.\n     * @param {boolean|number} [fromIndex=0] The index to search from or `true`\n     *  to perform a binary search on a sorted array.\n     * @returns {number} Returns the index of the matched value, else `-1`.\n     * @example\n     *\n     * _.indexOf([1, 2, 1, 2], 2);\n     * // => 1\n     *\n     * // using `fromIndex`\n     * _.indexOf([1, 2, 1, 2], 2, 2);\n     * // => 3\n     *\n     * // performing a binary search\n     * _.indexOf([1, 1, 2, 2], 2, true);\n     * // => 2\n     */\n    function indexOf(array, value, fromIndex) {\n      var length = array ? array.length : 0;\n      if (!length) {\n        return -1;\n      }\n      if (typeof fromIndex == 'number') {\n        fromIndex = fromIndex < 0 ? nativeMax(length + fromIndex, 0) : fromIndex;\n      } else if (fromIndex) {\n        var index = binaryIndex(array, value);\n        if (index < length &&\n            (value === value ? (value === array[index]) : (array[index] !== array[index]))) {\n          return index;\n        }\n        return -1;\n      }\n      return baseIndexOf(array, value, fromIndex || 0);\n    }\n\n    /**\n     * Gets all but the last element of `array`.\n     *\n     * @static\n     * @memberOf _\n     * @category Array\n     * @param {Array} array The array to query.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.initial([1, 2, 3]);\n     * // => [1, 2]\n     */\n    function initial(array) {\n      return dropRight(array, 1);\n    }\n\n    /**\n     * Creates an array of unique values that are included in all of the provided\n     * arrays using [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero)\n     * for equality comparisons.\n     *\n     * @static\n     * @memberOf _\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @returns {Array} Returns the new array of shared values.\n     * @example\n     * _.intersection([1, 2], [4, 2], [2, 1]);\n     * // => [2]\n     */\n    var intersection = restParam(function(arrays) {\n      var othLength = arrays.length,\n          othIndex = othLength,\n          caches = Array(length),\n          indexOf = getIndexOf(),\n          isCommon = indexOf == baseIndexOf,\n          result = [];\n\n      while (othIndex--) {\n        var value = arrays[othIndex] = isArrayLike(value = arrays[othIndex]) ? value : [];\n        caches[othIndex] = (isCommon && value.length >= 120) ? createCache(othIndex && value) : null;\n      }\n      var array = arrays[0],\n          index = -1,\n          length = array ? array.length : 0,\n          seen = caches[0];\n\n      outer:\n      while (++index < length) {\n        value = array[index];\n        if ((seen ? cacheIndexOf(seen, value) : indexOf(result, value, 0)) < 0) {\n          var othIndex = othLength;\n          while (--othIndex) {\n            var cache = caches[othIndex];\n            if ((cache ? cacheIndexOf(cache, value) : indexOf(arrays[othIndex], value, 0)) < 0) {\n              continue outer;\n            }\n          }\n          if (seen) {\n            seen.push(value);\n          }\n          result.push(value);\n        }\n      }\n      return result;\n    });\n\n    /**\n     * Gets the last element of `array`.\n     *\n     * @static\n     * @memberOf _\n     * @category Array\n     * @param {Array} array The array to query.\n     * @returns {*} Returns the last element of `array`.\n     * @example\n     *\n     * _.last([1, 2, 3]);\n     * // => 3\n     */\n    function last(array) {\n      var length = array ? array.length : 0;\n      return length ? array[length - 1] : undefined;\n    }\n\n    /**\n     * This method is like `_.indexOf` except that it iterates over elements of\n     * `array` from right to left.\n     *\n     * @static\n     * @memberOf _\n     * @category Array\n     * @param {Array} array The array to search.\n     * @param {*} value The value to search for.\n     * @param {boolean|number} [fromIndex=array.length-1] The index to search from\n     *  or `true` to perform a binary search on a sorted array.\n     * @returns {number} Returns the index of the matched value, else `-1`.\n     * @example\n     *\n     * _.lastIndexOf([1, 2, 1, 2], 2);\n     * // => 3\n     *\n     * // using `fromIndex`\n     * _.lastIndexOf([1, 2, 1, 2], 2, 2);\n     * // => 1\n     *\n     * // performing a binary search\n     * _.lastIndexOf([1, 1, 2, 2], 2, true);\n     * // => 3\n     */\n    function lastIndexOf(array, value, fromIndex) {\n      var length = array ? array.length : 0;\n      if (!length) {\n        return -1;\n      }\n      var index = length;\n      if (typeof fromIndex == 'number') {\n        index = (fromIndex < 0 ? nativeMax(length + fromIndex, 0) : nativeMin(fromIndex || 0, length - 1)) + 1;\n      } else if (fromIndex) {\n        index = binaryIndex(array, value, true) - 1;\n        var other = array[index];\n        if (value === value ? (value === other) : (other !== other)) {\n          return index;\n        }\n        return -1;\n      }\n      if (value !== value) {\n        return indexOfNaN(array, index, true);\n      }\n      while (index--) {\n        if (array[index] === value) {\n          return index;\n        }\n      }\n      return -1;\n    }\n\n    /**\n     * Removes all provided values from `array` using\n     * [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero)\n     * for equality comparisons.\n     *\n     * **Note:** Unlike `_.without`, this method mutates `array`.\n     *\n     * @static\n     * @memberOf _\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @param {...*} [values] The values to remove.\n     * @returns {Array} Returns `array`.\n     * @example\n     *\n     * var array = [1, 2, 3, 1, 2, 3];\n     *\n     * _.pull(array, 2, 3);\n     * console.log(array);\n     * // => [1, 1]\n     */\n    function pull() {\n      var args = arguments,\n          array = args[0];\n\n      if (!(array && array.length)) {\n        return array;\n      }\n      var index = 0,\n          indexOf = getIndexOf(),\n          length = args.length;\n\n      while (++index < length) {\n        var fromIndex = 0,\n            value = args[index];\n\n        while ((fromIndex = indexOf(array, value, fromIndex)) > -1) {\n          splice.call(array, fromIndex, 1);\n        }\n      }\n      return array;\n    }\n\n    /**\n     * Removes elements from `array` corresponding to the given indexes and returns\n     * an array of the removed elements. Indexes may be specified as an array of\n     * indexes or as individual arguments.\n     *\n     * **Note:** Unlike `_.at`, this method mutates `array`.\n     *\n     * @static\n     * @memberOf _\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @param {...(number|number[])} [indexes] The indexes of elements to remove,\n     *  specified as individual indexes or arrays of indexes.\n     * @returns {Array} Returns the new array of removed elements.\n     * @example\n     *\n     * var array = [5, 10, 15, 20];\n     * var evens = _.pullAt(array, 1, 3);\n     *\n     * console.log(array);\n     * // => [5, 15]\n     *\n     * console.log(evens);\n     * // => [10, 20]\n     */\n    var pullAt = restParam(function(array, indexes) {\n      indexes = baseFlatten(indexes);\n\n      var result = baseAt(array, indexes);\n      basePullAt(array, indexes.sort(baseCompareAscending));\n      return result;\n    });\n\n    /**\n     * Removes all elements from `array` that `predicate` returns truthy for\n     * and returns an array of the removed elements. The predicate is bound to\n     * `thisArg` and invoked with three arguments: (value, index, array).\n     *\n     * If a property name is provided for `predicate` the created `_.property`\n     * style callback returns the property value of the given element.\n     *\n     * If a value is also provided for `thisArg` the created `_.matchesProperty`\n     * style callback returns `true` for elements that have a matching property\n     * value, else `false`.\n     *\n     * If an object is provided for `predicate` the created `_.matches` style\n     * callback returns `true` for elements that have the properties of the given\n     * object, else `false`.\n     *\n     * **Note:** Unlike `_.filter`, this method mutates `array`.\n     *\n     * @static\n     * @memberOf _\n     * @category Array\n     * @param {Array} array The array to modify.\n     * @param {Function|Object|string} [predicate=_.identity] The function invoked\n     *  per iteration.\n     * @param {*} [thisArg] The `this` binding of `predicate`.\n     * @returns {Array} Returns the new array of removed elements.\n     * @example\n     *\n     * var array = [1, 2, 3, 4];\n     * var evens = _.remove(array, function(n) {\n     *   return n % 2 == 0;\n     * });\n     *\n     * console.log(array);\n     * // => [1, 3]\n     *\n     * console.log(evens);\n     * // => [2, 4]\n     */\n    function remove(array, predicate, thisArg) {\n      var result = [];\n      if (!(array && array.length)) {\n        return result;\n      }\n      var index = -1,\n          indexes = [],\n          length = array.length;\n\n      predicate = getCallback(predicate, thisArg, 3);\n      while (++index < length) {\n        var value = array[index];\n        if (predicate(value, index, array)) {\n          result.push(value);\n          indexes.push(index);\n        }\n      }\n      basePullAt(array, indexes);\n      return result;\n    }\n\n    /**\n     * Gets all but the first element of `array`.\n     *\n     * @static\n     * @memberOf _\n     * @alias tail\n     * @category Array\n     * @param {Array} array The array to query.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.rest([1, 2, 3]);\n     * // => [2, 3]\n     */\n    function rest(array) {\n      return drop(array, 1);\n    }\n\n    /**\n     * Creates a slice of `array` from `start` up to, but not including, `end`.\n     *\n     * **Note:** This method is used instead of `Array#slice` to support node\n     * lists in IE < 9 and to ensure dense arrays are returned.\n     *\n     * @static\n     * @memberOf _\n     * @category Array\n     * @param {Array} array The array to slice.\n     * @param {number} [start=0] The start position.\n     * @param {number} [end=array.length] The end position.\n     * @returns {Array} Returns the slice of `array`.\n     */\n    function slice(array, start, end) {\n      var length = array ? array.length : 0;\n      if (!length) {\n        return [];\n      }\n      if (end && typeof end != 'number' && isIterateeCall(array, start, end)) {\n        start = 0;\n        end = length;\n      }\n      return baseSlice(array, start, end);\n    }\n\n    /**\n     * Uses a binary search to determine the lowest index at which `value` should\n     * be inserted into `array` in order to maintain its sort order. If an iteratee\n     * function is provided it is invoked for `value` and each element of `array`\n     * to compute their sort ranking. The iteratee is bound to `thisArg` and\n     * invoked with one argument; (value).\n     *\n     * If a property name is provided for `iteratee` the created `_.property`\n     * style callback returns the property value of the given element.\n     *\n     * If a value is also provided for `thisArg` the created `_.matchesProperty`\n     * style callback returns `true` for elements that have a matching property\n     * value, else `false`.\n     *\n     * If an object is provided for `iteratee` the created `_.matches` style\n     * callback returns `true` for elements that have the properties of the given\n     * object, else `false`.\n     *\n     * @static\n     * @memberOf _\n     * @category Array\n     * @param {Array} array The sorted array to inspect.\n     * @param {*} value The value to evaluate.\n     * @param {Function|Object|string} [iteratee=_.identity] The function invoked\n     *  per iteration.\n     * @param {*} [thisArg] The `this` binding of `iteratee`.\n     * @returns {number} Returns the index at which `value` should be inserted\n     *  into `array`.\n     * @example\n     *\n     * _.sortedIndex([30, 50], 40);\n     * // => 1\n     *\n     * _.sortedIndex([4, 4, 5, 5], 5);\n     * // => 2\n     *\n     * var dict = { 'data': { 'thirty': 30, 'forty': 40, 'fifty': 50 } };\n     *\n     * // using an iteratee function\n     * _.sortedIndex(['thirty', 'fifty'], 'forty', function(word) {\n     *   return this.data[word];\n     * }, dict);\n     * // => 1\n     *\n     * // using the `_.property` callback shorthand\n     * _.sortedIndex([{ 'x': 30 }, { 'x': 50 }], { 'x': 40 }, 'x');\n     * // => 1\n     */\n    var sortedIndex = createSortedIndex();\n\n    /**\n     * This method is like `_.sortedIndex` except that it returns the highest\n     * index at which `value` should be inserted into `array` in order to\n     * maintain its sort order.\n     *\n     * @static\n     * @memberOf _\n     * @category Array\n     * @param {Array} array The sorted array to inspect.\n     * @param {*} value The value to evaluate.\n     * @param {Function|Object|string} [iteratee=_.identity] The function invoked\n     *  per iteration.\n     * @param {*} [thisArg] The `this` binding of `iteratee`.\n     * @returns {number} Returns the index at which `value` should be inserted\n     *  into `array`.\n     * @example\n     *\n     * _.sortedLastIndex([4, 4, 5, 5], 5);\n     * // => 4\n     */\n    var sortedLastIndex = createSortedIndex(true);\n\n    /**\n     * Creates a slice of `array` with `n` elements taken from the beginning.\n     *\n     * @static\n     * @memberOf _\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {number} [n=1] The number of elements to take.\n     * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.take([1, 2, 3]);\n     * // => [1]\n     *\n     * _.take([1, 2, 3], 2);\n     * // => [1, 2]\n     *\n     * _.take([1, 2, 3], 5);\n     * // => [1, 2, 3]\n     *\n     * _.take([1, 2, 3], 0);\n     * // => []\n     */\n    function take(array, n, guard) {\n      var length = array ? array.length : 0;\n      if (!length) {\n        return [];\n      }\n      if (guard ? isIterateeCall(array, n, guard) : n == null) {\n        n = 1;\n      }\n      return baseSlice(array, 0, n < 0 ? 0 : n);\n    }\n\n    /**\n     * Creates a slice of `array` with `n` elements taken from the end.\n     *\n     * @static\n     * @memberOf _\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {number} [n=1] The number of elements to take.\n     * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.takeRight([1, 2, 3]);\n     * // => [3]\n     *\n     * _.takeRight([1, 2, 3], 2);\n     * // => [2, 3]\n     *\n     * _.takeRight([1, 2, 3], 5);\n     * // => [1, 2, 3]\n     *\n     * _.takeRight([1, 2, 3], 0);\n     * // => []\n     */\n    function takeRight(array, n, guard) {\n      var length = array ? array.length : 0;\n      if (!length) {\n        return [];\n      }\n      if (guard ? isIterateeCall(array, n, guard) : n == null) {\n        n = 1;\n      }\n      n = length - (+n || 0);\n      return baseSlice(array, n < 0 ? 0 : n);\n    }\n\n    /**\n     * Creates a slice of `array` with elements taken from the end. Elements are\n     * taken until `predicate` returns falsey. The predicate is bound to `thisArg`\n     * and invoked with three arguments: (value, index, array).\n     *\n     * If a property name is provided for `predicate` the created `_.property`\n     * style callback returns the property value of the given element.\n     *\n     * If a value is also provided for `thisArg` the created `_.matchesProperty`\n     * style callback returns `true` for elements that have a matching property\n     * value, else `false`.\n     *\n     * If an object is provided for `predicate` the created `_.matches` style\n     * callback returns `true` for elements that have the properties of the given\n     * object, else `false`.\n     *\n     * @static\n     * @memberOf _\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {Function|Object|string} [predicate=_.identity] The function invoked\n     *  per iteration.\n     * @param {*} [thisArg] The `this` binding of `predicate`.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.takeRightWhile([1, 2, 3], function(n) {\n     *   return n > 1;\n     * });\n     * // => [2, 3]\n     *\n     * var users = [\n     *   { 'user': 'barney',  'active': true },\n     *   { 'user': 'fred',    'active': false },\n     *   { 'user': 'pebbles', 'active': false }\n     * ];\n     *\n     * // using the `_.matches` callback shorthand\n     * _.pluck(_.takeRightWhile(users, { 'user': 'pebbles', 'active': false }), 'user');\n     * // => ['pebbles']\n     *\n     * // using the `_.matchesProperty` callback shorthand\n     * _.pluck(_.takeRightWhile(users, 'active', false), 'user');\n     * // => ['fred', 'pebbles']\n     *\n     * // using the `_.property` callback shorthand\n     * _.pluck(_.takeRightWhile(users, 'active'), 'user');\n     * // => []\n     */\n    function takeRightWhile(array, predicate, thisArg) {\n      return (array && array.length)\n        ? baseWhile(array, getCallback(predicate, thisArg, 3), false, true)\n        : [];\n    }\n\n    /**\n     * Creates a slice of `array` with elements taken from the beginning. Elements\n     * are taken until `predicate` returns falsey. The predicate is bound to\n     * `thisArg` and invoked with three arguments: (value, index, array).\n     *\n     * If a property name is provided for `predicate` the created `_.property`\n     * style callback returns the property value of the given element.\n     *\n     * If a value is also provided for `thisArg` the created `_.matchesProperty`\n     * style callback returns `true` for elements that have a matching property\n     * value, else `false`.\n     *\n     * If an object is provided for `predicate` the created `_.matches` style\n     * callback returns `true` for elements that have the properties of the given\n     * object, else `false`.\n     *\n     * @static\n     * @memberOf _\n     * @category Array\n     * @param {Array} array The array to query.\n     * @param {Function|Object|string} [predicate=_.identity] The function invoked\n     *  per iteration.\n     * @param {*} [thisArg] The `this` binding of `predicate`.\n     * @returns {Array} Returns the slice of `array`.\n     * @example\n     *\n     * _.takeWhile([1, 2, 3], function(n) {\n     *   return n < 3;\n     * });\n     * // => [1, 2]\n     *\n     * var users = [\n     *   { 'user': 'barney',  'active': false },\n     *   { 'user': 'fred',    'active': false},\n     *   { 'user': 'pebbles', 'active': true }\n     * ];\n     *\n     * // using the `_.matches` callback shorthand\n     * _.pluck(_.takeWhile(users, { 'user': 'barney', 'active': false }), 'user');\n     * // => ['barney']\n     *\n     * // using the `_.matchesProperty` callback shorthand\n     * _.pluck(_.takeWhile(users, 'active', false), 'user');\n     * // => ['barney', 'fred']\n     *\n     * // using the `_.property` callback shorthand\n     * _.pluck(_.takeWhile(users, 'active'), 'user');\n     * // => []\n     */\n    function takeWhile(array, predicate, thisArg) {\n      return (array && array.length)\n        ? baseWhile(array, getCallback(predicate, thisArg, 3))\n        : [];\n    }\n\n    /**\n     * Creates an array of unique values, in order, from all of the provided arrays\n     * using [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero)\n     * for equality comparisons.\n     *\n     * @static\n     * @memberOf _\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @returns {Array} Returns the new array of combined values.\n     * @example\n     *\n     * _.union([1, 2], [4, 2], [2, 1]);\n     * // => [1, 2, 4]\n     */\n    var union = restParam(function(arrays) {\n      return baseUniq(baseFlatten(arrays, false, true));\n    });\n\n    /**\n     * Creates a duplicate-free version of an array, using\n     * [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero)\n     * for equality comparisons, in which only the first occurence of each element\n     * is kept. Providing `true` for `isSorted` performs a faster search algorithm\n     * for sorted arrays. If an iteratee function is provided it is invoked for\n     * each element in the array to generate the criterion by which uniqueness\n     * is computed. The `iteratee` is bound to `thisArg` and invoked with three\n     * arguments: (value, index, array).\n     *\n     * If a property name is provided for `iteratee` the created `_.property`\n     * style callback returns the property value of the given element.\n     *\n     * If a value is also provided for `thisArg` the created `_.matchesProperty`\n     * style callback returns `true` for elements that have a matching property\n     * value, else `false`.\n     *\n     * If an object is provided for `iteratee` the created `_.matches` style\n     * callback returns `true` for elements that have the properties of the given\n     * object, else `false`.\n     *\n     * @static\n     * @memberOf _\n     * @alias unique\n     * @category Array\n     * @param {Array} array The array to inspect.\n     * @param {boolean} [isSorted] Specify the array is sorted.\n     * @param {Function|Object|string} [iteratee] The function invoked per iteration.\n     * @param {*} [thisArg] The `this` binding of `iteratee`.\n     * @returns {Array} Returns the new duplicate-value-free array.\n     * @example\n     *\n     * _.uniq([2, 1, 2]);\n     * // => [2, 1]\n     *\n     * // using `isSorted`\n     * _.uniq([1, 1, 2], true);\n     * // => [1, 2]\n     *\n     * // using an iteratee function\n     * _.uniq([1, 2.5, 1.5, 2], function(n) {\n     *   return this.floor(n);\n     * }, Math);\n     * // => [1, 2.5]\n     *\n     * // using the `_.property` callback shorthand\n     * _.uniq([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');\n     * // => [{ 'x': 1 }, { 'x': 2 }]\n     */\n    function uniq(array, isSorted, iteratee, thisArg) {\n      var length = array ? array.length : 0;\n      if (!length) {\n        return [];\n      }\n      if (isSorted != null && typeof isSorted != 'boolean') {\n        thisArg = iteratee;\n        iteratee = isIterateeCall(array, isSorted, thisArg) ? undefined : isSorted;\n        isSorted = false;\n      }\n      var callback = getCallback();\n      if (!(iteratee == null && callback === baseCallback)) {\n        iteratee = callback(iteratee, thisArg, 3);\n      }\n      return (isSorted && getIndexOf() == baseIndexOf)\n        ? sortedUniq(array, iteratee)\n        : baseUniq(array, iteratee);\n    }\n\n    /**\n     * This method is like `_.zip` except that it accepts an array of grouped\n     * elements and creates an array regrouping the elements to their pre-zip\n     * configuration.\n     *\n     * @static\n     * @memberOf _\n     * @category Array\n     * @param {Array} array The array of grouped elements to process.\n     * @returns {Array} Returns the new array of regrouped elements.\n     * @example\n     *\n     * var zipped = _.zip(['fred', 'barney'], [30, 40], [true, false]);\n     * // => [['fred', 30, true], ['barney', 40, false]]\n     *\n     * _.unzip(zipped);\n     * // => [['fred', 'barney'], [30, 40], [true, false]]\n     */\n    function unzip(array) {\n      if (!(array && array.length)) {\n        return [];\n      }\n      var index = -1,\n          length = 0;\n\n      array = arrayFilter(array, function(group) {\n        if (isArrayLike(group)) {\n          length = nativeMax(group.length, length);\n          return true;\n        }\n      });\n      var result = Array(length);\n      while (++index < length) {\n        result[index] = arrayMap(array, baseProperty(index));\n      }\n      return result;\n    }\n\n    /**\n     * This method is like `_.unzip` except that it accepts an iteratee to specify\n     * how regrouped values should be combined. The `iteratee` is bound to `thisArg`\n     * and invoked with four arguments: (accumulator, value, index, group).\n     *\n     * @static\n     * @memberOf _\n     * @category Array\n     * @param {Array} array The array of grouped elements to process.\n     * @param {Function} [iteratee] The function to combine regrouped values.\n     * @param {*} [thisArg] The `this` binding of `iteratee`.\n     * @returns {Array} Returns the new array of regrouped elements.\n     * @example\n     *\n     * var zipped = _.zip([1, 2], [10, 20], [100, 200]);\n     * // => [[1, 10, 100], [2, 20, 200]]\n     *\n     * _.unzipWith(zipped, _.add);\n     * // => [3, 30, 300]\n     */\n    function unzipWith(array, iteratee, thisArg) {\n      var length = array ? array.length : 0;\n      if (!length) {\n        return [];\n      }\n      var result = unzip(array);\n      if (iteratee == null) {\n        return result;\n      }\n      iteratee = bindCallback(iteratee, thisArg, 4);\n      return arrayMap(result, function(group) {\n        return arrayReduce(group, iteratee, undefined, true);\n      });\n    }\n\n    /**\n     * Creates an array excluding all provided values using\n     * [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero)\n     * for equality comparisons.\n     *\n     * @static\n     * @memberOf _\n     * @category Array\n     * @param {Array} array The array to filter.\n     * @param {...*} [values] The values to exclude.\n     * @returns {Array} Returns the new array of filtered values.\n     * @example\n     *\n     * _.without([1, 2, 1, 3], 1, 2);\n     * // => [3]\n     */\n    var without = restParam(function(array, values) {\n      return isArrayLike(array)\n        ? baseDifference(array, values)\n        : [];\n    });\n\n    /**\n     * Creates an array of unique values that is the [symmetric difference](https://en.wikipedia.org/wiki/Symmetric_difference)\n     * of the provided arrays.\n     *\n     * @static\n     * @memberOf _\n     * @category Array\n     * @param {...Array} [arrays] The arrays to inspect.\n     * @returns {Array} Returns the new array of values.\n     * @example\n     *\n     * _.xor([1, 2], [4, 2]);\n     * // => [1, 4]\n     */\n    function xor() {\n      var index = -1,\n          length = arguments.length;\n\n      while (++index < length) {\n        var array = arguments[index];\n        if (isArrayLike(array)) {\n          var result = result\n            ? arrayPush(baseDifference(result, array), baseDifference(array, result))\n            : array;\n        }\n      }\n      return result ? baseUniq(result) : [];\n    }\n\n    /**\n     * Creates an array of grouped elements, the first of which contains the first\n     * elements of the given arrays, the second of which contains the second elements\n     * of the given arrays, and so on.\n     *\n     * @static\n     * @memberOf _\n     * @category Array\n     * @param {...Array} [arrays] The arrays to process.\n     * @returns {Array} Returns the new array of grouped elements.\n     * @example\n     *\n     * _.zip(['fred', 'barney'], [30, 40], [true, false]);\n     * // => [['fred', 30, true], ['barney', 40, false]]\n     */\n    var zip = restParam(unzip);\n\n    /**\n     * The inverse of `_.pairs`; this method returns an object composed from arrays\n     * of property names and values. Provide either a single two dimensional array,\n     * e.g. `[[key1, value1], [key2, value2]]` or two arrays, one of property names\n     * and one of corresponding values.\n     *\n     * @static\n     * @memberOf _\n     * @alias object\n     * @category Array\n     * @param {Array} props The property names.\n     * @param {Array} [values=[]] The property values.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * _.zipObject([['fred', 30], ['barney', 40]]);\n     * // => { 'fred': 30, 'barney': 40 }\n     *\n     * _.zipObject(['fred', 'barney'], [30, 40]);\n     * // => { 'fred': 30, 'barney': 40 }\n     */\n    function zipObject(props, values) {\n      var index = -1,\n          length = props ? props.length : 0,\n          result = {};\n\n      if (length && !values && !isArray(props[0])) {\n        values = [];\n      }\n      while (++index < length) {\n        var key = props[index];\n        if (values) {\n          result[key] = values[index];\n        } else if (key) {\n          result[key[0]] = key[1];\n        }\n      }\n      return result;\n    }\n\n    /**\n     * This method is like `_.zip` except that it accepts an iteratee to specify\n     * how grouped values should be combined. The `iteratee` is bound to `thisArg`\n     * and invoked with four arguments: (accumulator, value, index, group).\n     *\n     * @static\n     * @memberOf _\n     * @category Array\n     * @param {...Array} [arrays] The arrays to process.\n     * @param {Function} [iteratee] The function to combine grouped values.\n     * @param {*} [thisArg] The `this` binding of `iteratee`.\n     * @returns {Array} Returns the new array of grouped elements.\n     * @example\n     *\n     * _.zipWith([1, 2], [10, 20], [100, 200], _.add);\n     * // => [111, 222]\n     */\n    var zipWith = restParam(function(arrays) {\n      var length = arrays.length,\n          iteratee = length > 2 ? arrays[length - 2] : undefined,\n          thisArg = length > 1 ? arrays[length - 1] : undefined;\n\n      if (length > 2 && typeof iteratee == 'function') {\n        length -= 2;\n      } else {\n        iteratee = (length > 1 && typeof thisArg == 'function') ? (--length, thisArg) : undefined;\n        thisArg = undefined;\n      }\n      arrays.length = length;\n      return unzipWith(arrays, iteratee, thisArg);\n    });\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates a `lodash` object that wraps `value` with explicit method\n     * chaining enabled.\n     *\n     * @static\n     * @memberOf _\n     * @category Chain\n     * @param {*} value The value to wrap.\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'age': 36 },\n     *   { 'user': 'fred',    'age': 40 },\n     *   { 'user': 'pebbles', 'age': 1 }\n     * ];\n     *\n     * var youngest = _.chain(users)\n     *   .sortBy('age')\n     *   .map(function(chr) {\n     *     return chr.user + ' is ' + chr.age;\n     *   })\n     *   .first()\n     *   .value();\n     * // => 'pebbles is 1'\n     */\n    function chain(value) {\n      var result = lodash(value);\n      result.__chain__ = true;\n      return result;\n    }\n\n    /**\n     * This method invokes `interceptor` and returns `value`. The interceptor is\n     * bound to `thisArg` and invoked with one argument; (value). The purpose of\n     * this method is to \"tap into\" a method chain in order to perform operations\n     * on intermediate results within the chain.\n     *\n     * @static\n     * @memberOf _\n     * @category Chain\n     * @param {*} value The value to provide to `interceptor`.\n     * @param {Function} interceptor The function to invoke.\n     * @param {*} [thisArg] The `this` binding of `interceptor`.\n     * @returns {*} Returns `value`.\n     * @example\n     *\n     * _([1, 2, 3])\n     *  .tap(function(array) {\n     *    array.pop();\n     *  })\n     *  .reverse()\n     *  .value();\n     * // => [2, 1]\n     */\n    function tap(value, interceptor, thisArg) {\n      interceptor.call(thisArg, value);\n      return value;\n    }\n\n    /**\n     * This method is like `_.tap` except that it returns the result of `interceptor`.\n     *\n     * @static\n     * @memberOf _\n     * @category Chain\n     * @param {*} value The value to provide to `interceptor`.\n     * @param {Function} interceptor The function to invoke.\n     * @param {*} [thisArg] The `this` binding of `interceptor`.\n     * @returns {*} Returns the result of `interceptor`.\n     * @example\n     *\n     * _('  abc  ')\n     *  .chain()\n     *  .trim()\n     *  .thru(function(value) {\n     *    return [value];\n     *  })\n     *  .value();\n     * // => ['abc']\n     */\n    function thru(value, interceptor, thisArg) {\n      return interceptor.call(thisArg, value);\n    }\n\n    /**\n     * Enables explicit method chaining on the wrapper object.\n     *\n     * @name chain\n     * @memberOf _\n     * @category Chain\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney', 'age': 36 },\n     *   { 'user': 'fred',   'age': 40 }\n     * ];\n     *\n     * // without explicit chaining\n     * _(users).first();\n     * // => { 'user': 'barney', 'age': 36 }\n     *\n     * // with explicit chaining\n     * _(users).chain()\n     *   .first()\n     *   .pick('user')\n     *   .value();\n     * // => { 'user': 'barney' }\n     */\n    function wrapperChain() {\n      return chain(this);\n    }\n\n    /**\n     * Executes the chained sequence and returns the wrapped result.\n     *\n     * @name commit\n     * @memberOf _\n     * @category Chain\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * var array = [1, 2];\n     * var wrapped = _(array).push(3);\n     *\n     * console.log(array);\n     * // => [1, 2]\n     *\n     * wrapped = wrapped.commit();\n     * console.log(array);\n     * // => [1, 2, 3]\n     *\n     * wrapped.last();\n     * // => 3\n     *\n     * console.log(array);\n     * // => [1, 2, 3]\n     */\n    function wrapperCommit() {\n      return new LodashWrapper(this.value(), this.__chain__);\n    }\n\n    /**\n     * Creates a new array joining a wrapped array with any additional arrays\n     * and/or values.\n     *\n     * @name concat\n     * @memberOf _\n     * @category Chain\n     * @param {...*} [values] The values to concatenate.\n     * @returns {Array} Returns the new concatenated array.\n     * @example\n     *\n     * var array = [1];\n     * var wrapped = _(array).concat(2, [3], [[4]]);\n     *\n     * console.log(wrapped.value());\n     * // => [1, 2, 3, [4]]\n     *\n     * console.log(array);\n     * // => [1]\n     */\n    var wrapperConcat = restParam(function(values) {\n      values = baseFlatten(values);\n      return this.thru(function(array) {\n        return arrayConcat(isArray(array) ? array : [toObject(array)], values);\n      });\n    });\n\n    /**\n     * Creates a clone of the chained sequence planting `value` as the wrapped value.\n     *\n     * @name plant\n     * @memberOf _\n     * @category Chain\n     * @returns {Object} Returns the new `lodash` wrapper instance.\n     * @example\n     *\n     * var array = [1, 2];\n     * var wrapped = _(array).map(function(value) {\n     *   return Math.pow(value, 2);\n     * });\n     *\n     * var other = [3, 4];\n     * var otherWrapped = wrapped.plant(other);\n     *\n     * otherWrapped.value();\n     * // => [9, 16]\n     *\n     * wrapped.value();\n     * // => [1, 4]\n     */\n    function wrapperPlant(value) {\n      var result,\n          parent = this;\n\n      while (parent instanceof baseLodash) {\n        var clone = wrapperClone(parent);\n        if (result) {\n          previous.__wrapped__ = clone;\n        } else {\n          result = clone;\n        }\n        var previous = clone;\n        parent = parent.__wrapped__;\n      }\n      previous.__wrapped__ = value;\n      return result;\n    }\n\n    /**\n     * Reverses the wrapped array so the first element becomes the last, the\n     * second element becomes the second to last, and so on.\n     *\n     * **Note:** This method mutates the wrapped array.\n     *\n     * @name reverse\n     * @memberOf _\n     * @category Chain\n     * @returns {Object} Returns the new reversed `lodash` wrapper instance.\n     * @example\n     *\n     * var array = [1, 2, 3];\n     *\n     * _(array).reverse().value()\n     * // => [3, 2, 1]\n     *\n     * console.log(array);\n     * // => [3, 2, 1]\n     */\n    function wrapperReverse() {\n      var value = this.__wrapped__;\n\n      var interceptor = function(value) {\n        return (wrapped && wrapped.__dir__ < 0) ? value : value.reverse();\n      };\n      if (value instanceof LazyWrapper) {\n        var wrapped = value;\n        if (this.__actions__.length) {\n          wrapped = new LazyWrapper(this);\n        }\n        wrapped = wrapped.reverse();\n        wrapped.__actions__.push({ 'func': thru, 'args': [interceptor], 'thisArg': undefined });\n        return new LodashWrapper(wrapped, this.__chain__);\n      }\n      return this.thru(interceptor);\n    }\n\n    /**\n     * Produces the result of coercing the unwrapped value to a string.\n     *\n     * @name toString\n     * @memberOf _\n     * @category Chain\n     * @returns {string} Returns the coerced string value.\n     * @example\n     *\n     * _([1, 2, 3]).toString();\n     * // => '1,2,3'\n     */\n    function wrapperToString() {\n      return (this.value() + '');\n    }\n\n    /**\n     * Executes the chained sequence to extract the unwrapped value.\n     *\n     * @name value\n     * @memberOf _\n     * @alias run, toJSON, valueOf\n     * @category Chain\n     * @returns {*} Returns the resolved unwrapped value.\n     * @example\n     *\n     * _([1, 2, 3]).value();\n     * // => [1, 2, 3]\n     */\n    function wrapperValue() {\n      return baseWrapperValue(this.__wrapped__, this.__actions__);\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates an array of elements corresponding to the given keys, or indexes,\n     * of `collection`. Keys may be specified as individual arguments or as arrays\n     * of keys.\n     *\n     * @static\n     * @memberOf _\n     * @category Collection\n     * @param {Array|Object|string} collection The collection to iterate over.\n     * @param {...(number|number[]|string|string[])} [props] The property names\n     *  or indexes of elements to pick, specified individually or in arrays.\n     * @returns {Array} Returns the new array of picked elements.\n     * @example\n     *\n     * _.at(['a', 'b', 'c'], [0, 2]);\n     * // => ['a', 'c']\n     *\n     * _.at(['barney', 'fred', 'pebbles'], 0, 2);\n     * // => ['barney', 'pebbles']\n     */\n    var at = restParam(function(collection, props) {\n      return baseAt(collection, baseFlatten(props));\n    });\n\n    /**\n     * Creates an object composed of keys generated from the results of running\n     * each element of `collection` through `iteratee`. The corresponding value\n     * of each key is the number of times the key was returned by `iteratee`.\n     * The `iteratee` is bound to `thisArg` and invoked with three arguments:\n     * (value, index|key, collection).\n     *\n     * If a property name is provided for `iteratee` the created `_.property`\n     * style callback returns the property value of the given element.\n     *\n     * If a value is also provided for `thisArg` the created `_.matchesProperty`\n     * style callback returns `true` for elements that have a matching property\n     * value, else `false`.\n     *\n     * If an object is provided for `iteratee` the created `_.matches` style\n     * callback returns `true` for elements that have the properties of the given\n     * object, else `false`.\n     *\n     * @static\n     * @memberOf _\n     * @category Collection\n     * @param {Array|Object|string} collection The collection to iterate over.\n     * @param {Function|Object|string} [iteratee=_.identity] The function invoked\n     *  per iteration.\n     * @param {*} [thisArg] The `this` binding of `iteratee`.\n     * @returns {Object} Returns the composed aggregate object.\n     * @example\n     *\n     * _.countBy([4.3, 6.1, 6.4], function(n) {\n     *   return Math.floor(n);\n     * });\n     * // => { '4': 1, '6': 2 }\n     *\n     * _.countBy([4.3, 6.1, 6.4], function(n) {\n     *   return this.floor(n);\n     * }, Math);\n     * // => { '4': 1, '6': 2 }\n     *\n     * _.countBy(['one', 'two', 'three'], 'length');\n     * // => { '3': 2, '5': 1 }\n     */\n    var countBy = createAggregator(function(result, value, key) {\n      hasOwnProperty.call(result, key) ? ++result[key] : (result[key] = 1);\n    });\n\n    /**\n     * Checks if `predicate` returns truthy for **all** elements of `collection`.\n     * The predicate is bound to `thisArg` and invoked with three arguments:\n     * (value, index|key, collection).\n     *\n     * If a property name is provided for `predicate` the created `_.property`\n     * style callback returns the property value of the given element.\n     *\n     * If a value is also provided for `thisArg` the created `_.matchesProperty`\n     * style callback returns `true` for elements that have a matching property\n     * value, else `false`.\n     *\n     * If an object is provided for `predicate` the created `_.matches` style\n     * callback returns `true` for elements that have the properties of the given\n     * object, else `false`.\n     *\n     * @static\n     * @memberOf _\n     * @alias all\n     * @category Collection\n     * @param {Array|Object|string} collection The collection to iterate over.\n     * @param {Function|Object|string} [predicate=_.identity] The function invoked\n     *  per iteration.\n     * @param {*} [thisArg] The `this` binding of `predicate`.\n     * @returns {boolean} Returns `true` if all elements pass the predicate check,\n     *  else `false`.\n     * @example\n     *\n     * _.every([true, 1, null, 'yes'], Boolean);\n     * // => false\n     *\n     * var users = [\n     *   { 'user': 'barney', 'active': false },\n     *   { 'user': 'fred',   'active': false }\n     * ];\n     *\n     * // using the `_.matches` callback shorthand\n     * _.every(users, { 'user': 'barney', 'active': false });\n     * // => false\n     *\n     * // using the `_.matchesProperty` callback shorthand\n     * _.every(users, 'active', false);\n     * // => true\n     *\n     * // using the `_.property` callback shorthand\n     * _.every(users, 'active');\n     * // => false\n     */\n    function every(collection, predicate, thisArg) {\n      var func = isArray(collection) ? arrayEvery : baseEvery;\n      if (thisArg && isIterateeCall(collection, predicate, thisArg)) {\n        predicate = undefined;\n      }\n      if (typeof predicate != 'function' || thisArg !== undefined) {\n        predicate = getCallback(predicate, thisArg, 3);\n      }\n      return func(collection, predicate);\n    }\n\n    /**\n     * Iterates over elements of `collection`, returning an array of all elements\n     * `predicate` returns truthy for. The predicate is bound to `thisArg` and\n     * invoked with three arguments: (value, index|key, collection).\n     *\n     * If a property name is provided for `predicate` the created `_.property`\n     * style callback returns the property value of the given element.\n     *\n     * If a value is also provided for `thisArg` the created `_.matchesProperty`\n     * style callback returns `true` for elements that have a matching property\n     * value, else `false`.\n     *\n     * If an object is provided for `predicate` the created `_.matches` style\n     * callback returns `true` for elements that have the properties of the given\n     * object, else `false`.\n     *\n     * @static\n     * @memberOf _\n     * @alias select\n     * @category Collection\n     * @param {Array|Object|string} collection The collection to iterate over.\n     * @param {Function|Object|string} [predicate=_.identity] The function invoked\n     *  per iteration.\n     * @param {*} [thisArg] The `this` binding of `predicate`.\n     * @returns {Array} Returns the new filtered array.\n     * @example\n     *\n     * _.filter([4, 5, 6], function(n) {\n     *   return n % 2 == 0;\n     * });\n     * // => [4, 6]\n     *\n     * var users = [\n     *   { 'user': 'barney', 'age': 36, 'active': true },\n     *   { 'user': 'fred',   'age': 40, 'active': false }\n     * ];\n     *\n     * // using the `_.matches` callback shorthand\n     * _.pluck(_.filter(users, { 'age': 36, 'active': true }), 'user');\n     * // => ['barney']\n     *\n     * // using the `_.matchesProperty` callback shorthand\n     * _.pluck(_.filter(users, 'active', false), 'user');\n     * // => ['fred']\n     *\n     * // using the `_.property` callback shorthand\n     * _.pluck(_.filter(users, 'active'), 'user');\n     * // => ['barney']\n     */\n    function filter(collection, predicate, thisArg) {\n      var func = isArray(collection) ? arrayFilter : baseFilter;\n      predicate = getCallback(predicate, thisArg, 3);\n      return func(collection, predicate);\n    }\n\n    /**\n     * Iterates over elements of `collection`, returning the first element\n     * `predicate` returns truthy for. The predicate is bound to `thisArg` and\n     * invoked with three arguments: (value, index|key, collection).\n     *\n     * If a property name is provided for `predicate` the created `_.property`\n     * style callback returns the property value of the given element.\n     *\n     * If a value is also provided for `thisArg` the created `_.matchesProperty`\n     * style callback returns `true` for elements that have a matching property\n     * value, else `false`.\n     *\n     * If an object is provided for `predicate` the created `_.matches` style\n     * callback returns `true` for elements that have the properties of the given\n     * object, else `false`.\n     *\n     * @static\n     * @memberOf _\n     * @alias detect\n     * @category Collection\n     * @param {Array|Object|string} collection The collection to search.\n     * @param {Function|Object|string} [predicate=_.identity] The function invoked\n     *  per iteration.\n     * @param {*} [thisArg] The `this` binding of `predicate`.\n     * @returns {*} Returns the matched element, else `undefined`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney',  'age': 36, 'active': true },\n     *   { 'user': 'fred',    'age': 40, 'active': false },\n     *   { 'user': 'pebbles', 'age': 1,  'active': true }\n     * ];\n     *\n     * _.result(_.find(users, function(chr) {\n     *   return chr.age < 40;\n     * }), 'user');\n     * // => 'barney'\n     *\n     * // using the `_.matches` callback shorthand\n     * _.result(_.find(users, { 'age': 1, 'active': true }), 'user');\n     * // => 'pebbles'\n     *\n     * // using the `_.matchesProperty` callback shorthand\n     * _.result(_.find(users, 'active', false), 'user');\n     * // => 'fred'\n     *\n     * // using the `_.property` callback shorthand\n     * _.result(_.find(users, 'active'), 'user');\n     * // => 'barney'\n     */\n    var find = createFind(baseEach);\n\n    /**\n     * This method is like `_.find` except that it iterates over elements of\n     * `collection` from right to left.\n     *\n     * @static\n     * @memberOf _\n     * @category Collection\n     * @param {Array|Object|string} collection The collection to search.\n     * @param {Function|Object|string} [predicate=_.identity] The function invoked\n     *  per iteration.\n     * @param {*} [thisArg] The `this` binding of `predicate`.\n     * @returns {*} Returns the matched element, else `undefined`.\n     * @example\n     *\n     * _.findLast([1, 2, 3, 4], function(n) {\n     *   return n % 2 == 1;\n     * });\n     * // => 3\n     */\n    var findLast = createFind(baseEachRight, true);\n\n    /**\n     * Performs a deep comparison between each element in `collection` and the\n     * source object, returning the first element that has equivalent property\n     * values.\n     *\n     * **Note:** This method supports comparing arrays, booleans, `Date` objects,\n     * numbers, `Object` objects, regexes, and strings. Objects are compared by\n     * their own, not inherited, enumerable properties. For comparing a single\n     * own or inherited property value see `_.matchesProperty`.\n     *\n     * @static\n     * @memberOf _\n     * @category Collection\n     * @param {Array|Object|string} collection The collection to search.\n     * @param {Object} source The object of property values to match.\n     * @returns {*} Returns the matched element, else `undefined`.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney', 'age': 36, 'active': true },\n     *   { 'user': 'fred',   'age': 40, 'active': false }\n     * ];\n     *\n     * _.result(_.findWhere(users, { 'age': 36, 'active': true }), 'user');\n     * // => 'barney'\n     *\n     * _.result(_.findWhere(users, { 'age': 40, 'active': false }), 'user');\n     * // => 'fred'\n     */\n    function findWhere(collection, source) {\n      return find(collection, baseMatches(source));\n    }\n\n    /**\n     * Iterates over elements of `collection` invoking `iteratee` for each element.\n     * The `iteratee` is bound to `thisArg` and invoked with three arguments:\n     * (value, index|key, collection). Iteratee functions may exit iteration early\n     * by explicitly returning `false`.\n     *\n     * **Note:** As with other \"Collections\" methods, objects with a \"length\" property\n     * are iterated like arrays. To avoid this behavior `_.forIn` or `_.forOwn`\n     * may be used for object iteration.\n     *\n     * @static\n     * @memberOf _\n     * @alias each\n     * @category Collection\n     * @param {Array|Object|string} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @param {*} [thisArg] The `this` binding of `iteratee`.\n     * @returns {Array|Object|string} Returns `collection`.\n     * @example\n     *\n     * _([1, 2]).forEach(function(n) {\n     *   console.log(n);\n     * }).value();\n     * // => logs each value from left to right and returns the array\n     *\n     * _.forEach({ 'a': 1, 'b': 2 }, function(n, key) {\n     *   console.log(n, key);\n     * });\n     * // => logs each value-key pair and returns the object (iteration order is not guaranteed)\n     */\n    var forEach = createForEach(arrayEach, baseEach);\n\n    /**\n     * This method is like `_.forEach` except that it iterates over elements of\n     * `collection` from right to left.\n     *\n     * @static\n     * @memberOf _\n     * @alias eachRight\n     * @category Collection\n     * @param {Array|Object|string} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @param {*} [thisArg] The `this` binding of `iteratee`.\n     * @returns {Array|Object|string} Returns `collection`.\n     * @example\n     *\n     * _([1, 2]).forEachRight(function(n) {\n     *   console.log(n);\n     * }).value();\n     * // => logs each value from right to left and returns the array\n     */\n    var forEachRight = createForEach(arrayEachRight, baseEachRight);\n\n    /**\n     * Creates an object composed of keys generated from the results of running\n     * each element of `collection` through `iteratee`. The corresponding value\n     * of each key is an array of the elements responsible for generating the key.\n     * The `iteratee` is bound to `thisArg` and invoked with three arguments:\n     * (value, index|key, collection).\n     *\n     * If a property name is provided for `iteratee` the created `_.property`\n     * style callback returns the property value of the given element.\n     *\n     * If a value is also provided for `thisArg` the created `_.matchesProperty`\n     * style callback returns `true` for elements that have a matching property\n     * value, else `false`.\n     *\n     * If an object is provided for `iteratee` the created `_.matches` style\n     * callback returns `true` for elements that have the properties of the given\n     * object, else `false`.\n     *\n     * @static\n     * @memberOf _\n     * @category Collection\n     * @param {Array|Object|string} collection The collection to iterate over.\n     * @param {Function|Object|string} [iteratee=_.identity] The function invoked\n     *  per iteration.\n     * @param {*} [thisArg] The `this` binding of `iteratee`.\n     * @returns {Object} Returns the composed aggregate object.\n     * @example\n     *\n     * _.groupBy([4.2, 6.1, 6.4], function(n) {\n     *   return Math.floor(n);\n     * });\n     * // => { '4': [4.2], '6': [6.1, 6.4] }\n     *\n     * _.groupBy([4.2, 6.1, 6.4], function(n) {\n     *   return this.floor(n);\n     * }, Math);\n     * // => { '4': [4.2], '6': [6.1, 6.4] }\n     *\n     * // using the `_.property` callback shorthand\n     * _.groupBy(['one', 'two', 'three'], 'length');\n     * // => { '3': ['one', 'two'], '5': ['three'] }\n     */\n    var groupBy = createAggregator(function(result, value, key) {\n      if (hasOwnProperty.call(result, key)) {\n        result[key].push(value);\n      } else {\n        result[key] = [value];\n      }\n    });\n\n    /**\n     * Checks if `value` is in `collection` using\n     * [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero)\n     * for equality comparisons. If `fromIndex` is negative, it is used as the offset\n     * from the end of `collection`.\n     *\n     * @static\n     * @memberOf _\n     * @alias contains, include\n     * @category Collection\n     * @param {Array|Object|string} collection The collection to search.\n     * @param {*} target The value to search for.\n     * @param {number} [fromIndex=0] The index to search from.\n     * @param- {Object} [guard] Enables use as a callback for functions like `_.reduce`.\n     * @returns {boolean} Returns `true` if a matching element is found, else `false`.\n     * @example\n     *\n     * _.includes([1, 2, 3], 1);\n     * // => true\n     *\n     * _.includes([1, 2, 3], 1, 2);\n     * // => false\n     *\n     * _.includes({ 'user': 'fred', 'age': 40 }, 'fred');\n     * // => true\n     *\n     * _.includes('pebbles', 'eb');\n     * // => true\n     */\n    function includes(collection, target, fromIndex, guard) {\n      var length = collection ? getLength(collection) : 0;\n      if (!isLength(length)) {\n        collection = values(collection);\n        length = collection.length;\n      }\n      if (typeof fromIndex != 'number' || (guard && isIterateeCall(target, fromIndex, guard))) {\n        fromIndex = 0;\n      } else {\n        fromIndex = fromIndex < 0 ? nativeMax(length + fromIndex, 0) : (fromIndex || 0);\n      }\n      return (typeof collection == 'string' || !isArray(collection) && isString(collection))\n        ? (fromIndex <= length && collection.indexOf(target, fromIndex) > -1)\n        : (!!length && getIndexOf(collection, target, fromIndex) > -1);\n    }\n\n    /**\n     * Creates an object composed of keys generated from the results of running\n     * each element of `collection` through `iteratee`. The corresponding value\n     * of each key is the last element responsible for generating the key. The\n     * iteratee function is bound to `thisArg` and invoked with three arguments:\n     * (value, index|key, collection).\n     *\n     * If a property name is provided for `iteratee` the created `_.property`\n     * style callback returns the property value of the given element.\n     *\n     * If a value is also provided for `thisArg` the created `_.matchesProperty`\n     * style callback returns `true` for elements that have a matching property\n     * value, else `false`.\n     *\n     * If an object is provided for `iteratee` the created `_.matches` style\n     * callback returns `true` for elements that have the properties of the given\n     * object, else `false`.\n     *\n     * @static\n     * @memberOf _\n     * @category Collection\n     * @param {Array|Object|string} collection The collection to iterate over.\n     * @param {Function|Object|string} [iteratee=_.identity] The function invoked\n     *  per iteration.\n     * @param {*} [thisArg] The `this` binding of `iteratee`.\n     * @returns {Object} Returns the composed aggregate object.\n     * @example\n     *\n     * var keyData = [\n     *   { 'dir': 'left', 'code': 97 },\n     *   { 'dir': 'right', 'code': 100 }\n     * ];\n     *\n     * _.indexBy(keyData, 'dir');\n     * // => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } }\n     *\n     * _.indexBy(keyData, function(object) {\n     *   return String.fromCharCode(object.code);\n     * });\n     * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }\n     *\n     * _.indexBy(keyData, function(object) {\n     *   return this.fromCharCode(object.code);\n     * }, String);\n     * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }\n     */\n    var indexBy = createAggregator(function(result, value, key) {\n      result[key] = value;\n    });\n\n    /**\n     * Invokes the method at `path` of each element in `collection`, returning\n     * an array of the results of each invoked method. Any additional arguments\n     * are provided to each invoked method. If `methodName` is a function it is\n     * invoked for, and `this` bound to, each element in `collection`.\n     *\n     * @static\n     * @memberOf _\n     * @category Collection\n     * @param {Array|Object|string} collection The collection to iterate over.\n     * @param {Array|Function|string} path The path of the method to invoke or\n     *  the function invoked per iteration.\n     * @param {...*} [args] The arguments to invoke the method with.\n     * @returns {Array} Returns the array of results.\n     * @example\n     *\n     * _.invoke([[5, 1, 7], [3, 2, 1]], 'sort');\n     * // => [[1, 5, 7], [1, 2, 3]]\n     *\n     * _.invoke([123, 456], String.prototype.split, '');\n     * // => [['1', '2', '3'], ['4', '5', '6']]\n     */\n    var invoke = restParam(function(collection, path, args) {\n      var index = -1,\n          isFunc = typeof path == 'function',\n          isProp = isKey(path),\n          result = isArrayLike(collection) ? Array(collection.length) : [];\n\n      baseEach(collection, function(value) {\n        var func = isFunc ? path : ((isProp && value != null) ? value[path] : undefined);\n        result[++index] = func ? func.apply(value, args) : invokePath(value, path, args);\n      });\n      return result;\n    });\n\n    /**\n     * Creates an array of values by running each element in `collection` through\n     * `iteratee`. The `iteratee` is bound to `thisArg` and invoked with three\n     * arguments: (value, index|key, collection).\n     *\n     * If a property name is provided for `iteratee` the created `_.property`\n     * style callback returns the property value of the given element.\n     *\n     * If a value is also provided for `thisArg` the created `_.matchesProperty`\n     * style callback returns `true` for elements that have a matching property\n     * value, else `false`.\n     *\n     * If an object is provided for `iteratee` the created `_.matches` style\n     * callback returns `true` for elements that have the properties of the given\n     * object, else `false`.\n     *\n     * Many lodash methods are guarded to work as iteratees for methods like\n     * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`.\n     *\n     * The guarded methods are:\n     * `ary`, `callback`, `chunk`, `clone`, `create`, `curry`, `curryRight`,\n     * `drop`, `dropRight`, `every`, `fill`, `flatten`, `invert`, `max`, `min`,\n     * `parseInt`, `slice`, `sortBy`, `take`, `takeRight`, `template`, `trim`,\n     * `trimLeft`, `trimRight`, `trunc`, `random`, `range`, `sample`, `some`,\n     * `sum`, `uniq`, and `words`\n     *\n     * @static\n     * @memberOf _\n     * @alias collect\n     * @category Collection\n     * @param {Array|Object|string} collection The collection to iterate over.\n     * @param {Function|Object|string} [iteratee=_.identity] The function invoked\n     *  per iteration.\n     * @param {*} [thisArg] The `this` binding of `iteratee`.\n     * @returns {Array} Returns the new mapped array.\n     * @example\n     *\n     * function timesThree(n) {\n     *   return n * 3;\n     * }\n     *\n     * _.map([1, 2], timesThree);\n     * // => [3, 6]\n     *\n     * _.map({ 'a': 1, 'b': 2 }, timesThree);\n     * // => [3, 6] (iteration order is not guaranteed)\n     *\n     * var users = [\n     *   { 'user': 'barney' },\n     *   { 'user': 'fred' }\n     * ];\n     *\n     * // using the `_.property` callback shorthand\n     * _.map(users, 'user');\n     * // => ['barney', 'fred']\n     */\n    function map(collection, iteratee, thisArg) {\n      var func = isArray(collection) ? arrayMap : baseMap;\n      iteratee = getCallback(iteratee, thisArg, 3);\n      return func(collection, iteratee);\n    }\n\n    /**\n     * Creates an array of elements split into two groups, the first of which\n     * contains elements `predicate` returns truthy for, while the second of which\n     * contains elements `predicate` returns falsey for. The predicate is bound\n     * to `thisArg` and invoked with three arguments: (value, index|key, collection).\n     *\n     * If a property name is provided for `predicate` the created `_.property`\n     * style callback returns the property value of the given element.\n     *\n     * If a value is also provided for `thisArg` the created `_.matchesProperty`\n     * style callback returns `true` for elements that have a matching property\n     * value, else `false`.\n     *\n     * If an object is provided for `predicate` the created `_.matches` style\n     * callback returns `true` for elements that have the properties of the given\n     * object, else `false`.\n     *\n     * @static\n     * @memberOf _\n     * @category Collection\n     * @param {Array|Object|string} collection The collection to iterate over.\n     * @param {Function|Object|string} [predicate=_.identity] The function invoked\n     *  per iteration.\n     * @param {*} [thisArg] The `this` binding of `predicate`.\n     * @returns {Array} Returns the array of grouped elements.\n     * @example\n     *\n     * _.partition([1, 2, 3], function(n) {\n     *   return n % 2;\n     * });\n     * // => [[1, 3], [2]]\n     *\n     * _.partition([1.2, 2.3, 3.4], function(n) {\n     *   return this.floor(n) % 2;\n     * }, Math);\n     * // => [[1.2, 3.4], [2.3]]\n     *\n     * var users = [\n     *   { 'user': 'barney',  'age': 36, 'active': false },\n     *   { 'user': 'fred',    'age': 40, 'active': true },\n     *   { 'user': 'pebbles', 'age': 1,  'active': false }\n     * ];\n     *\n     * var mapper = function(array) {\n     *   return _.pluck(array, 'user');\n     * };\n     *\n     * // using the `_.matches` callback shorthand\n     * _.map(_.partition(users, { 'age': 1, 'active': false }), mapper);\n     * // => [['pebbles'], ['barney', 'fred']]\n     *\n     * // using the `_.matchesProperty` callback shorthand\n     * _.map(_.partition(users, 'active', false), mapper);\n     * // => [['barney', 'pebbles'], ['fred']]\n     *\n     * // using the `_.property` callback shorthand\n     * _.map(_.partition(users, 'active'), mapper);\n     * // => [['fred'], ['barney', 'pebbles']]\n     */\n    var partition = createAggregator(function(result, value, key) {\n      result[key ? 0 : 1].push(value);\n    }, function() { return [[], []]; });\n\n    /**\n     * Gets the property value of `path` from all elements in `collection`.\n     *\n     * @static\n     * @memberOf _\n     * @category Collection\n     * @param {Array|Object|string} collection The collection to iterate over.\n     * @param {Array|string} path The path of the property to pluck.\n     * @returns {Array} Returns the property values.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney', 'age': 36 },\n     *   { 'user': 'fred',   'age': 40 }\n     * ];\n     *\n     * _.pluck(users, 'user');\n     * // => ['barney', 'fred']\n     *\n     * var userIndex = _.indexBy(users, 'user');\n     * _.pluck(userIndex, 'age');\n     * // => [36, 40] (iteration order is not guaranteed)\n     */\n    function pluck(collection, path) {\n      return map(collection, property(path));\n    }\n\n    /**\n     * Reduces `collection` to a value which is the accumulated result of running\n     * each element in `collection` through `iteratee`, where each successive\n     * invocation is supplied the return value of the previous. If `accumulator`\n     * is not provided the first element of `collection` is used as the initial\n     * value. The `iteratee` is bound to `thisArg` and invoked with four arguments:\n     * (accumulator, value, index|key, collection).\n     *\n     * Many lodash methods are guarded to work as iteratees for methods like\n     * `_.reduce`, `_.reduceRight`, and `_.transform`.\n     *\n     * The guarded methods are:\n     * `assign`, `defaults`, `defaultsDeep`, `includes`, `merge`, `sortByAll`,\n     * and `sortByOrder`\n     *\n     * @static\n     * @memberOf _\n     * @alias foldl, inject\n     * @category Collection\n     * @param {Array|Object|string} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @param {*} [accumulator] The initial value.\n     * @param {*} [thisArg] The `this` binding of `iteratee`.\n     * @returns {*} Returns the accumulated value.\n     * @example\n     *\n     * _.reduce([1, 2], function(total, n) {\n     *   return total + n;\n     * });\n     * // => 3\n     *\n     * _.reduce({ 'a': 1, 'b': 2 }, function(result, n, key) {\n     *   result[key] = n * 3;\n     *   return result;\n     * }, {});\n     * // => { 'a': 3, 'b': 6 } (iteration order is not guaranteed)\n     */\n    var reduce = createReduce(arrayReduce, baseEach);\n\n    /**\n     * This method is like `_.reduce` except that it iterates over elements of\n     * `collection` from right to left.\n     *\n     * @static\n     * @memberOf _\n     * @alias foldr\n     * @category Collection\n     * @param {Array|Object|string} collection The collection to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @param {*} [accumulator] The initial value.\n     * @param {*} [thisArg] The `this` binding of `iteratee`.\n     * @returns {*} Returns the accumulated value.\n     * @example\n     *\n     * var array = [[0, 1], [2, 3], [4, 5]];\n     *\n     * _.reduceRight(array, function(flattened, other) {\n     *   return flattened.concat(other);\n     * }, []);\n     * // => [4, 5, 2, 3, 0, 1]\n     */\n    var reduceRight = createReduce(arrayReduceRight, baseEachRight);\n\n    /**\n     * The opposite of `_.filter`; this method returns the elements of `collection`\n     * that `predicate` does **not** return truthy for.\n     *\n     * @static\n     * @memberOf _\n     * @category Collection\n     * @param {Array|Object|string} collection The collection to iterate over.\n     * @param {Function|Object|string} [predicate=_.identity] The function invoked\n     *  per iteration.\n     * @param {*} [thisArg] The `this` binding of `predicate`.\n     * @returns {Array} Returns the new filtered array.\n     * @example\n     *\n     * _.reject([1, 2, 3, 4], function(n) {\n     *   return n % 2 == 0;\n     * });\n     * // => [1, 3]\n     *\n     * var users = [\n     *   { 'user': 'barney', 'age': 36, 'active': false },\n     *   { 'user': 'fred',   'age': 40, 'active': true }\n     * ];\n     *\n     * // using the `_.matches` callback shorthand\n     * _.pluck(_.reject(users, { 'age': 40, 'active': true }), 'user');\n     * // => ['barney']\n     *\n     * // using the `_.matchesProperty` callback shorthand\n     * _.pluck(_.reject(users, 'active', false), 'user');\n     * // => ['fred']\n     *\n     * // using the `_.property` callback shorthand\n     * _.pluck(_.reject(users, 'active'), 'user');\n     * // => ['barney']\n     */\n    function reject(collection, predicate, thisArg) {\n      var func = isArray(collection) ? arrayFilter : baseFilter;\n      predicate = getCallback(predicate, thisArg, 3);\n      return func(collection, function(value, index, collection) {\n        return !predicate(value, index, collection);\n      });\n    }\n\n    /**\n     * Gets a random element or `n` random elements from a collection.\n     *\n     * @static\n     * @memberOf _\n     * @category Collection\n     * @param {Array|Object|string} collection The collection to sample.\n     * @param {number} [n] The number of elements to sample.\n     * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.\n     * @returns {*} Returns the random sample(s).\n     * @example\n     *\n     * _.sample([1, 2, 3, 4]);\n     * // => 2\n     *\n     * _.sample([1, 2, 3, 4], 2);\n     * // => [3, 1]\n     */\n    function sample(collection, n, guard) {\n      if (guard ? isIterateeCall(collection, n, guard) : n == null) {\n        collection = toIterable(collection);\n        var length = collection.length;\n        return length > 0 ? collection[baseRandom(0, length - 1)] : undefined;\n      }\n      var index = -1,\n          result = toArray(collection),\n          length = result.length,\n          lastIndex = length - 1;\n\n      n = nativeMin(n < 0 ? 0 : (+n || 0), length);\n      while (++index < n) {\n        var rand = baseRandom(index, lastIndex),\n            value = result[rand];\n\n        result[rand] = result[index];\n        result[index] = value;\n      }\n      result.length = n;\n      return result;\n    }\n\n    /**\n     * Creates an array of shuffled values, using a version of the\n     * [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher-Yates_shuffle).\n     *\n     * @static\n     * @memberOf _\n     * @category Collection\n     * @param {Array|Object|string} collection The collection to shuffle.\n     * @returns {Array} Returns the new shuffled array.\n     * @example\n     *\n     * _.shuffle([1, 2, 3, 4]);\n     * // => [4, 1, 3, 2]\n     */\n    function shuffle(collection) {\n      return sample(collection, POSITIVE_INFINITY);\n    }\n\n    /**\n     * Gets the size of `collection` by returning its length for array-like\n     * values or the number of own enumerable properties for objects.\n     *\n     * @static\n     * @memberOf _\n     * @category Collection\n     * @param {Array|Object|string} collection The collection to inspect.\n     * @returns {number} Returns the size of `collection`.\n     * @example\n     *\n     * _.size([1, 2, 3]);\n     * // => 3\n     *\n     * _.size({ 'a': 1, 'b': 2 });\n     * // => 2\n     *\n     * _.size('pebbles');\n     * // => 7\n     */\n    function size(collection) {\n      var length = collection ? getLength(collection) : 0;\n      return isLength(length) ? length : keys(collection).length;\n    }\n\n    /**\n     * Checks if `predicate` returns truthy for **any** element of `collection`.\n     * The function returns as soon as it finds a passing value and does not iterate\n     * over the entire collection. The predicate is bound to `thisArg` and invoked\n     * with three arguments: (value, index|key, collection).\n     *\n     * If a property name is provided for `predicate` the created `_.property`\n     * style callback returns the property value of the given element.\n     *\n     * If a value is also provided for `thisArg` the created `_.matchesProperty`\n     * style callback returns `true` for elements that have a matching property\n     * value, else `false`.\n     *\n     * If an object is provided for `predicate` the created `_.matches` style\n     * callback returns `true` for elements that have the properties of the given\n     * object, else `false`.\n     *\n     * @static\n     * @memberOf _\n     * @alias any\n     * @category Collection\n     * @param {Array|Object|string} collection The collection to iterate over.\n     * @param {Function|Object|string} [predicate=_.identity] The function invoked\n     *  per iteration.\n     * @param {*} [thisArg] The `this` binding of `predicate`.\n     * @returns {boolean} Returns `true` if any element passes the predicate check,\n     *  else `false`.\n     * @example\n     *\n     * _.some([null, 0, 'yes', false], Boolean);\n     * // => true\n     *\n     * var users = [\n     *   { 'user': 'barney', 'active': true },\n     *   { 'user': 'fred',   'active': false }\n     * ];\n     *\n     * // using the `_.matches` callback shorthand\n     * _.some(users, { 'user': 'barney', 'active': false });\n     * // => false\n     *\n     * // using the `_.matchesProperty` callback shorthand\n     * _.some(users, 'active', false);\n     * // => true\n     *\n     * // using the `_.property` callback shorthand\n     * _.some(users, 'active');\n     * // => true\n     */\n    function some(collection, predicate, thisArg) {\n      var func = isArray(collection) ? arraySome : baseSome;\n      if (thisArg && isIterateeCall(collection, predicate, thisArg)) {\n        predicate = undefined;\n      }\n      if (typeof predicate != 'function' || thisArg !== undefined) {\n        predicate = getCallback(predicate, thisArg, 3);\n      }\n      return func(collection, predicate);\n    }\n\n    /**\n     * Creates an array of elements, sorted in ascending order by the results of\n     * running each element in a collection through `iteratee`. This method performs\n     * a stable sort, that is, it preserves the original sort order of equal elements.\n     * The `iteratee` is bound to `thisArg` and invoked with three arguments:\n     * (value, index|key, collection).\n     *\n     * If a property name is provided for `iteratee` the created `_.property`\n     * style callback returns the property value of the given element.\n     *\n     * If a value is also provided for `thisArg` the created `_.matchesProperty`\n     * style callback returns `true` for elements that have a matching property\n     * value, else `false`.\n     *\n     * If an object is provided for `iteratee` the created `_.matches` style\n     * callback returns `true` for elements that have the properties of the given\n     * object, else `false`.\n     *\n     * @static\n     * @memberOf _\n     * @category Collection\n     * @param {Array|Object|string} collection The collection to iterate over.\n     * @param {Function|Object|string} [iteratee=_.identity] The function invoked\n     *  per iteration.\n     * @param {*} [thisArg] The `this` binding of `iteratee`.\n     * @returns {Array} Returns the new sorted array.\n     * @example\n     *\n     * _.sortBy([1, 2, 3], function(n) {\n     *   return Math.sin(n);\n     * });\n     * // => [3, 1, 2]\n     *\n     * _.sortBy([1, 2, 3], function(n) {\n     *   return this.sin(n);\n     * }, Math);\n     * // => [3, 1, 2]\n     *\n     * var users = [\n     *   { 'user': 'fred' },\n     *   { 'user': 'pebbles' },\n     *   { 'user': 'barney' }\n     * ];\n     *\n     * // using the `_.property` callback shorthand\n     * _.pluck(_.sortBy(users, 'user'), 'user');\n     * // => ['barney', 'fred', 'pebbles']\n     */\n    function sortBy(collection, iteratee, thisArg) {\n      if (collection == null) {\n        return [];\n      }\n      if (thisArg && isIterateeCall(collection, iteratee, thisArg)) {\n        iteratee = undefined;\n      }\n      var index = -1;\n      iteratee = getCallback(iteratee, thisArg, 3);\n\n      var result = baseMap(collection, function(value, key, collection) {\n        return { 'criteria': iteratee(value, key, collection), 'index': ++index, 'value': value };\n      });\n      return baseSortBy(result, compareAscending);\n    }\n\n    /**\n     * This method is like `_.sortBy` except that it can sort by multiple iteratees\n     * or property names.\n     *\n     * If a property name is provided for an iteratee the created `_.property`\n     * style callback returns the property value of the given element.\n     *\n     * If an object is provided for an iteratee the created `_.matches` style\n     * callback returns `true` for elements that have the properties of the given\n     * object, else `false`.\n     *\n     * @static\n     * @memberOf _\n     * @category Collection\n     * @param {Array|Object|string} collection The collection to iterate over.\n     * @param {...(Function|Function[]|Object|Object[]|string|string[])} iteratees\n     *  The iteratees to sort by, specified as individual values or arrays of values.\n     * @returns {Array} Returns the new sorted array.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'fred',   'age': 48 },\n     *   { 'user': 'barney', 'age': 36 },\n     *   { 'user': 'fred',   'age': 42 },\n     *   { 'user': 'barney', 'age': 34 }\n     * ];\n     *\n     * _.map(_.sortByAll(users, ['user', 'age']), _.values);\n     * // => [['barney', 34], ['barney', 36], ['fred', 42], ['fred', 48]]\n     *\n     * _.map(_.sortByAll(users, 'user', function(chr) {\n     *   return Math.floor(chr.age / 10);\n     * }), _.values);\n     * // => [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 42]]\n     */\n    var sortByAll = restParam(function(collection, iteratees) {\n      if (collection == null) {\n        return [];\n      }\n      var guard = iteratees[2];\n      if (guard && isIterateeCall(iteratees[0], iteratees[1], guard)) {\n        iteratees.length = 1;\n      }\n      return baseSortByOrder(collection, baseFlatten(iteratees), []);\n    });\n\n    /**\n     * This method is like `_.sortByAll` except that it allows specifying the\n     * sort orders of the iteratees to sort by. If `orders` is unspecified, all\n     * values are sorted in ascending order. Otherwise, a value is sorted in\n     * ascending order if its corresponding order is \"asc\", and descending if \"desc\".\n     *\n     * If a property name is provided for an iteratee the created `_.property`\n     * style callback returns the property value of the given element.\n     *\n     * If an object is provided for an iteratee the created `_.matches` style\n     * callback returns `true` for elements that have the properties of the given\n     * object, else `false`.\n     *\n     * @static\n     * @memberOf _\n     * @category Collection\n     * @param {Array|Object|string} collection The collection to iterate over.\n     * @param {Function[]|Object[]|string[]} iteratees The iteratees to sort by.\n     * @param {boolean[]} [orders] The sort orders of `iteratees`.\n     * @param- {Object} [guard] Enables use as a callback for functions like `_.reduce`.\n     * @returns {Array} Returns the new sorted array.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'fred',   'age': 48 },\n     *   { 'user': 'barney', 'age': 34 },\n     *   { 'user': 'fred',   'age': 42 },\n     *   { 'user': 'barney', 'age': 36 }\n     * ];\n     *\n     * // sort by `user` in ascending order and by `age` in descending order\n     * _.map(_.sortByOrder(users, ['user', 'age'], ['asc', 'desc']), _.values);\n     * // => [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 42]]\n     */\n    function sortByOrder(collection, iteratees, orders, guard) {\n      if (collection == null) {\n        return [];\n      }\n      if (guard && isIterateeCall(iteratees, orders, guard)) {\n        orders = undefined;\n      }\n      if (!isArray(iteratees)) {\n        iteratees = iteratees == null ? [] : [iteratees];\n      }\n      if (!isArray(orders)) {\n        orders = orders == null ? [] : [orders];\n      }\n      return baseSortByOrder(collection, iteratees, orders);\n    }\n\n    /**\n     * Performs a deep comparison between each element in `collection` and the\n     * source object, returning an array of all elements that have equivalent\n     * property values.\n     *\n     * **Note:** This method supports comparing arrays, booleans, `Date` objects,\n     * numbers, `Object` objects, regexes, and strings. Objects are compared by\n     * their own, not inherited, enumerable properties. For comparing a single\n     * own or inherited property value see `_.matchesProperty`.\n     *\n     * @static\n     * @memberOf _\n     * @category Collection\n     * @param {Array|Object|string} collection The collection to search.\n     * @param {Object} source The object of property values to match.\n     * @returns {Array} Returns the new filtered array.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney', 'age': 36, 'active': false, 'pets': ['hoppy'] },\n     *   { 'user': 'fred',   'age': 40, 'active': true, 'pets': ['baby puss', 'dino'] }\n     * ];\n     *\n     * _.pluck(_.where(users, { 'age': 36, 'active': false }), 'user');\n     * // => ['barney']\n     *\n     * _.pluck(_.where(users, { 'pets': ['dino'] }), 'user');\n     * // => ['fred']\n     */\n    function where(collection, source) {\n      return filter(collection, baseMatches(source));\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Gets the number of milliseconds that have elapsed since the Unix epoch\n     * (1 January 1970 00:00:00 UTC).\n     *\n     * @static\n     * @memberOf _\n     * @category Date\n     * @example\n     *\n     * _.defer(function(stamp) {\n     *   console.log(_.now() - stamp);\n     * }, _.now());\n     * // => logs the number of milliseconds it took for the deferred function to be invoked\n     */\n    var now = nativeNow || function() {\n      return new Date().getTime();\n    };\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * The opposite of `_.before`; this method creates a function that invokes\n     * `func` once it is called `n` or more times.\n     *\n     * @static\n     * @memberOf _\n     * @category Function\n     * @param {number} n The number of calls before `func` is invoked.\n     * @param {Function} func The function to restrict.\n     * @returns {Function} Returns the new restricted function.\n     * @example\n     *\n     * var saves = ['profile', 'settings'];\n     *\n     * var done = _.after(saves.length, function() {\n     *   console.log('done saving!');\n     * });\n     *\n     * _.forEach(saves, function(type) {\n     *   asyncSave({ 'type': type, 'complete': done });\n     * });\n     * // => logs 'done saving!' after the two async saves have completed\n     */\n    function after(n, func) {\n      if (typeof func != 'function') {\n        if (typeof n == 'function') {\n          var temp = n;\n          n = func;\n          func = temp;\n        } else {\n          throw new TypeError(FUNC_ERROR_TEXT);\n        }\n      }\n      n = nativeIsFinite(n = +n) ? n : 0;\n      return function() {\n        if (--n < 1) {\n          return func.apply(this, arguments);\n        }\n      };\n    }\n\n    /**\n     * Creates a function that accepts up to `n` arguments ignoring any\n     * additional arguments.\n     *\n     * @static\n     * @memberOf _\n     * @category Function\n     * @param {Function} func The function to cap arguments for.\n     * @param {number} [n=func.length] The arity cap.\n     * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * _.map(['6', '8', '10'], _.ary(parseInt, 1));\n     * // => [6, 8, 10]\n     */\n    function ary(func, n, guard) {\n      if (guard && isIterateeCall(func, n, guard)) {\n        n = undefined;\n      }\n      n = (func && n == null) ? func.length : nativeMax(+n || 0, 0);\n      return createWrapper(func, ARY_FLAG, undefined, undefined, undefined, undefined, n);\n    }\n\n    /**\n     * Creates a function that invokes `func`, with the `this` binding and arguments\n     * of the created function, while it is called less than `n` times. Subsequent\n     * calls to the created function return the result of the last `func` invocation.\n     *\n     * @static\n     * @memberOf _\n     * @category Function\n     * @param {number} n The number of calls at which `func` is no longer invoked.\n     * @param {Function} func The function to restrict.\n     * @returns {Function} Returns the new restricted function.\n     * @example\n     *\n     * jQuery('#add').on('click', _.before(5, addContactToList));\n     * // => allows adding up to 4 contacts to the list\n     */\n    function before(n, func) {\n      var result;\n      if (typeof func != 'function') {\n        if (typeof n == 'function') {\n          var temp = n;\n          n = func;\n          func = temp;\n        } else {\n          throw new TypeError(FUNC_ERROR_TEXT);\n        }\n      }\n      return function() {\n        if (--n > 0) {\n          result = func.apply(this, arguments);\n        }\n        if (n <= 1) {\n          func = undefined;\n        }\n        return result;\n      };\n    }\n\n    /**\n     * Creates a function that invokes `func` with the `this` binding of `thisArg`\n     * and prepends any additional `_.bind` arguments to those provided to the\n     * bound function.\n     *\n     * The `_.bind.placeholder` value, which defaults to `_` in monolithic builds,\n     * may be used as a placeholder for partially applied arguments.\n     *\n     * **Note:** Unlike native `Function#bind` this method does not set the \"length\"\n     * property of bound functions.\n     *\n     * @static\n     * @memberOf _\n     * @category Function\n     * @param {Function} func The function to bind.\n     * @param {*} thisArg The `this` binding of `func`.\n     * @param {...*} [partials] The arguments to be partially applied.\n     * @returns {Function} Returns the new bound function.\n     * @example\n     *\n     * var greet = function(greeting, punctuation) {\n     *   return greeting + ' ' + this.user + punctuation;\n     * };\n     *\n     * var object = { 'user': 'fred' };\n     *\n     * var bound = _.bind(greet, object, 'hi');\n     * bound('!');\n     * // => 'hi fred!'\n     *\n     * // using placeholders\n     * var bound = _.bind(greet, object, _, '!');\n     * bound('hi');\n     * // => 'hi fred!'\n     */\n    var bind = restParam(function(func, thisArg, partials) {\n      var bitmask = BIND_FLAG;\n      if (partials.length) {\n        var holders = replaceHolders(partials, bind.placeholder);\n        bitmask |= PARTIAL_FLAG;\n      }\n      return createWrapper(func, bitmask, thisArg, partials, holders);\n    });\n\n    /**\n     * Binds methods of an object to the object itself, overwriting the existing\n     * method. Method names may be specified as individual arguments or as arrays\n     * of method names. If no method names are provided all enumerable function\n     * properties, own and inherited, of `object` are bound.\n     *\n     * **Note:** This method does not set the \"length\" property of bound functions.\n     *\n     * @static\n     * @memberOf _\n     * @category Function\n     * @param {Object} object The object to bind and assign the bound methods to.\n     * @param {...(string|string[])} [methodNames] The object method names to bind,\n     *  specified as individual method names or arrays of method names.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * var view = {\n     *   'label': 'docs',\n     *   'onClick': function() {\n     *     console.log('clicked ' + this.label);\n     *   }\n     * };\n     *\n     * _.bindAll(view);\n     * jQuery('#docs').on('click', view.onClick);\n     * // => logs 'clicked docs' when the element is clicked\n     */\n    var bindAll = restParam(function(object, methodNames) {\n      methodNames = methodNames.length ? baseFlatten(methodNames) : functions(object);\n\n      var index = -1,\n          length = methodNames.length;\n\n      while (++index < length) {\n        var key = methodNames[index];\n        object[key] = createWrapper(object[key], BIND_FLAG, object);\n      }\n      return object;\n    });\n\n    /**\n     * Creates a function that invokes the method at `object[key]` and prepends\n     * any additional `_.bindKey` arguments to those provided to the bound function.\n     *\n     * This method differs from `_.bind` by allowing bound functions to reference\n     * methods that may be redefined or don't yet exist.\n     * See [Peter Michaux's article](http://peter.michaux.ca/articles/lazy-function-definition-pattern)\n     * for more details.\n     *\n     * The `_.bindKey.placeholder` value, which defaults to `_` in monolithic\n     * builds, may be used as a placeholder for partially applied arguments.\n     *\n     * @static\n     * @memberOf _\n     * @category Function\n     * @param {Object} object The object the method belongs to.\n     * @param {string} key The key of the method.\n     * @param {...*} [partials] The arguments to be partially applied.\n     * @returns {Function} Returns the new bound function.\n     * @example\n     *\n     * var object = {\n     *   'user': 'fred',\n     *   'greet': function(greeting, punctuation) {\n     *     return greeting + ' ' + this.user + punctuation;\n     *   }\n     * };\n     *\n     * var bound = _.bindKey(object, 'greet', 'hi');\n     * bound('!');\n     * // => 'hi fred!'\n     *\n     * object.greet = function(greeting, punctuation) {\n     *   return greeting + 'ya ' + this.user + punctuation;\n     * };\n     *\n     * bound('!');\n     * // => 'hiya fred!'\n     *\n     * // using placeholders\n     * var bound = _.bindKey(object, 'greet', _, '!');\n     * bound('hi');\n     * // => 'hiya fred!'\n     */\n    var bindKey = restParam(function(object, key, partials) {\n      var bitmask = BIND_FLAG | BIND_KEY_FLAG;\n      if (partials.length) {\n        var holders = replaceHolders(partials, bindKey.placeholder);\n        bitmask |= PARTIAL_FLAG;\n      }\n      return createWrapper(key, bitmask, object, partials, holders);\n    });\n\n    /**\n     * Creates a function that accepts one or more arguments of `func` that when\n     * called either invokes `func` returning its result, if all `func` arguments\n     * have been provided, or returns a function that accepts one or more of the\n     * remaining `func` arguments, and so on. The arity of `func` may be specified\n     * if `func.length` is not sufficient.\n     *\n     * The `_.curry.placeholder` value, which defaults to `_` in monolithic builds,\n     * may be used as a placeholder for provided arguments.\n     *\n     * **Note:** This method does not set the \"length\" property of curried functions.\n     *\n     * @static\n     * @memberOf _\n     * @category Function\n     * @param {Function} func The function to curry.\n     * @param {number} [arity=func.length] The arity of `func`.\n     * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.\n     * @returns {Function} Returns the new curried function.\n     * @example\n     *\n     * var abc = function(a, b, c) {\n     *   return [a, b, c];\n     * };\n     *\n     * var curried = _.curry(abc);\n     *\n     * curried(1)(2)(3);\n     * // => [1, 2, 3]\n     *\n     * curried(1, 2)(3);\n     * // => [1, 2, 3]\n     *\n     * curried(1, 2, 3);\n     * // => [1, 2, 3]\n     *\n     * // using placeholders\n     * curried(1)(_, 3)(2);\n     * // => [1, 2, 3]\n     */\n    var curry = createCurry(CURRY_FLAG);\n\n    /**\n     * This method is like `_.curry` except that arguments are applied to `func`\n     * in the manner of `_.partialRight` instead of `_.partial`.\n     *\n     * The `_.curryRight.placeholder` value, which defaults to `_` in monolithic\n     * builds, may be used as a placeholder for provided arguments.\n     *\n     * **Note:** This method does not set the \"length\" property of curried functions.\n     *\n     * @static\n     * @memberOf _\n     * @category Function\n     * @param {Function} func The function to curry.\n     * @param {number} [arity=func.length] The arity of `func`.\n     * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.\n     * @returns {Function} Returns the new curried function.\n     * @example\n     *\n     * var abc = function(a, b, c) {\n     *   return [a, b, c];\n     * };\n     *\n     * var curried = _.curryRight(abc);\n     *\n     * curried(3)(2)(1);\n     * // => [1, 2, 3]\n     *\n     * curried(2, 3)(1);\n     * // => [1, 2, 3]\n     *\n     * curried(1, 2, 3);\n     * // => [1, 2, 3]\n     *\n     * // using placeholders\n     * curried(3)(1, _)(2);\n     * // => [1, 2, 3]\n     */\n    var curryRight = createCurry(CURRY_RIGHT_FLAG);\n\n    /**\n     * Creates a debounced function that delays invoking `func` until after `wait`\n     * milliseconds have elapsed since the last time the debounced function was\n     * invoked. The debounced function comes with a `cancel` method to cancel\n     * delayed invocations. Provide an options object to indicate that `func`\n     * should be invoked on the leading and/or trailing edge of the `wait` timeout.\n     * Subsequent calls to the debounced function return the result of the last\n     * `func` invocation.\n     *\n     * **Note:** If `leading` and `trailing` options are `true`, `func` is invoked\n     * on the trailing edge of the timeout only if the the debounced function is\n     * invoked more than once during the `wait` timeout.\n     *\n     * See [David Corbacho's article](http://drupalmotion.com/article/debounce-and-throttle-visual-explanation)\n     * for details over the differences between `_.debounce` and `_.throttle`.\n     *\n     * @static\n     * @memberOf _\n     * @category Function\n     * @param {Function} func The function to debounce.\n     * @param {number} [wait=0] The number of milliseconds to delay.\n     * @param {Object} [options] The options object.\n     * @param {boolean} [options.leading=false] Specify invoking on the leading\n     *  edge of the timeout.\n     * @param {number} [options.maxWait] The maximum time `func` is allowed to be\n     *  delayed before it is invoked.\n     * @param {boolean} [options.trailing=true] Specify invoking on the trailing\n     *  edge of the timeout.\n     * @returns {Function} Returns the new debounced function.\n     * @example\n     *\n     * // avoid costly calculations while the window size is in flux\n     * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n     *\n     * // invoke `sendMail` when the click event is fired, debouncing subsequent calls\n     * jQuery('#postbox').on('click', _.debounce(sendMail, 300, {\n     *   'leading': true,\n     *   'trailing': false\n     * }));\n     *\n     * // ensure `batchLog` is invoked once after 1 second of debounced calls\n     * var source = new EventSource('/stream');\n     * jQuery(source).on('message', _.debounce(batchLog, 250, {\n     *   'maxWait': 1000\n     * }));\n     *\n     * // cancel a debounced call\n     * var todoChanges = _.debounce(batchLog, 1000);\n     * Object.observe(models.todo, todoChanges);\n     *\n     * Object.observe(models, function(changes) {\n     *   if (_.find(changes, { 'user': 'todo', 'type': 'delete'})) {\n     *     todoChanges.cancel();\n     *   }\n     * }, ['delete']);\n     *\n     * // ...at some point `models.todo` is changed\n     * models.todo.completed = true;\n     *\n     * // ...before 1 second has passed `models.todo` is deleted\n     * // which cancels the debounced `todoChanges` call\n     * delete models.todo;\n     */\n    function debounce(func, wait, options) {\n      var args,\n          maxTimeoutId,\n          result,\n          stamp,\n          thisArg,\n          timeoutId,\n          trailingCall,\n          lastCalled = 0,\n          maxWait = false,\n          trailing = true;\n\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      wait = wait < 0 ? 0 : (+wait || 0);\n      if (options === true) {\n        var leading = true;\n        trailing = false;\n      } else if (isObject(options)) {\n        leading = !!options.leading;\n        maxWait = 'maxWait' in options && nativeMax(+options.maxWait || 0, wait);\n        trailing = 'trailing' in options ? !!options.trailing : trailing;\n      }\n\n      function cancel() {\n        if (timeoutId) {\n          clearTimeout(timeoutId);\n        }\n        if (maxTimeoutId) {\n          clearTimeout(maxTimeoutId);\n        }\n        lastCalled = 0;\n        maxTimeoutId = timeoutId = trailingCall = undefined;\n      }\n\n      function complete(isCalled, id) {\n        if (id) {\n          clearTimeout(id);\n        }\n        maxTimeoutId = timeoutId = trailingCall = undefined;\n        if (isCalled) {\n          lastCalled = now();\n          result = func.apply(thisArg, args);\n          if (!timeoutId && !maxTimeoutId) {\n            args = thisArg = undefined;\n          }\n        }\n      }\n\n      function delayed() {\n        var remaining = wait - (now() - stamp);\n        if (remaining <= 0 || remaining > wait) {\n          complete(trailingCall, maxTimeoutId);\n        } else {\n          timeoutId = setTimeout(delayed, remaining);\n        }\n      }\n\n      function maxDelayed() {\n        complete(trailing, timeoutId);\n      }\n\n      function debounced() {\n        args = arguments;\n        stamp = now();\n        thisArg = this;\n        trailingCall = trailing && (timeoutId || !leading);\n\n        if (maxWait === false) {\n          var leadingCall = leading && !timeoutId;\n        } else {\n          if (!maxTimeoutId && !leading) {\n            lastCalled = stamp;\n          }\n          var remaining = maxWait - (stamp - lastCalled),\n              isCalled = remaining <= 0 || remaining > maxWait;\n\n          if (isCalled) {\n            if (maxTimeoutId) {\n              maxTimeoutId = clearTimeout(maxTimeoutId);\n            }\n            lastCalled = stamp;\n            result = func.apply(thisArg, args);\n          }\n          else if (!maxTimeoutId) {\n            maxTimeoutId = setTimeout(maxDelayed, remaining);\n          }\n        }\n        if (isCalled && timeoutId) {\n          timeoutId = clearTimeout(timeoutId);\n        }\n        else if (!timeoutId && wait !== maxWait) {\n          timeoutId = setTimeout(delayed, wait);\n        }\n        if (leadingCall) {\n          isCalled = true;\n          result = func.apply(thisArg, args);\n        }\n        if (isCalled && !timeoutId && !maxTimeoutId) {\n          args = thisArg = undefined;\n        }\n        return result;\n      }\n      debounced.cancel = cancel;\n      return debounced;\n    }\n\n    /**\n     * Defers invoking the `func` until the current call stack has cleared. Any\n     * additional arguments are provided to `func` when it is invoked.\n     *\n     * @static\n     * @memberOf _\n     * @category Function\n     * @param {Function} func The function to defer.\n     * @param {...*} [args] The arguments to invoke the function with.\n     * @returns {number} Returns the timer id.\n     * @example\n     *\n     * _.defer(function(text) {\n     *   console.log(text);\n     * }, 'deferred');\n     * // logs 'deferred' after one or more milliseconds\n     */\n    var defer = restParam(function(func, args) {\n      return baseDelay(func, 1, args);\n    });\n\n    /**\n     * Invokes `func` after `wait` milliseconds. Any additional arguments are\n     * provided to `func` when it is invoked.\n     *\n     * @static\n     * @memberOf _\n     * @category Function\n     * @param {Function} func The function to delay.\n     * @param {number} wait The number of milliseconds to delay invocation.\n     * @param {...*} [args] The arguments to invoke the function with.\n     * @returns {number} Returns the timer id.\n     * @example\n     *\n     * _.delay(function(text) {\n     *   console.log(text);\n     * }, 1000, 'later');\n     * // => logs 'later' after one second\n     */\n    var delay = restParam(function(func, wait, args) {\n      return baseDelay(func, wait, args);\n    });\n\n    /**\n     * Creates a function that returns the result of invoking the provided\n     * functions with the `this` binding of the created function, where each\n     * successive invocation is supplied the return value of the previous.\n     *\n     * @static\n     * @memberOf _\n     * @category Function\n     * @param {...Function} [funcs] Functions to invoke.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * function square(n) {\n     *   return n * n;\n     * }\n     *\n     * var addSquare = _.flow(_.add, square);\n     * addSquare(1, 2);\n     * // => 9\n     */\n    var flow = createFlow();\n\n    /**\n     * This method is like `_.flow` except that it creates a function that\n     * invokes the provided functions from right to left.\n     *\n     * @static\n     * @memberOf _\n     * @alias backflow, compose\n     * @category Function\n     * @param {...Function} [funcs] Functions to invoke.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * function square(n) {\n     *   return n * n;\n     * }\n     *\n     * var addSquare = _.flowRight(square, _.add);\n     * addSquare(1, 2);\n     * // => 9\n     */\n    var flowRight = createFlow(true);\n\n    /**\n     * Creates a function that memoizes the result of `func`. If `resolver` is\n     * provided it determines the cache key for storing the result based on the\n     * arguments provided to the memoized function. By default, the first argument\n     * provided to the memoized function is coerced to a string and used as the\n     * cache key. The `func` is invoked with the `this` binding of the memoized\n     * function.\n     *\n     * **Note:** The cache is exposed as the `cache` property on the memoized\n     * function. Its creation may be customized by replacing the `_.memoize.Cache`\n     * constructor with one whose instances implement the [`Map`](http://ecma-international.org/ecma-262/6.0/#sec-properties-of-the-map-prototype-object)\n     * method interface of `get`, `has`, and `set`.\n     *\n     * @static\n     * @memberOf _\n     * @category Function\n     * @param {Function} func The function to have its output memoized.\n     * @param {Function} [resolver] The function to resolve the cache key.\n     * @returns {Function} Returns the new memoizing function.\n     * @example\n     *\n     * var upperCase = _.memoize(function(string) {\n     *   return string.toUpperCase();\n     * });\n     *\n     * upperCase('fred');\n     * // => 'FRED'\n     *\n     * // modifying the result cache\n     * upperCase.cache.set('fred', 'BARNEY');\n     * upperCase('fred');\n     * // => 'BARNEY'\n     *\n     * // replacing `_.memoize.Cache`\n     * var object = { 'user': 'fred' };\n     * var other = { 'user': 'barney' };\n     * var identity = _.memoize(_.identity);\n     *\n     * identity(object);\n     * // => { 'user': 'fred' }\n     * identity(other);\n     * // => { 'user': 'fred' }\n     *\n     * _.memoize.Cache = WeakMap;\n     * var identity = _.memoize(_.identity);\n     *\n     * identity(object);\n     * // => { 'user': 'fred' }\n     * identity(other);\n     * // => { 'user': 'barney' }\n     */\n    function memoize(func, resolver) {\n      if (typeof func != 'function' || (resolver && typeof resolver != 'function')) {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      var memoized = function() {\n        var args = arguments,\n            key = resolver ? resolver.apply(this, args) : args[0],\n            cache = memoized.cache;\n\n        if (cache.has(key)) {\n          return cache.get(key);\n        }\n        var result = func.apply(this, args);\n        memoized.cache = cache.set(key, result);\n        return result;\n      };\n      memoized.cache = new memoize.Cache;\n      return memoized;\n    }\n\n    /**\n     * Creates a function that runs each argument through a corresponding\n     * transform function.\n     *\n     * @static\n     * @memberOf _\n     * @category Function\n     * @param {Function} func The function to wrap.\n     * @param {...(Function|Function[])} [transforms] The functions to transform\n     * arguments, specified as individual functions or arrays of functions.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * function doubled(n) {\n     *   return n * 2;\n     * }\n     *\n     * function square(n) {\n     *   return n * n;\n     * }\n     *\n     * var modded = _.modArgs(function(x, y) {\n     *   return [x, y];\n     * }, square, doubled);\n     *\n     * modded(1, 2);\n     * // => [1, 4]\n     *\n     * modded(5, 10);\n     * // => [25, 20]\n     */\n    var modArgs = restParam(function(func, transforms) {\n      transforms = baseFlatten(transforms);\n      if (typeof func != 'function' || !arrayEvery(transforms, baseIsFunction)) {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      var length = transforms.length;\n      return restParam(function(args) {\n        var index = nativeMin(args.length, length);\n        while (index--) {\n          args[index] = transforms[index](args[index]);\n        }\n        return func.apply(this, args);\n      });\n    });\n\n    /**\n     * Creates a function that negates the result of the predicate `func`. The\n     * `func` predicate is invoked with the `this` binding and arguments of the\n     * created function.\n     *\n     * @static\n     * @memberOf _\n     * @category Function\n     * @param {Function} predicate The predicate to negate.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * function isEven(n) {\n     *   return n % 2 == 0;\n     * }\n     *\n     * _.filter([1, 2, 3, 4, 5, 6], _.negate(isEven));\n     * // => [1, 3, 5]\n     */\n    function negate(predicate) {\n      if (typeof predicate != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      return function() {\n        return !predicate.apply(this, arguments);\n      };\n    }\n\n    /**\n     * Creates a function that is restricted to invoking `func` once. Repeat calls\n     * to the function return the value of the first call. The `func` is invoked\n     * with the `this` binding and arguments of the created function.\n     *\n     * @static\n     * @memberOf _\n     * @category Function\n     * @param {Function} func The function to restrict.\n     * @returns {Function} Returns the new restricted function.\n     * @example\n     *\n     * var initialize = _.once(createApplication);\n     * initialize();\n     * initialize();\n     * // `initialize` invokes `createApplication` once\n     */\n    function once(func) {\n      return before(2, func);\n    }\n\n    /**\n     * Creates a function that invokes `func` with `partial` arguments prepended\n     * to those provided to the new function. This method is like `_.bind` except\n     * it does **not** alter the `this` binding.\n     *\n     * The `_.partial.placeholder` value, which defaults to `_` in monolithic\n     * builds, may be used as a placeholder for partially applied arguments.\n     *\n     * **Note:** This method does not set the \"length\" property of partially\n     * applied functions.\n     *\n     * @static\n     * @memberOf _\n     * @category Function\n     * @param {Function} func The function to partially apply arguments to.\n     * @param {...*} [partials] The arguments to be partially applied.\n     * @returns {Function} Returns the new partially applied function.\n     * @example\n     *\n     * var greet = function(greeting, name) {\n     *   return greeting + ' ' + name;\n     * };\n     *\n     * var sayHelloTo = _.partial(greet, 'hello');\n     * sayHelloTo('fred');\n     * // => 'hello fred'\n     *\n     * // using placeholders\n     * var greetFred = _.partial(greet, _, 'fred');\n     * greetFred('hi');\n     * // => 'hi fred'\n     */\n    var partial = createPartial(PARTIAL_FLAG);\n\n    /**\n     * This method is like `_.partial` except that partially applied arguments\n     * are appended to those provided to the new function.\n     *\n     * The `_.partialRight.placeholder` value, which defaults to `_` in monolithic\n     * builds, may be used as a placeholder for partially applied arguments.\n     *\n     * **Note:** This method does not set the \"length\" property of partially\n     * applied functions.\n     *\n     * @static\n     * @memberOf _\n     * @category Function\n     * @param {Function} func The function to partially apply arguments to.\n     * @param {...*} [partials] The arguments to be partially applied.\n     * @returns {Function} Returns the new partially applied function.\n     * @example\n     *\n     * var greet = function(greeting, name) {\n     *   return greeting + ' ' + name;\n     * };\n     *\n     * var greetFred = _.partialRight(greet, 'fred');\n     * greetFred('hi');\n     * // => 'hi fred'\n     *\n     * // using placeholders\n     * var sayHelloTo = _.partialRight(greet, 'hello', _);\n     * sayHelloTo('fred');\n     * // => 'hello fred'\n     */\n    var partialRight = createPartial(PARTIAL_RIGHT_FLAG);\n\n    /**\n     * Creates a function that invokes `func` with arguments arranged according\n     * to the specified indexes where the argument value at the first index is\n     * provided as the first argument, the argument value at the second index is\n     * provided as the second argument, and so on.\n     *\n     * @static\n     * @memberOf _\n     * @category Function\n     * @param {Function} func The function to rearrange arguments for.\n     * @param {...(number|number[])} indexes The arranged argument indexes,\n     *  specified as individual indexes or arrays of indexes.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var rearged = _.rearg(function(a, b, c) {\n     *   return [a, b, c];\n     * }, 2, 0, 1);\n     *\n     * rearged('b', 'c', 'a')\n     * // => ['a', 'b', 'c']\n     *\n     * var map = _.rearg(_.map, [1, 0]);\n     * map(function(n) {\n     *   return n * 3;\n     * }, [1, 2, 3]);\n     * // => [3, 6, 9]\n     */\n    var rearg = restParam(function(func, indexes) {\n      return createWrapper(func, REARG_FLAG, undefined, undefined, undefined, baseFlatten(indexes));\n    });\n\n    /**\n     * Creates a function that invokes `func` with the `this` binding of the\n     * created function and arguments from `start` and beyond provided as an array.\n     *\n     * **Note:** This method is based on the [rest parameter](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters).\n     *\n     * @static\n     * @memberOf _\n     * @category Function\n     * @param {Function} func The function to apply a rest parameter to.\n     * @param {number} [start=func.length-1] The start position of the rest parameter.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var say = _.restParam(function(what, names) {\n     *   return what + ' ' + _.initial(names).join(', ') +\n     *     (_.size(names) > 1 ? ', & ' : '') + _.last(names);\n     * });\n     *\n     * say('hello', 'fred', 'barney', 'pebbles');\n     * // => 'hello fred, barney, & pebbles'\n     */\n    function restParam(func, start) {\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      start = nativeMax(start === undefined ? (func.length - 1) : (+start || 0), 0);\n      return function() {\n        var args = arguments,\n            index = -1,\n            length = nativeMax(args.length - start, 0),\n            rest = Array(length);\n\n        while (++index < length) {\n          rest[index] = args[start + index];\n        }\n        switch (start) {\n          case 0: return func.call(this, rest);\n          case 1: return func.call(this, args[0], rest);\n          case 2: return func.call(this, args[0], args[1], rest);\n        }\n        var otherArgs = Array(start + 1);\n        index = -1;\n        while (++index < start) {\n          otherArgs[index] = args[index];\n        }\n        otherArgs[start] = rest;\n        return func.apply(this, otherArgs);\n      };\n    }\n\n    /**\n     * Creates a function that invokes `func` with the `this` binding of the created\n     * function and an array of arguments much like [`Function#apply`](https://es5.github.io/#x15.3.4.3).\n     *\n     * **Note:** This method is based on the [spread operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Spread_operator).\n     *\n     * @static\n     * @memberOf _\n     * @category Function\n     * @param {Function} func The function to spread arguments over.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var say = _.spread(function(who, what) {\n     *   return who + ' says ' + what;\n     * });\n     *\n     * say(['fred', 'hello']);\n     * // => 'fred says hello'\n     *\n     * // with a Promise\n     * var numbers = Promise.all([\n     *   Promise.resolve(40),\n     *   Promise.resolve(36)\n     * ]);\n     *\n     * numbers.then(_.spread(function(x, y) {\n     *   return x + y;\n     * }));\n     * // => a Promise of 76\n     */\n    function spread(func) {\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      return function(array) {\n        return func.apply(this, array);\n      };\n    }\n\n    /**\n     * Creates a throttled function that only invokes `func` at most once per\n     * every `wait` milliseconds. The throttled function comes with a `cancel`\n     * method to cancel delayed invocations. Provide an options object to indicate\n     * that `func` should be invoked on the leading and/or trailing edge of the\n     * `wait` timeout. Subsequent calls to the throttled function return the\n     * result of the last `func` call.\n     *\n     * **Note:** If `leading` and `trailing` options are `true`, `func` is invoked\n     * on the trailing edge of the timeout only if the the throttled function is\n     * invoked more than once during the `wait` timeout.\n     *\n     * See [David Corbacho's article](http://drupalmotion.com/article/debounce-and-throttle-visual-explanation)\n     * for details over the differences between `_.throttle` and `_.debounce`.\n     *\n     * @static\n     * @memberOf _\n     * @category Function\n     * @param {Function} func The function to throttle.\n     * @param {number} [wait=0] The number of milliseconds to throttle invocations to.\n     * @param {Object} [options] The options object.\n     * @param {boolean} [options.leading=true] Specify invoking on the leading\n     *  edge of the timeout.\n     * @param {boolean} [options.trailing=true] Specify invoking on the trailing\n     *  edge of the timeout.\n     * @returns {Function} Returns the new throttled function.\n     * @example\n     *\n     * // avoid excessively updating the position while scrolling\n     * jQuery(window).on('scroll', _.throttle(updatePosition, 100));\n     *\n     * // invoke `renewToken` when the click event is fired, but not more than once every 5 minutes\n     * jQuery('.interactive').on('click', _.throttle(renewToken, 300000, {\n     *   'trailing': false\n     * }));\n     *\n     * // cancel a trailing throttled call\n     * jQuery(window).on('popstate', throttled.cancel);\n     */\n    function throttle(func, wait, options) {\n      var leading = true,\n          trailing = true;\n\n      if (typeof func != 'function') {\n        throw new TypeError(FUNC_ERROR_TEXT);\n      }\n      if (options === false) {\n        leading = false;\n      } else if (isObject(options)) {\n        leading = 'leading' in options ? !!options.leading : leading;\n        trailing = 'trailing' in options ? !!options.trailing : trailing;\n      }\n      return debounce(func, wait, { 'leading': leading, 'maxWait': +wait, 'trailing': trailing });\n    }\n\n    /**\n     * Creates a function that provides `value` to the wrapper function as its\n     * first argument. Any additional arguments provided to the function are\n     * appended to those provided to the wrapper function. The wrapper is invoked\n     * with the `this` binding of the created function.\n     *\n     * @static\n     * @memberOf _\n     * @category Function\n     * @param {*} value The value to wrap.\n     * @param {Function} wrapper The wrapper function.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var p = _.wrap(_.escape, function(func, text) {\n     *   return '<p>' + func(text) + '</p>';\n     * });\n     *\n     * p('fred, barney, & pebbles');\n     * // => '<p>fred, barney, &amp; pebbles</p>'\n     */\n    function wrap(value, wrapper) {\n      wrapper = wrapper == null ? identity : wrapper;\n      return createWrapper(wrapper, PARTIAL_FLAG, undefined, [value], []);\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Creates a clone of `value`. If `isDeep` is `true` nested objects are cloned,\n     * otherwise they are assigned by reference. If `customizer` is provided it is\n     * invoked to produce the cloned values. If `customizer` returns `undefined`\n     * cloning is handled by the method instead. The `customizer` is bound to\n     * `thisArg` and invoked with two argument; (value [, index|key, object]).\n     *\n     * **Note:** This method is loosely based on the\n     * [structured clone algorithm](http://www.w3.org/TR/html5/infrastructure.html#internal-structured-cloning-algorithm).\n     * The enumerable properties of `arguments` objects and objects created by\n     * constructors other than `Object` are cloned to plain `Object` objects. An\n     * empty object is returned for uncloneable values such as functions, DOM nodes,\n     * Maps, Sets, and WeakMaps.\n     *\n     * @static\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to clone.\n     * @param {boolean} [isDeep] Specify a deep clone.\n     * @param {Function} [customizer] The function to customize cloning values.\n     * @param {*} [thisArg] The `this` binding of `customizer`.\n     * @returns {*} Returns the cloned value.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney' },\n     *   { 'user': 'fred' }\n     * ];\n     *\n     * var shallow = _.clone(users);\n     * shallow[0] === users[0];\n     * // => true\n     *\n     * var deep = _.clone(users, true);\n     * deep[0] === users[0];\n     * // => false\n     *\n     * // using a customizer callback\n     * var el = _.clone(document.body, function(value) {\n     *   if (_.isElement(value)) {\n     *     return value.cloneNode(false);\n     *   }\n     * });\n     *\n     * el === document.body\n     * // => false\n     * el.nodeName\n     * // => BODY\n     * el.childNodes.length;\n     * // => 0\n     */\n    function clone(value, isDeep, customizer, thisArg) {\n      if (isDeep && typeof isDeep != 'boolean' && isIterateeCall(value, isDeep, customizer)) {\n        isDeep = false;\n      }\n      else if (typeof isDeep == 'function') {\n        thisArg = customizer;\n        customizer = isDeep;\n        isDeep = false;\n      }\n      return typeof customizer == 'function'\n        ? baseClone(value, isDeep, bindCallback(customizer, thisArg, 1))\n        : baseClone(value, isDeep);\n    }\n\n    /**\n     * Creates a deep clone of `value`. If `customizer` is provided it is invoked\n     * to produce the cloned values. If `customizer` returns `undefined` cloning\n     * is handled by the method instead. The `customizer` is bound to `thisArg`\n     * and invoked with two argument; (value [, index|key, object]).\n     *\n     * **Note:** This method is loosely based on the\n     * [structured clone algorithm](http://www.w3.org/TR/html5/infrastructure.html#internal-structured-cloning-algorithm).\n     * The enumerable properties of `arguments` objects and objects created by\n     * constructors other than `Object` are cloned to plain `Object` objects. An\n     * empty object is returned for uncloneable values such as functions, DOM nodes,\n     * Maps, Sets, and WeakMaps.\n     *\n     * @static\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to deep clone.\n     * @param {Function} [customizer] The function to customize cloning values.\n     * @param {*} [thisArg] The `this` binding of `customizer`.\n     * @returns {*} Returns the deep cloned value.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney' },\n     *   { 'user': 'fred' }\n     * ];\n     *\n     * var deep = _.cloneDeep(users);\n     * deep[0] === users[0];\n     * // => false\n     *\n     * // using a customizer callback\n     * var el = _.cloneDeep(document.body, function(value) {\n     *   if (_.isElement(value)) {\n     *     return value.cloneNode(true);\n     *   }\n     * });\n     *\n     * el === document.body\n     * // => false\n     * el.nodeName\n     * // => BODY\n     * el.childNodes.length;\n     * // => 20\n     */\n    function cloneDeep(value, customizer, thisArg) {\n      return typeof customizer == 'function'\n        ? baseClone(value, true, bindCallback(customizer, thisArg, 1))\n        : baseClone(value, true);\n    }\n\n    /**\n     * Checks if `value` is greater than `other`.\n     *\n     * @static\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if `value` is greater than `other`, else `false`.\n     * @example\n     *\n     * _.gt(3, 1);\n     * // => true\n     *\n     * _.gt(3, 3);\n     * // => false\n     *\n     * _.gt(1, 3);\n     * // => false\n     */\n    function gt(value, other) {\n      return value > other;\n    }\n\n    /**\n     * Checks if `value` is greater than or equal to `other`.\n     *\n     * @static\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if `value` is greater than or equal to `other`, else `false`.\n     * @example\n     *\n     * _.gte(3, 1);\n     * // => true\n     *\n     * _.gte(3, 3);\n     * // => true\n     *\n     * _.gte(1, 3);\n     * // => false\n     */\n    function gte(value, other) {\n      return value >= other;\n    }\n\n    /**\n     * Checks if `value` is classified as an `arguments` object.\n     *\n     * @static\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.\n     * @example\n     *\n     * _.isArguments(function() { return arguments; }());\n     * // => true\n     *\n     * _.isArguments([1, 2, 3]);\n     * // => false\n     */\n    function isArguments(value) {\n      return isObjectLike(value) && isArrayLike(value) &&\n        hasOwnProperty.call(value, 'callee') && !propertyIsEnumerable.call(value, 'callee');\n    }\n\n    /**\n     * Checks if `value` is classified as an `Array` object.\n     *\n     * @static\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.\n     * @example\n     *\n     * _.isArray([1, 2, 3]);\n     * // => true\n     *\n     * _.isArray(function() { return arguments; }());\n     * // => false\n     */\n    var isArray = nativeIsArray || function(value) {\n      return isObjectLike(value) && isLength(value.length) && objToString.call(value) == arrayTag;\n    };\n\n    /**\n     * Checks if `value` is classified as a boolean primitive or object.\n     *\n     * @static\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.\n     * @example\n     *\n     * _.isBoolean(false);\n     * // => true\n     *\n     * _.isBoolean(null);\n     * // => false\n     */\n    function isBoolean(value) {\n      return value === true || value === false || (isObjectLike(value) && objToString.call(value) == boolTag);\n    }\n\n    /**\n     * Checks if `value` is classified as a `Date` object.\n     *\n     * @static\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.\n     * @example\n     *\n     * _.isDate(new Date);\n     * // => true\n     *\n     * _.isDate('Mon April 23 2012');\n     * // => false\n     */\n    function isDate(value) {\n      return isObjectLike(value) && objToString.call(value) == dateTag;\n    }\n\n    /**\n     * Checks if `value` is a DOM element.\n     *\n     * @static\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a DOM element, else `false`.\n     * @example\n     *\n     * _.isElement(document.body);\n     * // => true\n     *\n     * _.isElement('<body>');\n     * // => false\n     */\n    function isElement(value) {\n      return !!value && value.nodeType === 1 && isObjectLike(value) && !isPlainObject(value);\n    }\n\n    /**\n     * Checks if `value` is empty. A value is considered empty unless it is an\n     * `arguments` object, array, string, or jQuery-like collection with a length\n     * greater than `0` or an object with own enumerable properties.\n     *\n     * @static\n     * @memberOf _\n     * @category Lang\n     * @param {Array|Object|string} value The value to inspect.\n     * @returns {boolean} Returns `true` if `value` is empty, else `false`.\n     * @example\n     *\n     * _.isEmpty(null);\n     * // => true\n     *\n     * _.isEmpty(true);\n     * // => true\n     *\n     * _.isEmpty(1);\n     * // => true\n     *\n     * _.isEmpty([1, 2, 3]);\n     * // => false\n     *\n     * _.isEmpty({ 'a': 1 });\n     * // => false\n     */\n    function isEmpty(value) {\n      if (value == null) {\n        return true;\n      }\n      if (isArrayLike(value) && (isArray(value) || isString(value) || isArguments(value) ||\n          (isObjectLike(value) && isFunction(value.splice)))) {\n        return !value.length;\n      }\n      return !keys(value).length;\n    }\n\n    /**\n     * Performs a deep comparison between two values to determine if they are\n     * equivalent. If `customizer` is provided it is invoked to compare values.\n     * If `customizer` returns `undefined` comparisons are handled by the method\n     * instead. The `customizer` is bound to `thisArg` and invoked with three\n     * arguments: (value, other [, index|key]).\n     *\n     * **Note:** This method supports comparing arrays, booleans, `Date` objects,\n     * numbers, `Object` objects, regexes, and strings. Objects are compared by\n     * their own, not inherited, enumerable properties. Functions and DOM nodes\n     * are **not** supported. Provide a customizer function to extend support\n     * for comparing other values.\n     *\n     * @static\n     * @memberOf _\n     * @alias eq\n     * @category Lang\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @param {Function} [customizer] The function to customize value comparisons.\n     * @param {*} [thisArg] The `this` binding of `customizer`.\n     * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n     * @example\n     *\n     * var object = { 'user': 'fred' };\n     * var other = { 'user': 'fred' };\n     *\n     * object == other;\n     * // => false\n     *\n     * _.isEqual(object, other);\n     * // => true\n     *\n     * // using a customizer callback\n     * var array = ['hello', 'goodbye'];\n     * var other = ['hi', 'goodbye'];\n     *\n     * _.isEqual(array, other, function(value, other) {\n     *   if (_.every([value, other], RegExp.prototype.test, /^h(?:i|ello)$/)) {\n     *     return true;\n     *   }\n     * });\n     * // => true\n     */\n    function isEqual(value, other, customizer, thisArg) {\n      customizer = typeof customizer == 'function' ? bindCallback(customizer, thisArg, 3) : undefined;\n      var result = customizer ? customizer(value, other) : undefined;\n      return  result === undefined ? baseIsEqual(value, other, customizer) : !!result;\n    }\n\n    /**\n     * Checks if `value` is an `Error`, `EvalError`, `RangeError`, `ReferenceError`,\n     * `SyntaxError`, `TypeError`, or `URIError` object.\n     *\n     * @static\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an error object, else `false`.\n     * @example\n     *\n     * _.isError(new Error);\n     * // => true\n     *\n     * _.isError(Error);\n     * // => false\n     */\n    function isError(value) {\n      return isObjectLike(value) && typeof value.message == 'string' && objToString.call(value) == errorTag;\n    }\n\n    /**\n     * Checks if `value` is a finite primitive number.\n     *\n     * **Note:** This method is based on [`Number.isFinite`](http://ecma-international.org/ecma-262/6.0/#sec-number.isfinite).\n     *\n     * @static\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a finite number, else `false`.\n     * @example\n     *\n     * _.isFinite(10);\n     * // => true\n     *\n     * _.isFinite('10');\n     * // => false\n     *\n     * _.isFinite(true);\n     * // => false\n     *\n     * _.isFinite(Object(10));\n     * // => false\n     *\n     * _.isFinite(Infinity);\n     * // => false\n     */\n    function isFinite(value) {\n      return typeof value == 'number' && nativeIsFinite(value);\n    }\n\n    /**\n     * Checks if `value` is classified as a `Function` object.\n     *\n     * @static\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.\n     * @example\n     *\n     * _.isFunction(_);\n     * // => true\n     *\n     * _.isFunction(/abc/);\n     * // => false\n     */\n    function isFunction(value) {\n      // The use of `Object#toString` avoids issues with the `typeof` operator\n      // in older versions of Chrome and Safari which return 'function' for regexes\n      // and Safari 8 equivalents which return 'object' for typed array constructors.\n      return isObject(value) && objToString.call(value) == funcTag;\n    }\n\n    /**\n     * Checks if `value` is the [language type](https://es5.github.io/#x8) of `Object`.\n     * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n     *\n     * @static\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n     * @example\n     *\n     * _.isObject({});\n     * // => true\n     *\n     * _.isObject([1, 2, 3]);\n     * // => true\n     *\n     * _.isObject(1);\n     * // => false\n     */\n    function isObject(value) {\n      // Avoid a V8 JIT bug in Chrome 19-20.\n      // See https://code.google.com/p/v8/issues/detail?id=2291 for more details.\n      var type = typeof value;\n      return !!value && (type == 'object' || type == 'function');\n    }\n\n    /**\n     * Performs a deep comparison between `object` and `source` to determine if\n     * `object` contains equivalent property values. If `customizer` is provided\n     * it is invoked to compare values. If `customizer` returns `undefined`\n     * comparisons are handled by the method instead. The `customizer` is bound\n     * to `thisArg` and invoked with three arguments: (value, other, index|key).\n     *\n     * **Note:** This method supports comparing properties of arrays, booleans,\n     * `Date` objects, numbers, `Object` objects, regexes, and strings. Functions\n     * and DOM nodes are **not** supported. Provide a customizer function to extend\n     * support for comparing other values.\n     *\n     * @static\n     * @memberOf _\n     * @category Lang\n     * @param {Object} object The object to inspect.\n     * @param {Object} source The object of property values to match.\n     * @param {Function} [customizer] The function to customize value comparisons.\n     * @param {*} [thisArg] The `this` binding of `customizer`.\n     * @returns {boolean} Returns `true` if `object` is a match, else `false`.\n     * @example\n     *\n     * var object = { 'user': 'fred', 'age': 40 };\n     *\n     * _.isMatch(object, { 'age': 40 });\n     * // => true\n     *\n     * _.isMatch(object, { 'age': 36 });\n     * // => false\n     *\n     * // using a customizer callback\n     * var object = { 'greeting': 'hello' };\n     * var source = { 'greeting': 'hi' };\n     *\n     * _.isMatch(object, source, function(value, other) {\n     *   return _.every([value, other], RegExp.prototype.test, /^h(?:i|ello)$/) || undefined;\n     * });\n     * // => true\n     */\n    function isMatch(object, source, customizer, thisArg) {\n      customizer = typeof customizer == 'function' ? bindCallback(customizer, thisArg, 3) : undefined;\n      return baseIsMatch(object, getMatchData(source), customizer);\n    }\n\n    /**\n     * Checks if `value` is `NaN`.\n     *\n     * **Note:** This method is not the same as [`isNaN`](https://es5.github.io/#x15.1.2.4)\n     * which returns `true` for `undefined` and other non-numeric values.\n     *\n     * @static\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.\n     * @example\n     *\n     * _.isNaN(NaN);\n     * // => true\n     *\n     * _.isNaN(new Number(NaN));\n     * // => true\n     *\n     * isNaN(undefined);\n     * // => true\n     *\n     * _.isNaN(undefined);\n     * // => false\n     */\n    function isNaN(value) {\n      // An `NaN` primitive is the only value that is not equal to itself.\n      // Perform the `toStringTag` check first to avoid errors with some host objects in IE.\n      return isNumber(value) && value != +value;\n    }\n\n    /**\n     * Checks if `value` is a native function.\n     *\n     * @static\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a native function, else `false`.\n     * @example\n     *\n     * _.isNative(Array.prototype.push);\n     * // => true\n     *\n     * _.isNative(_);\n     * // => false\n     */\n    function isNative(value) {\n      if (value == null) {\n        return false;\n      }\n      if (isFunction(value)) {\n        return reIsNative.test(fnToString.call(value));\n      }\n      return isObjectLike(value) && reIsHostCtor.test(value);\n    }\n\n    /**\n     * Checks if `value` is `null`.\n     *\n     * @static\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is `null`, else `false`.\n     * @example\n     *\n     * _.isNull(null);\n     * // => true\n     *\n     * _.isNull(void 0);\n     * // => false\n     */\n    function isNull(value) {\n      return value === null;\n    }\n\n    /**\n     * Checks if `value` is classified as a `Number` primitive or object.\n     *\n     * **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are classified\n     * as numbers, use the `_.isFinite` method.\n     *\n     * @static\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.\n     * @example\n     *\n     * _.isNumber(8.4);\n     * // => true\n     *\n     * _.isNumber(NaN);\n     * // => true\n     *\n     * _.isNumber('8.4');\n     * // => false\n     */\n    function isNumber(value) {\n      return typeof value == 'number' || (isObjectLike(value) && objToString.call(value) == numberTag);\n    }\n\n    /**\n     * Checks if `value` is a plain object, that is, an object created by the\n     * `Object` constructor or one with a `[[Prototype]]` of `null`.\n     *\n     * **Note:** This method assumes objects created by the `Object` constructor\n     * have no inherited enumerable properties.\n     *\n     * @static\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     * }\n     *\n     * _.isPlainObject(new Foo);\n     * // => false\n     *\n     * _.isPlainObject([1, 2, 3]);\n     * // => false\n     *\n     * _.isPlainObject({ 'x': 0, 'y': 0 });\n     * // => true\n     *\n     * _.isPlainObject(Object.create(null));\n     * // => true\n     */\n    function isPlainObject(value) {\n      var Ctor;\n\n      // Exit early for non `Object` objects.\n      if (!(isObjectLike(value) && objToString.call(value) == objectTag && !isArguments(value)) ||\n          (!hasOwnProperty.call(value, 'constructor') && (Ctor = value.constructor, typeof Ctor == 'function' && !(Ctor instanceof Ctor)))) {\n        return false;\n      }\n      // IE < 9 iterates inherited properties before own properties. If the first\n      // iterated property is an object's own property then there are no inherited\n      // enumerable properties.\n      var result;\n      // In most environments an object's own properties are iterated before\n      // its inherited properties. If the last iterated property is an object's\n      // own property then there are no inherited enumerable properties.\n      baseForIn(value, function(subValue, key) {\n        result = key;\n      });\n      return result === undefined || hasOwnProperty.call(value, result);\n    }\n\n    /**\n     * Checks if `value` is classified as a `RegExp` object.\n     *\n     * @static\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.\n     * @example\n     *\n     * _.isRegExp(/abc/);\n     * // => true\n     *\n     * _.isRegExp('/abc/');\n     * // => false\n     */\n    function isRegExp(value) {\n      return isObject(value) && objToString.call(value) == regexpTag;\n    }\n\n    /**\n     * Checks if `value` is classified as a `String` primitive or object.\n     *\n     * @static\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.\n     * @example\n     *\n     * _.isString('abc');\n     * // => true\n     *\n     * _.isString(1);\n     * // => false\n     */\n    function isString(value) {\n      return typeof value == 'string' || (isObjectLike(value) && objToString.call(value) == stringTag);\n    }\n\n    /**\n     * Checks if `value` is classified as a typed array.\n     *\n     * @static\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`.\n     * @example\n     *\n     * _.isTypedArray(new Uint8Array);\n     * // => true\n     *\n     * _.isTypedArray([]);\n     * // => false\n     */\n    function isTypedArray(value) {\n      return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[objToString.call(value)];\n    }\n\n    /**\n     * Checks if `value` is `undefined`.\n     *\n     * @static\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to check.\n     * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`.\n     * @example\n     *\n     * _.isUndefined(void 0);\n     * // => true\n     *\n     * _.isUndefined(null);\n     * // => false\n     */\n    function isUndefined(value) {\n      return value === undefined;\n    }\n\n    /**\n     * Checks if `value` is less than `other`.\n     *\n     * @static\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if `value` is less than `other`, else `false`.\n     * @example\n     *\n     * _.lt(1, 3);\n     * // => true\n     *\n     * _.lt(3, 3);\n     * // => false\n     *\n     * _.lt(3, 1);\n     * // => false\n     */\n    function lt(value, other) {\n      return value < other;\n    }\n\n    /**\n     * Checks if `value` is less than or equal to `other`.\n     *\n     * @static\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to compare.\n     * @param {*} other The other value to compare.\n     * @returns {boolean} Returns `true` if `value` is less than or equal to `other`, else `false`.\n     * @example\n     *\n     * _.lte(1, 3);\n     * // => true\n     *\n     * _.lte(3, 3);\n     * // => true\n     *\n     * _.lte(3, 1);\n     * // => false\n     */\n    function lte(value, other) {\n      return value <= other;\n    }\n\n    /**\n     * Converts `value` to an array.\n     *\n     * @static\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {Array} Returns the converted array.\n     * @example\n     *\n     * (function() {\n     *   return _.toArray(arguments).slice(1);\n     * }(1, 2, 3));\n     * // => [2, 3]\n     */\n    function toArray(value) {\n      var length = value ? getLength(value) : 0;\n      if (!isLength(length)) {\n        return values(value);\n      }\n      if (!length) {\n        return [];\n      }\n      return arrayCopy(value);\n    }\n\n    /**\n     * Converts `value` to a plain object flattening inherited enumerable\n     * properties of `value` to own properties of the plain object.\n     *\n     * @static\n     * @memberOf _\n     * @category Lang\n     * @param {*} value The value to convert.\n     * @returns {Object} Returns the converted plain object.\n     * @example\n     *\n     * function Foo() {\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.assign({ 'a': 1 }, new Foo);\n     * // => { 'a': 1, 'b': 2 }\n     *\n     * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));\n     * // => { 'a': 1, 'b': 2, 'c': 3 }\n     */\n    function toPlainObject(value) {\n      return baseCopy(value, keysIn(value));\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Recursively merges own enumerable properties of the source object(s), that\n     * don't resolve to `undefined` into the destination object. Subsequent sources\n     * overwrite property assignments of previous sources. If `customizer` is\n     * provided it is invoked to produce the merged values of the destination and\n     * source properties. If `customizer` returns `undefined` merging is handled\n     * by the method instead. The `customizer` is bound to `thisArg` and invoked\n     * with five arguments: (objectValue, sourceValue, key, object, source).\n     *\n     * @static\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} [sources] The source objects.\n     * @param {Function} [customizer] The function to customize assigned values.\n     * @param {*} [thisArg] The `this` binding of `customizer`.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * var users = {\n     *   'data': [{ 'user': 'barney' }, { 'user': 'fred' }]\n     * };\n     *\n     * var ages = {\n     *   'data': [{ 'age': 36 }, { 'age': 40 }]\n     * };\n     *\n     * _.merge(users, ages);\n     * // => { 'data': [{ 'user': 'barney', 'age': 36 }, { 'user': 'fred', 'age': 40 }] }\n     *\n     * // using a customizer callback\n     * var object = {\n     *   'fruits': ['apple'],\n     *   'vegetables': ['beet']\n     * };\n     *\n     * var other = {\n     *   'fruits': ['banana'],\n     *   'vegetables': ['carrot']\n     * };\n     *\n     * _.merge(object, other, function(a, b) {\n     *   if (_.isArray(a)) {\n     *     return a.concat(b);\n     *   }\n     * });\n     * // => { 'fruits': ['apple', 'banana'], 'vegetables': ['beet', 'carrot'] }\n     */\n    var merge = createAssigner(baseMerge);\n\n    /**\n     * Assigns own enumerable properties of source object(s) to the destination\n     * object. Subsequent sources overwrite property assignments of previous sources.\n     * If `customizer` is provided it is invoked to produce the assigned values.\n     * The `customizer` is bound to `thisArg` and invoked with five arguments:\n     * (objectValue, sourceValue, key, object, source).\n     *\n     * **Note:** This method mutates `object` and is based on\n     * [`Object.assign`](http://ecma-international.org/ecma-262/6.0/#sec-object.assign).\n     *\n     * @static\n     * @memberOf _\n     * @alias extend\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} [sources] The source objects.\n     * @param {Function} [customizer] The function to customize assigned values.\n     * @param {*} [thisArg] The `this` binding of `customizer`.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * _.assign({ 'user': 'barney' }, { 'age': 40 }, { 'user': 'fred' });\n     * // => { 'user': 'fred', 'age': 40 }\n     *\n     * // using a customizer callback\n     * var defaults = _.partialRight(_.assign, function(value, other) {\n     *   return _.isUndefined(value) ? other : value;\n     * });\n     *\n     * defaults({ 'user': 'barney' }, { 'age': 36 }, { 'user': 'fred' });\n     * // => { 'user': 'barney', 'age': 36 }\n     */\n    var assign = createAssigner(function(object, source, customizer) {\n      return customizer\n        ? assignWith(object, source, customizer)\n        : baseAssign(object, source);\n    });\n\n    /**\n     * Creates an object that inherits from the given `prototype` object. If a\n     * `properties` object is provided its own enumerable properties are assigned\n     * to the created object.\n     *\n     * @static\n     * @memberOf _\n     * @category Object\n     * @param {Object} prototype The object to inherit from.\n     * @param {Object} [properties] The properties to assign to the object.\n     * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * function Shape() {\n     *   this.x = 0;\n     *   this.y = 0;\n     * }\n     *\n     * function Circle() {\n     *   Shape.call(this);\n     * }\n     *\n     * Circle.prototype = _.create(Shape.prototype, {\n     *   'constructor': Circle\n     * });\n     *\n     * var circle = new Circle;\n     * circle instanceof Circle;\n     * // => true\n     *\n     * circle instanceof Shape;\n     * // => true\n     */\n    function create(prototype, properties, guard) {\n      var result = baseCreate(prototype);\n      if (guard && isIterateeCall(prototype, properties, guard)) {\n        properties = undefined;\n      }\n      return properties ? baseAssign(result, properties) : result;\n    }\n\n    /**\n     * Assigns own enumerable properties of source object(s) to the destination\n     * object for all destination properties that resolve to `undefined`. Once a\n     * property is set, additional values of the same property are ignored.\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} [sources] The source objects.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * _.defaults({ 'user': 'barney' }, { 'age': 36 }, { 'user': 'fred' });\n     * // => { 'user': 'barney', 'age': 36 }\n     */\n    var defaults = createDefaults(assign, assignDefaults);\n\n    /**\n     * This method is like `_.defaults` except that it recursively assigns\n     * default properties.\n     *\n     * **Note:** This method mutates `object`.\n     *\n     * @static\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The destination object.\n     * @param {...Object} [sources] The source objects.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * _.defaultsDeep({ 'user': { 'name': 'barney' } }, { 'user': { 'name': 'fred', 'age': 36 } });\n     * // => { 'user': { 'name': 'barney', 'age': 36 } }\n     *\n     */\n    var defaultsDeep = createDefaults(merge, mergeDefaults);\n\n    /**\n     * This method is like `_.find` except that it returns the key of the first\n     * element `predicate` returns truthy for instead of the element itself.\n     *\n     * If a property name is provided for `predicate` the created `_.property`\n     * style callback returns the property value of the given element.\n     *\n     * If a value is also provided for `thisArg` the created `_.matchesProperty`\n     * style callback returns `true` for elements that have a matching property\n     * value, else `false`.\n     *\n     * If an object is provided for `predicate` the created `_.matches` style\n     * callback returns `true` for elements that have the properties of the given\n     * object, else `false`.\n     *\n     * @static\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The object to search.\n     * @param {Function|Object|string} [predicate=_.identity] The function invoked\n     *  per iteration.\n     * @param {*} [thisArg] The `this` binding of `predicate`.\n     * @returns {string|undefined} Returns the key of the matched element, else `undefined`.\n     * @example\n     *\n     * var users = {\n     *   'barney':  { 'age': 36, 'active': true },\n     *   'fred':    { 'age': 40, 'active': false },\n     *   'pebbles': { 'age': 1,  'active': true }\n     * };\n     *\n     * _.findKey(users, function(chr) {\n     *   return chr.age < 40;\n     * });\n     * // => 'barney' (iteration order is not guaranteed)\n     *\n     * // using the `_.matches` callback shorthand\n     * _.findKey(users, { 'age': 1, 'active': true });\n     * // => 'pebbles'\n     *\n     * // using the `_.matchesProperty` callback shorthand\n     * _.findKey(users, 'active', false);\n     * // => 'fred'\n     *\n     * // using the `_.property` callback shorthand\n     * _.findKey(users, 'active');\n     * // => 'barney'\n     */\n    var findKey = createFindKey(baseForOwn);\n\n    /**\n     * This method is like `_.findKey` except that it iterates over elements of\n     * a collection in the opposite order.\n     *\n     * If a property name is provided for `predicate` the created `_.property`\n     * style callback returns the property value of the given element.\n     *\n     * If a value is also provided for `thisArg` the created `_.matchesProperty`\n     * style callback returns `true` for elements that have a matching property\n     * value, else `false`.\n     *\n     * If an object is provided for `predicate` the created `_.matches` style\n     * callback returns `true` for elements that have the properties of the given\n     * object, else `false`.\n     *\n     * @static\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The object to search.\n     * @param {Function|Object|string} [predicate=_.identity] The function invoked\n     *  per iteration.\n     * @param {*} [thisArg] The `this` binding of `predicate`.\n     * @returns {string|undefined} Returns the key of the matched element, else `undefined`.\n     * @example\n     *\n     * var users = {\n     *   'barney':  { 'age': 36, 'active': true },\n     *   'fred':    { 'age': 40, 'active': false },\n     *   'pebbles': { 'age': 1,  'active': true }\n     * };\n     *\n     * _.findLastKey(users, function(chr) {\n     *   return chr.age < 40;\n     * });\n     * // => returns `pebbles` assuming `_.findKey` returns `barney`\n     *\n     * // using the `_.matches` callback shorthand\n     * _.findLastKey(users, { 'age': 36, 'active': true });\n     * // => 'barney'\n     *\n     * // using the `_.matchesProperty` callback shorthand\n     * _.findLastKey(users, 'active', false);\n     * // => 'fred'\n     *\n     * // using the `_.property` callback shorthand\n     * _.findLastKey(users, 'active');\n     * // => 'pebbles'\n     */\n    var findLastKey = createFindKey(baseForOwnRight);\n\n    /**\n     * Iterates over own and inherited enumerable properties of an object invoking\n     * `iteratee` for each property. The `iteratee` is bound to `thisArg` and invoked\n     * with three arguments: (value, key, object). Iteratee functions may exit\n     * iteration early by explicitly returning `false`.\n     *\n     * @static\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @param {*} [thisArg] The `this` binding of `iteratee`.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.forIn(new Foo, function(value, key) {\n     *   console.log(key);\n     * });\n     * // => logs 'a', 'b', and 'c' (iteration order is not guaranteed)\n     */\n    var forIn = createForIn(baseFor);\n\n    /**\n     * This method is like `_.forIn` except that it iterates over properties of\n     * `object` in the opposite order.\n     *\n     * @static\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @param {*} [thisArg] The `this` binding of `iteratee`.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.forInRight(new Foo, function(value, key) {\n     *   console.log(key);\n     * });\n     * // => logs 'c', 'b', and 'a' assuming `_.forIn ` logs 'a', 'b', and 'c'\n     */\n    var forInRight = createForIn(baseForRight);\n\n    /**\n     * Iterates over own enumerable properties of an object invoking `iteratee`\n     * for each property. The `iteratee` is bound to `thisArg` and invoked with\n     * three arguments: (value, key, object). Iteratee functions may exit iteration\n     * early by explicitly returning `false`.\n     *\n     * @static\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @param {*} [thisArg] The `this` binding of `iteratee`.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.forOwn(new Foo, function(value, key) {\n     *   console.log(key);\n     * });\n     * // => logs 'a' and 'b' (iteration order is not guaranteed)\n     */\n    var forOwn = createForOwn(baseForOwn);\n\n    /**\n     * This method is like `_.forOwn` except that it iterates over properties of\n     * `object` in the opposite order.\n     *\n     * @static\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @param {*} [thisArg] The `this` binding of `iteratee`.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.forOwnRight(new Foo, function(value, key) {\n     *   console.log(key);\n     * });\n     * // => logs 'b' and 'a' assuming `_.forOwn` logs 'a' and 'b'\n     */\n    var forOwnRight = createForOwn(baseForOwnRight);\n\n    /**\n     * Creates an array of function property names from all enumerable properties,\n     * own and inherited, of `object`.\n     *\n     * @static\n     * @memberOf _\n     * @alias methods\n     * @category Object\n     * @param {Object} object The object to inspect.\n     * @returns {Array} Returns the new array of property names.\n     * @example\n     *\n     * _.functions(_);\n     * // => ['after', 'ary', 'assign', ...]\n     */\n    function functions(object) {\n      return baseFunctions(object, keysIn(object));\n    }\n\n    /**\n     * Gets the property value at `path` of `object`. If the resolved value is\n     * `undefined` the `defaultValue` is used in its place.\n     *\n     * @static\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path of the property to get.\n     * @param {*} [defaultValue] The value returned if the resolved value is `undefined`.\n     * @returns {*} Returns the resolved value.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c': 3 } }] };\n     *\n     * _.get(object, 'a[0].b.c');\n     * // => 3\n     *\n     * _.get(object, ['a', '0', 'b', 'c']);\n     * // => 3\n     *\n     * _.get(object, 'a.b.c', 'default');\n     * // => 'default'\n     */\n    function get(object, path, defaultValue) {\n      var result = object == null ? undefined : baseGet(object, toPath(path), path + '');\n      return result === undefined ? defaultValue : result;\n    }\n\n    /**\n     * Checks if `path` is a direct property.\n     *\n     * @static\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path to check.\n     * @returns {boolean} Returns `true` if `path` is a direct property, else `false`.\n     * @example\n     *\n     * var object = { 'a': { 'b': { 'c': 3 } } };\n     *\n     * _.has(object, 'a');\n     * // => true\n     *\n     * _.has(object, 'a.b.c');\n     * // => true\n     *\n     * _.has(object, ['a', 'b', 'c']);\n     * // => true\n     */\n    function has(object, path) {\n      if (object == null) {\n        return false;\n      }\n      var result = hasOwnProperty.call(object, path);\n      if (!result && !isKey(path)) {\n        path = toPath(path);\n        object = path.length == 1 ? object : baseGet(object, baseSlice(path, 0, -1));\n        if (object == null) {\n          return false;\n        }\n        path = last(path);\n        result = hasOwnProperty.call(object, path);\n      }\n      return result || (isLength(object.length) && isIndex(path, object.length) &&\n        (isArray(object) || isArguments(object)));\n    }\n\n    /**\n     * Creates an object composed of the inverted keys and values of `object`.\n     * If `object` contains duplicate values, subsequent values overwrite property\n     * assignments of previous values unless `multiValue` is `true`.\n     *\n     * @static\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The object to invert.\n     * @param {boolean} [multiValue] Allow multiple values per key.\n     * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.\n     * @returns {Object} Returns the new inverted object.\n     * @example\n     *\n     * var object = { 'a': 1, 'b': 2, 'c': 1 };\n     *\n     * _.invert(object);\n     * // => { '1': 'c', '2': 'b' }\n     *\n     * // with `multiValue`\n     * _.invert(object, true);\n     * // => { '1': ['a', 'c'], '2': ['b'] }\n     */\n    function invert(object, multiValue, guard) {\n      if (guard && isIterateeCall(object, multiValue, guard)) {\n        multiValue = undefined;\n      }\n      var index = -1,\n          props = keys(object),\n          length = props.length,\n          result = {};\n\n      while (++index < length) {\n        var key = props[index],\n            value = object[key];\n\n        if (multiValue) {\n          if (hasOwnProperty.call(result, value)) {\n            result[value].push(key);\n          } else {\n            result[value] = [key];\n          }\n        }\n        else {\n          result[value] = key;\n        }\n      }\n      return result;\n    }\n\n    /**\n     * Creates an array of the own enumerable property names of `object`.\n     *\n     * **Note:** Non-object values are coerced to objects. See the\n     * [ES spec](http://ecma-international.org/ecma-262/6.0/#sec-object.keys)\n     * for more details.\n     *\n     * @static\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property names.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.keys(new Foo);\n     * // => ['a', 'b'] (iteration order is not guaranteed)\n     *\n     * _.keys('hi');\n     * // => ['0', '1']\n     */\n    var keys = !nativeKeys ? shimKeys : function(object) {\n      var Ctor = object == null ? undefined : object.constructor;\n      if ((typeof Ctor == 'function' && Ctor.prototype === object) ||\n          (typeof object != 'function' && isArrayLike(object))) {\n        return shimKeys(object);\n      }\n      return isObject(object) ? nativeKeys(object) : [];\n    };\n\n    /**\n     * Creates an array of the own and inherited enumerable property names of `object`.\n     *\n     * **Note:** Non-object values are coerced to objects.\n     *\n     * @static\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property names.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.keysIn(new Foo);\n     * // => ['a', 'b', 'c'] (iteration order is not guaranteed)\n     */\n    function keysIn(object) {\n      if (object == null) {\n        return [];\n      }\n      if (!isObject(object)) {\n        object = Object(object);\n      }\n      var length = object.length;\n      length = (length && isLength(length) &&\n        (isArray(object) || isArguments(object)) && length) || 0;\n\n      var Ctor = object.constructor,\n          index = -1,\n          isProto = typeof Ctor == 'function' && Ctor.prototype === object,\n          result = Array(length),\n          skipIndexes = length > 0;\n\n      while (++index < length) {\n        result[index] = (index + '');\n      }\n      for (var key in object) {\n        if (!(skipIndexes && isIndex(key, length)) &&\n            !(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {\n          result.push(key);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * The opposite of `_.mapValues`; this method creates an object with the\n     * same values as `object` and keys generated by running each own enumerable\n     * property of `object` through `iteratee`.\n     *\n     * @static\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function|Object|string} [iteratee=_.identity] The function invoked\n     *  per iteration.\n     * @param {*} [thisArg] The `this` binding of `iteratee`.\n     * @returns {Object} Returns the new mapped object.\n     * @example\n     *\n     * _.mapKeys({ 'a': 1, 'b': 2 }, function(value, key) {\n     *   return key + value;\n     * });\n     * // => { 'a1': 1, 'b2': 2 }\n     */\n    var mapKeys = createObjectMapper(true);\n\n    /**\n     * Creates an object with the same keys as `object` and values generated by\n     * running each own enumerable property of `object` through `iteratee`. The\n     * iteratee function is bound to `thisArg` and invoked with three arguments:\n     * (value, key, object).\n     *\n     * If a property name is provided for `iteratee` the created `_.property`\n     * style callback returns the property value of the given element.\n     *\n     * If a value is also provided for `thisArg` the created `_.matchesProperty`\n     * style callback returns `true` for elements that have a matching property\n     * value, else `false`.\n     *\n     * If an object is provided for `iteratee` the created `_.matches` style\n     * callback returns `true` for elements that have the properties of the given\n     * object, else `false`.\n     *\n     * @static\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The object to iterate over.\n     * @param {Function|Object|string} [iteratee=_.identity] The function invoked\n     *  per iteration.\n     * @param {*} [thisArg] The `this` binding of `iteratee`.\n     * @returns {Object} Returns the new mapped object.\n     * @example\n     *\n     * _.mapValues({ 'a': 1, 'b': 2 }, function(n) {\n     *   return n * 3;\n     * });\n     * // => { 'a': 3, 'b': 6 }\n     *\n     * var users = {\n     *   'fred':    { 'user': 'fred',    'age': 40 },\n     *   'pebbles': { 'user': 'pebbles', 'age': 1 }\n     * };\n     *\n     * // using the `_.property` callback shorthand\n     * _.mapValues(users, 'age');\n     * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)\n     */\n    var mapValues = createObjectMapper();\n\n    /**\n     * The opposite of `_.pick`; this method creates an object composed of the\n     * own and inherited enumerable properties of `object` that are not omitted.\n     *\n     * @static\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The source object.\n     * @param {Function|...(string|string[])} [predicate] The function invoked per\n     *  iteration or property names to omit, specified as individual property\n     *  names or arrays of property names.\n     * @param {*} [thisArg] The `this` binding of `predicate`.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * var object = { 'user': 'fred', 'age': 40 };\n     *\n     * _.omit(object, 'age');\n     * // => { 'user': 'fred' }\n     *\n     * _.omit(object, _.isNumber);\n     * // => { 'user': 'fred' }\n     */\n    var omit = restParam(function(object, props) {\n      if (object == null) {\n        return {};\n      }\n      if (typeof props[0] != 'function') {\n        var props = arrayMap(baseFlatten(props), String);\n        return pickByArray(object, baseDifference(keysIn(object), props));\n      }\n      var predicate = bindCallback(props[0], props[1], 3);\n      return pickByCallback(object, function(value, key, object) {\n        return !predicate(value, key, object);\n      });\n    });\n\n    /**\n     * Creates a two dimensional array of the key-value pairs for `object`,\n     * e.g. `[[key1, value1], [key2, value2]]`.\n     *\n     * @static\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the new array of key-value pairs.\n     * @example\n     *\n     * _.pairs({ 'barney': 36, 'fred': 40 });\n     * // => [['barney', 36], ['fred', 40]] (iteration order is not guaranteed)\n     */\n    function pairs(object) {\n      object = toObject(object);\n\n      var index = -1,\n          props = keys(object),\n          length = props.length,\n          result = Array(length);\n\n      while (++index < length) {\n        var key = props[index];\n        result[index] = [key, object[key]];\n      }\n      return result;\n    }\n\n    /**\n     * Creates an object composed of the picked `object` properties. Property\n     * names may be specified as individual arguments or as arrays of property\n     * names. If `predicate` is provided it is invoked for each property of `object`\n     * picking the properties `predicate` returns truthy for. The predicate is\n     * bound to `thisArg` and invoked with three arguments: (value, key, object).\n     *\n     * @static\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The source object.\n     * @param {Function|...(string|string[])} [predicate] The function invoked per\n     *  iteration or property names to pick, specified as individual property\n     *  names or arrays of property names.\n     * @param {*} [thisArg] The `this` binding of `predicate`.\n     * @returns {Object} Returns the new object.\n     * @example\n     *\n     * var object = { 'user': 'fred', 'age': 40 };\n     *\n     * _.pick(object, 'user');\n     * // => { 'user': 'fred' }\n     *\n     * _.pick(object, _.isString);\n     * // => { 'user': 'fred' }\n     */\n    var pick = restParam(function(object, props) {\n      if (object == null) {\n        return {};\n      }\n      return typeof props[0] == 'function'\n        ? pickByCallback(object, bindCallback(props[0], props[1], 3))\n        : pickByArray(object, baseFlatten(props));\n    });\n\n    /**\n     * This method is like `_.get` except that if the resolved value is a function\n     * it is invoked with the `this` binding of its parent object and its result\n     * is returned.\n     *\n     * @static\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The object to query.\n     * @param {Array|string} path The path of the property to resolve.\n     * @param {*} [defaultValue] The value returned if the resolved value is `undefined`.\n     * @returns {*} Returns the resolved value.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c1': 3, 'c2': _.constant(4) } }] };\n     *\n     * _.result(object, 'a[0].b.c1');\n     * // => 3\n     *\n     * _.result(object, 'a[0].b.c2');\n     * // => 4\n     *\n     * _.result(object, 'a.b.c', 'default');\n     * // => 'default'\n     *\n     * _.result(object, 'a.b.c', _.constant('default'));\n     * // => 'default'\n     */\n    function result(object, path, defaultValue) {\n      var result = object == null ? undefined : object[path];\n      if (result === undefined) {\n        if (object != null && !isKey(path, object)) {\n          path = toPath(path);\n          object = path.length == 1 ? object : baseGet(object, baseSlice(path, 0, -1));\n          result = object == null ? undefined : object[last(path)];\n        }\n        result = result === undefined ? defaultValue : result;\n      }\n      return isFunction(result) ? result.call(object) : result;\n    }\n\n    /**\n     * Sets the property value of `path` on `object`. If a portion of `path`\n     * does not exist it is created.\n     *\n     * @static\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The object to augment.\n     * @param {Array|string} path The path of the property to set.\n     * @param {*} value The value to set.\n     * @returns {Object} Returns `object`.\n     * @example\n     *\n     * var object = { 'a': [{ 'b': { 'c': 3 } }] };\n     *\n     * _.set(object, 'a[0].b.c', 4);\n     * console.log(object.a[0].b.c);\n     * // => 4\n     *\n     * _.set(object, 'x[0].y.z', 5);\n     * console.log(object.x[0].y.z);\n     * // => 5\n     */\n    function set(object, path, value) {\n      if (object == null) {\n        return object;\n      }\n      var pathKey = (path + '');\n      path = (object[pathKey] != null || isKey(path, object)) ? [pathKey] : toPath(path);\n\n      var index = -1,\n          length = path.length,\n          lastIndex = length - 1,\n          nested = object;\n\n      while (nested != null && ++index < length) {\n        var key = path[index];\n        if (isObject(nested)) {\n          if (index == lastIndex) {\n            nested[key] = value;\n          } else if (nested[key] == null) {\n            nested[key] = isIndex(path[index + 1]) ? [] : {};\n          }\n        }\n        nested = nested[key];\n      }\n      return object;\n    }\n\n    /**\n     * An alternative to `_.reduce`; this method transforms `object` to a new\n     * `accumulator` object which is the result of running each of its own enumerable\n     * properties through `iteratee`, with each invocation potentially mutating\n     * the `accumulator` object. The `iteratee` is bound to `thisArg` and invoked\n     * with four arguments: (accumulator, value, key, object). Iteratee functions\n     * may exit iteration early by explicitly returning `false`.\n     *\n     * @static\n     * @memberOf _\n     * @category Object\n     * @param {Array|Object} object The object to iterate over.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @param {*} [accumulator] The custom accumulator value.\n     * @param {*} [thisArg] The `this` binding of `iteratee`.\n     * @returns {*} Returns the accumulated value.\n     * @example\n     *\n     * _.transform([2, 3, 4], function(result, n) {\n     *   result.push(n *= n);\n     *   return n % 2 == 0;\n     * });\n     * // => [4, 9]\n     *\n     * _.transform({ 'a': 1, 'b': 2 }, function(result, n, key) {\n     *   result[key] = n * 3;\n     * });\n     * // => { 'a': 3, 'b': 6 }\n     */\n    function transform(object, iteratee, accumulator, thisArg) {\n      var isArr = isArray(object) || isTypedArray(object);\n      iteratee = getCallback(iteratee, thisArg, 4);\n\n      if (accumulator == null) {\n        if (isArr || isObject(object)) {\n          var Ctor = object.constructor;\n          if (isArr) {\n            accumulator = isArray(object) ? new Ctor : [];\n          } else {\n            accumulator = baseCreate(isFunction(Ctor) ? Ctor.prototype : undefined);\n          }\n        } else {\n          accumulator = {};\n        }\n      }\n      (isArr ? arrayEach : baseForOwn)(object, function(value, index, object) {\n        return iteratee(accumulator, value, index, object);\n      });\n      return accumulator;\n    }\n\n    /**\n     * Creates an array of the own enumerable property values of `object`.\n     *\n     * **Note:** Non-object values are coerced to objects.\n     *\n     * @static\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property values.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.values(new Foo);\n     * // => [1, 2] (iteration order is not guaranteed)\n     *\n     * _.values('hi');\n     * // => ['h', 'i']\n     */\n    function values(object) {\n      return baseValues(object, keys(object));\n    }\n\n    /**\n     * Creates an array of the own and inherited enumerable property values\n     * of `object`.\n     *\n     * **Note:** Non-object values are coerced to objects.\n     *\n     * @static\n     * @memberOf _\n     * @category Object\n     * @param {Object} object The object to query.\n     * @returns {Array} Returns the array of property values.\n     * @example\n     *\n     * function Foo() {\n     *   this.a = 1;\n     *   this.b = 2;\n     * }\n     *\n     * Foo.prototype.c = 3;\n     *\n     * _.valuesIn(new Foo);\n     * // => [1, 2, 3] (iteration order is not guaranteed)\n     */\n    function valuesIn(object) {\n      return baseValues(object, keysIn(object));\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Checks if `n` is between `start` and up to but not including, `end`. If\n     * `end` is not specified it is set to `start` with `start` then set to `0`.\n     *\n     * @static\n     * @memberOf _\n     * @category Number\n     * @param {number} n The number to check.\n     * @param {number} [start=0] The start of the range.\n     * @param {number} end The end of the range.\n     * @returns {boolean} Returns `true` if `n` is in the range, else `false`.\n     * @example\n     *\n     * _.inRange(3, 2, 4);\n     * // => true\n     *\n     * _.inRange(4, 8);\n     * // => true\n     *\n     * _.inRange(4, 2);\n     * // => false\n     *\n     * _.inRange(2, 2);\n     * // => false\n     *\n     * _.inRange(1.2, 2);\n     * // => true\n     *\n     * _.inRange(5.2, 4);\n     * // => false\n     */\n    function inRange(value, start, end) {\n      start = +start || 0;\n      if (end === undefined) {\n        end = start;\n        start = 0;\n      } else {\n        end = +end || 0;\n      }\n      return value >= nativeMin(start, end) && value < nativeMax(start, end);\n    }\n\n    /**\n     * Produces a random number between `min` and `max` (inclusive). If only one\n     * argument is provided a number between `0` and the given number is returned.\n     * If `floating` is `true`, or either `min` or `max` are floats, a floating-point\n     * number is returned instead of an integer.\n     *\n     * @static\n     * @memberOf _\n     * @category Number\n     * @param {number} [min=0] The minimum possible value.\n     * @param {number} [max=1] The maximum possible value.\n     * @param {boolean} [floating] Specify returning a floating-point number.\n     * @returns {number} Returns the random number.\n     * @example\n     *\n     * _.random(0, 5);\n     * // => an integer between 0 and 5\n     *\n     * _.random(5);\n     * // => also an integer between 0 and 5\n     *\n     * _.random(5, true);\n     * // => a floating-point number between 0 and 5\n     *\n     * _.random(1.2, 5.2);\n     * // => a floating-point number between 1.2 and 5.2\n     */\n    function random(min, max, floating) {\n      if (floating && isIterateeCall(min, max, floating)) {\n        max = floating = undefined;\n      }\n      var noMin = min == null,\n          noMax = max == null;\n\n      if (floating == null) {\n        if (noMax && typeof min == 'boolean') {\n          floating = min;\n          min = 1;\n        }\n        else if (typeof max == 'boolean') {\n          floating = max;\n          noMax = true;\n        }\n      }\n      if (noMin && noMax) {\n        max = 1;\n        noMax = false;\n      }\n      min = +min || 0;\n      if (noMax) {\n        max = min;\n        min = 0;\n      } else {\n        max = +max || 0;\n      }\n      if (floating || min % 1 || max % 1) {\n        var rand = nativeRandom();\n        return nativeMin(min + (rand * (max - min + parseFloat('1e-' + ((rand + '').length - 1)))), max);\n      }\n      return baseRandom(min, max);\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Converts `string` to [camel case](https://en.wikipedia.org/wiki/CamelCase).\n     *\n     * @static\n     * @memberOf _\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the camel cased string.\n     * @example\n     *\n     * _.camelCase('Foo Bar');\n     * // => 'fooBar'\n     *\n     * _.camelCase('--foo-bar');\n     * // => 'fooBar'\n     *\n     * _.camelCase('__foo_bar__');\n     * // => 'fooBar'\n     */\n    var camelCase = createCompounder(function(result, word, index) {\n      word = word.toLowerCase();\n      return result + (index ? (word.charAt(0).toUpperCase() + word.slice(1)) : word);\n    });\n\n    /**\n     * Capitalizes the first character of `string`.\n     *\n     * @static\n     * @memberOf _\n     * @category String\n     * @param {string} [string=''] The string to capitalize.\n     * @returns {string} Returns the capitalized string.\n     * @example\n     *\n     * _.capitalize('fred');\n     * // => 'Fred'\n     */\n    function capitalize(string) {\n      string = baseToString(string);\n      return string && (string.charAt(0).toUpperCase() + string.slice(1));\n    }\n\n    /**\n     * Deburrs `string` by converting [latin-1 supplementary letters](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table)\n     * to basic latin letters and removing [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks).\n     *\n     * @static\n     * @memberOf _\n     * @category String\n     * @param {string} [string=''] The string to deburr.\n     * @returns {string} Returns the deburred string.\n     * @example\n     *\n     * _.deburr('déjà vu');\n     * // => 'deja vu'\n     */\n    function deburr(string) {\n      string = baseToString(string);\n      return string && string.replace(reLatin1, deburrLetter).replace(reComboMark, '');\n    }\n\n    /**\n     * Checks if `string` ends with the given target string.\n     *\n     * @static\n     * @memberOf _\n     * @category String\n     * @param {string} [string=''] The string to search.\n     * @param {string} [target] The string to search for.\n     * @param {number} [position=string.length] The position to search from.\n     * @returns {boolean} Returns `true` if `string` ends with `target`, else `false`.\n     * @example\n     *\n     * _.endsWith('abc', 'c');\n     * // => true\n     *\n     * _.endsWith('abc', 'b');\n     * // => false\n     *\n     * _.endsWith('abc', 'b', 2);\n     * // => true\n     */\n    function endsWith(string, target, position) {\n      string = baseToString(string);\n      target = (target + '');\n\n      var length = string.length;\n      position = position === undefined\n        ? length\n        : nativeMin(position < 0 ? 0 : (+position || 0), length);\n\n      position -= target.length;\n      return position >= 0 && string.indexOf(target, position) == position;\n    }\n\n    /**\n     * Converts the characters \"&\", \"<\", \">\", '\"', \"'\", and \"\\`\", in `string` to\n     * their corresponding HTML entities.\n     *\n     * **Note:** No other characters are escaped. To escape additional characters\n     * use a third-party library like [_he_](https://mths.be/he).\n     *\n     * Though the \">\" character is escaped for symmetry, characters like\n     * \">\" and \"/\" don't need escaping in HTML and have no special meaning\n     * unless they're part of a tag or unquoted attribute value.\n     * See [Mathias Bynens's article](https://mathiasbynens.be/notes/ambiguous-ampersands)\n     * (under \"semi-related fun fact\") for more details.\n     *\n     * Backticks are escaped because in Internet Explorer < 9, they can break out\n     * of attribute values or HTML comments. See [#59](https://html5sec.org/#59),\n     * [#102](https://html5sec.org/#102), [#108](https://html5sec.org/#108), and\n     * [#133](https://html5sec.org/#133) of the [HTML5 Security Cheatsheet](https://html5sec.org/)\n     * for more details.\n     *\n     * When working with HTML you should always [quote attribute values](http://wonko.com/post/html-escaping)\n     * to reduce XSS vectors.\n     *\n     * @static\n     * @memberOf _\n     * @category String\n     * @param {string} [string=''] The string to escape.\n     * @returns {string} Returns the escaped string.\n     * @example\n     *\n     * _.escape('fred, barney, & pebbles');\n     * // => 'fred, barney, &amp; pebbles'\n     */\n    function escape(string) {\n      // Reset `lastIndex` because in IE < 9 `String#replace` does not.\n      string = baseToString(string);\n      return (string && reHasUnescapedHtml.test(string))\n        ? string.replace(reUnescapedHtml, escapeHtmlChar)\n        : string;\n    }\n\n    /**\n     * Escapes the `RegExp` special characters \"\\\", \"/\", \"^\", \"$\", \".\", \"|\", \"?\",\n     * \"*\", \"+\", \"(\", \")\", \"[\", \"]\", \"{\" and \"}\" in `string`.\n     *\n     * @static\n     * @memberOf _\n     * @category String\n     * @param {string} [string=''] The string to escape.\n     * @returns {string} Returns the escaped string.\n     * @example\n     *\n     * _.escapeRegExp('[lodash](https://lodash.com/)');\n     * // => '\\[lodash\\]\\(https:\\/\\/lodash\\.com\\/\\)'\n     */\n    function escapeRegExp(string) {\n      string = baseToString(string);\n      return (string && reHasRegExpChars.test(string))\n        ? string.replace(reRegExpChars, escapeRegExpChar)\n        : (string || '(?:)');\n    }\n\n    /**\n     * Converts `string` to [kebab case](https://en.wikipedia.org/wiki/Letter_case#Special_case_styles).\n     *\n     * @static\n     * @memberOf _\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the kebab cased string.\n     * @example\n     *\n     * _.kebabCase('Foo Bar');\n     * // => 'foo-bar'\n     *\n     * _.kebabCase('fooBar');\n     * // => 'foo-bar'\n     *\n     * _.kebabCase('__foo_bar__');\n     * // => 'foo-bar'\n     */\n    var kebabCase = createCompounder(function(result, word, index) {\n      return result + (index ? '-' : '') + word.toLowerCase();\n    });\n\n    /**\n     * Pads `string` on the left and right sides if it's shorter than `length`.\n     * Padding characters are truncated if they can't be evenly divided by `length`.\n     *\n     * @static\n     * @memberOf _\n     * @category String\n     * @param {string} [string=''] The string to pad.\n     * @param {number} [length=0] The padding length.\n     * @param {string} [chars=' '] The string used as padding.\n     * @returns {string} Returns the padded string.\n     * @example\n     *\n     * _.pad('abc', 8);\n     * // => '  abc   '\n     *\n     * _.pad('abc', 8, '_-');\n     * // => '_-abc_-_'\n     *\n     * _.pad('abc', 3);\n     * // => 'abc'\n     */\n    function pad(string, length, chars) {\n      string = baseToString(string);\n      length = +length;\n\n      var strLength = string.length;\n      if (strLength >= length || !nativeIsFinite(length)) {\n        return string;\n      }\n      var mid = (length - strLength) / 2,\n          leftLength = nativeFloor(mid),\n          rightLength = nativeCeil(mid);\n\n      chars = createPadding('', rightLength, chars);\n      return chars.slice(0, leftLength) + string + chars;\n    }\n\n    /**\n     * Pads `string` on the left side if it's shorter than `length`. Padding\n     * characters are truncated if they exceed `length`.\n     *\n     * @static\n     * @memberOf _\n     * @category String\n     * @param {string} [string=''] The string to pad.\n     * @param {number} [length=0] The padding length.\n     * @param {string} [chars=' '] The string used as padding.\n     * @returns {string} Returns the padded string.\n     * @example\n     *\n     * _.padLeft('abc', 6);\n     * // => '   abc'\n     *\n     * _.padLeft('abc', 6, '_-');\n     * // => '_-_abc'\n     *\n     * _.padLeft('abc', 3);\n     * // => 'abc'\n     */\n    var padLeft = createPadDir();\n\n    /**\n     * Pads `string` on the right side if it's shorter than `length`. Padding\n     * characters are truncated if they exceed `length`.\n     *\n     * @static\n     * @memberOf _\n     * @category String\n     * @param {string} [string=''] The string to pad.\n     * @param {number} [length=0] The padding length.\n     * @param {string} [chars=' '] The string used as padding.\n     * @returns {string} Returns the padded string.\n     * @example\n     *\n     * _.padRight('abc', 6);\n     * // => 'abc   '\n     *\n     * _.padRight('abc', 6, '_-');\n     * // => 'abc_-_'\n     *\n     * _.padRight('abc', 3);\n     * // => 'abc'\n     */\n    var padRight = createPadDir(true);\n\n    /**\n     * Converts `string` to an integer of the specified radix. If `radix` is\n     * `undefined` or `0`, a `radix` of `10` is used unless `value` is a hexadecimal,\n     * in which case a `radix` of `16` is used.\n     *\n     * **Note:** This method aligns with the [ES5 implementation](https://es5.github.io/#E)\n     * of `parseInt`.\n     *\n     * @static\n     * @memberOf _\n     * @category String\n     * @param {string} string The string to convert.\n     * @param {number} [radix] The radix to interpret `value` by.\n     * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.\n     * @returns {number} Returns the converted integer.\n     * @example\n     *\n     * _.parseInt('08');\n     * // => 8\n     *\n     * _.map(['6', '08', '10'], _.parseInt);\n     * // => [6, 8, 10]\n     */\n    function parseInt(string, radix, guard) {\n      // Firefox < 21 and Opera < 15 follow ES3 for `parseInt`.\n      // Chrome fails to trim leading <BOM> whitespace characters.\n      // See https://code.google.com/p/v8/issues/detail?id=3109 for more details.\n      if (guard ? isIterateeCall(string, radix, guard) : radix == null) {\n        radix = 0;\n      } else if (radix) {\n        radix = +radix;\n      }\n      string = trim(string);\n      return nativeParseInt(string, radix || (reHasHexPrefix.test(string) ? 16 : 10));\n    }\n\n    /**\n     * Repeats the given string `n` times.\n     *\n     * @static\n     * @memberOf _\n     * @category String\n     * @param {string} [string=''] The string to repeat.\n     * @param {number} [n=0] The number of times to repeat the string.\n     * @returns {string} Returns the repeated string.\n     * @example\n     *\n     * _.repeat('*', 3);\n     * // => '***'\n     *\n     * _.repeat('abc', 2);\n     * // => 'abcabc'\n     *\n     * _.repeat('abc', 0);\n     * // => ''\n     */\n    function repeat(string, n) {\n      var result = '';\n      string = baseToString(string);\n      n = +n;\n      if (n < 1 || !string || !nativeIsFinite(n)) {\n        return result;\n      }\n      // Leverage the exponentiation by squaring algorithm for a faster repeat.\n      // See https://en.wikipedia.org/wiki/Exponentiation_by_squaring for more details.\n      do {\n        if (n % 2) {\n          result += string;\n        }\n        n = nativeFloor(n / 2);\n        string += string;\n      } while (n);\n\n      return result;\n    }\n\n    /**\n     * Converts `string` to [snake case](https://en.wikipedia.org/wiki/Snake_case).\n     *\n     * @static\n     * @memberOf _\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the snake cased string.\n     * @example\n     *\n     * _.snakeCase('Foo Bar');\n     * // => 'foo_bar'\n     *\n     * _.snakeCase('fooBar');\n     * // => 'foo_bar'\n     *\n     * _.snakeCase('--foo-bar');\n     * // => 'foo_bar'\n     */\n    var snakeCase = createCompounder(function(result, word, index) {\n      return result + (index ? '_' : '') + word.toLowerCase();\n    });\n\n    /**\n     * Converts `string` to [start case](https://en.wikipedia.org/wiki/Letter_case#Stylistic_or_specialised_usage).\n     *\n     * @static\n     * @memberOf _\n     * @category String\n     * @param {string} [string=''] The string to convert.\n     * @returns {string} Returns the start cased string.\n     * @example\n     *\n     * _.startCase('--foo-bar');\n     * // => 'Foo Bar'\n     *\n     * _.startCase('fooBar');\n     * // => 'Foo Bar'\n     *\n     * _.startCase('__foo_bar__');\n     * // => 'Foo Bar'\n     */\n    var startCase = createCompounder(function(result, word, index) {\n      return result + (index ? ' ' : '') + (word.charAt(0).toUpperCase() + word.slice(1));\n    });\n\n    /**\n     * Checks if `string` starts with the given target string.\n     *\n     * @static\n     * @memberOf _\n     * @category String\n     * @param {string} [string=''] The string to search.\n     * @param {string} [target] The string to search for.\n     * @param {number} [position=0] The position to search from.\n     * @returns {boolean} Returns `true` if `string` starts with `target`, else `false`.\n     * @example\n     *\n     * _.startsWith('abc', 'a');\n     * // => true\n     *\n     * _.startsWith('abc', 'b');\n     * // => false\n     *\n     * _.startsWith('abc', 'b', 1);\n     * // => true\n     */\n    function startsWith(string, target, position) {\n      string = baseToString(string);\n      position = position == null\n        ? 0\n        : nativeMin(position < 0 ? 0 : (+position || 0), string.length);\n\n      return string.lastIndexOf(target, position) == position;\n    }\n\n    /**\n     * Creates a compiled template function that can interpolate data properties\n     * in \"interpolate\" delimiters, HTML-escape interpolated data properties in\n     * \"escape\" delimiters, and execute JavaScript in \"evaluate\" delimiters. Data\n     * properties may be accessed as free variables in the template. If a setting\n     * object is provided it takes precedence over `_.templateSettings` values.\n     *\n     * **Note:** In the development build `_.template` utilizes\n     * [sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl)\n     * for easier debugging.\n     *\n     * For more information on precompiling templates see\n     * [lodash's custom builds documentation](https://lodash.com/custom-builds).\n     *\n     * For more information on Chrome extension sandboxes see\n     * [Chrome's extensions documentation](https://developer.chrome.com/extensions/sandboxingEval).\n     *\n     * @static\n     * @memberOf _\n     * @category String\n     * @param {string} [string=''] The template string.\n     * @param {Object} [options] The options object.\n     * @param {RegExp} [options.escape] The HTML \"escape\" delimiter.\n     * @param {RegExp} [options.evaluate] The \"evaluate\" delimiter.\n     * @param {Object} [options.imports] An object to import into the template as free variables.\n     * @param {RegExp} [options.interpolate] The \"interpolate\" delimiter.\n     * @param {string} [options.sourceURL] The sourceURL of the template's compiled source.\n     * @param {string} [options.variable] The data object variable name.\n     * @param- {Object} [otherOptions] Enables the legacy `options` param signature.\n     * @returns {Function} Returns the compiled template function.\n     * @example\n     *\n     * // using the \"interpolate\" delimiter to create a compiled template\n     * var compiled = _.template('hello <%= user %>!');\n     * compiled({ 'user': 'fred' });\n     * // => 'hello fred!'\n     *\n     * // using the HTML \"escape\" delimiter to escape data property values\n     * var compiled = _.template('<b><%- value %></b>');\n     * compiled({ 'value': '<script>' });\n     * // => '<b>&lt;script&gt;</b>'\n     *\n     * // using the \"evaluate\" delimiter to execute JavaScript and generate HTML\n     * var compiled = _.template('<% _.forEach(users, function(user) { %><li><%- user %></li><% }); %>');\n     * compiled({ 'users': ['fred', 'barney'] });\n     * // => '<li>fred</li><li>barney</li>'\n     *\n     * // using the internal `print` function in \"evaluate\" delimiters\n     * var compiled = _.template('<% print(\"hello \" + user); %>!');\n     * compiled({ 'user': 'barney' });\n     * // => 'hello barney!'\n     *\n     * // using the ES delimiter as an alternative to the default \"interpolate\" delimiter\n     * var compiled = _.template('hello ${ user }!');\n     * compiled({ 'user': 'pebbles' });\n     * // => 'hello pebbles!'\n     *\n     * // using custom template delimiters\n     * _.templateSettings.interpolate = /{{([\\s\\S]+?)}}/g;\n     * var compiled = _.template('hello {{ user }}!');\n     * compiled({ 'user': 'mustache' });\n     * // => 'hello mustache!'\n     *\n     * // using backslashes to treat delimiters as plain text\n     * var compiled = _.template('<%= \"\\\\<%- value %\\\\>\" %>');\n     * compiled({ 'value': 'ignored' });\n     * // => '<%- value %>'\n     *\n     * // using the `imports` option to import `jQuery` as `jq`\n     * var text = '<% jq.each(users, function(user) { %><li><%- user %></li><% }); %>';\n     * var compiled = _.template(text, { 'imports': { 'jq': jQuery } });\n     * compiled({ 'users': ['fred', 'barney'] });\n     * // => '<li>fred</li><li>barney</li>'\n     *\n     * // using the `sourceURL` option to specify a custom sourceURL for the template\n     * var compiled = _.template('hello <%= user %>!', { 'sourceURL': '/basic/greeting.jst' });\n     * compiled(data);\n     * // => find the source of \"greeting.jst\" under the Sources tab or Resources panel of the web inspector\n     *\n     * // using the `variable` option to ensure a with-statement isn't used in the compiled template\n     * var compiled = _.template('hi <%= data.user %>!', { 'variable': 'data' });\n     * compiled.source;\n     * // => function(data) {\n     * //   var __t, __p = '';\n     * //   __p += 'hi ' + ((__t = ( data.user )) == null ? '' : __t) + '!';\n     * //   return __p;\n     * // }\n     *\n     * // using the `source` property to inline compiled templates for meaningful\n     * // line numbers in error messages and a stack trace\n     * fs.writeFileSync(path.join(cwd, 'jst.js'), '\\\n     *   var JST = {\\\n     *     \"main\": ' + _.template(mainText).source + '\\\n     *   };\\\n     * ');\n     */\n    function template(string, options, otherOptions) {\n      // Based on John Resig's `tmpl` implementation (http://ejohn.org/blog/javascript-micro-templating/)\n      // and Laura Doktorova's doT.js (https://github.com/olado/doT).\n      var settings = lodash.templateSettings;\n\n      if (otherOptions && isIterateeCall(string, options, otherOptions)) {\n        options = otherOptions = undefined;\n      }\n      string = baseToString(string);\n      options = assignWith(baseAssign({}, otherOptions || options), settings, assignOwnDefaults);\n\n      var imports = assignWith(baseAssign({}, options.imports), settings.imports, assignOwnDefaults),\n          importsKeys = keys(imports),\n          importsValues = baseValues(imports, importsKeys);\n\n      var isEscaping,\n          isEvaluating,\n          index = 0,\n          interpolate = options.interpolate || reNoMatch,\n          source = \"__p += '\";\n\n      // Compile the regexp to match each delimiter.\n      var reDelimiters = RegExp(\n        (options.escape || reNoMatch).source + '|' +\n        interpolate.source + '|' +\n        (interpolate === reInterpolate ? reEsTemplate : reNoMatch).source + '|' +\n        (options.evaluate || reNoMatch).source + '|$'\n      , 'g');\n\n      // Use a sourceURL for easier debugging.\n      var sourceURL = '//# sourceURL=' +\n        ('sourceURL' in options\n          ? options.sourceURL\n          : ('lodash.templateSources[' + (++templateCounter) + ']')\n        ) + '\\n';\n\n      string.replace(reDelimiters, function(match, escapeValue, interpolateValue, esTemplateValue, evaluateValue, offset) {\n        interpolateValue || (interpolateValue = esTemplateValue);\n\n        // Escape characters that can't be included in string literals.\n        source += string.slice(index, offset).replace(reUnescapedString, escapeStringChar);\n\n        // Replace delimiters with snippets.\n        if (escapeValue) {\n          isEscaping = true;\n          source += \"' +\\n__e(\" + escapeValue + \") +\\n'\";\n        }\n        if (evaluateValue) {\n          isEvaluating = true;\n          source += \"';\\n\" + evaluateValue + \";\\n__p += '\";\n        }\n        if (interpolateValue) {\n          source += \"' +\\n((__t = (\" + interpolateValue + \")) == null ? '' : __t) +\\n'\";\n        }\n        index = offset + match.length;\n\n        // The JS engine embedded in Adobe products requires returning the `match`\n        // string in order to produce the correct `offset` value.\n        return match;\n      });\n\n      source += \"';\\n\";\n\n      // If `variable` is not specified wrap a with-statement around the generated\n      // code to add the data object to the top of the scope chain.\n      var variable = options.variable;\n      if (!variable) {\n        source = 'with (obj) {\\n' + source + '\\n}\\n';\n      }\n      // Cleanup code by stripping empty strings.\n      source = (isEvaluating ? source.replace(reEmptyStringLeading, '') : source)\n        .replace(reEmptyStringMiddle, '$1')\n        .replace(reEmptyStringTrailing, '$1;');\n\n      // Frame code as the function body.\n      source = 'function(' + (variable || 'obj') + ') {\\n' +\n        (variable\n          ? ''\n          : 'obj || (obj = {});\\n'\n        ) +\n        \"var __t, __p = ''\" +\n        (isEscaping\n           ? ', __e = _.escape'\n           : ''\n        ) +\n        (isEvaluating\n          ? ', __j = Array.prototype.join;\\n' +\n            \"function print() { __p += __j.call(arguments, '') }\\n\"\n          : ';\\n'\n        ) +\n        source +\n        'return __p\\n}';\n\n      var result = attempt(function() {\n        return Function(importsKeys, sourceURL + 'return ' + source).apply(undefined, importsValues);\n      });\n\n      // Provide the compiled function's source by its `toString` method or\n      // the `source` property as a convenience for inlining compiled templates.\n      result.source = source;\n      if (isError(result)) {\n        throw result;\n      }\n      return result;\n    }\n\n    /**\n     * Removes leading and trailing whitespace or specified characters from `string`.\n     *\n     * @static\n     * @memberOf _\n     * @category String\n     * @param {string} [string=''] The string to trim.\n     * @param {string} [chars=whitespace] The characters to trim.\n     * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.\n     * @returns {string} Returns the trimmed string.\n     * @example\n     *\n     * _.trim('  abc  ');\n     * // => 'abc'\n     *\n     * _.trim('-_-abc-_-', '_-');\n     * // => 'abc'\n     *\n     * _.map(['  foo  ', '  bar  '], _.trim);\n     * // => ['foo', 'bar']\n     */\n    function trim(string, chars, guard) {\n      var value = string;\n      string = baseToString(string);\n      if (!string) {\n        return string;\n      }\n      if (guard ? isIterateeCall(value, chars, guard) : chars == null) {\n        return string.slice(trimmedLeftIndex(string), trimmedRightIndex(string) + 1);\n      }\n      chars = (chars + '');\n      return string.slice(charsLeftIndex(string, chars), charsRightIndex(string, chars) + 1);\n    }\n\n    /**\n     * Removes leading whitespace or specified characters from `string`.\n     *\n     * @static\n     * @memberOf _\n     * @category String\n     * @param {string} [string=''] The string to trim.\n     * @param {string} [chars=whitespace] The characters to trim.\n     * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.\n     * @returns {string} Returns the trimmed string.\n     * @example\n     *\n     * _.trimLeft('  abc  ');\n     * // => 'abc  '\n     *\n     * _.trimLeft('-_-abc-_-', '_-');\n     * // => 'abc-_-'\n     */\n    function trimLeft(string, chars, guard) {\n      var value = string;\n      string = baseToString(string);\n      if (!string) {\n        return string;\n      }\n      if (guard ? isIterateeCall(value, chars, guard) : chars == null) {\n        return string.slice(trimmedLeftIndex(string));\n      }\n      return string.slice(charsLeftIndex(string, (chars + '')));\n    }\n\n    /**\n     * Removes trailing whitespace or specified characters from `string`.\n     *\n     * @static\n     * @memberOf _\n     * @category String\n     * @param {string} [string=''] The string to trim.\n     * @param {string} [chars=whitespace] The characters to trim.\n     * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.\n     * @returns {string} Returns the trimmed string.\n     * @example\n     *\n     * _.trimRight('  abc  ');\n     * // => '  abc'\n     *\n     * _.trimRight('-_-abc-_-', '_-');\n     * // => '-_-abc'\n     */\n    function trimRight(string, chars, guard) {\n      var value = string;\n      string = baseToString(string);\n      if (!string) {\n        return string;\n      }\n      if (guard ? isIterateeCall(value, chars, guard) : chars == null) {\n        return string.slice(0, trimmedRightIndex(string) + 1);\n      }\n      return string.slice(0, charsRightIndex(string, (chars + '')) + 1);\n    }\n\n    /**\n     * Truncates `string` if it's longer than the given maximum string length.\n     * The last characters of the truncated string are replaced with the omission\n     * string which defaults to \"...\".\n     *\n     * @static\n     * @memberOf _\n     * @category String\n     * @param {string} [string=''] The string to truncate.\n     * @param {Object|number} [options] The options object or maximum string length.\n     * @param {number} [options.length=30] The maximum string length.\n     * @param {string} [options.omission='...'] The string to indicate text is omitted.\n     * @param {RegExp|string} [options.separator] The separator pattern to truncate to.\n     * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.\n     * @returns {string} Returns the truncated string.\n     * @example\n     *\n     * _.trunc('hi-diddly-ho there, neighborino');\n     * // => 'hi-diddly-ho there, neighbo...'\n     *\n     * _.trunc('hi-diddly-ho there, neighborino', 24);\n     * // => 'hi-diddly-ho there, n...'\n     *\n     * _.trunc('hi-diddly-ho there, neighborino', {\n     *   'length': 24,\n     *   'separator': ' '\n     * });\n     * // => 'hi-diddly-ho there,...'\n     *\n     * _.trunc('hi-diddly-ho there, neighborino', {\n     *   'length': 24,\n     *   'separator': /,? +/\n     * });\n     * // => 'hi-diddly-ho there...'\n     *\n     * _.trunc('hi-diddly-ho there, neighborino', {\n     *   'omission': ' [...]'\n     * });\n     * // => 'hi-diddly-ho there, neig [...]'\n     */\n    function trunc(string, options, guard) {\n      if (guard && isIterateeCall(string, options, guard)) {\n        options = undefined;\n      }\n      var length = DEFAULT_TRUNC_LENGTH,\n          omission = DEFAULT_TRUNC_OMISSION;\n\n      if (options != null) {\n        if (isObject(options)) {\n          var separator = 'separator' in options ? options.separator : separator;\n          length = 'length' in options ? (+options.length || 0) : length;\n          omission = 'omission' in options ? baseToString(options.omission) : omission;\n        } else {\n          length = +options || 0;\n        }\n      }\n      string = baseToString(string);\n      if (length >= string.length) {\n        return string;\n      }\n      var end = length - omission.length;\n      if (end < 1) {\n        return omission;\n      }\n      var result = string.slice(0, end);\n      if (separator == null) {\n        return result + omission;\n      }\n      if (isRegExp(separator)) {\n        if (string.slice(end).search(separator)) {\n          var match,\n              newEnd,\n              substring = string.slice(0, end);\n\n          if (!separator.global) {\n            separator = RegExp(separator.source, (reFlags.exec(separator) || '') + 'g');\n          }\n          separator.lastIndex = 0;\n          while ((match = separator.exec(substring))) {\n            newEnd = match.index;\n          }\n          result = result.slice(0, newEnd == null ? end : newEnd);\n        }\n      } else if (string.indexOf(separator, end) != end) {\n        var index = result.lastIndexOf(separator);\n        if (index > -1) {\n          result = result.slice(0, index);\n        }\n      }\n      return result + omission;\n    }\n\n    /**\n     * The inverse of `_.escape`; this method converts the HTML entities\n     * `&amp;`, `&lt;`, `&gt;`, `&quot;`, `&#39;`, and `&#96;` in `string` to their\n     * corresponding characters.\n     *\n     * **Note:** No other HTML entities are unescaped. To unescape additional HTML\n     * entities use a third-party library like [_he_](https://mths.be/he).\n     *\n     * @static\n     * @memberOf _\n     * @category String\n     * @param {string} [string=''] The string to unescape.\n     * @returns {string} Returns the unescaped string.\n     * @example\n     *\n     * _.unescape('fred, barney, &amp; pebbles');\n     * // => 'fred, barney, & pebbles'\n     */\n    function unescape(string) {\n      string = baseToString(string);\n      return (string && reHasEscapedHtml.test(string))\n        ? string.replace(reEscapedHtml, unescapeHtmlChar)\n        : string;\n    }\n\n    /**\n     * Splits `string` into an array of its words.\n     *\n     * @static\n     * @memberOf _\n     * @category String\n     * @param {string} [string=''] The string to inspect.\n     * @param {RegExp|string} [pattern] The pattern to match words.\n     * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.\n     * @returns {Array} Returns the words of `string`.\n     * @example\n     *\n     * _.words('fred, barney, & pebbles');\n     * // => ['fred', 'barney', 'pebbles']\n     *\n     * _.words('fred, barney, & pebbles', /[^, ]+/g);\n     * // => ['fred', 'barney', '&', 'pebbles']\n     */\n    function words(string, pattern, guard) {\n      if (guard && isIterateeCall(string, pattern, guard)) {\n        pattern = undefined;\n      }\n      string = baseToString(string);\n      return string.match(pattern || reWords) || [];\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Attempts to invoke `func`, returning either the result or the caught error\n     * object. Any additional arguments are provided to `func` when it is invoked.\n     *\n     * @static\n     * @memberOf _\n     * @category Utility\n     * @param {Function} func The function to attempt.\n     * @returns {*} Returns the `func` result or error object.\n     * @example\n     *\n     * // avoid throwing errors for invalid selectors\n     * var elements = _.attempt(function(selector) {\n     *   return document.querySelectorAll(selector);\n     * }, '>_>');\n     *\n     * if (_.isError(elements)) {\n     *   elements = [];\n     * }\n     */\n    var attempt = restParam(function(func, args) {\n      try {\n        return func.apply(undefined, args);\n      } catch(e) {\n        return isError(e) ? e : new Error(e);\n      }\n    });\n\n    /**\n     * Creates a function that invokes `func` with the `this` binding of `thisArg`\n     * and arguments of the created function. If `func` is a property name the\n     * created callback returns the property value for a given element. If `func`\n     * is an object the created callback returns `true` for elements that contain\n     * the equivalent object properties, otherwise it returns `false`.\n     *\n     * @static\n     * @memberOf _\n     * @alias iteratee\n     * @category Utility\n     * @param {*} [func=_.identity] The value to convert to a callback.\n     * @param {*} [thisArg] The `this` binding of `func`.\n     * @param- {Object} [guard] Enables use as a callback for functions like `_.map`.\n     * @returns {Function} Returns the callback.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney', 'age': 36 },\n     *   { 'user': 'fred',   'age': 40 }\n     * ];\n     *\n     * // wrap to create custom callback shorthands\n     * _.callback = _.wrap(_.callback, function(callback, func, thisArg) {\n     *   var match = /^(.+?)__([gl]t)(.+)$/.exec(func);\n     *   if (!match) {\n     *     return callback(func, thisArg);\n     *   }\n     *   return function(object) {\n     *     return match[2] == 'gt'\n     *       ? object[match[1]] > match[3]\n     *       : object[match[1]] < match[3];\n     *   };\n     * });\n     *\n     * _.filter(users, 'age__gt36');\n     * // => [{ 'user': 'fred', 'age': 40 }]\n     */\n    function callback(func, thisArg, guard) {\n      if (guard && isIterateeCall(func, thisArg, guard)) {\n        thisArg = undefined;\n      }\n      return isObjectLike(func)\n        ? matches(func)\n        : baseCallback(func, thisArg);\n    }\n\n    /**\n     * Creates a function that returns `value`.\n     *\n     * @static\n     * @memberOf _\n     * @category Utility\n     * @param {*} value The value to return from the new function.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var object = { 'user': 'fred' };\n     * var getter = _.constant(object);\n     *\n     * getter() === object;\n     * // => true\n     */\n    function constant(value) {\n      return function() {\n        return value;\n      };\n    }\n\n    /**\n     * This method returns the first argument provided to it.\n     *\n     * @static\n     * @memberOf _\n     * @category Utility\n     * @param {*} value Any value.\n     * @returns {*} Returns `value`.\n     * @example\n     *\n     * var object = { 'user': 'fred' };\n     *\n     * _.identity(object) === object;\n     * // => true\n     */\n    function identity(value) {\n      return value;\n    }\n\n    /**\n     * Creates a function that performs a deep comparison between a given object\n     * and `source`, returning `true` if the given object has equivalent property\n     * values, else `false`.\n     *\n     * **Note:** This method supports comparing arrays, booleans, `Date` objects,\n     * numbers, `Object` objects, regexes, and strings. Objects are compared by\n     * their own, not inherited, enumerable properties. For comparing a single\n     * own or inherited property value see `_.matchesProperty`.\n     *\n     * @static\n     * @memberOf _\n     * @category Utility\n     * @param {Object} source The object of property values to match.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney', 'age': 36, 'active': true },\n     *   { 'user': 'fred',   'age': 40, 'active': false }\n     * ];\n     *\n     * _.filter(users, _.matches({ 'age': 40, 'active': false }));\n     * // => [{ 'user': 'fred', 'age': 40, 'active': false }]\n     */\n    function matches(source) {\n      return baseMatches(baseClone(source, true));\n    }\n\n    /**\n     * Creates a function that compares the property value of `path` on a given\n     * object to `value`.\n     *\n     * **Note:** This method supports comparing arrays, booleans, `Date` objects,\n     * numbers, `Object` objects, regexes, and strings. Objects are compared by\n     * their own, not inherited, enumerable properties.\n     *\n     * @static\n     * @memberOf _\n     * @category Utility\n     * @param {Array|string} path The path of the property to get.\n     * @param {*} srcValue The value to match.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var users = [\n     *   { 'user': 'barney' },\n     *   { 'user': 'fred' }\n     * ];\n     *\n     * _.find(users, _.matchesProperty('user', 'fred'));\n     * // => { 'user': 'fred' }\n     */\n    function matchesProperty(path, srcValue) {\n      return baseMatchesProperty(path, baseClone(srcValue, true));\n    }\n\n    /**\n     * Creates a function that invokes the method at `path` on a given object.\n     * Any additional arguments are provided to the invoked method.\n     *\n     * @static\n     * @memberOf _\n     * @category Utility\n     * @param {Array|string} path The path of the method to invoke.\n     * @param {...*} [args] The arguments to invoke the method with.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var objects = [\n     *   { 'a': { 'b': { 'c': _.constant(2) } } },\n     *   { 'a': { 'b': { 'c': _.constant(1) } } }\n     * ];\n     *\n     * _.map(objects, _.method('a.b.c'));\n     * // => [2, 1]\n     *\n     * _.invoke(_.sortBy(objects, _.method(['a', 'b', 'c'])), 'a.b.c');\n     * // => [1, 2]\n     */\n    var method = restParam(function(path, args) {\n      return function(object) {\n        return invokePath(object, path, args);\n      };\n    });\n\n    /**\n     * The opposite of `_.method`; this method creates a function that invokes\n     * the method at a given path on `object`. Any additional arguments are\n     * provided to the invoked method.\n     *\n     * @static\n     * @memberOf _\n     * @category Utility\n     * @param {Object} object The object to query.\n     * @param {...*} [args] The arguments to invoke the method with.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var array = _.times(3, _.constant),\n     *     object = { 'a': array, 'b': array, 'c': array };\n     *\n     * _.map(['a[2]', 'c[0]'], _.methodOf(object));\n     * // => [2, 0]\n     *\n     * _.map([['a', '2'], ['c', '0']], _.methodOf(object));\n     * // => [2, 0]\n     */\n    var methodOf = restParam(function(object, args) {\n      return function(path) {\n        return invokePath(object, path, args);\n      };\n    });\n\n    /**\n     * Adds all own enumerable function properties of a source object to the\n     * destination object. If `object` is a function then methods are added to\n     * its prototype as well.\n     *\n     * **Note:** Use `_.runInContext` to create a pristine `lodash` function to\n     * avoid conflicts caused by modifying the original.\n     *\n     * @static\n     * @memberOf _\n     * @category Utility\n     * @param {Function|Object} [object=lodash] The destination object.\n     * @param {Object} source The object of functions to add.\n     * @param {Object} [options] The options object.\n     * @param {boolean} [options.chain=true] Specify whether the functions added\n     *  are chainable.\n     * @returns {Function|Object} Returns `object`.\n     * @example\n     *\n     * function vowels(string) {\n     *   return _.filter(string, function(v) {\n     *     return /[aeiou]/i.test(v);\n     *   });\n     * }\n     *\n     * _.mixin({ 'vowels': vowels });\n     * _.vowels('fred');\n     * // => ['e']\n     *\n     * _('fred').vowels().value();\n     * // => ['e']\n     *\n     * _.mixin({ 'vowels': vowels }, { 'chain': false });\n     * _('fred').vowels();\n     * // => ['e']\n     */\n    function mixin(object, source, options) {\n      if (options == null) {\n        var isObj = isObject(source),\n            props = isObj ? keys(source) : undefined,\n            methodNames = (props && props.length) ? baseFunctions(source, props) : undefined;\n\n        if (!(methodNames ? methodNames.length : isObj)) {\n          methodNames = false;\n          options = source;\n          source = object;\n          object = this;\n        }\n      }\n      if (!methodNames) {\n        methodNames = baseFunctions(source, keys(source));\n      }\n      var chain = true,\n          index = -1,\n          isFunc = isFunction(object),\n          length = methodNames.length;\n\n      if (options === false) {\n        chain = false;\n      } else if (isObject(options) && 'chain' in options) {\n        chain = options.chain;\n      }\n      while (++index < length) {\n        var methodName = methodNames[index],\n            func = source[methodName];\n\n        object[methodName] = func;\n        if (isFunc) {\n          object.prototype[methodName] = (function(func) {\n            return function() {\n              var chainAll = this.__chain__;\n              if (chain || chainAll) {\n                var result = object(this.__wrapped__),\n                    actions = result.__actions__ = arrayCopy(this.__actions__);\n\n                actions.push({ 'func': func, 'args': arguments, 'thisArg': object });\n                result.__chain__ = chainAll;\n                return result;\n              }\n              return func.apply(object, arrayPush([this.value()], arguments));\n            };\n          }(func));\n        }\n      }\n      return object;\n    }\n\n    /**\n     * Reverts the `_` variable to its previous value and returns a reference to\n     * the `lodash` function.\n     *\n     * @static\n     * @memberOf _\n     * @category Utility\n     * @returns {Function} Returns the `lodash` function.\n     * @example\n     *\n     * var lodash = _.noConflict();\n     */\n    function noConflict() {\n      root._ = oldDash;\n      return this;\n    }\n\n    /**\n     * A no-operation function that returns `undefined` regardless of the\n     * arguments it receives.\n     *\n     * @static\n     * @memberOf _\n     * @category Utility\n     * @example\n     *\n     * var object = { 'user': 'fred' };\n     *\n     * _.noop(object) === undefined;\n     * // => true\n     */\n    function noop() {\n      // No operation performed.\n    }\n\n    /**\n     * Creates a function that returns the property value at `path` on a\n     * given object.\n     *\n     * @static\n     * @memberOf _\n     * @category Utility\n     * @param {Array|string} path The path of the property to get.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var objects = [\n     *   { 'a': { 'b': { 'c': 2 } } },\n     *   { 'a': { 'b': { 'c': 1 } } }\n     * ];\n     *\n     * _.map(objects, _.property('a.b.c'));\n     * // => [2, 1]\n     *\n     * _.pluck(_.sortBy(objects, _.property(['a', 'b', 'c'])), 'a.b.c');\n     * // => [1, 2]\n     */\n    function property(path) {\n      return isKey(path) ? baseProperty(path) : basePropertyDeep(path);\n    }\n\n    /**\n     * The opposite of `_.property`; this method creates a function that returns\n     * the property value at a given path on `object`.\n     *\n     * @static\n     * @memberOf _\n     * @category Utility\n     * @param {Object} object The object to query.\n     * @returns {Function} Returns the new function.\n     * @example\n     *\n     * var array = [0, 1, 2],\n     *     object = { 'a': array, 'b': array, 'c': array };\n     *\n     * _.map(['a[2]', 'c[0]'], _.propertyOf(object));\n     * // => [2, 0]\n     *\n     * _.map([['a', '2'], ['c', '0']], _.propertyOf(object));\n     * // => [2, 0]\n     */\n    function propertyOf(object) {\n      return function(path) {\n        return baseGet(object, toPath(path), path + '');\n      };\n    }\n\n    /**\n     * Creates an array of numbers (positive and/or negative) progressing from\n     * `start` up to, but not including, `end`. If `end` is not specified it is\n     * set to `start` with `start` then set to `0`. If `end` is less than `start`\n     * a zero-length range is created unless a negative `step` is specified.\n     *\n     * @static\n     * @memberOf _\n     * @category Utility\n     * @param {number} [start=0] The start of the range.\n     * @param {number} end The end of the range.\n     * @param {number} [step=1] The value to increment or decrement by.\n     * @returns {Array} Returns the new array of numbers.\n     * @example\n     *\n     * _.range(4);\n     * // => [0, 1, 2, 3]\n     *\n     * _.range(1, 5);\n     * // => [1, 2, 3, 4]\n     *\n     * _.range(0, 20, 5);\n     * // => [0, 5, 10, 15]\n     *\n     * _.range(0, -4, -1);\n     * // => [0, -1, -2, -3]\n     *\n     * _.range(1, 4, 0);\n     * // => [1, 1, 1]\n     *\n     * _.range(0);\n     * // => []\n     */\n    function range(start, end, step) {\n      if (step && isIterateeCall(start, end, step)) {\n        end = step = undefined;\n      }\n      start = +start || 0;\n      step = step == null ? 1 : (+step || 0);\n\n      if (end == null) {\n        end = start;\n        start = 0;\n      } else {\n        end = +end || 0;\n      }\n      // Use `Array(length)` so engines like Chakra and V8 avoid slower modes.\n      // See https://youtu.be/XAqIpGU8ZZk#t=17m25s for more details.\n      var index = -1,\n          length = nativeMax(nativeCeil((end - start) / (step || 1)), 0),\n          result = Array(length);\n\n      while (++index < length) {\n        result[index] = start;\n        start += step;\n      }\n      return result;\n    }\n\n    /**\n     * Invokes the iteratee function `n` times, returning an array of the results\n     * of each invocation. The `iteratee` is bound to `thisArg` and invoked with\n     * one argument; (index).\n     *\n     * @static\n     * @memberOf _\n     * @category Utility\n     * @param {number} n The number of times to invoke `iteratee`.\n     * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n     * @param {*} [thisArg] The `this` binding of `iteratee`.\n     * @returns {Array} Returns the array of results.\n     * @example\n     *\n     * var diceRolls = _.times(3, _.partial(_.random, 1, 6, false));\n     * // => [3, 6, 4]\n     *\n     * _.times(3, function(n) {\n     *   mage.castSpell(n);\n     * });\n     * // => invokes `mage.castSpell(n)` three times with `n` of `0`, `1`, and `2`\n     *\n     * _.times(3, function(n) {\n     *   this.cast(n);\n     * }, mage);\n     * // => also invokes `mage.castSpell(n)` three times\n     */\n    function times(n, iteratee, thisArg) {\n      n = nativeFloor(n);\n\n      // Exit early to avoid a JSC JIT bug in Safari 8\n      // where `Array(0)` is treated as `Array(1)`.\n      if (n < 1 || !nativeIsFinite(n)) {\n        return [];\n      }\n      var index = -1,\n          result = Array(nativeMin(n, MAX_ARRAY_LENGTH));\n\n      iteratee = bindCallback(iteratee, thisArg, 1);\n      while (++index < n) {\n        if (index < MAX_ARRAY_LENGTH) {\n          result[index] = iteratee(index);\n        } else {\n          iteratee(index);\n        }\n      }\n      return result;\n    }\n\n    /**\n     * Generates a unique ID. If `prefix` is provided the ID is appended to it.\n     *\n     * @static\n     * @memberOf _\n     * @category Utility\n     * @param {string} [prefix] The value to prefix the ID with.\n     * @returns {string} Returns the unique ID.\n     * @example\n     *\n     * _.uniqueId('contact_');\n     * // => 'contact_104'\n     *\n     * _.uniqueId();\n     * // => '105'\n     */\n    function uniqueId(prefix) {\n      var id = ++idCounter;\n      return baseToString(prefix) + id;\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * Adds two numbers.\n     *\n     * @static\n     * @memberOf _\n     * @category Math\n     * @param {number} augend The first number to add.\n     * @param {number} addend The second number to add.\n     * @returns {number} Returns the sum.\n     * @example\n     *\n     * _.add(6, 4);\n     * // => 10\n     */\n    function add(augend, addend) {\n      return (+augend || 0) + (+addend || 0);\n    }\n\n    /**\n     * Calculates `n` rounded up to `precision`.\n     *\n     * @static\n     * @memberOf _\n     * @category Math\n     * @param {number} n The number to round up.\n     * @param {number} [precision=0] The precision to round up to.\n     * @returns {number} Returns the rounded up number.\n     * @example\n     *\n     * _.ceil(4.006);\n     * // => 5\n     *\n     * _.ceil(6.004, 2);\n     * // => 6.01\n     *\n     * _.ceil(6040, -2);\n     * // => 6100\n     */\n    var ceil = createRound('ceil');\n\n    /**\n     * Calculates `n` rounded down to `precision`.\n     *\n     * @static\n     * @memberOf _\n     * @category Math\n     * @param {number} n The number to round down.\n     * @param {number} [precision=0] The precision to round down to.\n     * @returns {number} Returns the rounded down number.\n     * @example\n     *\n     * _.floor(4.006);\n     * // => 4\n     *\n     * _.floor(0.046, 2);\n     * // => 0.04\n     *\n     * _.floor(4060, -2);\n     * // => 4000\n     */\n    var floor = createRound('floor');\n\n    /**\n     * Gets the maximum value of `collection`. If `collection` is empty or falsey\n     * `-Infinity` is returned. If an iteratee function is provided it is invoked\n     * for each value in `collection` to generate the criterion by which the value\n     * is ranked. The `iteratee` is bound to `thisArg` and invoked with three\n     * arguments: (value, index, collection).\n     *\n     * If a property name is provided for `iteratee` the created `_.property`\n     * style callback returns the property value of the given element.\n     *\n     * If a value is also provided for `thisArg` the created `_.matchesProperty`\n     * style callback returns `true` for elements that have a matching property\n     * value, else `false`.\n     *\n     * If an object is provided for `iteratee` the created `_.matches` style\n     * callback returns `true` for elements that have the properties of the given\n     * object, else `false`.\n     *\n     * @static\n     * @memberOf _\n     * @category Math\n     * @param {Array|Object|string} collection The collection to iterate over.\n     * @param {Function|Object|string} [iteratee] The function invoked per iteration.\n     * @param {*} [thisArg] The `this` binding of `iteratee`.\n     * @returns {*} Returns the maximum value.\n     * @example\n     *\n     * _.max([4, 2, 8, 6]);\n     * // => 8\n     *\n     * _.max([]);\n     * // => -Infinity\n     *\n     * var users = [\n     *   { 'user': 'barney', 'age': 36 },\n     *   { 'user': 'fred',   'age': 40 }\n     * ];\n     *\n     * _.max(users, function(chr) {\n     *   return chr.age;\n     * });\n     * // => { 'user': 'fred', 'age': 40 }\n     *\n     * // using the `_.property` callback shorthand\n     * _.max(users, 'age');\n     * // => { 'user': 'fred', 'age': 40 }\n     */\n    var max = createExtremum(gt, NEGATIVE_INFINITY);\n\n    /**\n     * Gets the minimum value of `collection`. If `collection` is empty or falsey\n     * `Infinity` is returned. If an iteratee function is provided it is invoked\n     * for each value in `collection` to generate the criterion by which the value\n     * is ranked. The `iteratee` is bound to `thisArg` and invoked with three\n     * arguments: (value, index, collection).\n     *\n     * If a property name is provided for `iteratee` the created `_.property`\n     * style callback returns the property value of the given element.\n     *\n     * If a value is also provided for `thisArg` the created `_.matchesProperty`\n     * style callback returns `true` for elements that have a matching property\n     * value, else `false`.\n     *\n     * If an object is provided for `iteratee` the created `_.matches` style\n     * callback returns `true` for elements that have the properties of the given\n     * object, else `false`.\n     *\n     * @static\n     * @memberOf _\n     * @category Math\n     * @param {Array|Object|string} collection The collection to iterate over.\n     * @param {Function|Object|string} [iteratee] The function invoked per iteration.\n     * @param {*} [thisArg] The `this` binding of `iteratee`.\n     * @returns {*} Returns the minimum value.\n     * @example\n     *\n     * _.min([4, 2, 8, 6]);\n     * // => 2\n     *\n     * _.min([]);\n     * // => Infinity\n     *\n     * var users = [\n     *   { 'user': 'barney', 'age': 36 },\n     *   { 'user': 'fred',   'age': 40 }\n     * ];\n     *\n     * _.min(users, function(chr) {\n     *   return chr.age;\n     * });\n     * // => { 'user': 'barney', 'age': 36 }\n     *\n     * // using the `_.property` callback shorthand\n     * _.min(users, 'age');\n     * // => { 'user': 'barney', 'age': 36 }\n     */\n    var min = createExtremum(lt, POSITIVE_INFINITY);\n\n    /**\n     * Calculates `n` rounded to `precision`.\n     *\n     * @static\n     * @memberOf _\n     * @category Math\n     * @param {number} n The number to round.\n     * @param {number} [precision=0] The precision to round to.\n     * @returns {number} Returns the rounded number.\n     * @example\n     *\n     * _.round(4.006);\n     * // => 4\n     *\n     * _.round(4.006, 2);\n     * // => 4.01\n     *\n     * _.round(4060, -2);\n     * // => 4100\n     */\n    var round = createRound('round');\n\n    /**\n     * Gets the sum of the values in `collection`.\n     *\n     * @static\n     * @memberOf _\n     * @category Math\n     * @param {Array|Object|string} collection The collection to iterate over.\n     * @param {Function|Object|string} [iteratee] The function invoked per iteration.\n     * @param {*} [thisArg] The `this` binding of `iteratee`.\n     * @returns {number} Returns the sum.\n     * @example\n     *\n     * _.sum([4, 6]);\n     * // => 10\n     *\n     * _.sum({ 'a': 4, 'b': 6 });\n     * // => 10\n     *\n     * var objects = [\n     *   { 'n': 4 },\n     *   { 'n': 6 }\n     * ];\n     *\n     * _.sum(objects, function(object) {\n     *   return object.n;\n     * });\n     * // => 10\n     *\n     * // using the `_.property` callback shorthand\n     * _.sum(objects, 'n');\n     * // => 10\n     */\n    function sum(collection, iteratee, thisArg) {\n      if (thisArg && isIterateeCall(collection, iteratee, thisArg)) {\n        iteratee = undefined;\n      }\n      iteratee = getCallback(iteratee, thisArg, 3);\n      return iteratee.length == 1\n        ? arraySum(isArray(collection) ? collection : toIterable(collection), iteratee)\n        : baseSum(collection, iteratee);\n    }\n\n    /*------------------------------------------------------------------------*/\n\n    // Ensure wrappers are instances of `baseLodash`.\n    lodash.prototype = baseLodash.prototype;\n\n    LodashWrapper.prototype = baseCreate(baseLodash.prototype);\n    LodashWrapper.prototype.constructor = LodashWrapper;\n\n    LazyWrapper.prototype = baseCreate(baseLodash.prototype);\n    LazyWrapper.prototype.constructor = LazyWrapper;\n\n    // Add functions to the `Map` cache.\n    MapCache.prototype['delete'] = mapDelete;\n    MapCache.prototype.get = mapGet;\n    MapCache.prototype.has = mapHas;\n    MapCache.prototype.set = mapSet;\n\n    // Add functions to the `Set` cache.\n    SetCache.prototype.push = cachePush;\n\n    // Assign cache to `_.memoize`.\n    memoize.Cache = MapCache;\n\n    // Add functions that return wrapped values when chaining.\n    lodash.after = after;\n    lodash.ary = ary;\n    lodash.assign = assign;\n    lodash.at = at;\n    lodash.before = before;\n    lodash.bind = bind;\n    lodash.bindAll = bindAll;\n    lodash.bindKey = bindKey;\n    lodash.callback = callback;\n    lodash.chain = chain;\n    lodash.chunk = chunk;\n    lodash.compact = compact;\n    lodash.constant = constant;\n    lodash.countBy = countBy;\n    lodash.create = create;\n    lodash.curry = curry;\n    lodash.curryRight = curryRight;\n    lodash.debounce = debounce;\n    lodash.defaults = defaults;\n    lodash.defaultsDeep = defaultsDeep;\n    lodash.defer = defer;\n    lodash.delay = delay;\n    lodash.difference = difference;\n    lodash.drop = drop;\n    lodash.dropRight = dropRight;\n    lodash.dropRightWhile = dropRightWhile;\n    lodash.dropWhile = dropWhile;\n    lodash.fill = fill;\n    lodash.filter = filter;\n    lodash.flatten = flatten;\n    lodash.flattenDeep = flattenDeep;\n    lodash.flow = flow;\n    lodash.flowRight = flowRight;\n    lodash.forEach = forEach;\n    lodash.forEachRight = forEachRight;\n    lodash.forIn = forIn;\n    lodash.forInRight = forInRight;\n    lodash.forOwn = forOwn;\n    lodash.forOwnRight = forOwnRight;\n    lodash.functions = functions;\n    lodash.groupBy = groupBy;\n    lodash.indexBy = indexBy;\n    lodash.initial = initial;\n    lodash.intersection = intersection;\n    lodash.invert = invert;\n    lodash.invoke = invoke;\n    lodash.keys = keys;\n    lodash.keysIn = keysIn;\n    lodash.map = map;\n    lodash.mapKeys = mapKeys;\n    lodash.mapValues = mapValues;\n    lodash.matches = matches;\n    lodash.matchesProperty = matchesProperty;\n    lodash.memoize = memoize;\n    lodash.merge = merge;\n    lodash.method = method;\n    lodash.methodOf = methodOf;\n    lodash.mixin = mixin;\n    lodash.modArgs = modArgs;\n    lodash.negate = negate;\n    lodash.omit = omit;\n    lodash.once = once;\n    lodash.pairs = pairs;\n    lodash.partial = partial;\n    lodash.partialRight = partialRight;\n    lodash.partition = partition;\n    lodash.pick = pick;\n    lodash.pluck = pluck;\n    lodash.property = property;\n    lodash.propertyOf = propertyOf;\n    lodash.pull = pull;\n    lodash.pullAt = pullAt;\n    lodash.range = range;\n    lodash.rearg = rearg;\n    lodash.reject = reject;\n    lodash.remove = remove;\n    lodash.rest = rest;\n    lodash.restParam = restParam;\n    lodash.set = set;\n    lodash.shuffle = shuffle;\n    lodash.slice = slice;\n    lodash.sortBy = sortBy;\n    lodash.sortByAll = sortByAll;\n    lodash.sortByOrder = sortByOrder;\n    lodash.spread = spread;\n    lodash.take = take;\n    lodash.takeRight = takeRight;\n    lodash.takeRightWhile = takeRightWhile;\n    lodash.takeWhile = takeWhile;\n    lodash.tap = tap;\n    lodash.throttle = throttle;\n    lodash.thru = thru;\n    lodash.times = times;\n    lodash.toArray = toArray;\n    lodash.toPlainObject = toPlainObject;\n    lodash.transform = transform;\n    lodash.union = union;\n    lodash.uniq = uniq;\n    lodash.unzip = unzip;\n    lodash.unzipWith = unzipWith;\n    lodash.values = values;\n    lodash.valuesIn = valuesIn;\n    lodash.where = where;\n    lodash.without = without;\n    lodash.wrap = wrap;\n    lodash.xor = xor;\n    lodash.zip = zip;\n    lodash.zipObject = zipObject;\n    lodash.zipWith = zipWith;\n\n    // Add aliases.\n    lodash.backflow = flowRight;\n    lodash.collect = map;\n    lodash.compose = flowRight;\n    lodash.each = forEach;\n    lodash.eachRight = forEachRight;\n    lodash.extend = assign;\n    lodash.iteratee = callback;\n    lodash.methods = functions;\n    lodash.object = zipObject;\n    lodash.select = filter;\n    lodash.tail = rest;\n    lodash.unique = uniq;\n\n    // Add functions to `lodash.prototype`.\n    mixin(lodash, lodash);\n\n    /*------------------------------------------------------------------------*/\n\n    // Add functions that return unwrapped values when chaining.\n    lodash.add = add;\n    lodash.attempt = attempt;\n    lodash.camelCase = camelCase;\n    lodash.capitalize = capitalize;\n    lodash.ceil = ceil;\n    lodash.clone = clone;\n    lodash.cloneDeep = cloneDeep;\n    lodash.deburr = deburr;\n    lodash.endsWith = endsWith;\n    lodash.escape = escape;\n    lodash.escapeRegExp = escapeRegExp;\n    lodash.every = every;\n    lodash.find = find;\n    lodash.findIndex = findIndex;\n    lodash.findKey = findKey;\n    lodash.findLast = findLast;\n    lodash.findLastIndex = findLastIndex;\n    lodash.findLastKey = findLastKey;\n    lodash.findWhere = findWhere;\n    lodash.first = first;\n    lodash.floor = floor;\n    lodash.get = get;\n    lodash.gt = gt;\n    lodash.gte = gte;\n    lodash.has = has;\n    lodash.identity = identity;\n    lodash.includes = includes;\n    lodash.indexOf = indexOf;\n    lodash.inRange = inRange;\n    lodash.isArguments = isArguments;\n    lodash.isArray = isArray;\n    lodash.isBoolean = isBoolean;\n    lodash.isDate = isDate;\n    lodash.isElement = isElement;\n    lodash.isEmpty = isEmpty;\n    lodash.isEqual = isEqual;\n    lodash.isError = isError;\n    lodash.isFinite = isFinite;\n    lodash.isFunction = isFunction;\n    lodash.isMatch = isMatch;\n    lodash.isNaN = isNaN;\n    lodash.isNative = isNative;\n    lodash.isNull = isNull;\n    lodash.isNumber = isNumber;\n    lodash.isObject = isObject;\n    lodash.isPlainObject = isPlainObject;\n    lodash.isRegExp = isRegExp;\n    lodash.isString = isString;\n    lodash.isTypedArray = isTypedArray;\n    lodash.isUndefined = isUndefined;\n    lodash.kebabCase = kebabCase;\n    lodash.last = last;\n    lodash.lastIndexOf = lastIndexOf;\n    lodash.lt = lt;\n    lodash.lte = lte;\n    lodash.max = max;\n    lodash.min = min;\n    lodash.noConflict = noConflict;\n    lodash.noop = noop;\n    lodash.now = now;\n    lodash.pad = pad;\n    lodash.padLeft = padLeft;\n    lodash.padRight = padRight;\n    lodash.parseInt = parseInt;\n    lodash.random = random;\n    lodash.reduce = reduce;\n    lodash.reduceRight = reduceRight;\n    lodash.repeat = repeat;\n    lodash.result = result;\n    lodash.round = round;\n    lodash.runInContext = runInContext;\n    lodash.size = size;\n    lodash.snakeCase = snakeCase;\n    lodash.some = some;\n    lodash.sortedIndex = sortedIndex;\n    lodash.sortedLastIndex = sortedLastIndex;\n    lodash.startCase = startCase;\n    lodash.startsWith = startsWith;\n    lodash.sum = sum;\n    lodash.template = template;\n    lodash.trim = trim;\n    lodash.trimLeft = trimLeft;\n    lodash.trimRight = trimRight;\n    lodash.trunc = trunc;\n    lodash.unescape = unescape;\n    lodash.uniqueId = uniqueId;\n    lodash.words = words;\n\n    // Add aliases.\n    lodash.all = every;\n    lodash.any = some;\n    lodash.contains = includes;\n    lodash.eq = isEqual;\n    lodash.detect = find;\n    lodash.foldl = reduce;\n    lodash.foldr = reduceRight;\n    lodash.head = first;\n    lodash.include = includes;\n    lodash.inject = reduce;\n\n    mixin(lodash, (function() {\n      var source = {};\n      baseForOwn(lodash, function(func, methodName) {\n        if (!lodash.prototype[methodName]) {\n          source[methodName] = func;\n        }\n      });\n      return source;\n    }()), false);\n\n    /*------------------------------------------------------------------------*/\n\n    // Add functions capable of returning wrapped and unwrapped values when chaining.\n    lodash.sample = sample;\n\n    lodash.prototype.sample = function(n) {\n      if (!this.__chain__ && n == null) {\n        return sample(this.value());\n      }\n      return this.thru(function(value) {\n        return sample(value, n);\n      });\n    };\n\n    /*------------------------------------------------------------------------*/\n\n    /**\n     * The semantic version number.\n     *\n     * @static\n     * @memberOf _\n     * @type string\n     */\n    lodash.VERSION = VERSION;\n\n    // Assign default placeholders.\n    arrayEach(['bind', 'bindKey', 'curry', 'curryRight', 'partial', 'partialRight'], function(methodName) {\n      lodash[methodName].placeholder = lodash;\n    });\n\n    // Add `LazyWrapper` methods for `_.drop` and `_.take` variants.\n    arrayEach(['drop', 'take'], function(methodName, index) {\n      LazyWrapper.prototype[methodName] = function(n) {\n        var filtered = this.__filtered__;\n        if (filtered && !index) {\n          return new LazyWrapper(this);\n        }\n        n = n == null ? 1 : nativeMax(nativeFloor(n) || 0, 0);\n\n        var result = this.clone();\n        if (filtered) {\n          result.__takeCount__ = nativeMin(result.__takeCount__, n);\n        } else {\n          result.__views__.push({ 'size': n, 'type': methodName + (result.__dir__ < 0 ? 'Right' : '') });\n        }\n        return result;\n      };\n\n      LazyWrapper.prototype[methodName + 'Right'] = function(n) {\n        return this.reverse()[methodName](n).reverse();\n      };\n    });\n\n    // Add `LazyWrapper` methods that accept an `iteratee` value.\n    arrayEach(['filter', 'map', 'takeWhile'], function(methodName, index) {\n      var type = index + 1,\n          isFilter = type != LAZY_MAP_FLAG;\n\n      LazyWrapper.prototype[methodName] = function(iteratee, thisArg) {\n        var result = this.clone();\n        result.__iteratees__.push({ 'iteratee': getCallback(iteratee, thisArg, 1), 'type': type });\n        result.__filtered__ = result.__filtered__ || isFilter;\n        return result;\n      };\n    });\n\n    // Add `LazyWrapper` methods for `_.first` and `_.last`.\n    arrayEach(['first', 'last'], function(methodName, index) {\n      var takeName = 'take' + (index ? 'Right' : '');\n\n      LazyWrapper.prototype[methodName] = function() {\n        return this[takeName](1).value()[0];\n      };\n    });\n\n    // Add `LazyWrapper` methods for `_.initial` and `_.rest`.\n    arrayEach(['initial', 'rest'], function(methodName, index) {\n      var dropName = 'drop' + (index ? '' : 'Right');\n\n      LazyWrapper.prototype[methodName] = function() {\n        return this.__filtered__ ? new LazyWrapper(this) : this[dropName](1);\n      };\n    });\n\n    // Add `LazyWrapper` methods for `_.pluck` and `_.where`.\n    arrayEach(['pluck', 'where'], function(methodName, index) {\n      var operationName = index ? 'filter' : 'map',\n          createCallback = index ? baseMatches : property;\n\n      LazyWrapper.prototype[methodName] = function(value) {\n        return this[operationName](createCallback(value));\n      };\n    });\n\n    LazyWrapper.prototype.compact = function() {\n      return this.filter(identity);\n    };\n\n    LazyWrapper.prototype.reject = function(predicate, thisArg) {\n      predicate = getCallback(predicate, thisArg, 1);\n      return this.filter(function(value) {\n        return !predicate(value);\n      });\n    };\n\n    LazyWrapper.prototype.slice = function(start, end) {\n      start = start == null ? 0 : (+start || 0);\n\n      var result = this;\n      if (result.__filtered__ && (start > 0 || end < 0)) {\n        return new LazyWrapper(result);\n      }\n      if (start < 0) {\n        result = result.takeRight(-start);\n      } else if (start) {\n        result = result.drop(start);\n      }\n      if (end !== undefined) {\n        end = (+end || 0);\n        result = end < 0 ? result.dropRight(-end) : result.take(end - start);\n      }\n      return result;\n    };\n\n    LazyWrapper.prototype.takeRightWhile = function(predicate, thisArg) {\n      return this.reverse().takeWhile(predicate, thisArg).reverse();\n    };\n\n    LazyWrapper.prototype.toArray = function() {\n      return this.take(POSITIVE_INFINITY);\n    };\n\n    // Add `LazyWrapper` methods to `lodash.prototype`.\n    baseForOwn(LazyWrapper.prototype, function(func, methodName) {\n      var checkIteratee = /^(?:filter|map|reject)|While$/.test(methodName),\n          retUnwrapped = /^(?:first|last)$/.test(methodName),\n          lodashFunc = lodash[retUnwrapped ? ('take' + (methodName == 'last' ? 'Right' : '')) : methodName];\n\n      if (!lodashFunc) {\n        return;\n      }\n      lodash.prototype[methodName] = function() {\n        var args = retUnwrapped ? [1] : arguments,\n            chainAll = this.__chain__,\n            value = this.__wrapped__,\n            isHybrid = !!this.__actions__.length,\n            isLazy = value instanceof LazyWrapper,\n            iteratee = args[0],\n            useLazy = isLazy || isArray(value);\n\n        if (useLazy && checkIteratee && typeof iteratee == 'function' && iteratee.length != 1) {\n          // Avoid lazy use if the iteratee has a \"length\" value other than `1`.\n          isLazy = useLazy = false;\n        }\n        var interceptor = function(value) {\n          return (retUnwrapped && chainAll)\n            ? lodashFunc(value, 1)[0]\n            : lodashFunc.apply(undefined, arrayPush([value], args));\n        };\n\n        var action = { 'func': thru, 'args': [interceptor], 'thisArg': undefined },\n            onlyLazy = isLazy && !isHybrid;\n\n        if (retUnwrapped && !chainAll) {\n          if (onlyLazy) {\n            value = value.clone();\n            value.__actions__.push(action);\n            return func.call(value);\n          }\n          return lodashFunc.call(undefined, this.value())[0];\n        }\n        if (!retUnwrapped && useLazy) {\n          value = onlyLazy ? value : new LazyWrapper(this);\n          var result = func.apply(value, args);\n          result.__actions__.push(action);\n          return new LodashWrapper(result, chainAll);\n        }\n        return this.thru(interceptor);\n      };\n    });\n\n    // Add `Array` and `String` methods to `lodash.prototype`.\n    arrayEach(['join', 'pop', 'push', 'replace', 'shift', 'sort', 'splice', 'split', 'unshift'], function(methodName) {\n      var func = (/^(?:replace|split)$/.test(methodName) ? stringProto : arrayProto)[methodName],\n          chainName = /^(?:push|sort|unshift)$/.test(methodName) ? 'tap' : 'thru',\n          retUnwrapped = /^(?:join|pop|replace|shift)$/.test(methodName);\n\n      lodash.prototype[methodName] = function() {\n        var args = arguments;\n        if (retUnwrapped && !this.__chain__) {\n          return func.apply(this.value(), args);\n        }\n        return this[chainName](function(value) {\n          return func.apply(value, args);\n        });\n      };\n    });\n\n    // Map minified function names to their real names.\n    baseForOwn(LazyWrapper.prototype, function(func, methodName) {\n      var lodashFunc = lodash[methodName];\n      if (lodashFunc) {\n        var key = lodashFunc.name,\n            names = realNames[key] || (realNames[key] = []);\n\n        names.push({ 'name': methodName, 'func': lodashFunc });\n      }\n    });\n\n    realNames[createHybridWrapper(undefined, BIND_KEY_FLAG).name] = [{ 'name': 'wrapper', 'func': undefined }];\n\n    // Add functions to the lazy wrapper.\n    LazyWrapper.prototype.clone = lazyClone;\n    LazyWrapper.prototype.reverse = lazyReverse;\n    LazyWrapper.prototype.value = lazyValue;\n\n    // Add chaining functions to the `lodash` wrapper.\n    lodash.prototype.chain = wrapperChain;\n    lodash.prototype.commit = wrapperCommit;\n    lodash.prototype.concat = wrapperConcat;\n    lodash.prototype.plant = wrapperPlant;\n    lodash.prototype.reverse = wrapperReverse;\n    lodash.prototype.toString = wrapperToString;\n    lodash.prototype.run = lodash.prototype.toJSON = lodash.prototype.valueOf = lodash.prototype.value = wrapperValue;\n\n    // Add function aliases to the `lodash` wrapper.\n    lodash.prototype.collect = lodash.prototype.map;\n    lodash.prototype.head = lodash.prototype.first;\n    lodash.prototype.select = lodash.prototype.filter;\n    lodash.prototype.tail = lodash.prototype.rest;\n\n    return lodash;\n  }\n\n  /*--------------------------------------------------------------------------*/\n\n  // Export lodash.\n  var _ = runInContext();\n\n  // Some AMD build optimizers like r.js check for condition patterns like the following:\n  if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) {\n    // Expose lodash to the global object when an AMD loader is present to avoid\n    // errors in cases where lodash is loaded by a script tag and not intended\n    // as an AMD module. See http://requirejs.org/docs/errors.html#mismatch for\n    // more details.\n    root._ = _;\n\n    // Define as an anonymous module so, through path mapping, it can be\n    // referenced as the \"underscore\" module.\n    define(function() {\n      return _;\n    });\n  }\n  // Check for `exports` after `define` in case a build optimizer adds an `exports` object.\n  else if (freeExports && freeModule) {\n    // Export for Node.js or RingoJS.\n    if (moduleExports) {\n      (freeModule.exports = _)._ = _;\n    }\n    // Export for Rhino with CommonJS support.\n    else {\n      freeExports._ = _;\n    }\n  }\n  else {\n    // Export for a browser or Rhino.\n    root._ = _;\n  }\n}.call(this));\n","/* ========================================================================\n * Bootstrap: transition.js v3.3.6\n * http://getbootstrap.com/javascript/#transitions\n * ========================================================================\n * Copyright 2011-2015 Twitter, Inc.\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)\n * ======================================================================== */\n\n\n+function ($) {\n  'use strict';\n\n  // CSS TRANSITION SUPPORT (Shoutout: http://www.modernizr.com/)\n  // ============================================================\n\n  function transitionEnd() {\n    var el = document.createElement('bootstrap')\n\n    var transEndEventNames = {\n      WebkitTransition : 'webkitTransitionEnd',\n      MozTransition    : 'transitionend',\n      OTransition      : 'oTransitionEnd otransitionend',\n      transition       : 'transitionend'\n    }\n\n    for (var name in transEndEventNames) {\n      if (el.style[name] !== undefined) {\n        return { end: transEndEventNames[name] }\n      }\n    }\n\n    return false // explicit for ie8 (  ._.)\n  }\n\n  // http://blog.alexmaccaw.com/css-transitions\n  $.fn.emulateTransitionEnd = function (duration) {\n    var called = false\n    var $el = this\n    $(this).one('bsTransitionEnd', function () { called = true })\n    var callback = function () { if (!called) $($el).trigger($.support.transition.end) }\n    setTimeout(callback, duration)\n    return this\n  }\n\n  $(function () {\n    $.support.transition = transitionEnd()\n\n    if (!$.support.transition) return\n\n    $.event.special.bsTransitionEnd = {\n      bindType: $.support.transition.end,\n      delegateType: $.support.transition.end,\n      handle: function (e) {\n        if ($(e.target).is(this)) return e.handleObj.handler.apply(this, arguments)\n      }\n    }\n  })\n\n}(jQuery);\n","/* ========================================================================\n * Bootstrap: button.js v3.3.6\n * http://getbootstrap.com/javascript/#buttons\n * ========================================================================\n * Copyright 2011-2015 Twitter, Inc.\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)\n * ======================================================================== */\n\n\n+function ($) {\n  'use strict';\n\n  // BUTTON PUBLIC CLASS DEFINITION\n  // ==============================\n\n  var Button = function (element, options) {\n    this.$element  = $(element)\n    this.options   = $.extend({}, Button.DEFAULTS, options)\n    this.isLoading = false\n  }\n\n  Button.VERSION  = '3.3.6'\n\n  Button.DEFAULTS = {\n    loadingText: 'loading...'\n  }\n\n  Button.prototype.setState = function (state) {\n    var d    = 'disabled'\n    var $el  = this.$element\n    var val  = $el.is('input') ? 'val' : 'html'\n    var data = $el.data()\n\n    state += 'Text'\n\n    if (data.resetText == null) $el.data('resetText', $el[val]())\n\n    // push to event loop to allow forms to submit\n    setTimeout($.proxy(function () {\n      $el[val](data[state] == null ? this.options[state] : data[state])\n\n      if (state == 'loadingText') {\n        this.isLoading = true\n        $el.addClass(d).attr(d, d)\n      } else if (this.isLoading) {\n        this.isLoading = false\n        $el.removeClass(d).removeAttr(d)\n      }\n    }, this), 0)\n  }\n\n  Button.prototype.toggle = function () {\n    var changed = true\n    var $parent = this.$element.closest('[data-toggle=\"buttons\"]')\n\n    if ($parent.length) {\n      var $input = this.$element.find('input')\n      if ($input.prop('type') == 'radio') {\n        if ($input.prop('checked')) changed = false\n        $parent.find('.active').removeClass('active')\n        this.$element.addClass('active')\n      } else if ($input.prop('type') == 'checkbox') {\n        if (($input.prop('checked')) !== this.$element.hasClass('active')) changed = false\n        this.$element.toggleClass('active')\n      }\n      $input.prop('checked', this.$element.hasClass('active'))\n      if (changed) $input.trigger('change')\n    } else {\n      this.$element.attr('aria-pressed', !this.$element.hasClass('active'))\n      this.$element.toggleClass('active')\n    }\n  }\n\n\n  // BUTTON PLUGIN DEFINITION\n  // ========================\n\n  function Plugin(option) {\n    return this.each(function () {\n      var $this   = $(this)\n      var data    = $this.data('bs.button')\n      var options = typeof option == 'object' && option\n\n      if (!data) $this.data('bs.button', (data = new Button(this, options)))\n\n      if (option == 'toggle') data.toggle()\n      else if (option) data.setState(option)\n    })\n  }\n\n  var old = $.fn.button\n\n  $.fn.button             = Plugin\n  $.fn.button.Constructor = Button\n\n\n  // BUTTON NO CONFLICT\n  // ==================\n\n  $.fn.button.noConflict = function () {\n    $.fn.button = old\n    return this\n  }\n\n\n  // BUTTON DATA-API\n  // ===============\n\n  $(document)\n    .on('click.bs.button.data-api', '[data-toggle^=\"button\"]', function (e) {\n      var $btn = $(e.target)\n      if (!$btn.hasClass('btn')) $btn = $btn.closest('.btn')\n      Plugin.call($btn, 'toggle')\n      if (!($(e.target).is('input[type=\"radio\"]') || $(e.target).is('input[type=\"checkbox\"]'))) e.preventDefault()\n    })\n    .on('focus.bs.button.data-api blur.bs.button.data-api', '[data-toggle^=\"button\"]', function (e) {\n      $(e.target).closest('.btn').toggleClass('focus', /^focus(in)?$/.test(e.type))\n    })\n\n}(jQuery);\n","/* ========================================================================\n * Bootstrap: dropdown.js v3.3.6\n * http://getbootstrap.com/javascript/#dropdowns\n * ========================================================================\n * Copyright 2011-2015 Twitter, Inc.\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)\n * ======================================================================== */\n\n\n+function ($) {\n  'use strict';\n\n  // DROPDOWN CLASS DEFINITION\n  // =========================\n\n  var backdrop = '.dropdown-backdrop'\n  var toggle   = '[data-toggle=\"dropdown\"]'\n  var Dropdown = function (element) {\n    $(element).on('click.bs.dropdown', this.toggle)\n  }\n\n  Dropdown.VERSION = '3.3.6'\n\n  function getParent($this) {\n    var selector = $this.attr('data-target')\n\n    if (!selector) {\n      selector = $this.attr('href')\n      selector = selector && /#[A-Za-z]/.test(selector) && selector.replace(/.*(?=#[^\\s]*$)/, '') // strip for ie7\n    }\n\n    var $parent = selector && $(selector)\n\n    return $parent && $parent.length ? $parent : $this.parent()\n  }\n\n  function clearMenus(e) {\n    if (e && e.which === 3) return\n    $(backdrop).remove()\n    $(toggle).each(function () {\n      var $this         = $(this)\n      var $parent       = getParent($this)\n      var relatedTarget = { relatedTarget: this }\n\n      if (!$parent.hasClass('open')) return\n\n      if (e && e.type == 'click' && /input|textarea/i.test(e.target.tagName) && $.contains($parent[0], e.target)) return\n\n      $parent.trigger(e = $.Event('hide.bs.dropdown', relatedTarget))\n\n      if (e.isDefaultPrevented()) return\n\n      $this.attr('aria-expanded', 'false')\n      $parent.removeClass('open').trigger($.Event('hidden.bs.dropdown', relatedTarget))\n    })\n  }\n\n  Dropdown.prototype.toggle = function (e) {\n    var $this = $(this)\n\n    if ($this.is('.disabled, :disabled')) return\n\n    var $parent  = getParent($this)\n    var isActive = $parent.hasClass('open')\n\n    clearMenus()\n\n    if (!isActive) {\n      if ('ontouchstart' in document.documentElement && !$parent.closest('.navbar-nav').length) {\n        // if mobile we use a backdrop because click events don't delegate\n        $(document.createElement('div'))\n          .addClass('dropdown-backdrop')\n          .insertAfter($(this))\n          .on('click', clearMenus)\n      }\n\n      var relatedTarget = { relatedTarget: this }\n      $parent.trigger(e = $.Event('show.bs.dropdown', relatedTarget))\n\n      if (e.isDefaultPrevented()) return\n\n      $this\n        .trigger('focus')\n        .attr('aria-expanded', 'true')\n\n      $parent\n        .toggleClass('open')\n        .trigger($.Event('shown.bs.dropdown', relatedTarget))\n    }\n\n    return false\n  }\n\n  Dropdown.prototype.keydown = function (e) {\n    if (!/(38|40|27|32)/.test(e.which) || /input|textarea/i.test(e.target.tagName)) return\n\n    var $this = $(this)\n\n    e.preventDefault()\n    e.stopPropagation()\n\n    if ($this.is('.disabled, :disabled')) return\n\n    var $parent  = getParent($this)\n    var isActive = $parent.hasClass('open')\n\n    if (!isActive && e.which != 27 || isActive && e.which == 27) {\n      if (e.which == 27) $parent.find(toggle).trigger('focus')\n      return $this.trigger('click')\n    }\n\n    var desc = ' li:not(.disabled):visible a'\n    var $items = $parent.find('.dropdown-menu' + desc)\n\n    if (!$items.length) return\n\n    var index = $items.index(e.target)\n\n    if (e.which == 38 && index > 0)                 index--         // up\n    if (e.which == 40 && index < $items.length - 1) index++         // down\n    if (!~index)                                    index = 0\n\n    $items.eq(index).trigger('focus')\n  }\n\n\n  // DROPDOWN PLUGIN DEFINITION\n  // ==========================\n\n  function Plugin(option) {\n    return this.each(function () {\n      var $this = $(this)\n      var data  = $this.data('bs.dropdown')\n\n      if (!data) $this.data('bs.dropdown', (data = new Dropdown(this)))\n      if (typeof option == 'string') data[option].call($this)\n    })\n  }\n\n  var old = $.fn.dropdown\n\n  $.fn.dropdown             = Plugin\n  $.fn.dropdown.Constructor = Dropdown\n\n\n  // DROPDOWN NO CONFLICT\n  // ====================\n\n  $.fn.dropdown.noConflict = function () {\n    $.fn.dropdown = old\n    return this\n  }\n\n\n  // APPLY TO STANDARD DROPDOWN ELEMENTS\n  // ===================================\n\n  $(document)\n    .on('click.bs.dropdown.data-api', clearMenus)\n    .on('click.bs.dropdown.data-api', '.dropdown form', function (e) { e.stopPropagation() })\n    .on('click.bs.dropdown.data-api', toggle, Dropdown.prototype.toggle)\n    .on('keydown.bs.dropdown.data-api', toggle, Dropdown.prototype.keydown)\n    .on('keydown.bs.dropdown.data-api', '.dropdown-menu', Dropdown.prototype.keydown)\n\n}(jQuery);\n","/* ========================================================================\n * Bootstrap: collapse.js v3.3.6\n * http://getbootstrap.com/javascript/#collapse\n * ========================================================================\n * Copyright 2011-2015 Twitter, Inc.\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)\n * ======================================================================== */\n\n\n+function ($) {\n  'use strict';\n\n  // COLLAPSE PUBLIC CLASS DEFINITION\n  // ================================\n\n  var Collapse = function (element, options) {\n    this.$element      = $(element)\n    this.options       = $.extend({}, Collapse.DEFAULTS, options)\n    this.$trigger      = $('[data-toggle=\"collapse\"][href=\"#' + element.id + '\"],' +\n                           '[data-toggle=\"collapse\"][data-target=\"#' + element.id + '\"]')\n    this.transitioning = null\n\n    if (this.options.parent) {\n      this.$parent = this.getParent()\n    } else {\n      this.addAriaAndCollapsedClass(this.$element, this.$trigger)\n    }\n\n    if (this.options.toggle) this.toggle()\n  }\n\n  Collapse.VERSION  = '3.3.6'\n\n  Collapse.TRANSITION_DURATION = 350\n\n  Collapse.DEFAULTS = {\n    toggle: true\n  }\n\n  Collapse.prototype.dimension = function () {\n    var hasWidth = this.$element.hasClass('width')\n    return hasWidth ? 'width' : 'height'\n  }\n\n  Collapse.prototype.show = function () {\n    if (this.transitioning || this.$element.hasClass('in')) return\n\n    var activesData\n    var actives = this.$parent && this.$parent.children('.panel').children('.in, .collapsing')\n\n    if (actives && actives.length) {\n      activesData = actives.data('bs.collapse')\n      if (activesData && activesData.transitioning) return\n    }\n\n    var startEvent = $.Event('show.bs.collapse')\n    this.$element.trigger(startEvent)\n    if (startEvent.isDefaultPrevented()) return\n\n    if (actives && actives.length) {\n      Plugin.call(actives, 'hide')\n      activesData || actives.data('bs.collapse', null)\n    }\n\n    var dimension = this.dimension()\n\n    this.$element\n      .removeClass('collapse')\n      .addClass('collapsing')[dimension](0)\n      .attr('aria-expanded', true)\n\n    this.$trigger\n      .removeClass('collapsed')\n      .attr('aria-expanded', true)\n\n    this.transitioning = 1\n\n    var complete = function () {\n      this.$element\n        .removeClass('collapsing')\n        .addClass('collapse in')[dimension]('')\n      this.transitioning = 0\n      this.$element\n        .trigger('shown.bs.collapse')\n    }\n\n    if (!$.support.transition) return complete.call(this)\n\n    var scrollSize = $.camelCase(['scroll', dimension].join('-'))\n\n    this.$element\n      .one('bsTransitionEnd', $.proxy(complete, this))\n      .emulateTransitionEnd(Collapse.TRANSITION_DURATION)[dimension](this.$element[0][scrollSize])\n  }\n\n  Collapse.prototype.hide = function () {\n    if (this.transitioning || !this.$element.hasClass('in')) return\n\n    var startEvent = $.Event('hide.bs.collapse')\n    this.$element.trigger(startEvent)\n    if (startEvent.isDefaultPrevented()) return\n\n    var dimension = this.dimension()\n\n    this.$element[dimension](this.$element[dimension]())[0].offsetHeight\n\n    this.$element\n      .addClass('collapsing')\n      .removeClass('collapse in')\n      .attr('aria-expanded', false)\n\n    this.$trigger\n      .addClass('collapsed')\n      .attr('aria-expanded', false)\n\n    this.transitioning = 1\n\n    var complete = function () {\n      this.transitioning = 0\n      this.$element\n        .removeClass('collapsing')\n        .addClass('collapse')\n        .trigger('hidden.bs.collapse')\n    }\n\n    if (!$.support.transition) return complete.call(this)\n\n    this.$element\n      [dimension](0)\n      .one('bsTransitionEnd', $.proxy(complete, this))\n      .emulateTransitionEnd(Collapse.TRANSITION_DURATION)\n  }\n\n  Collapse.prototype.toggle = function () {\n    this[this.$element.hasClass('in') ? 'hide' : 'show']()\n  }\n\n  Collapse.prototype.getParent = function () {\n    return $(this.options.parent)\n      .find('[data-toggle=\"collapse\"][data-parent=\"' + this.options.parent + '\"]')\n      .each($.proxy(function (i, element) {\n        var $element = $(element)\n        this.addAriaAndCollapsedClass(getTargetFromTrigger($element), $element)\n      }, this))\n      .end()\n  }\n\n  Collapse.prototype.addAriaAndCollapsedClass = function ($element, $trigger) {\n    var isOpen = $element.hasClass('in')\n\n    $element.attr('aria-expanded', isOpen)\n    $trigger\n      .toggleClass('collapsed', !isOpen)\n      .attr('aria-expanded', isOpen)\n  }\n\n  function getTargetFromTrigger($trigger) {\n    var href\n    var target = $trigger.attr('data-target')\n      || (href = $trigger.attr('href')) && href.replace(/.*(?=#[^\\s]+$)/, '') // strip for ie7\n\n    return $(target)\n  }\n\n\n  // COLLAPSE PLUGIN DEFINITION\n  // ==========================\n\n  function Plugin(option) {\n    return this.each(function () {\n      var $this   = $(this)\n      var data    = $this.data('bs.collapse')\n      var options = $.extend({}, Collapse.DEFAULTS, $this.data(), typeof option == 'object' && option)\n\n      if (!data && options.toggle && /show|hide/.test(option)) options.toggle = false\n      if (!data) $this.data('bs.collapse', (data = new Collapse(this, options)))\n      if (typeof option == 'string') data[option]()\n    })\n  }\n\n  var old = $.fn.collapse\n\n  $.fn.collapse             = Plugin\n  $.fn.collapse.Constructor = Collapse\n\n\n  // COLLAPSE NO CONFLICT\n  // ====================\n\n  $.fn.collapse.noConflict = function () {\n    $.fn.collapse = old\n    return this\n  }\n\n\n  // COLLAPSE DATA-API\n  // =================\n\n  $(document).on('click.bs.collapse.data-api', '[data-toggle=\"collapse\"]', function (e) {\n    var $this   = $(this)\n\n    if (!$this.attr('data-target')) e.preventDefault()\n\n    var $target = getTargetFromTrigger($this)\n    var data    = $target.data('bs.collapse')\n    var option  = data ? 'toggle' : $this.data()\n\n    Plugin.call($target, option)\n  })\n\n}(jQuery);\n","/* ========================================================================\n * Bootstrap: alert.js v3.3.6\n * http://getbootstrap.com/javascript/#alerts\n * ========================================================================\n * Copyright 2011-2015 Twitter, Inc.\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)\n * ======================================================================== */\n\n\n+function ($) {\n  'use strict';\n\n  // ALERT CLASS DEFINITION\n  // ======================\n\n  var dismiss = '[data-dismiss=\"alert\"]'\n  var Alert   = function (el) {\n    $(el).on('click', dismiss, this.close)\n  }\n\n  Alert.VERSION = '3.3.6'\n\n  Alert.TRANSITION_DURATION = 150\n\n  Alert.prototype.close = function (e) {\n    var $this    = $(this)\n    var selector = $this.attr('data-target')\n\n    if (!selector) {\n      selector = $this.attr('href')\n      selector = selector && selector.replace(/.*(?=#[^\\s]*$)/, '') // strip for ie7\n    }\n\n    var $parent = $(selector)\n\n    if (e) e.preventDefault()\n\n    if (!$parent.length) {\n      $parent = $this.closest('.alert')\n    }\n\n    $parent.trigger(e = $.Event('close.bs.alert'))\n\n    if (e.isDefaultPrevented()) return\n\n    $parent.removeClass('in')\n\n    function removeElement() {\n      // detach from parent, fire event then clean up data\n      $parent.detach().trigger('closed.bs.alert').remove()\n    }\n\n    $.support.transition && $parent.hasClass('fade') ?\n      $parent\n        .one('bsTransitionEnd', removeElement)\n        .emulateTransitionEnd(Alert.TRANSITION_DURATION) :\n      removeElement()\n  }\n\n\n  // ALERT PLUGIN DEFINITION\n  // =======================\n\n  function Plugin(option) {\n    return this.each(function () {\n      var $this = $(this)\n      var data  = $this.data('bs.alert')\n\n      if (!data) $this.data('bs.alert', (data = new Alert(this)))\n      if (typeof option == 'string') data[option].call($this)\n    })\n  }\n\n  var old = $.fn.alert\n\n  $.fn.alert             = Plugin\n  $.fn.alert.Constructor = Alert\n\n\n  // ALERT NO CONFLICT\n  // =================\n\n  $.fn.alert.noConflict = function () {\n    $.fn.alert = old\n    return this\n  }\n\n\n  // ALERT DATA-API\n  // ==============\n\n  $(document).on('click.bs.alert.data-api', dismiss, Alert.prototype.close)\n\n}(jQuery);\n","/* ========================================================================\n * Bootstrap: popover.js v3.3.6\n * http://getbootstrap.com/javascript/#popovers\n * ========================================================================\n * Copyright 2011-2015 Twitter, Inc.\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)\n * ======================================================================== */\n\n\n+function ($) {\n  'use strict';\n\n  // POPOVER PUBLIC CLASS DEFINITION\n  // ===============================\n\n  var Popover = function (element, options) {\n    this.init('popover', element, options)\n  }\n\n  if (!$.fn.tooltip) throw new Error('Popover requires tooltip.js')\n\n  Popover.VERSION  = '3.3.6'\n\n  Popover.DEFAULTS = $.extend({}, $.fn.tooltip.Constructor.DEFAULTS, {\n    placement: 'right',\n    trigger: 'click',\n    content: '',\n    template: '<div class=\"popover\" role=\"tooltip\"><div class=\"arrow\"></div><h3 class=\"popover-title\"></h3><div class=\"popover-content\"></div></div>'\n  })\n\n\n  // NOTE: POPOVER EXTENDS tooltip.js\n  // ================================\n\n  Popover.prototype = $.extend({}, $.fn.tooltip.Constructor.prototype)\n\n  Popover.prototype.constructor = Popover\n\n  Popover.prototype.getDefaults = function () {\n    return Popover.DEFAULTS\n  }\n\n  Popover.prototype.setContent = function () {\n    var $tip    = this.tip()\n    var title   = this.getTitle()\n    var content = this.getContent()\n\n    $tip.find('.popover-title')[this.options.html ? 'html' : 'text'](title)\n    $tip.find('.popover-content').children().detach().end()[ // we use append for html objects to maintain js events\n      this.options.html ? (typeof content == 'string' ? 'html' : 'append') : 'text'\n    ](content)\n\n    $tip.removeClass('fade top bottom left right in')\n\n    // IE8 doesn't accept hiding via the `:empty` pseudo selector, we have to do\n    // this manually by checking the contents.\n    if (!$tip.find('.popover-title').html()) $tip.find('.popover-title').hide()\n  }\n\n  Popover.prototype.hasContent = function () {\n    return this.getTitle() || this.getContent()\n  }\n\n  Popover.prototype.getContent = function () {\n    var $e = this.$element\n    var o  = this.options\n\n    return $e.attr('data-content')\n      || (typeof o.content == 'function' ?\n            o.content.call($e[0]) :\n            o.content)\n  }\n\n  Popover.prototype.arrow = function () {\n    return (this.$arrow = this.$arrow || this.tip().find('.arrow'))\n  }\n\n\n  // POPOVER PLUGIN DEFINITION\n  // =========================\n\n  function Plugin(option) {\n    return this.each(function () {\n      var $this   = $(this)\n      var data    = $this.data('bs.popover')\n      var options = typeof option == 'object' && option\n\n      if (!data && /destroy|hide/.test(option)) return\n      if (!data) $this.data('bs.popover', (data = new Popover(this, options)))\n      if (typeof option == 'string') data[option]()\n    })\n  }\n\n  var old = $.fn.popover\n\n  $.fn.popover             = Plugin\n  $.fn.popover.Constructor = Popover\n\n\n  // POPOVER NO CONFLICT\n  // ===================\n\n  $.fn.popover.noConflict = function () {\n    $.fn.popover = old\n    return this\n  }\n\n}(jQuery);\n","/* ========================================================================\n * Bootstrap: modal.js v3.3.6\n * http://getbootstrap.com/javascript/#modals\n * ========================================================================\n * Copyright 2011-2015 Twitter, Inc.\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)\n * ======================================================================== */\n\n\n+function ($) {\n  'use strict';\n\n  // MODAL CLASS DEFINITION\n  // ======================\n\n  var Modal = function (element, options) {\n    this.options             = options\n    this.$body               = $(document.body)\n    this.$element            = $(element)\n    this.$dialog             = this.$element.find('.modal-dialog')\n    this.$backdrop           = null\n    this.isShown             = null\n    this.originalBodyPad     = null\n    this.scrollbarWidth      = 0\n    this.ignoreBackdropClick = false\n\n    if (this.options.remote) {\n      this.$element\n        .find('.modal-content')\n        .load(this.options.remote, $.proxy(function () {\n          this.$element.trigger('loaded.bs.modal')\n        }, this))\n    }\n  }\n\n  Modal.VERSION  = '3.3.6'\n\n  Modal.TRANSITION_DURATION = 300\n  Modal.BACKDROP_TRANSITION_DURATION = 150\n\n  Modal.DEFAULTS = {\n    backdrop: true,\n    keyboard: true,\n    show: true\n  }\n\n  Modal.prototype.toggle = function (_relatedTarget) {\n    return this.isShown ? this.hide() : this.show(_relatedTarget)\n  }\n\n  Modal.prototype.show = function (_relatedTarget) {\n    var that = this\n    var e    = $.Event('show.bs.modal', { relatedTarget: _relatedTarget })\n\n    this.$element.trigger(e)\n\n    if (this.isShown || e.isDefaultPrevented()) return\n\n    this.isShown = true\n\n    this.checkScrollbar()\n    this.setScrollbar()\n    this.$body.addClass('modal-open')\n\n    this.escape()\n    this.resize()\n\n    this.$element.on('click.dismiss.bs.modal', '[data-dismiss=\"modal\"]', $.proxy(this.hide, this))\n\n    this.$dialog.on('mousedown.dismiss.bs.modal', function () {\n      that.$element.one('mouseup.dismiss.bs.modal', function (e) {\n        if ($(e.target).is(that.$element)) that.ignoreBackdropClick = true\n      })\n    })\n\n    this.backdrop(function () {\n      var transition = $.support.transition && that.$element.hasClass('fade')\n\n      if (!that.$element.parent().length) {\n        that.$element.appendTo(that.$body) // don't move modals dom position\n      }\n\n      that.$element\n        .show()\n        .scrollTop(0)\n\n      that.adjustDialog()\n\n      if (transition) {\n        that.$element[0].offsetWidth // force reflow\n      }\n\n      that.$element.addClass('in')\n\n      that.enforceFocus()\n\n      var e = $.Event('shown.bs.modal', { relatedTarget: _relatedTarget })\n\n      transition ?\n        that.$dialog // wait for modal to slide in\n          .one('bsTransitionEnd', function () {\n            that.$element.trigger('focus').trigger(e)\n          })\n          .emulateTransitionEnd(Modal.TRANSITION_DURATION) :\n        that.$element.trigger('focus').trigger(e)\n    })\n  }\n\n  Modal.prototype.hide = function (e) {\n    if (e) e.preventDefault()\n\n    e = $.Event('hide.bs.modal')\n\n    this.$element.trigger(e)\n\n    if (!this.isShown || e.isDefaultPrevented()) return\n\n    this.isShown = false\n\n    this.escape()\n    this.resize()\n\n    $(document).off('focusin.bs.modal')\n\n    this.$element\n      .removeClass('in')\n      .off('click.dismiss.bs.modal')\n      .off('mouseup.dismiss.bs.modal')\n\n    this.$dialog.off('mousedown.dismiss.bs.modal')\n\n    $.support.transition && this.$element.hasClass('fade') ?\n      this.$element\n        .one('bsTransitionEnd', $.proxy(this.hideModal, this))\n        .emulateTransitionEnd(Modal.TRANSITION_DURATION) :\n      this.hideModal()\n  }\n\n  Modal.prototype.enforceFocus = function () {\n    $(document)\n      .off('focusin.bs.modal') // guard against infinite focus loop\n      .on('focusin.bs.modal', $.proxy(function (e) {\n        if (this.$element[0] !== e.target && !this.$element.has(e.target).length) {\n          this.$element.trigger('focus')\n        }\n      }, this))\n  }\n\n  Modal.prototype.escape = function () {\n    if (this.isShown && this.options.keyboard) {\n      this.$element.on('keydown.dismiss.bs.modal', $.proxy(function (e) {\n        e.which == 27 && this.hide()\n      }, this))\n    } else if (!this.isShown) {\n      this.$element.off('keydown.dismiss.bs.modal')\n    }\n  }\n\n  Modal.prototype.resize = function () {\n    if (this.isShown) {\n      $(window).on('resize.bs.modal', $.proxy(this.handleUpdate, this))\n    } else {\n      $(window).off('resize.bs.modal')\n    }\n  }\n\n  Modal.prototype.hideModal = function () {\n    var that = this\n    this.$element.hide()\n    this.backdrop(function () {\n      that.$body.removeClass('modal-open')\n      that.resetAdjustments()\n      that.resetScrollbar()\n      that.$element.trigger('hidden.bs.modal')\n    })\n  }\n\n  Modal.prototype.removeBackdrop = function () {\n    this.$backdrop && this.$backdrop.remove()\n    this.$backdrop = null\n  }\n\n  Modal.prototype.backdrop = function (callback) {\n    var that = this\n    var animate = this.$element.hasClass('fade') ? 'fade' : ''\n\n    if (this.isShown && this.options.backdrop) {\n      var doAnimate = $.support.transition && animate\n\n      this.$backdrop = $(document.createElement('div'))\n        .addClass('modal-backdrop ' + animate)\n        .appendTo(this.$body)\n\n      this.$element.on('click.dismiss.bs.modal', $.proxy(function (e) {\n        if (this.ignoreBackdropClick) {\n          this.ignoreBackdropClick = false\n          return\n        }\n        if (e.target !== e.currentTarget) return\n        this.options.backdrop == 'static'\n          ? this.$element[0].focus()\n          : this.hide()\n      }, this))\n\n      if (doAnimate) this.$backdrop[0].offsetWidth // force reflow\n\n      this.$backdrop.addClass('in')\n\n      if (!callback) return\n\n      doAnimate ?\n        this.$backdrop\n          .one('bsTransitionEnd', callback)\n          .emulateTransitionEnd(Modal.BACKDROP_TRANSITION_DURATION) :\n        callback()\n\n    } else if (!this.isShown && this.$backdrop) {\n      this.$backdrop.removeClass('in')\n\n      var callbackRemove = function () {\n        that.removeBackdrop()\n        callback && callback()\n      }\n      $.support.transition && this.$element.hasClass('fade') ?\n        this.$backdrop\n          .one('bsTransitionEnd', callbackRemove)\n          .emulateTransitionEnd(Modal.BACKDROP_TRANSITION_DURATION) :\n        callbackRemove()\n\n    } else if (callback) {\n      callback()\n    }\n  }\n\n  // these following methods are used to handle overflowing modals\n\n  Modal.prototype.handleUpdate = function () {\n    this.adjustDialog()\n  }\n\n  Modal.prototype.adjustDialog = function () {\n    var modalIsOverflowing = this.$element[0].scrollHeight > document.documentElement.clientHeight\n\n    this.$element.css({\n      paddingLeft:  !this.bodyIsOverflowing && modalIsOverflowing ? this.scrollbarWidth : '',\n      paddingRight: this.bodyIsOverflowing && !modalIsOverflowing ? this.scrollbarWidth : ''\n    })\n  }\n\n  Modal.prototype.resetAdjustments = function () {\n    this.$element.css({\n      paddingLeft: '',\n      paddingRight: ''\n    })\n  }\n\n  Modal.prototype.checkScrollbar = function () {\n    var fullWindowWidth = window.innerWidth\n    if (!fullWindowWidth) { // workaround for missing window.innerWidth in IE8\n      var documentElementRect = document.documentElement.getBoundingClientRect()\n      fullWindowWidth = documentElementRect.right - Math.abs(documentElementRect.left)\n    }\n    this.bodyIsOverflowing = document.body.clientWidth < fullWindowWidth\n    this.scrollbarWidth = this.measureScrollbar()\n  }\n\n  Modal.prototype.setScrollbar = function () {\n    var bodyPad = parseInt((this.$body.css('padding-right') || 0), 10)\n    this.originalBodyPad = document.body.style.paddingRight || ''\n    if (this.bodyIsOverflowing) this.$body.css('padding-right', bodyPad + this.scrollbarWidth)\n  }\n\n  Modal.prototype.resetScrollbar = function () {\n    this.$body.css('padding-right', this.originalBodyPad)\n  }\n\n  Modal.prototype.measureScrollbar = function () { // thx walsh\n    var scrollDiv = document.createElement('div')\n    scrollDiv.className = 'modal-scrollbar-measure'\n    this.$body.append(scrollDiv)\n    var scrollbarWidth = scrollDiv.offsetWidth - scrollDiv.clientWidth\n    this.$body[0].removeChild(scrollDiv)\n    return scrollbarWidth\n  }\n\n\n  // MODAL PLUGIN DEFINITION\n  // =======================\n\n  function Plugin(option, _relatedTarget) {\n    return this.each(function () {\n      var $this   = $(this)\n      var data    = $this.data('bs.modal')\n      var options = $.extend({}, Modal.DEFAULTS, $this.data(), typeof option == 'object' && option)\n\n      if (!data) $this.data('bs.modal', (data = new Modal(this, options)))\n      if (typeof option == 'string') data[option](_relatedTarget)\n      else if (options.show) data.show(_relatedTarget)\n    })\n  }\n\n  var old = $.fn.modal\n\n  $.fn.modal             = Plugin\n  $.fn.modal.Constructor = Modal\n\n\n  // MODAL NO CONFLICT\n  // =================\n\n  $.fn.modal.noConflict = function () {\n    $.fn.modal = old\n    return this\n  }\n\n\n  // MODAL DATA-API\n  // ==============\n\n  $(document).on('click.bs.modal.data-api', '[data-toggle=\"modal\"]', function (e) {\n    var $this   = $(this)\n    var href    = $this.attr('href')\n    var $target = $($this.attr('data-target') || (href && href.replace(/.*(?=#[^\\s]+$)/, ''))) // strip for ie7\n    var option  = $target.data('bs.modal') ? 'toggle' : $.extend({ remote: !/#/.test(href) && href }, $target.data(), $this.data())\n\n    if ($this.is('a')) e.preventDefault()\n\n    $target.one('show.bs.modal', function (showEvent) {\n      if (showEvent.isDefaultPrevented()) return // only register focus restorer if modal will actually get shown\n      $target.one('hidden.bs.modal', function () {\n        $this.is(':visible') && $this.trigger('focus')\n      })\n    })\n    Plugin.call($target, option, this)\n  })\n\n}(jQuery);\n","/* ========================================================================\n * Bootstrap: scrollspy.js v3.3.6\n * http://getbootstrap.com/javascript/#scrollspy\n * ========================================================================\n * Copyright 2011-2015 Twitter, Inc.\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)\n * ======================================================================== */\n\n\n+function ($) {\n  'use strict';\n\n  // SCROLLSPY CLASS DEFINITION\n  // ==========================\n\n  function ScrollSpy(element, options) {\n    this.$body          = $(document.body)\n    this.$scrollElement = $(element).is(document.body) ? $(window) : $(element)\n    this.options        = $.extend({}, ScrollSpy.DEFAULTS, options)\n    this.selector       = (this.options.target || '') + ' .nav li > a'\n    this.offsets        = []\n    this.targets        = []\n    this.activeTarget   = null\n    this.scrollHeight   = 0\n\n    this.$scrollElement.on('scroll.bs.scrollspy', $.proxy(this.process, this))\n    this.refresh()\n    this.process()\n  }\n\n  ScrollSpy.VERSION  = '3.3.6'\n\n  ScrollSpy.DEFAULTS = {\n    offset: 10\n  }\n\n  ScrollSpy.prototype.getScrollHeight = function () {\n    return this.$scrollElement[0].scrollHeight || Math.max(this.$body[0].scrollHeight, document.documentElement.scrollHeight)\n  }\n\n  ScrollSpy.prototype.refresh = function () {\n    var that          = this\n    var offsetMethod  = 'offset'\n    var offsetBase    = 0\n\n    this.offsets      = []\n    this.targets      = []\n    this.scrollHeight = this.getScrollHeight()\n\n    if (!$.isWindow(this.$scrollElement[0])) {\n      offsetMethod = 'position'\n      offsetBase   = this.$scrollElement.scrollTop()\n    }\n\n    this.$body\n      .find(this.selector)\n      .map(function () {\n        var $el   = $(this)\n        var href  = $el.data('target') || $el.attr('href')\n        var $href = /^#./.test(href) && $(href)\n\n        return ($href\n          && $href.length\n          && $href.is(':visible')\n          && [[$href[offsetMethod]().top + offsetBase, href]]) || null\n      })\n      .sort(function (a, b) { return a[0] - b[0] })\n      .each(function () {\n        that.offsets.push(this[0])\n        that.targets.push(this[1])\n      })\n  }\n\n  ScrollSpy.prototype.process = function () {\n    var scrollTop    = this.$scrollElement.scrollTop() + this.options.offset\n    var scrollHeight = this.getScrollHeight()\n    var maxScroll    = this.options.offset + scrollHeight - this.$scrollElement.height()\n    var offsets      = this.offsets\n    var targets      = this.targets\n    var activeTarget = this.activeTarget\n    var i\n\n    if (this.scrollHeight != scrollHeight) {\n      this.refresh()\n    }\n\n    if (scrollTop >= maxScroll) {\n      return activeTarget != (i = targets[targets.length - 1]) && this.activate(i)\n    }\n\n    if (activeTarget && scrollTop < offsets[0]) {\n      this.activeTarget = null\n      return this.clear()\n    }\n\n    for (i = offsets.length; i--;) {\n      activeTarget != targets[i]\n        && scrollTop >= offsets[i]\n        && (offsets[i + 1] === undefined || scrollTop < offsets[i + 1])\n        && this.activate(targets[i])\n    }\n  }\n\n  ScrollSpy.prototype.activate = function (target) {\n    this.activeTarget = target\n\n    this.clear()\n\n    var selector = this.selector +\n      '[data-target=\"' + target + '\"],' +\n      this.selector + '[href=\"' + target + '\"]'\n\n    var active = $(selector)\n      .parents('li')\n      .addClass('active')\n\n    if (active.parent('.dropdown-menu').length) {\n      active = active\n        .closest('li.dropdown')\n        .addClass('active')\n    }\n\n    active.trigger('activate.bs.scrollspy')\n  }\n\n  ScrollSpy.prototype.clear = function () {\n    $(this.selector)\n      .parentsUntil(this.options.target, '.active')\n      .removeClass('active')\n  }\n\n\n  // SCROLLSPY PLUGIN DEFINITION\n  // ===========================\n\n  function Plugin(option) {\n    return this.each(function () {\n      var $this   = $(this)\n      var data    = $this.data('bs.scrollspy')\n      var options = typeof option == 'object' && option\n\n      if (!data) $this.data('bs.scrollspy', (data = new ScrollSpy(this, options)))\n      if (typeof option == 'string') data[option]()\n    })\n  }\n\n  var old = $.fn.scrollspy\n\n  $.fn.scrollspy             = Plugin\n  $.fn.scrollspy.Constructor = ScrollSpy\n\n\n  // SCROLLSPY NO CONFLICT\n  // =====================\n\n  $.fn.scrollspy.noConflict = function () {\n    $.fn.scrollspy = old\n    return this\n  }\n\n\n  // SCROLLSPY DATA-API\n  // ==================\n\n  $(window).on('load.bs.scrollspy.data-api', function () {\n    $('[data-spy=\"scroll\"]').each(function () {\n      var $spy = $(this)\n      Plugin.call($spy, $spy.data())\n    })\n  })\n\n}(jQuery);\n","/* ========================================================================\n * Bootstrap: carousel.js v3.3.6\n * http://getbootstrap.com/javascript/#carousel\n * ========================================================================\n * Copyright 2011-2015 Twitter, Inc.\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)\n * ======================================================================== */\n\n\n+function ($) {\n  'use strict';\n\n  // CAROUSEL CLASS DEFINITION\n  // =========================\n\n  var Carousel = function (element, options) {\n    this.$element    = $(element)\n    this.$indicators = this.$element.find('.carousel-indicators')\n    this.options     = options\n    this.paused      = null\n    this.sliding     = null\n    this.interval    = null\n    this.$active     = null\n    this.$items      = null\n\n    this.options.keyboard && this.$element.on('keydown.bs.carousel', $.proxy(this.keydown, this))\n\n    this.options.pause == 'hover' && !('ontouchstart' in document.documentElement) && this.$element\n      .on('mouseenter.bs.carousel', $.proxy(this.pause, this))\n      .on('mouseleave.bs.carousel', $.proxy(this.cycle, this))\n  }\n\n  Carousel.VERSION  = '3.3.6'\n\n  Carousel.TRANSITION_DURATION = 600\n\n  Carousel.DEFAULTS = {\n    interval: 5000,\n    pause: 'hover',\n    wrap: true,\n    keyboard: true\n  }\n\n  Carousel.prototype.keydown = function (e) {\n    if (/input|textarea/i.test(e.target.tagName)) return\n    switch (e.which) {\n      case 37: this.prev(); break\n      case 39: this.next(); break\n      default: return\n    }\n\n    e.preventDefault()\n  }\n\n  Carousel.prototype.cycle = function (e) {\n    e || (this.paused = false)\n\n    this.interval && clearInterval(this.interval)\n\n    this.options.interval\n      && !this.paused\n      && (this.interval = setInterval($.proxy(this.next, this), this.options.interval))\n\n    return this\n  }\n\n  Carousel.prototype.getItemIndex = function (item) {\n    this.$items = item.parent().children('.item')\n    return this.$items.index(item || this.$active)\n  }\n\n  Carousel.prototype.getItemForDirection = function (direction, active) {\n    var activeIndex = this.getItemIndex(active)\n    var willWrap = (direction == 'prev' && activeIndex === 0)\n                || (direction == 'next' && activeIndex == (this.$items.length - 1))\n    if (willWrap && !this.options.wrap) return active\n    var delta = direction == 'prev' ? -1 : 1\n    var itemIndex = (activeIndex + delta) % this.$items.length\n    return this.$items.eq(itemIndex)\n  }\n\n  Carousel.prototype.to = function (pos) {\n    var that        = this\n    var activeIndex = this.getItemIndex(this.$active = this.$element.find('.item.active'))\n\n    if (pos > (this.$items.length - 1) || pos < 0) return\n\n    if (this.sliding)       return this.$element.one('slid.bs.carousel', function () { that.to(pos) }) // yes, \"slid\"\n    if (activeIndex == pos) return this.pause().cycle()\n\n    return this.slide(pos > activeIndex ? 'next' : 'prev', this.$items.eq(pos))\n  }\n\n  Carousel.prototype.pause = function (e) {\n    e || (this.paused = true)\n\n    if (this.$element.find('.next, .prev').length && $.support.transition) {\n      this.$element.trigger($.support.transition.end)\n      this.cycle(true)\n    }\n\n    this.interval = clearInterval(this.interval)\n\n    return this\n  }\n\n  Carousel.prototype.next = function () {\n    if (this.sliding) return\n    return this.slide('next')\n  }\n\n  Carousel.prototype.prev = function () {\n    if (this.sliding) return\n    return this.slide('prev')\n  }\n\n  Carousel.prototype.slide = function (type, next) {\n    var $active   = this.$element.find('.item.active')\n    var $next     = next || this.getItemForDirection(type, $active)\n    var isCycling = this.interval\n    var direction = type == 'next' ? 'left' : 'right'\n    var that      = this\n\n    if ($next.hasClass('active')) return (this.sliding = false)\n\n    var relatedTarget = $next[0]\n    var slideEvent = $.Event('slide.bs.carousel', {\n      relatedTarget: relatedTarget,\n      direction: direction\n    })\n    this.$element.trigger(slideEvent)\n    if (slideEvent.isDefaultPrevented()) return\n\n    this.sliding = true\n\n    isCycling && this.pause()\n\n    if (this.$indicators.length) {\n      this.$indicators.find('.active').removeClass('active')\n      var $nextIndicator = $(this.$indicators.children()[this.getItemIndex($next)])\n      $nextIndicator && $nextIndicator.addClass('active')\n    }\n\n    var slidEvent = $.Event('slid.bs.carousel', { relatedTarget: relatedTarget, direction: direction }) // yes, \"slid\"\n    if ($.support.transition && this.$element.hasClass('slide')) {\n      $next.addClass(type)\n      $next[0].offsetWidth // force reflow\n      $active.addClass(direction)\n      $next.addClass(direction)\n      $active\n        .one('bsTransitionEnd', function () {\n          $next.removeClass([type, direction].join(' ')).addClass('active')\n          $active.removeClass(['active', direction].join(' '))\n          that.sliding = false\n          setTimeout(function () {\n            that.$element.trigger(slidEvent)\n          }, 0)\n        })\n        .emulateTransitionEnd(Carousel.TRANSITION_DURATION)\n    } else {\n      $active.removeClass('active')\n      $next.addClass('active')\n      this.sliding = false\n      this.$element.trigger(slidEvent)\n    }\n\n    isCycling && this.cycle()\n\n    return this\n  }\n\n\n  // CAROUSEL PLUGIN DEFINITION\n  // ==========================\n\n  function Plugin(option) {\n    return this.each(function () {\n      var $this   = $(this)\n      var data    = $this.data('bs.carousel')\n      var options = $.extend({}, Carousel.DEFAULTS, $this.data(), typeof option == 'object' && option)\n      var action  = typeof option == 'string' ? option : options.slide\n\n      if (!data) $this.data('bs.carousel', (data = new Carousel(this, options)))\n      if (typeof option == 'number') data.to(option)\n      else if (action) data[action]()\n      else if (options.interval) data.pause().cycle()\n    })\n  }\n\n  var old = $.fn.carousel\n\n  $.fn.carousel             = Plugin\n  $.fn.carousel.Constructor = Carousel\n\n\n  // CAROUSEL NO CONFLICT\n  // ====================\n\n  $.fn.carousel.noConflict = function () {\n    $.fn.carousel = old\n    return this\n  }\n\n\n  // CAROUSEL DATA-API\n  // =================\n\n  var clickHandler = function (e) {\n    var href\n    var $this   = $(this)\n    var $target = $($this.attr('data-target') || (href = $this.attr('href')) && href.replace(/.*(?=#[^\\s]+$)/, '')) // strip for ie7\n    if (!$target.hasClass('carousel')) return\n    var options = $.extend({}, $target.data(), $this.data())\n    var slideIndex = $this.attr('data-slide-to')\n    if (slideIndex) options.interval = false\n\n    Plugin.call($target, options)\n\n    if (slideIndex) {\n      $target.data('bs.carousel').to(slideIndex)\n    }\n\n    e.preventDefault()\n  }\n\n  $(document)\n    .on('click.bs.carousel.data-api', '[data-slide]', clickHandler)\n    .on('click.bs.carousel.data-api', '[data-slide-to]', clickHandler)\n\n  $(window).on('load', function () {\n    $('[data-ride=\"carousel\"]').each(function () {\n      var $carousel = $(this)\n      Plugin.call($carousel, $carousel.data())\n    })\n  })\n\n}(jQuery);\n","/* ========================================================================\n * Bootstrap: tab.js v3.3.6\n * http://getbootstrap.com/javascript/#tabs\n * ========================================================================\n * Copyright 2011-2015 Twitter, Inc.\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)\n * ======================================================================== */\n\n\n+function ($) {\n  'use strict';\n\n  // TAB CLASS DEFINITION\n  // ====================\n\n  var Tab = function (element) {\n    // jscs:disable requireDollarBeforejQueryAssignment\n    this.element = $(element)\n    // jscs:enable requireDollarBeforejQueryAssignment\n  }\n\n  Tab.VERSION = '3.3.6'\n\n  Tab.TRANSITION_DURATION = 150\n\n  Tab.prototype.show = function () {\n    var $this    = this.element\n    var $ul      = $this.closest('ul:not(.dropdown-menu)')\n    var selector = $this.data('target')\n\n    if (!selector) {\n      selector = $this.attr('href')\n      selector = selector && selector.replace(/.*(?=#[^\\s]*$)/, '') // strip for ie7\n    }\n\n    if ($this.parent('li').hasClass('active')) return\n\n    var $previous = $ul.find('.active:last a')\n    var hideEvent = $.Event('hide.bs.tab', {\n      relatedTarget: $this[0]\n    })\n    var showEvent = $.Event('show.bs.tab', {\n      relatedTarget: $previous[0]\n    })\n\n    $previous.trigger(hideEvent)\n    $this.trigger(showEvent)\n\n    if (showEvent.isDefaultPrevented() || hideEvent.isDefaultPrevented()) return\n\n    var $target = $(selector)\n\n    this.activate($this.closest('li'), $ul)\n    this.activate($target, $target.parent(), function () {\n      $previous.trigger({\n        type: 'hidden.bs.tab',\n        relatedTarget: $this[0]\n      })\n      $this.trigger({\n        type: 'shown.bs.tab',\n        relatedTarget: $previous[0]\n      })\n    })\n  }\n\n  Tab.prototype.activate = function (element, container, callback) {\n    var $active    = container.find('> .active')\n    var transition = callback\n      && $.support.transition\n      && ($active.length && $active.hasClass('fade') || !!container.find('> .fade').length)\n\n    function next() {\n      $active\n        .removeClass('active')\n        .find('> .dropdown-menu > .active')\n          .removeClass('active')\n        .end()\n        .find('[data-toggle=\"tab\"]')\n          .attr('aria-expanded', false)\n\n      element\n        .addClass('active')\n        .find('[data-toggle=\"tab\"]')\n          .attr('aria-expanded', true)\n\n      if (transition) {\n        element[0].offsetWidth // reflow for transition\n        element.addClass('in')\n      } else {\n        element.removeClass('fade')\n      }\n\n      if (element.parent('.dropdown-menu').length) {\n        element\n          .closest('li.dropdown')\n            .addClass('active')\n          .end()\n          .find('[data-toggle=\"tab\"]')\n            .attr('aria-expanded', true)\n      }\n\n      callback && callback()\n    }\n\n    $active.length && transition ?\n      $active\n        .one('bsTransitionEnd', next)\n        .emulateTransitionEnd(Tab.TRANSITION_DURATION) :\n      next()\n\n    $active.removeClass('in')\n  }\n\n\n  // TAB PLUGIN DEFINITION\n  // =====================\n\n  function Plugin(option) {\n    return this.each(function () {\n      var $this = $(this)\n      var data  = $this.data('bs.tab')\n\n      if (!data) $this.data('bs.tab', (data = new Tab(this)))\n      if (typeof option == 'string') data[option]()\n    })\n  }\n\n  var old = $.fn.tab\n\n  $.fn.tab             = Plugin\n  $.fn.tab.Constructor = Tab\n\n\n  // TAB NO CONFLICT\n  // ===============\n\n  $.fn.tab.noConflict = function () {\n    $.fn.tab = old\n    return this\n  }\n\n\n  // TAB DATA-API\n  // ============\n\n  var clickHandler = function (e) {\n    e.preventDefault()\n    Plugin.call($(this), 'show')\n  }\n\n  $(document)\n    .on('click.bs.tab.data-api', '[data-toggle=\"tab\"]', clickHandler)\n    .on('click.bs.tab.data-api', '[data-toggle=\"pill\"]', clickHandler)\n\n}(jQuery);\n","/* ========================================================================\n * Bootstrap: affix.js v3.3.6\n * http://getbootstrap.com/javascript/#affix\n * ========================================================================\n * Copyright 2011-2015 Twitter, Inc.\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)\n * ======================================================================== */\n\n\n+function ($) {\n  'use strict';\n\n  // AFFIX CLASS DEFINITION\n  // ======================\n\n  var Affix = function (element, options) {\n    this.options = $.extend({}, Affix.DEFAULTS, options)\n\n    this.$target = $(this.options.target)\n      .on('scroll.bs.affix.data-api', $.proxy(this.checkPosition, this))\n      .on('click.bs.affix.data-api',  $.proxy(this.checkPositionWithEventLoop, this))\n\n    this.$element     = $(element)\n    this.affixed      = null\n    this.unpin        = null\n    this.pinnedOffset = null\n\n    this.checkPosition()\n  }\n\n  Affix.VERSION  = '3.3.6'\n\n  Affix.RESET    = 'affix affix-top affix-bottom'\n\n  Affix.DEFAULTS = {\n    offset: 0,\n    target: window\n  }\n\n  Affix.prototype.getState = function (scrollHeight, height, offsetTop, offsetBottom) {\n    var scrollTop    = this.$target.scrollTop()\n    var position     = this.$element.offset()\n    var targetHeight = this.$target.height()\n\n    if (offsetTop != null && this.affixed == 'top') return scrollTop < offsetTop ? 'top' : false\n\n    if (this.affixed == 'bottom') {\n      if (offsetTop != null) return (scrollTop + this.unpin <= position.top) ? false : 'bottom'\n      return (scrollTop + targetHeight <= scrollHeight - offsetBottom) ? false : 'bottom'\n    }\n\n    var initializing   = this.affixed == null\n    var colliderTop    = initializing ? scrollTop : position.top\n    var colliderHeight = initializing ? targetHeight : height\n\n    if (offsetTop != null && scrollTop <= offsetTop) return 'top'\n    if (offsetBottom != null && (colliderTop + colliderHeight >= scrollHeight - offsetBottom)) return 'bottom'\n\n    return false\n  }\n\n  Affix.prototype.getPinnedOffset = function () {\n    if (this.pinnedOffset) return this.pinnedOffset\n    this.$element.removeClass(Affix.RESET).addClass('affix')\n    var scrollTop = this.$target.scrollTop()\n    var position  = this.$element.offset()\n    return (this.pinnedOffset = position.top - scrollTop)\n  }\n\n  Affix.prototype.checkPositionWithEventLoop = function () {\n    setTimeout($.proxy(this.checkPosition, this), 1)\n  }\n\n  Affix.prototype.checkPosition = function () {\n    if (!this.$element.is(':visible')) return\n\n    var height       = this.$element.height()\n    var offset       = this.options.offset\n    var offsetTop    = offset.top\n    var offsetBottom = offset.bottom\n    var scrollHeight = Math.max($(document).height(), $(document.body).height())\n\n    if (typeof offset != 'object')         offsetBottom = offsetTop = offset\n    if (typeof offsetTop == 'function')    offsetTop    = offset.top(this.$element)\n    if (typeof offsetBottom == 'function') offsetBottom = offset.bottom(this.$element)\n\n    var affix = this.getState(scrollHeight, height, offsetTop, offsetBottom)\n\n    if (this.affixed != affix) {\n      if (this.unpin != null) this.$element.css('top', '')\n\n      var affixType = 'affix' + (affix ? '-' + affix : '')\n      var e         = $.Event(affixType + '.bs.affix')\n\n      this.$element.trigger(e)\n\n      if (e.isDefaultPrevented()) return\n\n      this.affixed = affix\n      this.unpin = affix == 'bottom' ? this.getPinnedOffset() : null\n\n      this.$element\n        .removeClass(Affix.RESET)\n        .addClass(affixType)\n        .trigger(affixType.replace('affix', 'affixed') + '.bs.affix')\n    }\n\n    if (affix == 'bottom') {\n      this.$element.offset({\n        top: scrollHeight - height - offsetBottom\n      })\n    }\n  }\n\n\n  // AFFIX PLUGIN DEFINITION\n  // =======================\n\n  function Plugin(option) {\n    return this.each(function () {\n      var $this   = $(this)\n      var data    = $this.data('bs.affix')\n      var options = typeof option == 'object' && option\n\n      if (!data) $this.data('bs.affix', (data = new Affix(this, options)))\n      if (typeof option == 'string') data[option]()\n    })\n  }\n\n  var old = $.fn.affix\n\n  $.fn.affix             = Plugin\n  $.fn.affix.Constructor = Affix\n\n\n  // AFFIX NO CONFLICT\n  // =================\n\n  $.fn.affix.noConflict = function () {\n    $.fn.affix = old\n    return this\n  }\n\n\n  // AFFIX DATA-API\n  // ==============\n\n  $(window).on('load', function () {\n    $('[data-spy=\"affix\"]').each(function () {\n      var $spy = $(this)\n      var data = $spy.data()\n\n      data.offset = data.offset || {}\n\n      if (data.offsetBottom != null) data.offset.bottom = data.offsetBottom\n      if (data.offsetTop    != null) data.offset.top    = data.offsetTop\n\n      Plugin.call($spy, data)\n    })\n  })\n\n}(jQuery);\n","/* ========================================================================\n * Bootstrap: tooltip.js v3.3.6\n * http://getbootstrap.com/javascript/#tooltip\n * Inspired by the original jQuery.tipsy by Jason Frame\n * ========================================================================\n * Copyright 2011-2015 Twitter, Inc.\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)\n * ======================================================================== */\n\n\n+function ($) {\n  'use strict';\n\n  // TOOLTIP PUBLIC CLASS DEFINITION\n  // ===============================\n\n  var Tooltip = function (element, options) {\n    this.type       = null\n    this.options    = null\n    this.enabled    = null\n    this.timeout    = null\n    this.hoverState = null\n    this.$element   = null\n    this.inState    = null\n\n    this.init('tooltip', element, options)\n  }\n\n  Tooltip.VERSION  = '3.3.6'\n\n  Tooltip.TRANSITION_DURATION = 150\n\n  Tooltip.DEFAULTS = {\n    animation: true,\n    placement: 'top',\n    selector: false,\n    template: '<div class=\"tooltip\" role=\"tooltip\"><div class=\"tooltip-arrow\"></div><div class=\"tooltip-inner\"></div></div>',\n    trigger: 'hover focus',\n    title: '',\n    delay: 0,\n    html: false,\n    container: false,\n    viewport: {\n      selector: 'body',\n      padding: 0\n    }\n  }\n\n  Tooltip.prototype.init = function (type, element, options) {\n    this.enabled   = true\n    this.type      = type\n    this.$element  = $(element)\n    this.options   = this.getOptions(options)\n    this.$viewport = this.options.viewport && $($.isFunction(this.options.viewport) ? this.options.viewport.call(this, this.$element) : (this.options.viewport.selector || this.options.viewport))\n    this.inState   = { click: false, hover: false, focus: false }\n\n    if (this.$element[0] instanceof document.constructor && !this.options.selector) {\n      throw new Error('`selector` option must be specified when initializing ' + this.type + ' on the window.document object!')\n    }\n\n    var triggers = this.options.trigger.split(' ')\n\n    for (var i = triggers.length; i--;) {\n      var trigger = triggers[i]\n\n      if (trigger == 'click') {\n        this.$element.on('click.' + this.type, this.options.selector, $.proxy(this.toggle, this))\n      } else if (trigger != 'manual') {\n        var eventIn  = trigger == 'hover' ? 'mouseenter' : 'focusin'\n        var eventOut = trigger == 'hover' ? 'mouseleave' : 'focusout'\n\n        this.$element.on(eventIn  + '.' + this.type, this.options.selector, $.proxy(this.enter, this))\n        this.$element.on(eventOut + '.' + this.type, this.options.selector, $.proxy(this.leave, this))\n      }\n    }\n\n    this.options.selector ?\n      (this._options = $.extend({}, this.options, { trigger: 'manual', selector: '' })) :\n      this.fixTitle()\n  }\n\n  Tooltip.prototype.getDefaults = function () {\n    return Tooltip.DEFAULTS\n  }\n\n  Tooltip.prototype.getOptions = function (options) {\n    options = $.extend({}, this.getDefaults(), this.$element.data(), options)\n\n    if (options.delay && typeof options.delay == 'number') {\n      options.delay = {\n        show: options.delay,\n        hide: options.delay\n      }\n    }\n\n    return options\n  }\n\n  Tooltip.prototype.getDelegateOptions = function () {\n    var options  = {}\n    var defaults = this.getDefaults()\n\n    this._options && $.each(this._options, function (key, value) {\n      if (defaults[key] != value) options[key] = value\n    })\n\n    return options\n  }\n\n  Tooltip.prototype.enter = function (obj) {\n    var self = obj instanceof this.constructor ?\n      obj : $(obj.currentTarget).data('bs.' + this.type)\n\n    if (!self) {\n      self = new this.constructor(obj.currentTarget, this.getDelegateOptions())\n      $(obj.currentTarget).data('bs.' + this.type, self)\n    }\n\n    if (obj instanceof $.Event) {\n      self.inState[obj.type == 'focusin' ? 'focus' : 'hover'] = true\n    }\n\n    if (self.tip().hasClass('in') || self.hoverState == 'in') {\n      self.hoverState = 'in'\n      return\n    }\n\n    clearTimeout(self.timeout)\n\n    self.hoverState = 'in'\n\n    if (!self.options.delay || !self.options.delay.show) return self.show()\n\n    self.timeout = setTimeout(function () {\n      if (self.hoverState == 'in') self.show()\n    }, self.options.delay.show)\n  }\n\n  Tooltip.prototype.isInStateTrue = function () {\n    for (var key in this.inState) {\n      if (this.inState[key]) return true\n    }\n\n    return false\n  }\n\n  Tooltip.prototype.leave = function (obj) {\n    var self = obj instanceof this.constructor ?\n      obj : $(obj.currentTarget).data('bs.' + this.type)\n\n    if (!self) {\n      self = new this.constructor(obj.currentTarget, this.getDelegateOptions())\n      $(obj.currentTarget).data('bs.' + this.type, self)\n    }\n\n    if (obj instanceof $.Event) {\n      self.inState[obj.type == 'focusout' ? 'focus' : 'hover'] = false\n    }\n\n    if (self.isInStateTrue()) return\n\n    clearTimeout(self.timeout)\n\n    self.hoverState = 'out'\n\n    if (!self.options.delay || !self.options.delay.hide) return self.hide()\n\n    self.timeout = setTimeout(function () {\n      if (self.hoverState == 'out') self.hide()\n    }, self.options.delay.hide)\n  }\n\n  Tooltip.prototype.show = function () {\n    var e = $.Event('show.bs.' + this.type)\n\n    if (this.hasContent() && this.enabled) {\n      this.$element.trigger(e)\n\n      var inDom = $.contains(this.$element[0].ownerDocument.documentElement, this.$element[0])\n      if (e.isDefaultPrevented() || !inDom) return\n      var that = this\n\n      var $tip = this.tip()\n\n      var tipId = this.getUID(this.type)\n\n      this.setContent()\n      $tip.attr('id', tipId)\n      this.$element.attr('aria-describedby', tipId)\n\n      if (this.options.animation) $tip.addClass('fade')\n\n      var placement = typeof this.options.placement == 'function' ?\n        this.options.placement.call(this, $tip[0], this.$element[0]) :\n        this.options.placement\n\n      var autoToken = /\\s?auto?\\s?/i\n      var autoPlace = autoToken.test(placement)\n      if (autoPlace) placement = placement.replace(autoToken, '') || 'top'\n\n      $tip\n        .detach()\n        .css({ top: 0, left: 0, display: 'block' })\n        .addClass(placement)\n        .data('bs.' + this.type, this)\n\n      this.options.container ? $tip.appendTo(this.options.container) : $tip.insertAfter(this.$element)\n      this.$element.trigger('inserted.bs.' + this.type)\n\n      var pos          = this.getPosition()\n      var actualWidth  = $tip[0].offsetWidth\n      var actualHeight = $tip[0].offsetHeight\n\n      if (autoPlace) {\n        var orgPlacement = placement\n        var viewportDim = this.getPosition(this.$viewport)\n\n        placement = placement == 'bottom' && pos.bottom + actualHeight > viewportDim.bottom ? 'top'    :\n                    placement == 'top'    && pos.top    - actualHeight < viewportDim.top    ? 'bottom' :\n                    placement == 'right'  && pos.right  + actualWidth  > viewportDim.width  ? 'left'   :\n                    placement == 'left'   && pos.left   - actualWidth  < viewportDim.left   ? 'right'  :\n                    placement\n\n        $tip\n          .removeClass(orgPlacement)\n          .addClass(placement)\n      }\n\n      var calculatedOffset = this.getCalculatedOffset(placement, pos, actualWidth, actualHeight)\n\n      this.applyPlacement(calculatedOffset, placement)\n\n      var complete = function () {\n        var prevHoverState = that.hoverState\n        that.$element.trigger('shown.bs.' + that.type)\n        that.hoverState = null\n\n        if (prevHoverState == 'out') that.leave(that)\n      }\n\n      $.support.transition && this.$tip.hasClass('fade') ?\n        $tip\n          .one('bsTransitionEnd', complete)\n          .emulateTransitionEnd(Tooltip.TRANSITION_DURATION) :\n        complete()\n    }\n  }\n\n  Tooltip.prototype.applyPlacement = function (offset, placement) {\n    var $tip   = this.tip()\n    var width  = $tip[0].offsetWidth\n    var height = $tip[0].offsetHeight\n\n    // manually read margins because getBoundingClientRect includes difference\n    var marginTop = parseInt($tip.css('margin-top'), 10)\n    var marginLeft = parseInt($tip.css('margin-left'), 10)\n\n    // we must check for NaN for ie 8/9\n    if (isNaN(marginTop))  marginTop  = 0\n    if (isNaN(marginLeft)) marginLeft = 0\n\n    offset.top  += marginTop\n    offset.left += marginLeft\n\n    // $.fn.offset doesn't round pixel values\n    // so we use setOffset directly with our own function B-0\n    $.offset.setOffset($tip[0], $.extend({\n      using: function (props) {\n        $tip.css({\n          top: Math.round(props.top),\n          left: Math.round(props.left)\n        })\n      }\n    }, offset), 0)\n\n    $tip.addClass('in')\n\n    // check to see if placing tip in new offset caused the tip to resize itself\n    var actualWidth  = $tip[0].offsetWidth\n    var actualHeight = $tip[0].offsetHeight\n\n    if (placement == 'top' && actualHeight != height) {\n      offset.top = offset.top + height - actualHeight\n    }\n\n    var delta = this.getViewportAdjustedDelta(placement, offset, actualWidth, actualHeight)\n\n    if (delta.left) offset.left += delta.left\n    else offset.top += delta.top\n\n    var isVertical          = /top|bottom/.test(placement)\n    var arrowDelta          = isVertical ? delta.left * 2 - width + actualWidth : delta.top * 2 - height + actualHeight\n    var arrowOffsetPosition = isVertical ? 'offsetWidth' : 'offsetHeight'\n\n    $tip.offset(offset)\n    this.replaceArrow(arrowDelta, $tip[0][arrowOffsetPosition], isVertical)\n  }\n\n  Tooltip.prototype.replaceArrow = function (delta, dimension, isVertical) {\n    this.arrow()\n      .css(isVertical ? 'left' : 'top', 50 * (1 - delta / dimension) + '%')\n      .css(isVertical ? 'top' : 'left', '')\n  }\n\n  Tooltip.prototype.setContent = function () {\n    var $tip  = this.tip()\n    var title = this.getTitle()\n\n    $tip.find('.tooltip-inner')[this.options.html ? 'html' : 'text'](title)\n    $tip.removeClass('fade in top bottom left right')\n  }\n\n  Tooltip.prototype.hide = function (callback) {\n    var that = this\n    var $tip = $(this.$tip)\n    var e    = $.Event('hide.bs.' + this.type)\n\n    function complete() {\n      if (that.hoverState != 'in') $tip.detach()\n      that.$element\n        .removeAttr('aria-describedby')\n        .trigger('hidden.bs.' + that.type)\n      callback && callback()\n    }\n\n    this.$element.trigger(e)\n\n    if (e.isDefaultPrevented()) return\n\n    $tip.removeClass('in')\n\n    $.support.transition && $tip.hasClass('fade') ?\n      $tip\n        .one('bsTransitionEnd', complete)\n        .emulateTransitionEnd(Tooltip.TRANSITION_DURATION) :\n      complete()\n\n    this.hoverState = null\n\n    return this\n  }\n\n  Tooltip.prototype.fixTitle = function () {\n    var $e = this.$element\n    if ($e.attr('title') || typeof $e.attr('data-original-title') != 'string') {\n      $e.attr('data-original-title', $e.attr('title') || '').attr('title', '')\n    }\n  }\n\n  Tooltip.prototype.hasContent = function () {\n    return this.getTitle()\n  }\n\n  Tooltip.prototype.getPosition = function ($element) {\n    $element   = $element || this.$element\n\n    var el     = $element[0]\n    var isBody = el.tagName == 'BODY'\n\n    var elRect    = el.getBoundingClientRect()\n    if (elRect.width == null) {\n      // width and height are missing in IE8, so compute them manually; see https://github.com/twbs/bootstrap/issues/14093\n      elRect = $.extend({}, elRect, { width: elRect.right - elRect.left, height: elRect.bottom - elRect.top })\n    }\n    var elOffset  = isBody ? { top: 0, left: 0 } : $element.offset()\n    var scroll    = { scroll: isBody ? document.documentElement.scrollTop || document.body.scrollTop : $element.scrollTop() }\n    var outerDims = isBody ? { width: $(window).width(), height: $(window).height() } : null\n\n    return $.extend({}, elRect, scroll, outerDims, elOffset)\n  }\n\n  Tooltip.prototype.getCalculatedOffset = function (placement, pos, actualWidth, actualHeight) {\n    return placement == 'bottom' ? { top: pos.top + pos.height,   left: pos.left + pos.width / 2 - actualWidth / 2 } :\n           placement == 'top'    ? { top: pos.top - actualHeight, left: pos.left + pos.width / 2 - actualWidth / 2 } :\n           placement == 'left'   ? { top: pos.top + pos.height / 2 - actualHeight / 2, left: pos.left - actualWidth } :\n        /* placement == 'right' */ { top: pos.top + pos.height / 2 - actualHeight / 2, left: pos.left + pos.width }\n\n  }\n\n  Tooltip.prototype.getViewportAdjustedDelta = function (placement, pos, actualWidth, actualHeight) {\n    var delta = { top: 0, left: 0 }\n    if (!this.$viewport) return delta\n\n    var viewportPadding = this.options.viewport && this.options.viewport.padding || 0\n    var viewportDimensions = this.getPosition(this.$viewport)\n\n    if (/right|left/.test(placement)) {\n      var topEdgeOffset    = pos.top - viewportPadding - viewportDimensions.scroll\n      var bottomEdgeOffset = pos.top + viewportPadding - viewportDimensions.scroll + actualHeight\n      if (topEdgeOffset < viewportDimensions.top) { // top overflow\n        delta.top = viewportDimensions.top - topEdgeOffset\n      } else if (bottomEdgeOffset > viewportDimensions.top + viewportDimensions.height) { // bottom overflow\n        delta.top = viewportDimensions.top + viewportDimensions.height - bottomEdgeOffset\n      }\n    } else {\n      var leftEdgeOffset  = pos.left - viewportPadding\n      var rightEdgeOffset = pos.left + viewportPadding + actualWidth\n      if (leftEdgeOffset < viewportDimensions.left) { // left overflow\n        delta.left = viewportDimensions.left - leftEdgeOffset\n      } else if (rightEdgeOffset > viewportDimensions.right) { // right overflow\n        delta.left = viewportDimensions.left + viewportDimensions.width - rightEdgeOffset\n      }\n    }\n\n    return delta\n  }\n\n  Tooltip.prototype.getTitle = function () {\n    var title\n    var $e = this.$element\n    var o  = this.options\n\n    title = $e.attr('data-original-title')\n      || (typeof o.title == 'function' ? o.title.call($e[0]) :  o.title)\n\n    return title\n  }\n\n  Tooltip.prototype.getUID = function (prefix) {\n    do prefix += ~~(Math.random() * 1000000)\n    while (document.getElementById(prefix))\n    return prefix\n  }\n\n  Tooltip.prototype.tip = function () {\n    if (!this.$tip) {\n      this.$tip = $(this.options.template)\n      if (this.$tip.length != 1) {\n        throw new Error(this.type + ' `template` option must consist of exactly 1 top-level element!')\n      }\n    }\n    return this.$tip\n  }\n\n  Tooltip.prototype.arrow = function () {\n    return (this.$arrow = this.$arrow || this.tip().find('.tooltip-arrow'))\n  }\n\n  Tooltip.prototype.enable = function () {\n    this.enabled = true\n  }\n\n  Tooltip.prototype.disable = function () {\n    this.enabled = false\n  }\n\n  Tooltip.prototype.toggleEnabled = function () {\n    this.enabled = !this.enabled\n  }\n\n  Tooltip.prototype.toggle = function (e) {\n    var self = this\n    if (e) {\n      self = $(e.currentTarget).data('bs.' + this.type)\n      if (!self) {\n        self = new this.constructor(e.currentTarget, this.getDelegateOptions())\n        $(e.currentTarget).data('bs.' + this.type, self)\n      }\n    }\n\n    if (e) {\n      self.inState.click = !self.inState.click\n      if (self.isInStateTrue()) self.enter(self)\n      else self.leave(self)\n    } else {\n      self.tip().hasClass('in') ? self.leave(self) : self.enter(self)\n    }\n  }\n\n  Tooltip.prototype.destroy = function () {\n    var that = this\n    clearTimeout(this.timeout)\n    this.hide(function () {\n      that.$element.off('.' + that.type).removeData('bs.' + that.type)\n      if (that.$tip) {\n        that.$tip.detach()\n      }\n      that.$tip = null\n      that.$arrow = null\n      that.$viewport = null\n    })\n  }\n\n\n  // TOOLTIP PLUGIN DEFINITION\n  // =========================\n\n  function Plugin(option) {\n    return this.each(function () {\n      var $this   = $(this)\n      var data    = $this.data('bs.tooltip')\n      var options = typeof option == 'object' && option\n\n      if (!data && /destroy|hide/.test(option)) return\n      if (!data) $this.data('bs.tooltip', (data = new Tooltip(this, options)))\n      if (typeof option == 'string') data[option]()\n    })\n  }\n\n  var old = $.fn.tooltip\n\n  $.fn.tooltip             = Plugin\n  $.fn.tooltip.Constructor = Tooltip\n\n\n  // TOOLTIP NO CONFLICT\n  // ===================\n\n  $.fn.tooltip.noConflict = function () {\n    $.fn.tooltip = old\n    return this\n  }\n\n}(jQuery);\n"]}