{"version":3,"sources":["webpack:///employment-bef109a214aa0e57ba54.bundle.js","webpack:///webpack/bootstrap bef109a214aa0e57ba54?ca99**************","webpack:///./~/underscore/underscore.js?31a5*************","webpack:///external \"$\"?57aa*************","webpack:///./~/promise/lib/finally.js?1c58*************","webpack:///./~/bootstrap/js/collapse.js","webpack:///./~/promise/lib/index.js?d0e4*************","webpack:///./~/promise/lib/node-extensions.js?001f*************","webpack:///./js/templates/slidedown.html","webpack:///./~/promise/lib/synchronous.js?70fd*************","webpack:///./~/promise/~/asap/browser-asap.js?9b3f*************","webpack:///./~/promise/lib/core.js?fed0*************","webpack:///./~/backbone/backbone.js?b8b2*************","webpack:///./js/lib/views/collapsible.js?aa03","webpack:///(webpack)/buildin/global.js?3698*************","webpack:///./~/promise/~/asap/browser-raw.js?0985*************","webpack:///./js/lib/views/slidedown.js","webpack:///./js/lib/helpers.js?5321************","webpack:///./sass/pages/employment.scss","webpack:///./~/promise/index.js?2167*************","webpack:///./~/promise/lib/done.js?24cc*************","webpack:///./~/promise/lib/es6-extensions.js?5bdc*************","webpack:///./js/pages/employment.js"],"names":["modules","__webpack_require__","moduleId","installedModules","exports","module","i","l","call","m","c","value","d","name","getter","o","Object","defineProperty","configurable","enumerable","get","n","__esModule","object","property","prototype","hasOwnProperty","p","s","0","__WEBPACK_AMD_DEFINE_ARRAY__","__WEBPACK_AMD_DEFINE_RESULT__","createReduce","dir","iterator","obj","iteratee","memo","keys","index","length","currentKey","context","optimizeCb","isArrayLike","_","arguments","createPredicateIndexFinder","array","predicate","cb","getLength","createIndexFinder","predicateFind","sortedIndex","item","idx","Math","max","min","slice","isNaN","collectNonEnumProps","nonEnumIdx","nonEnumerableProps","constructor","proto","isFunction","ObjProto","prop","has","contains","push","root","this","previousUnderscore","ArrayProto","Array","FuncProto","Function","toString","nativeIsArray","isArray","nativeKeys","nativeBind","bind","nativeCreate","create","Ctor","_wrapped","VERSION","func","argCount","other","collection","accumulator","apply","identity","isObject","matcher","Infinity","createAssigner","keysFunc","undefinedOnly","source","key","baseCreate","result","MAX_ARRAY_INDEX","pow","each","forEach","map","collect","results","reduce","foldl","inject","reduceRight","foldr","find","detect","findIndex","findKey","filter","select","list","reject","negate","every","all","some","any","includes","include","fromIndex","guard","values","indexOf","invoke","method","args","isFunc","pluck","where","attrs","findWhere","computed","lastComputed","shuffle","rand","set","shuffled","random","sample","sortBy","criteria","sort","left","right","a","b","group","behavior","groupBy","indexBy","countBy","toArray","size","partition","pass","fail","first","head","take","initial","last","rest","tail","drop","compact","flatten","input","shallow","strict","startIndex","output","isArguments","j","len","without","difference","uniq","unique","isSorted","isBoolean","seen","union","intersection","argsLength","zip","unzip","findLastIndex","low","high","mid","floor","lastIndexOf","range","start","stop","step","ceil","executeBound","sourceFunc","boundFunc","callingContext","self","TypeError","bound","concat","partial","boundArgs","position","bindAll","Error","memoize","hasher","cache","address","delay","wait","setTimeout","defer","throttle","options","timeout","previous","later","leading","now","remaining","clearTimeout","trailing","debounce","immediate","timestamp","callNow","wrap","wrapper","compose","after","times","before","once","hasEnumBug","propertyIsEnumerable","allKeys","mapObject","pairs","invert","functions","methods","names","extend","extendOwn","assign","pick","oiteratee","omit","String","defaults","props","clone","tap","interceptor","isMatch","eq","aStack","bStack","className","areArrays","aCtor","bCtor","pop","isEqual","isEmpty","isString","isElement","nodeType","type","Int8Array","isFinite","parseFloat","isNumber","isNull","isUndefined","noConflict","constant","noop","propertyOf","matches","accum","Date","getTime","escapeMap","&","<",">","\"","'","`","unescapeMap","createEscaper","escaper","match","join","testRegexp","RegExp","replaceRegexp","string","test","replace","escape","unescape","fallback","idCounter","uniqueId","prefix","id","templateSettings","evaluate","interpolate","noMatch","escapes","\\","\r","\n","
","
","escapeChar","template","text","settings","oldSettings","offset","variable","render","e","data","chain","instance","_chain","mixin","valueOf","toJSON","undefined","1","$","10","Promise","f","then","resolve","err","105","jQuery","getTargetFromTrigger","$trigger","href","target","attr","Plugin","option","$this","Collapse","DEFAULTS","toggle","element","$element","transitioning","parent","$parent","getParent","addAriaAndCollapsedClass","TRANSITION_DURATION","dimension","hasClass","show","activesData","actives","children","startEvent","Event","trigger","isDefaultPrevented","removeClass","addClass","complete","support","transition","scrollSize","camelCase","one","proxy","emulateTransitionEnd","hide","offsetHeight","end","isOpen","toggleClass","old","fn","collapse","Constructor","document","on","preventDefault","$target","11","12","denodeifyWithCount","argumentCount","body","callbackFn","denodeifyWithoutCount","fnLength","asap","denodeify","nodeify","callback","ctx","ex","120","__t","__p","__j","print","13","enableSynchronous","isPending","getState","isFulfilled","isRejected","getValue","_65","_55","getReason","disableSynchronous","14","throwFirstError","pendingErrors","shift","task","rawTask","freeTasks","RawTask","rawAsap","requestErrorThrow","makeRequestCallFromTimer","error","onerror","2","getThen","LAST_ERROR","IS_ERROR","tryCallOne","tryCallTwo","_40","_72","doResolve","safeThen","onFulfilled","onRejected","res","handle","Handler","deferred","_37","handleResolved","promise","ret","newValue","finale","_87","done","reason","_61","3","global","factory","Backbone","previousBackbone","emulateHTTP","emulateJSON","addMethod","attribute","defaultVal","unshift","addUnderscoreMethods","Class","_isModel","modelMatcher","model","attributes","Events","eventSplitter","eventsApi","events","opts","split","internalOn","listening","_events","onApi","_listeners","listenTo","_listenId","listeningTo","_listeningTo","thisId","objId","count","handlers","off","offApi","listeners","stopListening","ids","handler","_callback","onceMap","listenToOnce","offer","triggerApi","objEvents","allEvents","triggerEvents","ev","a1","a2","a3","unbind","Model","cid","cidPrefix","parse","changed","initialize","validationError","idAttribute","sync","val","_validate","unset","silent","changes","changing","_changing","_previousAttributes","current","prev","_pending","clear","hasChanged","changedAttributes","diff","previousAttributes","fetch","success","resp","serverAttrs","wrapError","save","validate","isNew","patch","xhr","destroy","url","base","urlError","encodeURIComponent","isValid","Collection","models","comparator","_reset","reset","setOptions","add","remove","merge","addOptions","splice","insert","at","singular","removed","_removeModels","added","merged","toAdd","toMerge","toRemove","modelMap","sortable","sortAttr","existing","_prepareModel","_addReference","orderChanged","_removeReference","previousModels","_byId","modelId","callbackOpts","_onModelEvent","event","prevId","View","viewOptions","_ensureElement","delegateEventSplitter","tagName","selector","$el","_removeElement","setElement","undelegateEvents","_setElement","delegateEvents","el","delegate","eventName","listener","undelegate","_createElement","createElement","_setAttributes","methodMap","params","dataType","contentType","JSON","stringify","_method","beforeSend","setRequestHeader","processData","textStatus","errorThrown","ajax","update","delete","read","Router","routes","_bindRoutes","optionalParam","namedParam","splatParam","escapeRegExp","route","isRegExp","_routeToRegExp","router","history","fragment","_extractParameters","execute","navigate","optional","exec","param","decodeURIComponent","History","checkUrl","window","location","routeStripper","rootStripper","pathStripper","started","interval","atRoot","pathname","getSearch","matchRoot","decodeFragment","decodeURI","getHash","getPath","path","charAt","getFragment","_usePushState","_wantsHashChange","hashChange","_hasHashChange","documentMode","_useHashChange","_wantsPushState","pushState","_hasPushState","rootPath","iframe","src","style","display","tabIndex","iWindow","insertBefore","firstChild","contentWindow","open","close","hash","addEventListener","attachEvent","_checkUrlInterval","setInterval","loadUrl","removeEventListener","detachEvent","removeChild","clearInterval","title","_updateHash","protoProps","staticProps","child","__super__","38","_helpers","MMCollapsible","shown.bs.collapse","scrollUpBuffer","panelTitleSelector","maybeScrollToTitle","panelTop","top","scrollTopDistance","animate","scrollTop","collapsibleFactory","default","4","g","eval","5","queue","requestFlush","flushing","flush","currentIndex","capacity","scan","newLength","handleTimer","timeoutHandle","intervalHandle","scope","BrowserMutationObserver","MutationObserver","WebKitMutationObserver","observer","node","createTextNode","observe","characterData","55","makeSlidedown","modelTransformer","slidedown","Slidedown","SlidedownPanel","makeSlidedowns","$container","html","acc","$panelEl","panelTpl","content","6","getParameterByName","regex","getHashFromCurrentUrl","truncateWords","truncationChars","words","truncateCharacters","substring","toTitleCase","str","txt","toUpperCase","substr","toLowerCase","randomString","possible","pageYOffset","documentElement","toggleScroll","flag","css","whenScrollReached","onScroll","66","fa-cc-visa","desktop-search-overlay","fa-sheqel","fa-rocket","fa-battery-1","fa-scribd","fa-sort-numeric-desc","fa-arrow-circle-o-down","fa-hand-pointer-o","fa-meh-o","fa-blind","fa-globe","fa-yahoo","fa-map-o","fa-feed","fa-moon-o","fa-hand-lizard-o","social-share-flat","hs-input","fa-sort-up","fa-cc-diners-club","fa-anchor","fa-bell-slash","fa-birthday-cake","fa-sort-desc","fa-mobile","fa-optin-monster","fa-columns","fa-facebook","fa-fonticons","fa-github-alt","highlighted","fa-angle-double-down","ctc-container","fa-paste","fa-git-square","fa-calculator","fa-registered","wide","fa-dollar","fa-hashtag","fa-play-circle","fa-chevron-down","fa-sticky-note-o","fa-mars","hero-header","fa-window-minimize","fa-amazon","fa-square","fa-code-fork","fa-navicon","fa-qq","fa-map-signs","fa-play-circle-o","navbar-toggle","footer-contact","fa-weixin","fa-caret-square-o-right","fa-superscript","fa-recycle","fa-question-circle","side-bar","fa-file-movie-o","fa-ra","fa-hourglass-3","li","fa-gbp","fa-inverse","fa-credit-card-alt","fa-edit","fa-hourglass-half","fa-paperclip","fa-download","fa-flickr","fa-thumbs-down","fa-git","fa-hand-paper-o","fa-plus-square-o","fa-bank","fa-hotel","fa-sticky-note","fa-sort-asc","fa-share-alt","section","fa-euro","fa-thermometer-3","fa-li","fa-pied-piper","fa-close","fa-gear","fa-adjust","fa-stumbleupon","fa-wpforms","dropdown-mega","fa-paypal","fa-toggle-left","card-top-alert","fa-id-badge","fa-hand-o-right","fa-exchange","fa-binoculars","fa-gg","fa-plus-circle","fa-toggle-right","dropdown-florida-list","no-float","input-container","fa-facebook-square","fa-indent","fa-calendar-minus-o","placeholder","fa-heartbeat","fa-windows","fa-vimeo-square","nav-email-col","nav-ctc-container","fa-viacoin","fa-drivers-license","navbar","fa-long-arrow-left","results-container","fa-money","recent-firm-news-item","fa-sign-in","fa-arrow-circle-right","fa-puzzle-piece","sr-only-focusable","fa-codiepie","btn-black","fa-openid","fa-shopping-bag","fa-info","fa-check-square","pointer","fa-cc-paypal","fa-circle","mm-recent-firm-news","fa-eraser","fa-chevron-up","fa-copy","fa-chevron-circle-down","fa-bluetooth","fa-share-square","fa-repeat","fa-desktop","fa-hand-rock-o","fa-th-large","fa-arrow-circle-o-up","fa-google","social-share-expanding","fa-bold","pullquote-right","fa-video-camera","fa-file-audio-o","fa-bus","btn-ctc","fa-stumbleupon-circle","fa-yc","fa-heart","fa-frown-o","fa-mail-reply","fa-vine","fa-sign-language","fa-tv","fa-user-times","faq-card","fa-database","fa-codepen","fa-simplybuilt","experiment-semaphore","fa-window-maximize","fa-map-marker","fa-sort-amount-desc","fa-file-picture-o","fa-usb","fa-terminal","fa-bar-chart","fa-product-hunt","fa-image","fa-stop-circle-o","fa-venus-mars","benefit","fa-commenting","fa-trophy","fa-rotate-270","fa-soundcloud","highlighteable","fa-gavel","fa-random","fa-stack-2x","fa-ul","fa-asterisk","fa-arrows-h","fa-jpy","fa-y-combinator","fa-mail-forward","fa-legal","email","fa-volume-off","fa-external-link-square","fa-opera","fa-superpowers","fa-maxcdn","fa-apple","fa-foursquare","fa-scissors","sub-title","fa-cloud-download","fa-twitch","pullquote-left","fa-snowflake-o","fa-tablet","fa-star","fa-leanpub","fa-play","fa-creative-commons","fa-wechat","fa-stop","fa-tachometer","fa-ambulance","fa-weibo","btn-pagination","recent-firm-news-more-results","fa-wifi","fa-mail-reply-all","fa-space-shuttle","fa-soccer-ball-o","fa-user-o","modal-body","fa-trash","fa-paw","items-3","fa-ticket","fa-times-circle","fa-grav","fa-angle-left","fa-btc","fa-medkit","fa-user-circle","fa-unlock","fa-linkedin","fa-area-chart","fa-arrow-circle-o-right","fa-address-book-o","fa-thermometer-three-quarters","fa-american-sign-language-interpreting","fa-fast-backward","fa-github-square","fa-times-rectangle-o","nav-call-col","fa-subway","fa-newspaper-o","fa-google-plus-circle","fa-bitbucket","mm-search","fa-reorder","focused","fa-thumbs-o-down","fa-street-view","fa-calendar-times-o","fa-keyboard-o","fa-magnet","fa-ship","general-form","fa-automobile","fa-wpbeginner","fa-battery-half","fa-pinterest","fa-th","fa-share","fa-sort-numeric-asc","fa-percent","fa-mercury","breadcrumb","fa-thermometer","fa-mortar-board","header-title","fa-key","fa-s15","dropdown-locations","btn-red","fa-cab","fa-slideshare","fa-angle-double-left","fa-ravelry","fb-comments","fa-lastfm","fa-rebel","fa-chain-broken","items-1","employment","fa-strikethrough","fa-sort-alpha-desc","fa-phone-square","pull-right","fa-envelope","fa-th-list","fa-at","fa-remove","fa-life-bouy","fa-battery-empty","yt","fa-arrow-circle-left","fa-arrow-circle-up","fa-pulse","advertisement","collapsed","fa-expand","fa-mars-double","fa-comment-o","fa-adn","fa-vk","fa-ruble","fa-laptop","fa-xing-square","fa-expeditedssl","fa-first-order","btn-twitter","fa-google-plus","fa-caret-right","fa-code","btn","fa-building-o","fa-check-circle-o","fa-circle-thin","fa-angle-up","fa-text-height","fa-gittip","fa-angle-double-up","fa-usd","fa-file-archive-o","fa-gift","fa-thermometer-full","sr-only","fa-steam","fa-3x","fa-battery-4","fa-address-card","fa-fw","fa-motorcycle","fa-times","fa-list-ol","fa-black-tie","footer-form","hs-error-msgs","fa-address-card-o","fa-map","selected","btn-ghost-black","fa-file-sound-o","fa-meanpath","fa-info-circle","fa-dedent","search-expand-lg","fa-toggle-off","fa-certificate","fa-font-awesome","mm-table","fa-camera","fa-sort-down","fa-thermometer-2","footer-logo","fa-user","fa-group","fa-power-off","fa-android","fa-futbol-o","fa-circle-o","fa-pencil","fa-sign-out","fa-sort-amount-asc","nav-search","fa-spin","fa-users","fa-align-center","fa-connectdevelop","fa-qrcode","fa-tags","fa-minus-square-o","fa-star-half","fa-eject","fa-stack-overflow","fa-bicycle","fa-cut","fa-rss","fa-joomla","more","fa-server","modal-header","fa-4x","fa-chevron-circle-right","fa-clone","fa-align-left","fa-mouse-pointer","fa-hourglass-o","result-container","metadata","fa-linode","fa-bug","fa-thumb-tack","fa-bed","fa-link","dropdown-menu","fa-reply-all","fa-subscript","masthead","card-content-alert","mobile","fa-align-justify","fa-ioxhost","fa-credit-card","social-card","fa-youtube-square","fa-battery-three-quarters","fa-bullhorn","fa-tasks","fa-filter","fa-pinterest-p","fa-bathtub","fa-2x","fa-share-square-o","fa-flag-o","fa-thumbs-up","fa-underline","fa-star-half-full","fa-delicious","fa-gg-circle","fa-vcard","fa-hand-o-left","fa-i-cursor","fa-arrow-left","fa-won","panel-body","fa-odnoklassniki","fa-caret-square-o-left","fa-search-plus","fa-pied-piper-alt","fa-chrome","fa-youtube-play","fa-bitcoin","fa-crop","form-control","fa-object-ungroup","fa-neuter","fa-dropbox","fa-assistive-listening-systems","fa-linkedin-square","fa-ellipsis-v","fa-caret-square-o-up","fa-glide","btn-close","fa-eye","fa-list-ul","facebook-comment-wrapper","rt","fa-cogs","fa-bar-chart-o","fa-question","fa-pause-circle-o","btn-social","fa-volume-down","fa-map-pin","expander","fa-file","fa-check","fa-reply","fa-hand-spock-o","fa-unlock-alt","fa-drivers-license-o","card-content","fa-compress","panel","gp","affix","fa-inbox","fa-cart-arrow-down","fa-reddit-alien","fa-behance","fa-calendar","recent-firm-news-title","fa-google-plus-square","fa-wheelchair-alt","follow-row","fa-folder-open","fa-yen","fa-spoon","fa-ils","fa-trello","fa-envelope-open","fa-cc-discover","fa-mobile-phone","fa-comment","fa-eercast","nav","fa-cc-amex","fa-archive","fa-sun-o","fa-thermometer-1","fa-arrows","fa-quote-right","fa-universal-access","fa-train","hidden-lg","network","fa-pie-chart","fa-buysellads","fa-taxi","footer-subnav-links","fa-sellsy","fa-glide-g","fa-retweet","fa-text-width","fa-rupee","fa-ellipsis-h","fa-folder-open-o","fa-photo","fa-object-group","fa-unlink","pin","fa-slack","fa-twitter","hs_yes_sign_me_up_for_the_newsletter_","fa-caret-left","fa-exclamation","fa-file-powerpoint-o","fa-eyedropper","fa-contao","fa-search","fa-exclamation-triangle","hero-unit","fa-twitter-square","fa-plug","fa-dashboard","dropdown-toggle","panel-title","fa-file-word-o","fa-eye-slash","fa-xing","fa-thermometer-half","fa-handshake-o","fa-chevron-circle-left","fa-glass","desktop","fa-eur","fa-braille","fa-floppy-o","card-top","fa-skype","fa-volume-up","fa-cc-stripe","fa-hourglass-end","fa-microphone","fa-5x","fa-font","fa-meetup","fa-arrows-alt","fa-pencil-square-o","fa-hdd-o","fa-home","fa-road","fa-crosshairs","nav-logo","fa-building","recent-firm-news-details","fa-level-up","fa-stop-circle","expandable","fa-id-card-o","fa-thermometer-empty","fa-chevron-right","fa-file-excel-o","fa-plane","fa-venus-double","fa-check-circle","fa-envelope-o","fa-toggle-up","fa-snapchat-ghost","fa-try","fa-file-photo-o","image-column","fa-long-arrow-down","fa-plus","fa-battery-quarter","fa-hourglass-start","fa-line-chart","double-wide","fa-history","fa-folder","btn-dark","fa-microchip","fa-bomb","pointer-wrapper","fa-tint","fa-low-vision","fa-snapchat-square","caret","fa-bolt","fa-undo","fa-arrow-up","search-expand-md","fa-pagelines","fa-heart-o","fa-send-o","fa-television","fa-support","fa-opencart","fa-diamond","modal-title","fa-battery","fa-500px","fa-film","fa-book","fa-window-close","fa-comments","fa-themeisle","more-related-articles","fa-suitcase","fa-clipboard","fa-check-square-o","links-row","fa-tree","search-expand-sm","fa-medium","fa-location-arrow","fa-user-plus","fa-stack","fa-krw","fa-hand-scissors-o","fa-houzz","fa-volume-control-phone","fa-clock-o","fa-fire","fa-file-text-o","fa-arrow-circle-o-left","fa-hand-o-up","fa-lg","fa-life-buoy","fa-align-right","fa-arrows-v","fa-viadeo","fa-vcard-o","testimonials-items","fa-hand-peace-o","sidebar-form","fa-safari","fa-reddit-square","fa-vimeo","fa-files-o","fa-file-text","fa-copyright","fa-id-card","fa-chain","fa-dashcube","fa-facebook-official","fa-pull-left","fa-pied-piper-pp","fa-audio-description","has-results","fa-cog","fa-venus","fa-odnoklassniki-square","fa-angle-down","fa-minus-circle","fa-drupal","fa-dribbble","btn-red-centered","fa-file-video-o","fa-industry","fa-user-md","fa-pull-right","fa-folder-o","fa-fire-extinguisher","fa-shopping-basket","fa-yc-square","fa-life-saver","fa-square-o","fa-etsy","pull-left","fa-resistance","fa-bell-o","fa-skyatlas","fa-battery-3","fa-quote-left","mm-header-container","nav-desktop","fa-toggle-down","fa-shield","panel-group","fa-step-forward","fa-commenting-o","fa-camera-retro","fa-paper-plane","fa-briefcase","fa-digg","centered-button","fa-thumbs-o-up","fa-behance-square","fa-italic","col-md-4","fa-sort-alpha-asc","fa-step-backward","fb","fa-flip-vertical","employment-locations","fa-stack-1x","fa-sitemap","clicktocall","header-bar","fa-border","fa-file-image-o","fa-asl-interpreting","fa-pencil-square","tw","fa-linux","fa-wordpress","fa-comments-o","fa-toggle-on","fa-cloud","inputs-list","fa-user-secret","btn-fb","fa-deviantart","fa-signal","fa-rotate-right","testimonials-header","fa-star-o","fa-angellist","fa-tumblr-square","fa-cny","fa-battery-0","visible-lg","fa-list","fa-lemon-o","fa-fort-awesome","fa-chevron-circle-up","fa-fighter-jet","btn-yt","fa-cc-jcb","fa-deaf","fa-bookmark-o","fa-arrow-circle-down","fa-warning","fa-empire","fa-turkish-lira","fa-long-arrow-up","mm-search-input","fa-steam-square","fa-chevron-left","fa-facebook-f","fa-transgender-alt","btn-ghost","form-blurb","fa-tag","fa-bath","fa-cutlery","footer-subnav","fa-shekel","fa-flag","fa-fax","fa-envira","go-to-top-container","recent-firm-news-header","fa-shopping-cart","fa-file-o","fa-thermometer-4","fa-angle-right","fa-mars-stroke-h","fa-user-circle-o","fa-arrow-down","popup-contact-form","fa-life-ring","fa-ge","hs-button","fa-battery-2","fa-address-book","fa-caret-square-o-down","fa-google-wallet","fa-hand-grab-o","fa-barcode","fa-thermometer-0","fa-header","fa-beer","fa-inr","fa-hourglass-1","fa-minus-square","fa-reddit","num","fa-renren","fa-backward","contact-card","fa-calendar-check-o","fa-gamepad","fa-calendar-plus-o","hs-richtext","fa-caret-up","fa-file-code-o","fa-star-half-empty","fa-youtube","go-top","fa-bell","fa-telegram","fa-viadeo-square","fa-external-link","call-us","fa-cube","fa-forumbee","fa-snapchat","fa-graduation-cap","fa-arrow-right","fa-flash","fa-smile-o","fa-headphones","fa-instagram","most-popular","mm-sortable-table","fa-yelp","fa-y-combinator-square","fa-hand-stop-o","fa-edge","hs-form-field","hs_submit","fa-cubes","fa-pause","fa-ban","fa-rouble","featured-link","dropdown","fa-tumblr","fa-unsorted","navbar-header","fa-rmb","expanded","fa-window-close-o","fa-circle-o-notch","fa-coffee","fa-hand-o-down","fa-paragraph","fa-gitlab","phone","fa-mars-stroke-v","fa-stethoscope","fa-quora","fa-institution","fa-stack-exchange","fa-shirtsinbulk","fa-thermometer-quarter","fa-cc","fa-h-square","fa-leaf","fa-compass","related-article-box","fa-window-restore","fa-github","fa-times-rectangle","mm-news-articles-basic","fa-print","fa-wikipedia-w","fa-css3","row-testimonials","fa-intersex","fa-bell-slash-o","fa-firefox","fa-hard-of-hearing","fa-wheelchair","fa-picture-o","social","testimonials-see-more","fa-bars","fa-get-pocket","fa-pause-circle","fa-exclamation-circle","fa-question-circle-o","fa-modx","fa-hacker-news","fa-trash-o","fa-forward","fa-fast-forward","fa-google-plus-official","fa-rss-square","ca-logo","fa-child","fa-spinner","fa-rotate-left","fa-balance-scale","btn-play","fa-music","fa-rub","fa-internet-explorer","fa-sliders","more-related-articles-container","row","fa-times-circle-o","fa-car","fa-paint-brush","fa-tty","in","fa-bitbucket-square","employment-benefits","fa-rotate-90","fa-envelope-square","fa-lightbulb-o","fa-file-zip-o","footer-form-wrapper","fa-tencent-weibo","fa-dot-circle-o","fa-truck","fa-male","fa-microphone-slash","fa-umbrella","fa-hourglass-2","fa-genderless","basic-see-more","fa-lastfm-square","panel-heading","fa-phone","fa-whatsapp","fa-signing","fa-university","fa-battery-full","fa-magic","fa-html5","fa-trademark","star-black","fa-sort","fa-envelope-open-o","fa-gears","star-orange","fa-bluetooth-b","icon-bar","fa-file-pdf-o","fa-list-alt","fa-yoast","grouped","recent-firm-news-description","fa-language","fa-long-arrow-right","fa-send","fa-refresh","fa-search-minus","fa-hospital-o","fa-jsfiddle","items-2","fa-spotify","fa-shower","fa-flag-checkered","fa-podcast","see-all","fa-imdb","fa-bookmark","fa-level-down","fa-wrench","fa-mixcloud","fa-outdent","fa-share-alt-square","fa-lock","fa-gratipay","fa-table","fa-flip-horizontal","fa-plus-square","fa-transgender","actions","fa-bullseye","fa-star-half-o","fa","fa-female","fa-angle-double-right","fa-free-code-camp","fa-cart-plus","fa-rotate-180","fa-calendar-o","fa-flask","fa-bandcamp","fa-caret-down","fa-hourglass","social-share-flat-wrapper","fa-pinterest-square","fa-paper-plane-o","fa-fa","fa-mars-stroke","fa-save","fa-upload","fa-cc-mastercard","fa-wpexplorer","fa-cloud-upload","fa-minus","recent-firm-news-image","fa-tripadvisor","fa-deafness","btn-close-expander","7","8","9","valuePromise","TRUE","FALSE","NULL","UNDEFINED","ZERO","EMPTYSTRING","arr","race","91","_slidedown","_collapsible","_collapsible2","Job","full_title","department","jobsTpl","groupedByCity","city","reverse","jobs"],"mappings":"CAAS,SAAUA,GCInB,QAAAC,GAAAC,GAGA,GAAAC,EAAAD,GACA,MAAAC,GAAAD,GAAAE,OAGA,IAAAC,GAAAF,EAAAD,IACAI,EAAAJ,EACAK,GAAA,EACAH,WAUA,OANAJ,GAAAE,GAAAM,KAAAH,EAAAD,QAAAC,IAAAD,QAAAH,GAGAI,EAAAE,GAAA,EAGAF,EAAAD,QAvBA,GAAAD,KA4BAF,GAAAQ,EAAAT,EAGAC,EAAAS,EAAAP,EAGAF,EAAAK,EAAA,SAAAK,GAA2C,MAAAA,IAG3CV,EAAAW,EAAA,SAAAR,EAAAS,EAAAC,GACAb,EAAAc,EAAAX,EAAAS,IACAG,OAAAC,eAAAb,EAAAS,GACAK,cAAA,EACAC,YAAA,EACAC,IAAAN,KAMAb,EAAAoB,EAAA,SAAAhB,GACA,GAAAS,GAAAT,KAAAiB,WACA,WAA2B,MAAAjB,GAAA,SAC3B,WAAiC,MAAAA,GAEjC,OADAJ,GAAAW,EAAAE,EAAA,IAAAA,GACAA,GAIAb,EAAAc,EAAA,SAAAQ,EAAAC,GAAsD,MAAAR,QAAAS,UAAAC,eAAAlB,KAAAe,EAAAC,IAGtDvB,EAAA0B,EAAA,GAGA1B,IAAA2B,EAAA,MDMMC,EACA,SAAUxB,EAAQD,EAASH,GEvEjC,GAAA6B,GAAAC,GAKA,WA4KA,QAAAC,GAAAC,GAGA,QAAAC,GAAAC,EAAAC,EAAAC,EAAAC,EAAAC,EAAAC,GACA,KAAYD,GAAA,GAAAA,EAAAC,EAA8BD,GAAAN,EAAA,CAC1C,GAAAQ,GAAAH,IAAAC,IACAF,GAAAD,EAAAC,EAAAF,EAAAM,KAAAN,GAEA,MAAAE,GAGA,gBAAAF,EAAAC,EAAAC,EAAAK,GACAN,EAAAO,EAAAP,EAAAM,EAAA,EACA,IAAAJ,IAAAM,EAAAT,IAAAU,EAAAP,KAAAH,GACAK,GAAAF,GAAAH,GAAAK,OACAD,EAAAN,EAAA,IAAAO,EAAA,CAMA,OAJAM,WAAAN,OAAA,IACAH,EAAAF,EAAAG,IAAAC,MACAA,GAAAN,GAEAC,EAAAC,EAAAC,EAAAC,EAAAC,EAAAC,EAAAC,IA+ZA,QAAAO,GAAAd,GACA,gBAAAe,EAAAC,EAAAP,GACAO,EAAAC,EAAAD,EAAAP,EAGA,KAFA,GAAAF,GAAAW,EAAAH,GACAT,EAAAN,EAAA,IAAAO,EAAA,EACYD,GAAA,GAAAA,EAAAC,EAA8BD,GAAAN,EAC1C,GAAAgB,EAAAD,EAAAT,KAAAS,GAAA,MAAAT,EAEA,WAsBA,QAAAa,GAAAnB,EAAAoB,EAAAC,GACA,gBAAAN,EAAAO,EAAAC,GACA,GAAAlD,GAAA,EAAAkC,EAAAW,EAAAH,EACA,oBAAAQ,GACAvB,EAAA,EACA3B,EAAAkD,GAAA,EAAAA,EAAAC,KAAAC,IAAAF,EAAAhB,EAAAlC,GAEAkC,EAAAgB,GAAA,EAAAC,KAAAE,IAAAH,EAAA,EAAAhB,GAAAgB,EAAAhB,EAAA,MAEO,IAAAc,GAAAE,GAAAhB,EAEP,MADAgB,GAAAF,EAAAN,EAAAO,GACAP,EAAAQ,KAAAD,EAAAC,GAAA,CAEA,IAAAD,MAEA,MADAC,GAAAH,EAAAO,EAAApD,KAAAwC,EAAA1C,EAAAkC,GAAAK,EAAAgB,OACAL,GAAA,EAAAA,EAAAlD,GAAA,CAEA,KAAAkD,EAAAvB,EAAA,EAAA3B,EAAAkC,EAAA,EAA0CgB,GAAA,GAAAA,EAAAhB,EAA0BgB,GAAAvB,EACpE,GAAAe,EAAAQ,KAAAD,EAAA,MAAAC,EAEA,WAqPA,QAAAM,GAAA3B,EAAAG,GACA,GAAAyB,GAAAC,EAAAxB,OACAyB,EAAA9B,EAAA8B,YACAC,EAAArB,EAAAsB,WAAAF,MAAAxC,WAAA2C,EAGAC,EAAA,aAGA,KAFAxB,EAAAyB,IAAAnC,EAAAkC,KAAAxB,EAAA0B,SAAAjC,EAAA+B,IAAA/B,EAAAkC,KAAAH,GAEAN,MACAM,EAAAL,EAAAD,KACA5B,MAAAkC,KAAAH,EAAAG,KAAAxB,EAAA0B,SAAAjC,EAAA+B,IACA/B,EAAAkC,KAAAH,GA74BA,GAAAI,GAAAC,KAGAC,EAAAF,EAAA5B,EAGA+B,EAAAC,MAAApD,UAAA2C,EAAApD,OAAAS,UAAAqD,EAAAC,SAAAtD,UAIA+C,EAAAI,EAAAJ,KACAZ,EAAAgB,EAAAhB,MACAoB,EAAAZ,EAAAY,SACAtD,EAAA0C,EAAA1C,eAKAuD,EAAAJ,MAAAK,QACAC,EAAAnE,OAAAsB,KACA8C,EAAAN,EAAAO,KACAC,EAAAtE,OAAAuE,OAGAC,EAAA,aAGA3C,EAAA,SAAAV,GACA,MAAAA,aAAAU,GAAAV,EACAuC,eAAA7B,QACA6B,KAAAe,SAAAtD,GADA,GAAAU,GAAAV,QAQA,KAAA9B,KAAAD,UACAA,EAAAC,EAAAD,QAAAyC,GAEAzC,EAAAyC,IAMAA,EAAA6C,QAAA,OAKA,IAAA/C,GAAA,SAAAgD,EAAAjD,EAAAkD,GACA,YAAAlD,EAAA,MAAAiD,EACA,cAAAC,EAAA,EAAAA,GACA,uBAAAjF,GACA,MAAAgF,GAAAnF,KAAAkC,EAAA/B,GAEA,wBAAAA,EAAAkF,GACA,MAAAF,GAAAnF,KAAAkC,EAAA/B,EAAAkF,GAEA,wBAAAlF,EAAA4B,EAAAuD,GACA,MAAAH,GAAAnF,KAAAkC,EAAA/B,EAAA4B,EAAAuD,GAEA,wBAAAC,EAAApF,EAAA4B,EAAAuD,GACA,MAAAH,GAAAnF,KAAAkC,EAAAqD,EAAApF,EAAA4B,EAAAuD,IAGA,kBACA,MAAAH,GAAAK,MAAAtD,EAAAI,aAOAI,EAAA,SAAAvC,EAAA+B,EAAAkD,GACA,aAAAjF,EAAAkC,EAAAoD,SACApD,EAAAsB,WAAAxD,GAAAgC,EAAAhC,EAAA+B,EAAAkD,GACA/C,EAAAqD,SAAAvF,GAAAkC,EAAAsD,QAAAxF,GACAkC,EAAArB,SAAAb,GAEAkC,GAAAT,SAAA,SAAAzB,EAAA+B,GACA,MAAAQ,GAAAvC,EAAA+B,EAAA0D,KAIA,IAAAC,GAAA,SAAAC,EAAAC,GACA,gBAAApE,GACA,GAAAK,GAAAM,UAAAN,MACA,IAAAA,EAAA,SAAAL,EAAA,MAAAA,EACA,QAAAI,GAAA,EAAyBA,EAAAC,EAAgBD,IAIzC,OAHAiE,GAAA1D,UAAAP,GACAD,EAAAgE,EAAAE,GACAjG,EAAA+B,EAAAE,OACAlC,EAAA,EAAuBA,EAAAC,EAAOD,IAAA,CAC9B,GAAAmG,GAAAnE,EAAAhC,EACAiG,QAAA,KAAApE,EAAAsE,KAAAtE,EAAAsE,GAAAD,EAAAC,IAGA,MAAAtE,KAKAuE,EAAA,SAAAjF,GACA,IAAAoB,EAAAqD,SAAAzE,GAAA,QACA,IAAA6D,EAAA,MAAAA,GAAA7D,EACA+D,GAAA/D,WACA,IAAAkF,GAAA,GAAAnB,EAEA,OADAA,GAAA/D,UAAA,KACAkF,GAGAnF,EAAA,SAAAiF,GACA,gBAAAtE,GACA,aAAAA,MAAA,GAAAA,EAAAsE,KAQAG,EAAAnD,KAAAoD,IAAA,QACA1D,EAAA3B,EAAA,UACAoB,EAAA,SAAAkD,GACA,GAAAtD,GAAAW,EAAA2C,EACA,uBAAAtD,OAAA,GAAAA,GAAAoE,EASA/D,GAAAiE,KAAAjE,EAAAkE,QAAA,SAAA5E,EAAAC,EAAAM,GACAN,EAAAO,EAAAP,EAAAM,EACA,IAAApC,GAAAkC,CACA,IAAAI,EAAAT,GACA,IAAA7B,EAAA,EAAAkC,EAAAL,EAAAK,OAAsClC,EAAAkC,EAAYlC,IAClD8B,EAAAD,EAAA7B,KAAA6B,OAEK,CACL,GAAAG,GAAAO,EAAAP,KAAAH,EACA,KAAA7B,EAAA,EAAAkC,EAAAF,EAAAE,OAAuClC,EAAAkC,EAAYlC,IACnD8B,EAAAD,EAAAG,EAAAhC,IAAAgC,EAAAhC,GAAA6B,GAGA,MAAAA,IAIAU,EAAAmE,IAAAnE,EAAAoE,QAAA,SAAA9E,EAAAC,EAAAM,GACAN,EAAAc,EAAAd,EAAAM,EAIA,QAHAJ,IAAAM,EAAAT,IAAAU,EAAAP,KAAAH,GACAK,GAAAF,GAAAH,GAAAK,OACA0E,EAAArC,MAAArC,GACAD,EAAA,EAAuBA,EAAAC,EAAgBD,IAAA,CACvC,GAAAE,GAAAH,IAAAC,IACA2E,GAAA3E,GAAAH,EAAAD,EAAAM,KAAAN,GAEA,MAAA+E,IA+BArE,EAAAsE,OAAAtE,EAAAuE,MAAAvE,EAAAwE,OAAArF,EAAA,GAGAa,EAAAyE,YAAAzE,EAAA0E,MAAAvF,GAAA,GAGAa,EAAA2E,KAAA3E,EAAA4E,OAAA,SAAAtF,EAAAc,EAAAP,GACA,GAAA+D,EAMA,cAJAA,EADA7D,EAAAT,GACAU,EAAA6E,UAAAvF,EAAAc,EAAAP,GAEAG,EAAA8E,QAAAxF,EAAAc,EAAAP,MAEA,IAAA+D,EAAA,MAAAtE,GAAAsE,IAKA5D,EAAA+E,OAAA/E,EAAAgF,OAAA,SAAA1F,EAAAc,EAAAP,GACA,GAAAwE,KAKA,OAJAjE,GAAAC,EAAAD,EAAAP,GACAG,EAAAiE,KAAA3E,EAAA,SAAAxB,EAAA4B,EAAAuF,GACA7E,EAAAtC,EAAA4B,EAAAuF,IAAAZ,EAAA1C,KAAA7D,KAEAuG,GAIArE,EAAAkF,OAAA,SAAA5F,EAAAc,EAAAP,GACA,MAAAG,GAAA+E,OAAAzF,EAAAU,EAAAmF,OAAA9E,EAAAD,IAAAP,IAKAG,EAAAoF,MAAApF,EAAAqF,IAAA,SAAA/F,EAAAc,EAAAP,GACAO,EAAAC,EAAAD,EAAAP,EAGA,QAFAJ,IAAAM,EAAAT,IAAAU,EAAAP,KAAAH,GACAK,GAAAF,GAAAH,GAAAK,OACAD,EAAA,EAAuBA,EAAAC,EAAgBD,IAAA,CACvC,GAAAE,GAAAH,IAAAC,IACA,KAAAU,EAAAd,EAAAM,KAAAN,GAAA,SAEA,UAKAU,EAAAsF,KAAAtF,EAAAuF,IAAA,SAAAjG,EAAAc,EAAAP,GACAO,EAAAC,EAAAD,EAAAP,EAGA,QAFAJ,IAAAM,EAAAT,IAAAU,EAAAP,KAAAH,GACAK,GAAAF,GAAAH,GAAAK,OACAD,EAAA,EAAuBA,EAAAC,EAAgBD,IAAA,CACvC,GAAAE,GAAAH,IAAAC,IACA,IAAAU,EAAAd,EAAAM,KAAAN,GAAA,SAEA,UAKAU,EAAA0B,SAAA1B,EAAAwF,SAAAxF,EAAAyF,QAAA,SAAAnG,EAAAoB,EAAAgF,EAAAC,GAGA,MAFA5F,GAAAT,OAAAU,EAAA4F,OAAAtG,KACA,gBAAAoG,IAAAC,KAAAD,EAAA,GACA1F,EAAA6F,QAAAvG,EAAAoB,EAAAgF,IAAA,GAIA1F,EAAA8F,OAAA,SAAAxG,EAAAyG,GACA,GAAAC,GAAAjF,EAAApD,KAAAsC,UAAA,GACAgG,EAAAjG,EAAAsB,WAAAyE,EACA,OAAA/F,GAAAmE,IAAA7E,EAAA,SAAAxB,GACA,GAAAgF,GAAAmD,EAAAF,EAAAjI,EAAAiI,EACA,cAAAjD,MAAAK,MAAArF,EAAAkI,MAKAhG,EAAAkG,MAAA,SAAA5G,EAAAsE,GACA,MAAA5D,GAAAmE,IAAA7E,EAAAU,EAAArB,SAAAiF,KAKA5D,EAAAmG,MAAA,SAAA7G,EAAA8G,GACA,MAAApG,GAAA+E,OAAAzF,EAAAU,EAAAsD,QAAA8C,KAKApG,EAAAqG,UAAA,SAAA/G,EAAA8G,GACA,MAAApG,GAAA2E,KAAArF,EAAAU,EAAAsD,QAAA8C,KAIApG,EAAAa,IAAA,SAAAvB,EAAAC,EAAAM,GACA,GACA/B,GAAAwI,EADAxC,GAAAP,IAAAgD,GAAAhD,GAEA,UAAAhE,GAAA,MAAAD,EAAA,CACAA,EAAAS,EAAAT,KAAAU,EAAA4F,OAAAtG,EACA,QAAA7B,GAAA,EAAAkC,EAAAL,EAAAK,OAA0ClC,EAAAkC,EAAYlC,KACtDK,EAAAwB,EAAA7B,IACAqG,IACAA,EAAAhG,OAIAyB,GAAAc,EAAAd,EAAAM,GACAG,EAAAiE,KAAA3E,EAAA,SAAAxB,EAAA4B,EAAAuF,KACAqB,EAAA/G,EAAAzB,EAAA4B,EAAAuF,IACAsB,GAAAD,KAAA/C,KAAAO,KAAAP,OACAO,EAAAhG,EACAyI,EAAAD,IAIA,OAAAxC,IAIA9D,EAAAc,IAAA,SAAAxB,EAAAC,EAAAM,GACA,GACA/B,GAAAwI,EADAxC,EAAAP,IAAAgD,EAAAhD,GAEA,UAAAhE,GAAA,MAAAD,EAAA,CACAA,EAAAS,EAAAT,KAAAU,EAAA4F,OAAAtG,EACA,QAAA7B,GAAA,EAAAkC,EAAAL,EAAAK,OAA0ClC,EAAAkC,EAAYlC,KACtDK,EAAAwB,EAAA7B,IACAqG,IACAA,EAAAhG,OAIAyB,GAAAc,EAAAd,EAAAM,GACAG,EAAAiE,KAAA3E,EAAA,SAAAxB,EAAA4B,EAAAuF,KACAqB,EAAA/G,EAAAzB,EAAA4B,EAAAuF,IACAsB,GAAAD,IAAA/C,KAAAO,IAAAP,OACAO,EAAAhG,EACAyI,EAAAD,IAIA,OAAAxC,IAKA9D,EAAAwG,QAAA,SAAAlH,GAIA,OAAAmH,GAHAC,EAAA3G,EAAAT,KAAAU,EAAA4F,OAAAtG,GACAK,EAAA+G,EAAA/G,OACAgH,EAAA3E,MAAArC,GACAD,EAAA,EAA6BA,EAAAC,EAAgBD,IAC7C+G,EAAAzG,EAAA4G,OAAA,EAAAlH,GACA+G,IAAA/G,IAAAiH,EAAAjH,GAAAiH,EAAAF,IACAE,EAAAF,GAAAC,EAAAhH,EAEA,OAAAiH,IAMA3G,EAAA6G,OAAA,SAAAvH,EAAAd,EAAAmH,GACA,aAAAnH,GAAAmH,GACA5F,EAAAT,OAAAU,EAAA4F,OAAAtG,IACAA,EAAAU,EAAA4G,OAAAtH,EAAAK,OAAA,KAEAK,EAAAwG,QAAAlH,GAAAyB,MAAA,EAAAH,KAAAC,IAAA,EAAArC,KAIAwB,EAAA8G,OAAA,SAAAxH,EAAAC,EAAAM,GAEA,MADAN,GAAAc,EAAAd,EAAAM,GACAG,EAAAkG,MAAAlG,EAAAmE,IAAA7E,EAAA,SAAAxB,EAAA4B,EAAAuF,GACA,OACAnH,QACA4B,QACAqH,SAAAxH,EAAAzB,EAAA4B,EAAAuF,MAEK+B,KAAA,SAAAC,EAAAC,GACL,GAAAC,GAAAF,EAAAF,SACAK,EAAAF,EAAAH,QACA,IAAAI,IAAAC,EAAA,CACA,GAAAD,EAAAC,OAAA,KAAAD,EAAA,QACA,IAAAA,EAAAC,OAAA,KAAAA,EAAA,SAEA,MAAAH,GAAAvH,MAAAwH,EAAAxH,QACK,SAIL,IAAA2H,GAAA,SAAAC,GACA,gBAAAhI,EAAAC,EAAAM,GACA,GAAAiE,KAMA,OALAvE,GAAAc,EAAAd,EAAAM,GACAG,EAAAiE,KAAA3E,EAAA,SAAAxB,EAAA4B,GACA,GAAAkE,GAAArE,EAAAzB,EAAA4B,EAAAJ,EACAgI,GAAAxD,EAAAhG,EAAA8F,KAEAE,GAMA9D,GAAAuH,QAAAF,EAAA,SAAAvD,EAAAhG,EAAA8F,GACA5D,EAAAyB,IAAAqC,EAAAF,GAAAE,EAAAF,GAAAjC,KAAA7D,GAAoDgG,EAAAF,IAAA9F,KAKpDkC,EAAAwH,QAAAH,EAAA,SAAAvD,EAAAhG,EAAA8F,GACAE,EAAAF,GAAA9F,IAMAkC,EAAAyH,QAAAJ,EAAA,SAAAvD,EAAAhG,EAAA8F,GACA5D,EAAAyB,IAAAqC,EAAAF,GAAAE,EAAAF,KAA0CE,EAAAF,GAAA,IAI1C5D,EAAA0H,QAAA,SAAApI,GACA,MAAAA,GACAU,EAAAqC,QAAA/C,GAAAyB,EAAApD,KAAA2B,GACAS,EAAAT,GAAAU,EAAAmE,IAAA7E,EAAAU,EAAAoD,UACApD,EAAA4F,OAAAtG,OAIAU,EAAA2H,KAAA,SAAArI,GACA,aAAAA,EAAA,EACAS,EAAAT,KAAAK,OAAAK,EAAAP,KAAAH,GAAAK,QAKAK,EAAA4H,UAAA,SAAAtI,EAAAc,EAAAP,GACAO,EAAAC,EAAAD,EAAAP,EACA,IAAAgI,MAAAC,IAIA,OAHA9H,GAAAiE,KAAA3E,EAAA,SAAAxB,EAAA8F,EAAAtE,IACAc,EAAAtC,EAAA8F,EAAAtE,GAAAuI,EAAAC,GAAAnG,KAAA7D,MAEA+J,EAAAC,IASA9H,EAAA+H,MAAA/H,EAAAgI,KAAAhI,EAAAiI,KAAA,SAAA9H,EAAA3B,EAAAmH,GACA,SAAAxF,EACA,aAAA3B,GAAAmH,EAAAxF,EAAA,GACAH,EAAAkI,QAAA/H,IAAAR,OAAAnB,IAMAwB,EAAAkI,QAAA,SAAA/H,EAAA3B,EAAAmH,GACA,MAAA5E,GAAApD,KAAAwC,EAAA,EAAAS,KAAAC,IAAA,EAAAV,EAAAR,QAAA,MAAAnB,GAAAmH,EAAA,EAAAnH,MAKAwB,EAAAmI,KAAA,SAAAhI,EAAA3B,EAAAmH,GACA,SAAAxF,EACA,aAAA3B,GAAAmH,EAAAxF,IAAAR,OAAA,GACAK,EAAAoI,KAAAjI,EAAAS,KAAAC,IAAA,EAAAV,EAAAR,OAAAnB,KAMAwB,EAAAoI,KAAApI,EAAAqI,KAAArI,EAAAsI,KAAA,SAAAnI,EAAA3B,EAAAmH,GACA,MAAA5E,GAAApD,KAAAwC,EAAA,MAAA3B,GAAAmH,EAAA,EAAAnH,IAIAwB,EAAAuI,QAAA,SAAApI,GACA,MAAAH,GAAA+E,OAAA5E,EAAAH,EAAAoD,UAIA,IAAAoF,GAAA,SAAAC,EAAAC,EAAAC,EAAAC,GAEA,OADAC,MAAAlI,EAAA,EACAlD,EAAAmL,GAAA,EAAAjJ,EAAAW,EAAAmI,GAA4DhL,EAAAkC,EAAYlC,IAAA,CACxE,GAAAK,GAAA2K,EAAAhL,EACA,IAAAsC,EAAAjC,KAAAkC,EAAAqC,QAAAvE,IAAAkC,EAAA8I,YAAAhL,IAAA,CAEA4K,IAAA5K,EAAA0K,EAAA1K,EAAA4K,EAAAC,GACA,IAAAI,GAAA,EAAAC,EAAAlL,EAAA6B,MAEA,KADAkJ,EAAAlJ,QAAAqJ,EACAD,EAAAC,GACAH,EAAAlI,KAAA7C,EAAAiL,SAEOJ,KACPE,EAAAlI,KAAA7C,GAGA,MAAA+K,GAIA7I,GAAAwI,QAAA,SAAArI,EAAAuI,GACA,MAAAF,GAAArI,EAAAuI,GAAA,IAIA1I,EAAAiJ,QAAA,SAAA9I,GACA,MAAAH,GAAAkJ,WAAA/I,EAAAY,EAAApD,KAAAsC,UAAA,KAMAD,EAAAmJ,KAAAnJ,EAAAoJ,OAAA,SAAAjJ,EAAAkJ,EAAA9J,EAAAM,GACAG,EAAAsJ,UAAAD,KACAxJ,EAAAN,EACAA,EAAA8J,EACAA,GAAA,GAEA,MAAA9J,MAAAc,EAAAd,EAAAM,GAGA,QAFAiE,MACAyF,KACA9L,EAAA,EAAAkC,EAAAW,EAAAH,GAA8C1C,EAAAkC,EAAYlC,IAAA,CAC1D,GAAAK,GAAAqC,EAAA1C,GACA6I,EAAA/G,IAAAzB,EAAAL,EAAA0C,GAAArC,CACAuL,IACA5L,GAAA8L,IAAAjD,GAAAxC,EAAAnC,KAAA7D,GACAyL,EAAAjD,GACO/G,EACPS,EAAA0B,SAAA6H,EAAAjD,KACAiD,EAAA5H,KAAA2E,GACAxC,EAAAnC,KAAA7D,IAEOkC,EAAA0B,SAAAoC,EAAAhG,IACPgG,EAAAnC,KAAA7D,GAGA,MAAAgG,IAKA9D,EAAAwJ,MAAA,WACA,MAAAxJ,GAAAmJ,KAAAX,EAAAvI,WAAA,QAKAD,EAAAyJ,aAAA,SAAAtJ,GAGA,OAFA2D,MACA4F,EAAAzJ,UAAAN,OACAlC,EAAA,EAAAkC,EAAAW,EAAAH,GAA8C1C,EAAAkC,EAAYlC,IAAA,CAC1D,GAAAiD,GAAAP,EAAA1C,EACA,KAAAuC,EAAA0B,SAAAoC,EAAApD,GAAA,CACA,OAAAqI,GAAA,EAAqBA,EAAAW,GACrB1J,EAAA0B,SAAAzB,UAAA8I,GAAArI,GADqCqI,KAGrCA,IAAAW,GAAA5F,EAAAnC,KAAAjB,IAEA,MAAAoD,IAKA9D,EAAAkJ,WAAA,SAAA/I,GACA,GAAAiI,GAAAI,EAAAvI,WAAA,OACA,OAAAD,GAAA+E,OAAA5E,EAAA,SAAArC,GACA,OAAAkC,EAAA0B,SAAA0G,EAAAtK,MAMAkC,EAAA2J,IAAA,WACA,MAAA3J,GAAA4J,MAAA3J,YAKAD,EAAA4J,MAAA,SAAAzJ,GAIA,OAHAR,GAAAQ,GAAAH,EAAAa,IAAAV,EAAAG,GAAAX,QAAA,EACAmE,EAAA9B,MAAArC,GAEAD,EAAA,EAAuBA,EAAAC,EAAgBD,IACvCoE,EAAApE,GAAAM,EAAAkG,MAAA/F,EAAAT,EAEA,OAAAoE,IAMA9D,EAAAtB,OAAA,SAAAuG,EAAAW,GAEA,OADA9B,MACArG,EAAA,EAAAkC,EAAAW,EAAA2E,GAA6CxH,EAAAkC,EAAYlC,IACzDmI,EACA9B,EAAAmB,EAAAxH,IAAAmI,EAAAnI,GAEAqG,EAAAmB,EAAAxH,GAAA,IAAAwH,EAAAxH,GAAA,EAGA,OAAAqG,IAiBA9D,EAAA6E,UAAA3E,EAAA,GACAF,EAAA6J,cAAA3J,GAAA,GAIAF,EAAAS,YAAA,SAAAN,EAAAb,EAAAC,EAAAM,GACAN,EAAAc,EAAAd,EAAAM,EAAA,EAGA,KAFA,GAAA/B,GAAAyB,EAAAD,GACAwK,EAAA,EAAAC,EAAAzJ,EAAAH,GACA2J,EAAAC,GAAA,CACA,GAAAC,GAAApJ,KAAAqJ,OAAAH,EAAAC,GAAA,EACAxK,GAAAY,EAAA6J,IAAAlM,EAAAgM,EAAAE,EAAA,EAAsDD,EAAAC,EAEtD,MAAAF,IAgCA9J,EAAA6F,QAAAtF,EAAA,EAAAP,EAAA6E,UAAA7E,EAAAS,aACAT,EAAAkK,YAAA3J,GAAA,EAAAP,EAAA6J,eAKA7J,EAAAmK,MAAA,SAAAC,EAAAC,EAAAC,GACA,MAAAD,IACAA,EAAAD,GAAA,EACAA,EAAA,GAEAE,KAAA,CAKA,QAHA3K,GAAAiB,KAAAC,IAAAD,KAAA2J,MAAAF,EAAAD,GAAAE,GAAA,GACAH,EAAAnI,MAAArC,GAEAgB,EAAA,EAAqBA,EAAAhB,EAAcgB,IAAAyJ,GAAAE,EACnCH,EAAAxJ,GAAAyJ,CAGA,OAAAD,GAQA,IAAAK,GAAA,SAAAC,EAAAC,EAAA7K,EAAA8K,EAAA3E,GACA,KAAA2E,YAAAD,IAAA,MAAAD,GAAAtH,MAAAtD,EAAAmG,EACA,IAAA4E,GAAA/G,EAAA4G,EAAA7L,WACAkF,EAAA2G,EAAAtH,MAAAyH,EAAA5E,EACA,OAAAhG,GAAAqD,SAAAS,KACA8G,EAMA5K,GAAAwC,KAAA,SAAAM,EAAAjD,GACA,GAAA0C,GAAAO,EAAAN,OAAAD,EAAA,MAAAA,GAAAY,MAAAL,EAAA/B,EAAApD,KAAAsC,UAAA,GACA,KAAAD,EAAAsB,WAAAwB,GAAA,SAAA+H,WAAA,oCACA,IAAA7E,GAAAjF,EAAApD,KAAAsC,UAAA,GACA6K,EAAA,WACA,MAAAN,GAAA1H,EAAAgI,EAAAjL,EAAAgC,KAAAmE,EAAA+E,OAAAhK,EAAApD,KAAAsC,aAEA,OAAA6K,IAMA9K,EAAAgL,QAAA,SAAAlI,GACA,GAAAmI,GAAAlK,EAAApD,KAAAsC,UAAA,GACA6K,EAAA,WAGA,OAFAI,GAAA,EAAAvL,EAAAsL,EAAAtL,OACAqG,EAAAhE,MAAArC,GACAlC,EAAA,EAAqBA,EAAAkC,EAAYlC,IACjCuI,EAAAvI,GAAAwN,EAAAxN,KAAAuC,EAAAC,UAAAiL,KAAAD,EAAAxN,EAEA,MAAAyN,EAAAjL,UAAAN,QAAAqG,EAAArE,KAAA1B,UAAAiL,KACA,OAAAV,GAAA1H,EAAAgI,EAAAjJ,UAAAmE,GAEA,OAAA8E,IAMA9K,EAAAmL,QAAA,SAAA7L,GACA,GAAA7B,GAAAmG,EAAAjE,EAAAM,UAAAN,MACA,IAAAA,GAAA,WAAAyL,OAAA,wCACA,KAAA3N,EAAA,EAAeA,EAAAkC,EAAYlC,IAC3BmG,EAAA3D,UAAAxC,GACA6B,EAAAsE,GAAA5D,EAAAwC,KAAAlD,EAAAsE,GAAAtE,EAEA,OAAAA,IAIAU,EAAAqL,QAAA,SAAAvI,EAAAwI,GACA,GAAAD,GAAA,SAAAzH,GACA,GAAA2H,GAAAF,EAAAE,MACAC,EAAA,IAAAF,IAAAnI,MAAAtB,KAAA5B,WAAA2D,EAEA,OADA5D,GAAAyB,IAAA8J,EAAAC,KAAAD,EAAAC,GAAA1I,EAAAK,MAAAtB,KAAA5B,YACAsL,EAAAC,GAGA,OADAH,GAAAE,SACAF,GAKArL,EAAAyL,MAAA,SAAA3I,EAAA4I,GACA,GAAA1F,GAAAjF,EAAApD,KAAAsC,UAAA,EACA,OAAA0L,YAAA,WACA,MAAA7I,GAAAK,MAAA,KAAA6C,IACK0F,IAKL1L,EAAA4L,MAAA5L,EAAAgL,QAAAhL,EAAAyL,MAAAzL,EAAA,GAOAA,EAAA6L,SAAA,SAAA/I,EAAA4I,EAAAI,GACA,GAAAjM,GAAAmG,EAAAlC,EACAiI,EAAA,KACAC,EAAA,CACAF,UACA,IAAAG,GAAA,WACAD,GAAA,IAAAF,EAAAI,QAAA,EAAAlM,EAAAmM,MACAJ,EAAA,KACAjI,EAAAhB,EAAAK,MAAAtD,EAAAmG,GACA+F,IAAAlM,EAAAmG,EAAA,MAEA,mBACA,GAAAmG,GAAAnM,EAAAmM,KACAH,KAAA,IAAAF,EAAAI,UAAAF,EAAAG,EACA,IAAAC,GAAAV,GAAAS,EAAAH,EAcA,OAbAnM,GAAAgC,KACAmE,EAAA/F,UACAmM,GAAA,GAAAA,EAAAV,GACAK,IACAM,aAAAN,GACAA,EAAA,MAEAC,EAAAG,EACArI,EAAAhB,EAAAK,MAAAtD,EAAAmG,GACA+F,IAAAlM,EAAAmG,EAAA,OACO+F,IAAA,IAAAD,EAAAQ,WACPP,EAAAJ,WAAAM,EAAAG,IAEAtI,IAQA9D,EAAAuM,SAAA,SAAAzJ,EAAA4I,EAAAc,GACA,GAAAT,GAAA/F,EAAAnG,EAAA4M,EAAA3I,EAEAmI,EAAA,WACA,GAAA9D,GAAAnI,EAAAmM,MAAAM,CAEAtE,GAAAuD,GAAAvD,GAAA,EACA4D,EAAAJ,WAAAM,EAAAP,EAAAvD,IAEA4D,EAAA,KACAS,IACA1I,EAAAhB,EAAAK,MAAAtD,EAAAmG,GACA+F,IAAAlM,EAAAmG,EAAA,QAKA,mBACAnG,EAAAgC,KACAmE,EAAA/F,UACAwM,EAAAzM,EAAAmM,KACA,IAAAO,GAAAF,IAAAT,CAOA,OANAA,OAAAJ,WAAAM,EAAAP,IACAgB,IACA5I,EAAAhB,EAAAK,MAAAtD,EAAAmG,GACAnG,EAAAmG,EAAA,MAGAlC,IAOA9D,EAAA2M,KAAA,SAAA7J,EAAA8J,GACA,MAAA5M,GAAAgL,QAAA4B,EAAA9J,IAIA9C,EAAAmF,OAAA,SAAA/E,GACA,kBACA,OAAAA,EAAA+C,MAAAtB,KAAA5B,aAMAD,EAAA6M,QAAA,WACA,GAAA7G,GAAA/F,UACAmK,EAAApE,EAAArG,OAAA,CACA,mBAGA,IAFA,GAAAlC,GAAA2M,EACAtG,EAAAkC,EAAAoE,GAAAjH,MAAAtB,KAAA5B,WACAxC,KAAAqG,EAAAkC,EAAAvI,GAAAE,KAAAkE,KAAAiC,EACA,OAAAA,KAKA9D,EAAA8M,MAAA,SAAAC,EAAAjK,GACA,kBACA,KAAAiK,EAAA,EACA,MAAAjK,GAAAK,MAAAtB,KAAA5B,aAMAD,EAAAgN,OAAA,SAAAD,EAAAjK,GACA,GAAAtD,EACA,mBAKA,QAJAuN,EAAA,IACAvN,EAAAsD,EAAAK,MAAAtB,KAAA5B,YAEA8M,GAAA,IAAAjK,EAAA,MACAtD,IAMAQ,EAAAiN,KAAAjN,EAAAgL,QAAAhL,EAAAgN,OAAA,EAMA,IAAAE,KAAqB/K,SAAA,MAAegL,qBAAA,YACpChM,GAAA,qCACA,yDAqBAnB,GAAAP,KAAA,SAAAH,GACA,IAAAU,EAAAqD,SAAA/D,GAAA,QACA,IAAAgD,EAAA,MAAAA,GAAAhD,EACA,IAAAG,KACA,QAAAmE,KAAAtE,GAAAU,EAAAyB,IAAAnC,EAAAsE,IAAAnE,EAAAkC,KAAAiC,EAGA,OADAsJ,IAAAjM,EAAA3B,EAAAG,GACAA,GAIAO,EAAAoN,QAAA,SAAA9N,GACA,IAAAU,EAAAqD,SAAA/D,GAAA,QACA,IAAAG,KACA,QAAAmE,KAAAtE,GAAAG,EAAAkC,KAAAiC,EAGA,OADAsJ,IAAAjM,EAAA3B,EAAAG,GACAA,GAIAO,EAAA4F,OAAA,SAAAtG,GAIA,OAHAG,GAAAO,EAAAP,KAAAH,GACAK,EAAAF,EAAAE,OACAiG,EAAA5D,MAAArC,GACAlC,EAAA,EAAmBA,EAAAkC,EAAYlC,IAC/BmI,EAAAnI,GAAA6B,EAAAG,EAAAhC,GAEA,OAAAmI,IAKA5F,EAAAqN,UAAA,SAAA/N,EAAAC,EAAAM,GACAN,EAAAc,EAAAd,EAAAM,EAKA,QADAD,GAHAH,EAAAO,EAAAP,KAAAH,GACAK,EAAAF,EAAAE,OACA0E,KAEA3E,EAAA,EAAyBA,EAAAC,EAAgBD,IACzCE,EAAAH,EAAAC,GACA2E,EAAAzE,GAAAL,EAAAD,EAAAM,KAAAN,EAEA,OAAA+E,IAIArE,EAAAsN,MAAA,SAAAhO,GAIA,OAHAG,GAAAO,EAAAP,KAAAH,GACAK,EAAAF,EAAAE,OACA2N,EAAAtL,MAAArC,GACAlC,EAAA,EAAmBA,EAAAkC,EAAYlC,IAC/B6P,EAAA7P,IAAAgC,EAAAhC,GAAA6B,EAAAG,EAAAhC,IAEA,OAAA6P,IAIAtN,EAAAuN,OAAA,SAAAjO,GAGA,OAFAwE,MACArE,EAAAO,EAAAP,KAAAH,GACA7B,EAAA,EAAAkC,EAAAF,EAAAE,OAAyClC,EAAAkC,EAAYlC,IACrDqG,EAAAxE,EAAAG,EAAAhC,KAAAgC,EAAAhC,EAEA,OAAAqG,IAKA9D,EAAAwN,UAAAxN,EAAAyN,QAAA,SAAAnO,GACA,GAAAoO,KACA,QAAA9J,KAAAtE,GACAU,EAAAsB,WAAAhC,EAAAsE,KAAA8J,EAAA/L,KAAAiC,EAEA,OAAA8J,GAAA1G,QAIAhH,EAAA2N,OAAAnK,EAAAxD,EAAAoN,SAIApN,EAAA4N,UAAA5N,EAAA6N,OAAArK,EAAAxD,EAAAP,MAGAO,EAAA8E,QAAA,SAAAxF,EAAAc,EAAAP,GACAO,EAAAC,EAAAD,EAAAP,EAEA,QADA+D,GAAAnE,EAAAO,EAAAP,KAAAH,GACA7B,EAAA,EAAAkC,EAAAF,EAAAE,OAAyClC,EAAAkC,EAAYlC,IAErD,GADAmG,EAAAnE,EAAAhC,GACA2C,EAAAd,EAAAsE,KAAAtE,GAAA,MAAAsE,IAKA5D,EAAA8N,KAAA,SAAApP,EAAAqP,EAAAlO,GACA,GAAmBN,GAAAE,EAAnBqE,KAAmBxE,EAAAZ,CACnB,UAAAY,EAAA,MAAAwE,EACA9D,GAAAsB,WAAAyM,IACAtO,EAAAO,EAAAoN,QAAA9N,GACAC,EAAAO,EAAAiO,EAAAlO,KAEAJ,EAAA+I,EAAAvI,WAAA,QACAV,EAAA,SAAAzB,EAAA8F,EAAAtE,GAA4C,MAAAsE,KAAAtE,IAC5CA,EAAAnB,OAAAmB,GAEA,QAAA7B,GAAA,EAAAkC,EAAAF,EAAAE,OAAyClC,EAAAkC,EAAYlC,IAAA,CACrD,GAAAmG,GAAAnE,EAAAhC,GACAK,EAAAwB,EAAAsE,EACArE,GAAAzB,EAAA8F,EAAAtE,KAAAwE,EAAAF,GAAA9F,GAEA,MAAAgG,IAIA9D,EAAAgO,KAAA,SAAA1O,EAAAC,EAAAM,GACA,GAAAG,EAAAsB,WAAA/B,GACAA,EAAAS,EAAAmF,OAAA5F,OACK,CACL,GAAAE,GAAAO,EAAAmE,IAAAqE,EAAAvI,WAAA,QAAAgO,OACA1O,GAAA,SAAAzB,EAAA8F,GACA,OAAA5D,EAAA0B,SAAAjC,EAAAmE,IAGA,MAAA5D,GAAA8N,KAAAxO,EAAAC,EAAAM,IAIAG,EAAAkO,SAAA1K,EAAAxD,EAAAoN,SAAA,GAKApN,EAAA0C,OAAA,SAAA9D,EAAAuP,GACA,GAAArK,GAAAD,EAAAjF,EAEA,OADAuP,IAAAnO,EAAA4N,UAAA9J,EAAAqK,GACArK,GAIA9D,EAAAoO,MAAA,SAAA9O,GACA,MAAAU,GAAAqD,SAAA/D,GACAU,EAAAqC,QAAA/C,KAAAyB,QAAAf,EAAA2N,UAAqDrO,GADrDA,GAOAU,EAAAqO,IAAA,SAAA/O,EAAAgP,GAEA,MADAA,GAAAhP,GACAA,GAIAU,EAAAuO,QAAA,SAAA7P,EAAA0H,GACA,GAAA3G,GAAAO,EAAAP,KAAA2G,GAAAzG,EAAAF,EAAAE,MACA,UAAAjB,EAAA,OAAAiB,CAEA,QADAL,GAAAnB,OAAAO,GACAjB,EAAA,EAAmBA,EAAAkC,EAAYlC,IAAA,CAC/B,GAAAmG,GAAAnE,EAAAhC,EACA,IAAA2I,EAAAxC,KAAAtE,EAAAsE,UAAAtE,IAAA,SAEA,SAKA,IAAAkP,GAAA,SAAArH,EAAAC,EAAAqH,EAAAC,GAGA,GAAAvH,IAAAC,EAAA,WAAAD,GAAA,EAAAA,GAAA,EAAAC,CAEA,UAAAD,GAAA,MAAAC,EAAA,MAAAD,KAAAC,CAEAD,aAAAnH,KAAAmH,IAAAvE,UACAwE,YAAApH,KAAAoH,IAAAxE,SAEA,IAAA+L,GAAAxM,EAAAxE,KAAAwJ,EACA,IAAAwH,IAAAxM,EAAAxE,KAAAyJ,GAAA,QACA,QAAAuH,GAEA,sBAEA,sBAGA,SAAAxH,GAAA,GAAAC,CACA,uBAGA,OAAAD,OAAAC,MAEA,IAAAD,EAAA,GAAAA,GAAA,EAAAC,GAAAD,IAAAC,CACA,qBACA,uBAIA,OAAAD,IAAAC,EAGA,GAAAwH,GAAA,mBAAAD,CACA,KAAAC,EAAA,CACA,mBAAAzH,IAAA,gBAAAC,GAAA,QAIA,IAAAyH,GAAA1H,EAAA/F,YAAA0N,EAAA1H,EAAAhG,WACA,IAAAyN,IAAAC,KAAA9O,EAAAsB,WAAAuN,oBACA7O,EAAAsB,WAAAwN,qBACA,eAAA3H,IAAA,eAAAC,GACA,SAQAqH,QACAC,OAEA,KADA,GAAA/O,GAAA8O,EAAA9O,OACAA,KAGA,GAAA8O,EAAA9O,KAAAwH,EAAA,MAAAuH,GAAA/O,KAAAyH,CAQA,IAJAqH,EAAA9M,KAAAwF,GACAuH,EAAA/M,KAAAyF,GAGAwH,EAAA,CAGA,IADAjP,EAAAwH,EAAAxH,UACAyH,EAAAzH,OAAA,QAEA,MAAAA,KACA,IAAA6O,EAAArH,EAAAxH,GAAAyH,EAAAzH,GAAA8O,EAAAC,GAAA,aAEK,CAEL,GAAA9K,GAAAnE,EAAAO,EAAAP,KAAA0H,EAGA,IAFAxH,EAAAF,EAAAE,OAEAK,EAAAP,KAAA2H,GAAAzH,WAAA,QACA,MAAAA,KAGA,GADAiE,EAAAnE,EAAAE,IACAK,EAAAyB,IAAA2F,EAAAxD,KAAA4K,EAAArH,EAAAvD,GAAAwD,EAAAxD,GAAA6K,EAAAC,GAAA,SAMA,MAFAD,GAAAM,MACAL,EAAAK,OACA,EAIA/O,GAAAgP,QAAA,SAAA7H,EAAAC,GACA,MAAAoH,GAAArH,EAAAC,IAKApH,EAAAiP,QAAA,SAAA3P,GACA,aAAAA,IACAS,EAAAT,KAAAU,EAAAqC,QAAA/C,IAAAU,EAAAkP,SAAA5P,IAAAU,EAAA8I,YAAAxJ,IAAA,IAAAA,EAAAK,OACA,IAAAK,EAAAP,KAAAH,GAAAK,SAIAK,EAAAmP,UAAA,SAAA7P,GACA,SAAAA,GAAA,IAAAA,EAAA8P,WAKApP,EAAAqC,QAAAD,GAAA,SAAA9C,GACA,yBAAA6C,EAAAxE,KAAA2B,IAIAU,EAAAqD,SAAA,SAAA/D,GACA,GAAA+P,SAAA/P,EACA,oBAAA+P,GAAA,WAAAA,KAAA/P,GAIAU,EAAAiE,MAAA,2EAAAjG,GACAgC,EAAA,KAAAhC,GAAA,SAAAsB,GACA,MAAA6C,GAAAxE,KAAA2B,KAAA,WAAAtB,EAAA,OAMAgC,EAAA8I,YAAA7I,aACAD,EAAA8I,YAAA,SAAAxJ,GACA,MAAAU,GAAAyB,IAAAnC,EAAA,YAMA,uCAAAgQ,aACAtP,EAAAsB,WAAA,SAAAhC,GACA,wBAAAA,KAAA,IAKAU,EAAAuP,SAAA,SAAAjQ,GACA,MAAAiQ,UAAAjQ,KAAA0B,MAAAwO,WAAAlQ,KAIAU,EAAAgB,MAAA,SAAA1B,GACA,MAAAU,GAAAyP,SAAAnQ,YAIAU,EAAAsJ,UAAA,SAAAhK,GACA,WAAAA,IAAA,IAAAA,GAAA,qBAAA6C,EAAAxE,KAAA2B,IAIAU,EAAA0P,OAAA,SAAApQ,GACA,cAAAA,GAIAU,EAAA2P,YAAA,SAAArQ,GACA,gBAAAA,GAKAU,EAAAyB,IAAA,SAAAnC,EAAAsE,GACA,aAAAtE,GAAAT,EAAAlB,KAAA2B,EAAAsE,IAQA5D,EAAA4P,WAAA,WAEA,MADAhO,GAAA5B,EAAA8B,EACAD,MAIA7B,EAAAoD,SAAA,SAAAtF,GACA,MAAAA,IAIAkC,EAAA6P,SAAA,SAAA/R,GACA,kBACA,MAAAA,KAIAkC,EAAA8P,KAAA,aAEA9P,EAAArB,WAGAqB,EAAA+P,WAAA,SAAAzQ,GACA,aAAAA,EAAA,aAAqC,SAAAsE,GACrC,MAAAtE,GAAAsE,KAMA5D,EAAAsD,QAAAtD,EAAAgQ,QAAA,SAAA5J,GAEA,MADAA,GAAApG,EAAA4N,aAA0BxH,GAC1B,SAAA9G,GACA,MAAAU,GAAAuO,QAAAjP,EAAA8G,KAKApG,EAAA+M,MAAA,SAAAvO,EAAAe,EAAAM,GACA,GAAAoQ,GAAAjO,MAAApB,KAAAC,IAAA,EAAArC,GACAe,GAAAO,EAAAP,EAAAM,EAAA,EACA,QAAApC,GAAA,EAAmBA,EAAAe,EAAOf,IAAAwS,EAAAxS,GAAA8B,EAAA9B,EAC1B,OAAAwS,IAIAjQ,EAAA4G,OAAA,SAAA9F,EAAAD,GAKA,MAJA,OAAAA,IACAA,EAAAC,EACAA,EAAA,GAEAA,EAAAF,KAAAqJ,MAAArJ,KAAAgG,UAAA/F,EAAAC,EAAA,KAIAd,EAAAmM,IAAA+D,KAAA/D,KAAA,WACA,UAAA+D,OAAAC,UAIA,IAAAC,IACAC,IAAA,QACAC,IAAA,OACAC,IAAA,OACAC,IAAA,SACAC,IAAA,SACAC,IAAA,UAEAC,EAAA3Q,EAAAuN,OAAA6C,GAGAQ,EAAA,SAAAzM,GACA,GAAA0M,GAAA,SAAAC,GACA,MAAA3M,GAAA2M,IAGAnN,EAAA,MAAA3D,EAAAP,KAAA0E,GAAA4M,KAAA,SACAC,EAAAC,OAAAtN,GACAuN,EAAAD,OAAAtN,EAAA,IACA,iBAAAwN,GAEA,MADAA,GAAA,MAAAA,EAAA,MAAAA,EACAH,EAAAI,KAAAD,KAAAE,QAAAH,EAAAL,GAAAM,GAGAnR,GAAAsR,OAAAV,EAAAR,GACApQ,EAAAuR,SAAAX,EAAAD,GAIA3Q,EAAA8D,OAAA,SAAApF,EAAAC,EAAA6S,GACA,GAAA1T,GAAA,MAAAY,MAAA,GAAAA,EAAAC,EAIA,YAHA,KAAAb,IACAA,EAAA0T,GAEAxR,EAAAsB,WAAAxD,KAAAH,KAAAe,GAAAZ,EAKA,IAAA2T,GAAA,CACAzR,GAAA0R,SAAA,SAAAC,GACA,GAAAC,KAAAH,EAAA,EACA,OAAAE,KAAAC,KAKA5R,EAAA6R,kBACAC,SAAA,kBACAC,YAAA,mBACAT,OAAA,mBAMA,IAAAU,GAAA,OAIAC,GACAxB,IAAA,IACAyB,KAAA,KACAC,KAAA,IACAC,KAAA,IACAC,SAAA,QACAC,SAAA,SAGAzB,EAAA,4BAEA0B,EAAA,SAAAzB,GACA,WAAAmB,EAAAnB,GAOA9Q,GAAAwS,SAAA,SAAAC,EAAAC,EAAAC,IACAD,GAAAC,IAAAD,EAAAC,GACAD,EAAA1S,EAAAkO,YAA4BwE,EAAA1S,EAAA6R,iBAG5B,IAAAvO,GAAA2N,SACAyB,EAAApB,QAAAU,GAAArO,QACA+O,EAAAX,aAAAC,GAAArO,QACA+O,EAAAZ,UAAAE,GAAArO,QACAoN,KAAA,eAGArR,EAAA,EACAiE,EAAA,QACA8O,GAAApB,QAAA/N,EAAA,SAAAwN,EAAAQ,EAAAS,EAAAD,EAAAc,GAaA,MAZAjP,IAAA8O,EAAA1R,MAAArB,EAAAkT,GAAAvB,QAAAR,EAAA0B,GACA7S,EAAAkT,EAAA9B,EAAAnR,OAEA2R,EACA3N,GAAA,cAAA2N,EAAA,iCACOS,EACPpO,GAAA,cAAAoO,EAAA,uBACOD,IACPnO,GAAA,OAAqBmO,EAAA,YAIrBhB,IAEAnN,GAAA,OAGA+O,EAAAG,WAAAlP,EAAA,mBAAoDA,EAAA,OAEpDA,EAAA,4FAEAA,EAAA,eAEA,KACA,GAAAmP,GAAA,GAAA5Q,UAAAwQ,EAAAG,UAAA,UAAAlP,GACK,MAAAoP,GAEL,KADAA,GAAApP,SACAoP,EAGA,GAAAP,GAAA,SAAAQ,GACA,MAAAF,GAAAnV,KAAAkE,KAAAmR,EAAAhT,GAOA,OAFAwS,GAAA7O,OAAA,aADA+O,EAAAG,UAAA,OACA,OAAkDlP,EAAA,IAElD6O,GAIAxS,EAAAiT,MAAA,SAAA3T,GACA,GAAA4T,GAAAlT,EAAAV,EAEA,OADA4T,GAAAC,QAAA,EACAD,EAUA,IAAApP,GAAA,SAAAoP,EAAA5T,GACA,MAAA4T,GAAAC,OAAAnT,EAAAV,GAAA2T,QAAA3T,EAIAU,GAAAoT,MAAA,SAAA9T,GACAU,EAAAiE,KAAAjE,EAAAwN,UAAAlO,GAAA,SAAAtB,GACA,GAAA8E,GAAA9C,EAAAhC,GAAAsB,EAAAtB,EACAgC,GAAApB,UAAAZ,GAAA,WACA,GAAAgI,IAAAnE,KAAAe,SAEA,OADAjB,GAAAwB,MAAA6C,EAAA/F,WACA6D,EAAAjC,KAAAiB,EAAAK,MAAAnD,EAAAgG,QAMAhG,EAAAoT,MAAApT,GAGAA,EAAAiE,MAAA,mEAAAjG,GACA,GAAA+H,GAAAhE,EAAA/D,EACAgC,GAAApB,UAAAZ,GAAA,WACA,GAAAsB,GAAAuC,KAAAe,QAGA,OAFAmD,GAAA5C,MAAA7D,EAAAW,WACA,UAAAjC,GAAA,WAAAA,GAAA,IAAAsB,EAAAK,cAAAL,GAAA,GACAwE,EAAAjC,KAAAvC,MAKAU,EAAAiE,MAAA,kCAAAjG,GACA,GAAA+H,GAAAhE,EAAA/D,EACAgC,GAAApB,UAAAZ,GAAA,WACA,MAAA8F,GAAAjC,KAAAkE,EAAA5C,MAAAtB,KAAAe,SAAA3C,eAKAD,EAAApB,UAAAd,MAAA,WACA,MAAA+D,MAAAe,UAKA5C,EAAApB,UAAAyU,QAAArT,EAAApB,UAAA0U,OAAAtT,EAAApB,UAAAd,MAEAkC,EAAApB,UAAAuD,SAAA,WACA,SAAAN,KAAAe,UAWA3D,SAEKsU,MAFLrU,EAAA,WACA,MAAAc,IACKmD,MAAA5F,EAAA0B,MAAAzB,EAAAD,QAAA2B,KAEJvB,KAAAkE,OF+EK2R,EACA,SAAUhW,EAAQD,GG3lDxBC,EAAAD,QAAAkW,GHimDMC,GACA,SAAUlW,EAAQD,EAASH,GAEjC,YIlmDA,IAAAuW,GAAAvW,EAAA,EAEAI,GAAAD,QAAAoW,EACAA,EAAA/U,UAAA,iBAAAgV,GACA,MAAA/R,MAAAgS,KAAA,SAAA/V,GACA,MAAA6V,GAAAG,QAAAF,KAAAC,KAAA,WACA,MAAA/V,MAEG,SAAAiW,GACH,MAAAJ,GAAAG,QAAAF,KAAAC,KAAA,WACA,KAAAE,SJ6mDMC,IACA,SAAUxW,EAAQD,EAASH,IK1nDjC,SAAA6W,IAUA,SAAAR,GACA,YAkJA,SAAAS,GAAAC,GACA,GAAAC,GACAC,EAAAF,EAAAG,KAAA,iBACAF,EAAAD,EAAAG,KAAA,UAAAF,EAAA/C,QAAA,oBAEA,OAAAoC,GAAAY,GAOA,QAAAE,GAAAC,GACA,MAAA3S,MAAAoC,KAAA,WACA,GAAAwQ,GAAAhB,EAAA5R,MACAmR,EAAAyB,EAAAzB,KAAA,eACAlH,EAAA2H,EAAA9F,UAA+B+G,EAAAC,SAAAF,EAAAzB,OAAA,gBAAAwB,QAE/BxB,GAAAlH,EAAA8I,QAAA,YAAAxD,KAAAoD,KAAA1I,EAAA8I,QAAA,GACA5B,GAAAyB,EAAAzB,KAAA,cAAAA,EAAA,GAAA0B,GAAA7S,KAAAiK,IACA,gBAAA0I,IAAAxB,EAAAwB,OAjKA,GAAAE,GAAA,SAAAG,EAAA/I,GACAjK,KAAAiT,SAAArB,EAAAoB,GACAhT,KAAAiK,QAAA2H,EAAA9F,UAAoC+G,EAAAC,SAAA7I,GACpCjK,KAAAsS,SAAAV,EAAA,mCAAAoB,EAAAjD,GAAA,6CACAiD,EAAAjD,GAAA,MACA/P,KAAAkT,cAAA,KAEAlT,KAAAiK,QAAAkJ,OACAnT,KAAAoT,QAAApT,KAAAqT,YAEArT,KAAAsT,yBAAAtT,KAAAiT,SAAAjT,KAAAsS,UAGAtS,KAAAiK,QAAA8I,QAAA/S,KAAA+S,SAGAF,GAAA7R,QAAA,QAEA6R,EAAAU,oBAAA,IAEAV,EAAAC,UACAC,QAAA,GAGAF,EAAA9V,UAAAyW,UAAA,WAEA,MADAxT,MAAAiT,SAAAQ,SAAA,SACA,kBAGAZ,EAAA9V,UAAA2W,KAAA,WACA,IAAA1T,KAAAkT,gBAAAlT,KAAAiT,SAAAQ,SAAA,OAEA,GAAAE,GACAC,EAAA5T,KAAAoT,SAAApT,KAAAoT,QAAAS,SAAA,UAAAA,SAAA,mBAEA,MAAAD,KAAA9V,SACA6V,EAAAC,EAAAzC,KAAA,iBACAwC,EAAAT,eAFA,CAKA,GAAAY,GAAAlC,EAAAmC,MAAA,mBAEA,IADA/T,KAAAiT,SAAAe,QAAAF,IACAA,EAAAG,qBAAA,CAEAL,KAAA9V,SACA4U,EAAA5W,KAAA8X,EAAA,QACAD,GAAAC,EAAAzC,KAAA,oBAGA,IAAAqC,GAAAxT,KAAAwT,WAEAxT,MAAAiT,SACAiB,YAAA,YACAC,SAAA,cAAAX,GAAA,GACAf,KAAA,oBAEAzS,KAAAsS,SACA4B,YAAA,aACAzB,KAAA,oBAEAzS,KAAAkT,cAAA,CAEA,IAAAkB,GAAA,WACApU,KAAAiT,SACAiB,YAAA,cACAC,SAAA,eAAAX,GAAA,IACAxT,KAAAkT,cAAA,EACAlT,KAAAiT,SACAe,QAAA,qBAGA,KAAApC,EAAAyC,QAAAC,WAAA,MAAAF,GAAAtY,KAAAkE,KAEA,IAAAuU,GAAA3C,EAAA4C,WAAA,SAAAhB,GAAAtE,KAAA,KAEAlP,MAAAiT,SACAwB,IAAA,kBAAA7C,EAAA8C,MAAAN,EAAApU,OACA2U,qBAAA9B,EAAAU,qBAAAC,GAAAxT,KAAAiT,SAAA,GAAAsB,QAGA1B,EAAA9V,UAAA6X,KAAA,WACA,IAAA5U,KAAAkT,eAAAlT,KAAAiT,SAAAQ,SAAA,OAEA,GAAAK,GAAAlC,EAAAmC,MAAA,mBAEA,IADA/T,KAAAiT,SAAAe,QAAAF,IACAA,EAAAG,qBAAA,CAEA,GAAAT,GAAAxT,KAAAwT,WAEAxT,MAAAiT,SAAAO,GAAAxT,KAAAiT,SAAAO,MAAA,GAAAqB,aAEA7U,KAAAiT,SACAkB,SAAA,cACAD,YAAA,eACAzB,KAAA,oBAEAzS,KAAAsS,SACA6B,SAAA,aACA1B,KAAA,oBAEAzS,KAAAkT,cAAA,CAEA,IAAAkB,GAAA,WACApU,KAAAkT,cAAA,EACAlT,KAAAiT,SACAiB,YAAA,cACAC,SAAA,YACAH,QAAA,sBAGA,KAAApC,EAAAyC,QAAAC,WAAA,MAAAF,GAAAtY,KAAAkE,KAEAA,MAAAiT,SACAO,GAAA,GACAiB,IAAA,kBAAA7C,EAAA8C,MAAAN,EAAApU,OACA2U,qBAAA9B,EAAAU,wBAGAV,EAAA9V,UAAAgW,OAAA,WACA/S,UAAAiT,SAAAQ,SAAA,wBAGAZ,EAAA9V,UAAAsW,UAAA,WACA,MAAAzB,GAAA5R,KAAAiK,QAAAkJ,QACArQ,KAAA,yCAAA9C,KAAAiK,QAAAkJ,OAAA,MACA/Q,KAAAwP,EAAA8C,MAAA,SAAA9Y,EAAAoX,GACA,GAAAC,GAAArB,EAAAoB,EACAhT,MAAAsT,yBAAAjB,EAAAY,OACOjT,OACP8U,OAGAjC,EAAA9V,UAAAuW,yBAAA,SAAAL,EAAAX,GACA,GAAAyC,GAAA9B,EAAAQ,SAAA,KAEAR,GAAAR,KAAA,gBAAAsC,GACAzC,EACA0C,YAAA,aAAAD,GACAtC,KAAA,gBAAAsC,GA2BA,IAAAE,GAAArD,EAAAsD,GAAAC,QAEAvD,GAAAsD,GAAAC,SAAAzC,EACAd,EAAAsD,GAAAC,SAAAC,YAAAvC,EAMAjB,EAAAsD,GAAAC,SAAApH,WAAA,WAEA,MADA6D,GAAAsD,GAAAC,SAAAF,EACAjV,MAOA4R,EAAAyD,UAAAC,GAAA,iEAAApE,GACA,GAAA0B,GAAAhB,EAAA5R,KAEA4S,GAAAH,KAAA,gBAAAvB,EAAAqE,gBAEA,IAAAC,GAAAnD,EAAAO,GACAzB,EAAAqE,EAAArE,KAAA,eACAwB,EAAAxB,EAAA,SAAAyB,EAAAzB,MAEAuB,GAAA5W,KAAA0Z,EAAA7C,MAGCP,KL8nD4BtW,KAAKJ,EAASH,EAAoB,KAIzDka,GACA,SAAU9Z,EAAQD,EAASH,GAEjC,YMt1DAI,GAAAD,QAAAH,EAAA,GACAA,EAAA,GACAA,EAAA,IACAA,EAAA,GACAA,EAAA,IACAA,EAAA,KN81DMma,GACA,SAAU/Z,EAAQD,EAASH,GAEjC,YO70DA,SAAAoa,GAAAT,EAAAU,GAEA,OADAzR,MACAvI,EAAA,EAAiBA,EAAAga,EAAmBha,IACpCuI,EAAArE,KAAA,IAAAlE,EAEA,IAAAia,IACA,oBAAA1R,EAAA+K,KAAA,WACA,mBACA,yCACA,sBACA,QAAAhG,OAAA/E,GAAA+E,QAAA4M,IAAA5G,KAAA,KACA,KACA,aACA,4DACA,iCACA,eACA,MACA,MACAA,KAAA,GACA,OAAA7O,WAAA,gBAAAwV,GAAA/D,EAAAoD,GAEA,QAAAa,GAAAb,GAGA,OAFAc,GAAAjX,KAAAC,IAAAkW,EAAApX,OAAA,KACAqG,KACAvI,EAAA,EAAiBA,EAAAoa,EAAcpa,IAC/BuI,EAAArE,KAAA,IAAAlE,EAEA,IAAAia,IACA,oBAAA1R,EAAA+K,KAAA,WACA,mBACA,YACA,oCACA,0BAAA8G,EAAA,MACA,0CACA,+CACA,0BACA,IACA,IACA,yCACA,YAAAF,EAAA,IACA,WACA,uBACA3R,EAAA+E,QAAA,UAAA5G,IAAA,SAAAnE,EAAAN,GACA,MACA,6BACA,QAAAqL,OAAA/E,EAAAjF,MAAA,EAAArB,IAAAqL,OAAA,MAAAgG,KAAA,kBAGKA,KAAA,IACL,WACA,wBACA,8BACA,IAEA,aACA,4DACA,iCACA,eACA,MACA,MACAA,KAAA,GAEA,OAAA7O,WACA,gBACAwV,GACA/D,EAAAoD,GAvFA,GAAApD,GAAAvW,EAAA,GACA0a,EAAA1a,EAAA,GAEAI,GAAAD,QAAAoW,EAIAA,EAAAoE,UAAA,SAAAhB,EAAAU,GACA,MACA,gBAAAA,QAAAlU,IAEAiU,EAAAT,EAAAU,GAEAG,EAAAb,GAIA,IAAAY,GAAA,+DAyEAhE,GAAAqE,QAAA,SAAAjB,GACA,kBACA,GAAA/Q,GAAAhE,MAAApD,UAAAmC,MAAApD,KAAAsC,WACAgY,EACA,kBAAAjS,KAAArG,OAAA,GAAAqG,EAAA+I,MAAA,KACAmJ,EAAArW,IACA,KACA,MAAAkV,GAAA5T,MAAAtB,KAAA5B,WAAA+X,QAAAC,EAAAC,GACK,MAAAC,GACL,UAAAF,OAAA,KAAAA,EACA,UAAAtE,GAAA,SAAAG,EAAA5O,GACAA,EAAAiT,IAGAL,GAAA,WACAG,EAAAta,KAAAua,EAAAC,QAOAxE,EAAA/U,UAAAoZ,QAAA,SAAAC,EAAAC,GACA,qBAAAD,GAAA,MAAApW,KAEAA,MAAAgS,KAAA,SAAA/V,GACAga,EAAA,WACAG,EAAAta,KAAAua,EAAA,KAAApa,MAEG,SAAAiW,GACH+D,EAAA,WACAG,EAAAta,KAAAua,EAAAnE,SPi3DMqE,IACA,SAAU5a,OAAQD,SQh/DxBC,OAAAD,QAAA,SAAA+B,KACA,GAAA+Y,KAAAC,IAAA,GAAAC,IAAAvW,MAAApD,UAAAmS,KAAAyH,MAAA,WAAyDF,KAAAC,IAAA5a,KAAAsC,UAAA,IACzD,MAAAX,QACAgZ,KAAA,0IACA,OAAAD,IAAA,OAAAA,KACA,wJACA,OAAAA,IAAA,OAAAA,KACA,mDACA,OAAAA,IAAA,OAAAA,KACA,wBACA,OAAAA,IAAA,UAAAA,KACA,0EACA,OAAAA,IAAA,OAAAA,KACA,8EACA,OAAAA,IAAA,OAAAA,KACA,sDACA,OAAAA,IAAA,YAAAA,KACA,sCAEA,OAAAC,ORw/DMG,GACA,SAAUjb,EAAQD,EAASH,GAEjC,YS5gEA,IAAAuW,GAAAvW,EAAA,EAEAI,GAAAD,QAAAoW,EACAA,EAAA+E,kBAAA,WACA/E,EAAA/U,UAAA+Z,UAAA,WACA,UAAA9W,KAAA+W,YAGAjF,EAAA/U,UAAAia,YAAA,WACA,UAAAhX,KAAA+W,YAGAjF,EAAA/U,UAAAka,WAAA,WACA,UAAAjX,KAAA+W,YAGAjF,EAAA/U,UAAAma,SAAA,WACA,OAAAlX,KAAAmX,IACA,MAAAnX,MAAAoX,IAAAF,UAGA,KAAAlX,KAAAgX,cACA,SAAAzN,OAAA,gDAGA,OAAAvJ,MAAAoX,KAGAtF,EAAA/U,UAAAsa,UAAA,WACA,OAAArX,KAAAmX,IACA,MAAAnX,MAAAoX,IAAAC,WAGA,KAAArX,KAAAiX,aACA,SAAA1N,OAAA,2DAGA,OAAAvJ,MAAAoX,KAGAtF,EAAA/U,UAAAga,SAAA,WACA,WAAA/W,KAAAmX,IACAnX,KAAAoX,IAAAL,YAEA,IAAA/W,KAAAmX,MAAA,IAAAnX,KAAAmX,IACA,EAGAnX,KAAAmX,MAIArF,EAAAwF,mBAAA,WACAxF,EAAA/U,UAAA+Z,cAAApF,GACAI,EAAA/U,UAAAia,gBAAAtF,GACAI,EAAA/U,UAAAka,eAAAvF,GACAI,EAAA/U,UAAAma,aAAAxF,GACAI,EAAA/U,UAAAsa,cAAA3F,GACAI,EAAA/U,UAAAga,aAAArF,KTqhEM6F,GACA,SAAU5b,EAAQD,EAASH,GAEjC,YUzkEA,SAAAic,KACA,GAAAC,EAAA3Z,OACA,KAAA2Z,GAAAC,QAaA,QAAAzB,GAAA0B,GACA,GAAAC,EAEAA,GADAC,EAAA/Z,OACA+Z,EAAA3K,MAEA,GAAA4K,GAEAF,EAAAD,OACAI,EAAAH,GAKA,QAAAE,KACA9X,KAAA2X,KAAA,KArCA,GAAAI,GAAAxc,EAAA,GAEAsc,KAGAJ,KACAO,EAAAD,EAAAE,yBAAAT,EAgBA7b,GAAAD,QAAAua,EAoBA6B,EAAA/a,UAAAjB,KAAA,WACA,IACAkE,KAAA2X,KAAA7b,OACK,MAAAoc,GACLjC,EAAAkC,QAIAlC,EAAAkC,QAAAD,IAKAT,EAAA3X,KAAAoY,GACAF,KAEK,QACLhY,KAAA2X,KAAA,KACAE,IAAA/Z,QAAAkC,QV4lEMoY,EACA,SAAUzc,EAAQD,EAASH,GAEjC,YW1pEA,SAAA0S,MAqBA,QAAAoK,GAAA5a,GACA,IACA,MAAAA,GAAAuU,KACG,MAAAsE,GAEH,MADAgC,GAAAhC,EACAiC,GAIA,QAAAC,GAAAtD,EAAA5P,GACA,IACA,MAAA4P,GAAA5P,GACG,MAAAgR,GAEH,MADAgC,GAAAhC,EACAiC,GAGA,QAAAE,GAAAvD,EAAA5P,EAAAC,GACA,IACA2P,EAAA5P,EAAAC,GACG,MAAA+Q,GAEH,MADAgC,GAAAhC,EACAiC,GAMA,QAAAzG,GAAAoD,GACA,mBAAAlV,MACA,SAAAgJ,WAAA,uCAEA,sBAAAkM,GACA,SAAAlM,WAAA,mDAEAhJ,MAAA0Y,IAAA,EACA1Y,KAAAmX,IAAA,EACAnX,KAAAoX,IAAA,KACApX,KAAA2Y,IAAA,KACAzD,IAAAjH,GACA2K,EAAA1D,EAAAlV,MAeA,QAAA6Y,GAAA9P,EAAA+P,EAAAC,GACA,UAAAhQ,GAAAxJ,YAAA,SAAA0S,EAAA5O,GACA,GAAA2V,GAAA,GAAAlH,GAAA7D,EACA+K,GAAAhH,KAAAC,EAAA5O,GACA4V,EAAAlQ,EAAA,GAAAmQ,GAAAJ,EAAAC,EAAAC,MAGA,QAAAC,GAAAlQ,EAAAoQ,GACA,SAAApQ,EAAAoO,KACApO,IAAAqO,GAKA,IAHAtF,EAAAsH,KACAtH,EAAAsH,IAAArQ,GAEA,IAAAA,EAAAoO,IACA,WAAApO,EAAA2P,KACA3P,EAAA2P,IAAA,OACA3P,EAAA4P,IAAAQ,IAGA,IAAApQ,EAAA2P,KACA3P,EAAA2P,IAAA,OACA3P,EAAA4P,KAAA5P,EAAA4P,IAAAQ,SAGApQ,GAAA4P,IAAA7Y,KAAAqZ,EAGAE,GAAAtQ,EAAAoQ,GAGA,QAAAE,GAAAtQ,EAAAoQ,GACAlD,EAAA,WACA,GAAAzX,GAAA,IAAAuK,EAAAoO,IAAAgC,EAAAL,YAAAK,EAAAJ,UACA,WAAAva,EAMA,YALA,IAAAuK,EAAAoO,IACAlF,EAAAkH,EAAAG,QAAAvQ,EAAAqO,KAEA/T,EAAA8V,EAAAG,QAAAvQ,EAAAqO,KAIA,IAAAmC,GAAAf,EAAAha,EAAAuK,EAAAqO,IACAmC,KAAAhB,EACAlV,EAAA8V,EAAAG,QAAAhB,GAEArG,EAAAkH,EAAAG,QAAAC,KAIA,QAAAtH,GAAAlJ,EAAAyQ,GAEA,GAAAA,IAAAzQ,EACA,MAAA1F,GACA0F,EACA,GAAAC,WAAA,6CAGA,IACAwQ,IACA,gBAAAA,IAAA,kBAAAA,IACA,CACA,GAAAxH,GAAAqG,EAAAmB,EACA,IAAAxH,IAAAuG,EACA,MAAAlV,GAAA0F,EAAAuP,EAEA,IACAtG,IAAAjJ,EAAAiJ,MACAwH,YAAA1H,GAKA,MAHA/I,GAAAoO,IAAA,EACApO,EAAAqO,IAAAoC,MACAC,GAAA1Q,EAEK,sBAAAiJ,GAEL,WADA4G,GAAA5G,EAAArR,KAAA6Y,GAAAzQ,GAIAA,EAAAoO,IAAA,EACApO,EAAAqO,IAAAoC,EACAC,EAAA1Q,GAGA,QAAA1F,GAAA0F,EAAAyQ,GACAzQ,EAAAoO,IAAA,EACApO,EAAAqO,IAAAoC,EACA1H,EAAA4H,KACA5H,EAAA4H,IAAA3Q,EAAAyQ,GAEAC,EAAA1Q,GAEA,QAAA0Q,GAAA1Q,GAKA,GAJA,IAAAA,EAAA2P,MACAO,EAAAlQ,IAAA4P,KACA5P,EAAA4P,IAAA,MAEA,IAAA5P,EAAA2P,IAAA,CACA,OAAA9c,GAAA,EAAmBA,EAAAmN,EAAA4P,IAAA7a,OAAqBlC,IACxCqd,EAAAlQ,IAAA4P,IAAA/c,GAEAmN,GAAA4P,IAAA,MAIA,QAAAO,GAAAJ,EAAAC,EAAAO,GACAtZ,KAAA8Y,YAAA,kBAAAA,KAAA,KACA9Y,KAAA+Y,WAAA,kBAAAA,KAAA,KACA/Y,KAAAsZ,UASA,QAAAV,GAAA1D,EAAAoE,GACA,GAAAK,IAAA,EACAX,EAAAP,EAAAvD,EAAA,SAAAjZ,GACA0d,IACAA,GAAA,EACA1H,EAAAqH,EAAArd,KACG,SAAA2d,GACHD,IACAA,GAAA,EACAtW,EAAAiW,EAAAM,KAEAD,IAAAX,IAAAT,IACAoB,GAAA,EACAtW,EAAAiW,EAAAhB,IAhNA,GAAArC,GAAA1a,EAAA,GAqBA+c,EAAA,KACAC,IA2BA5c,GAAAD,QAAAoW,EAgBAA,EAAAsH,IAAA,KACAtH,EAAA4H,IAAA,KACA5H,EAAA+H,IAAA5L,EAEA6D,EAAA/U,UAAAiV,KAAA,SAAA8G,EAAAC,GACA,GAAA/Y,KAAAT,cAAAuS,EACA,MAAA+G,GAAA7Y,KAAA8Y,EAAAC,EAEA,IAAAC,GAAA,GAAAlH,GAAA7D,EAEA,OADAgL,GAAAjZ,KAAA,GAAAkZ,GAAAJ,EAAAC,EAAAC,IACAA,IX2yEMc,EACA,SAAUne,EAAQD,EAASH,IAEL,SAASwe,GY33ErC,GAAA3c,GAAAC,GAOA,SAAA2c,GAIA,GAAAja,GAAA,gBAAAgJ,+BACA,gBAAAgR,mBAIA3c,IAAA7B,EAAA,GAAAA,EAAA,GAAAG,OAIKgW,MAJLrU,EAAA,SAAAc,EAAAyT,EAAAlW,GAGAqE,EAAAka,SAAAD,EAAAja,EAAArE,EAAAyC,EAAAyT,IACKtQ,MAAA5F,EAAA0B,MAAAzB,EAAAD,QAAA2B,IAaJ,SAAA0C,EAAAka,EAAA9b,EAAAyT,GAOD,GAAAsI,GAAAna,EAAAka,SAGA/a,EAAAiB,MAAApD,UAAAmC,KAGA+a,GAAAjZ,QAAA,QAIAiZ,EAAArI,IAIAqI,EAAAlM,WAAA,WAEA,MADAhO,GAAAka,SAAAC,EACAla,MAMAia,EAAAE,aAAA,EAMAF,EAAAG,aAAA,CASA,IAAAC,GAAA,SAAAvc,EAAAoG,EAAAoW,GACA,OAAAxc,GACA,yBACA,MAAAK,GAAA+F,GAAAlE,KAAAsa,IAEA,wBAAAre,GACA,MAAAkC,GAAA+F,GAAAlE,KAAAsa,GAAAre,GAEA,wBAAAyB,EAAAM,GACA,MAAAG,GAAA+F,GAAAlE,KAAAsa,GAAA9b,EAAAd,EAAAsC,MAAAhC,GAEA,wBAAAN,EAAA6c,EAAAvc,GACA,MAAAG,GAAA+F,GAAAlE,KAAAsa,GAAA9b,EAAAd,EAAAsC,MAAAua,EAAAvc,GAEA,2BACA,GAAAmG,GAAAjF,EAAApD,KAAAsC,UAEA,OADA+F,GAAAqW,QAAAxa,KAAAsa,IACAnc,EAAA+F,GAAA5C,MAAAnD,EAAAgG,MAIAsW,EAAA,SAAAC,EAAA9O,EAAA0O,GACAnc,EAAAiE,KAAAwJ,EAAA,SAAA9N,EAAAoG,GACA/F,EAAA+F,KAAAwW,EAAA3d,UAAAmH,GAAAmW,EAAAvc,EAAAoG,EAAAoW,OAKA9b,EAAA,SAAAd,EAAA2T,GACA,MAAAlT,GAAAsB,WAAA/B,KACAS,EAAAqD,SAAA9D,KAAA2T,EAAAsJ,SAAAjd,GAAAkd,EAAAld,GACAS,EAAAkP,SAAA3P,GAAA,SAAAmd,GAAsD,MAAAA,GAAAne,IAAAgB,IACtDA,GAEAkd,EAAA,SAAArW,GACA,GAAA9C,GAAAtD,EAAAgQ,QAAA5J,EACA,iBAAAsW,GACA,MAAApZ,GAAAoZ,EAAAC,cAiBAC,EAAAd,EAAAc,UAGAC,EAAA,MAKAC,EAAA,SAAAvd,EAAAwd,EAAA/e,EAAAia,EAAA+E,GACA,GAAAtP,GAAAjQ,EAAA,CACA,IAAAO,GAAA,gBAAAA,GAAA,KAEA,KAAAia,GAAA,WAAA+E,QAAA,KAAAA,EAAAnd,UAAAmd,EAAAnd,QAAAoY,EACA,KAAAvK,EAAA1N,EAAAP,KAAAzB,GAAgCP,EAAAiQ,EAAA/N,OAAmBlC,IACnDsf,EAAAD,EAAAvd,EAAAwd,EAAArP,EAAAjQ,GAAAO,EAAA0P,EAAAjQ,IAAAuf,OAEK,IAAAhf,GAAA6e,EAAAzL,KAAApT,GAEL,IAAA0P,EAAA1P,EAAAif,MAAAJ,GAA6Cpf,EAAAiQ,EAAA/N,OAAkBlC,IAC/Dsf,EAAAxd,EAAAwd,EAAArP,EAAAjQ,GAAAwa,EAAA+E,OAIAD,GAAAxd,EAAAwd,EAAA/e,EAAAia,EAAA+E,EAEA,OAAAD,GAKAH,GAAAzF,GAAA,SAAAnZ,EAAAia,EAAApY,GACA,MAAAqd,GAAArb,KAAA7D,EAAAia,EAAApY,GAIA,IAAAqd,GAAA,SAAA5d,EAAAtB,EAAAia,EAAApY,EAAAsd,GAOA,GANA7d,EAAA8d,QAAAN,EAAAO,EAAA/d,EAAA8d,YAAoDpf,EAAAia,GACpDpY,UACAqY,IAAA5Y,EACA6d,cAGAA,EAAA,EACA7d,EAAAge,aAAAhe,EAAAge,gBACAH,EAAAvL,IAAAuL,EAGA,MAAA7d,GAMAsd,GAAAW,SAAA,SAAAje,EAAAtB,EAAAia,GACA,IAAA3Y,EAAA,MAAAuC,KACA,IAAA+P,GAAAtS,EAAAke,YAAAle,EAAAke,UAAAxd,EAAA0R,SAAA,MACA+L,EAAA5b,KAAA6b,eAAA7b,KAAA6b,iBACAP,EAAAM,EAAA7L,EAIA,KAAAuL,EAAA,CACA,GAAAQ,GAAA9b,KAAA2b,YAAA3b,KAAA2b,UAAAxd,EAAA0R,SAAA,KACAyL,GAAAM,EAAA7L,IAAqCtS,MAAAse,MAAAhM,KAAA+L,EAAAF,cAAAI,MAAA,GAKrC,MADAX,GAAA5d,EAAAtB,EAAAia,EAAApW,KAAAsb,GACAtb,KAIA,IAAAwb,GAAA,SAAAN,EAAA/e,EAAAia,EAAAnM,GACA,GAAAmM,EAAA,CACA,GAAA6F,GAAAf,EAAA/e,KAAA+e,EAAA/e,OACA6B,EAAAiM,EAAAjM,QAAAqY,EAAApM,EAAAoM,IAAAiF,EAAArR,EAAAqR,SACAA,MAAAU,QAEAC,EAAAnc,MAAqBsW,WAAApY,UAAAqY,IAAArY,GAAAqY,EAAAiF,cAErB,MAAAJ,GAOAH,GAAAmB,IAAA,SAAA/f,EAAAia,EAAApY,GACA,MAAAgC,MAAAub,SACAvb,KAAAub,QAAAN,EAAAkB,EAAAnc,KAAAub,QAAApf,EAAAia,GACApY,UACAoe,UAAApc,KAAAyb,aAEAzb,MALAA,MAUA+a,EAAAsB,cAAA,SAAA5e,EAAAtB,EAAAia,GACA,GAAAwF,GAAA5b,KAAA6b,YACA,KAAAD,EAAA,MAAA5b,KAIA,QAFAsc,GAAA7e,KAAAke,WAAAxd,EAAAP,KAAAge,GAEAhgB,EAAA,EAAmBA,EAAA0gB,EAAAxe,OAAgBlC,IAAA,CACnC,GAAA0f,GAAAM,EAAAU,EAAA1gB,GAIA,KAAA0f,EAAA,KAEAA,GAAA7d,IAAAye,IAAA/f,EAAAia,EAAApW,MAGA,MAAAA,MAIA,IAAAmc,GAAA,SAAAjB,EAAA/e,EAAAia,EAAAnM,GACA,GAAAiR,EAAA,CAEA,GAAAI,GAAA1f,EAAA,EACAoC,EAAAiM,EAAAjM,QAAAoe,EAAAnS,EAAAmS,SAGA,IAAAjgB,GAAAia,GAAApY,EAAA,CAWA,IADA,GAAA6N,GAAA1P,MAAAgC,EAAAP,KAAAsd,GACUtf,EAAAiQ,EAAA/N,OAAkBlC,IAAA,CAC5BO,EAAA0P,EAAAjQ,EACA,IAAAqgB,GAAAf,EAAA/e,EAGA,KAAA8f,EAAA,KAIA,QADA1R,MACArD,EAAA,EAAqBA,EAAA+U,EAAAne,OAAqBoJ,IAAA,CAC1C,GAAAqV,GAAAN,EAAA/U,EAEAkP,QAAAmG,EAAAnG,UACAA,IAAAmG,EAAAnG,SAAAoG,WACAxe,OAAAue,EAAAve,QAEAuM,EAAAzK,KAAAyc,IAEAjB,EAAAiB,EAAAjB,YACA,KAAAA,EAAAU,cACAI,GAAAd,EAAAvL,UACAuL,GAAAM,YAAAN,EAAAS,QAMAxR,EAAAzM,OACAod,EAAA/e,GAAAoO,QAEA2Q,GAAA/e,GAGA,MAAA+e,GA1CA,IADA,GAAAoB,GAAAne,EAAAP,KAAAwe,GACYxgB,EAAA0gB,EAAAxe,OAAgBlC,IAC5B0f,EAAAc,EAAAE,EAAA1gB,UACAwgB,GAAAd,EAAAvL,UACAuL,GAAAM,YAAAN,EAAAS,QA8CAhB,GAAA3P,KAAA,SAAAjP,EAAAia,EAAApY,GAEA,GAAAkd,GAAAD,EAAAwB,KAAsCtgB,EAAAia,EAAAjY,EAAAwC,KAAAX,KAAAkc,IAAAlc,MAEtC,OADA,gBAAA7D,IAAA,MAAA6B,IAAAoY,MAAA,IACApW,KAAAsV,GAAA4F,EAAA9E,EAAApY,IAIA+c,EAAA2B,aAAA,SAAAjf,EAAAtB,EAAAia,GAEA,GAAA8E,GAAAD,EAAAwB,KAAsCtgB,EAAAia,EAAAjY,EAAAwC,KAAAX,KAAAqc,cAAArc,KAAAvC,GACtC,OAAAuC,MAAA0b,SAAAje,EAAAyd,GAKA,IAAAuB,GAAA,SAAAna,EAAAnG,EAAAia,EAAAuG,GACA,GAAAvG,EAAA,CACA,GAAAhL,GAAA9I,EAAAnG,GAAAgC,EAAAiN,KAAA,WACAuR,EAAAxgB,EAAAiP,GACAgL,EAAA9U,MAAAtB,KAAA5B,YAEAgN,GAAAoR,UAAApG,EAEA,MAAA9T,GAOAyY,GAAA/G,QAAA,SAAA7X,GACA,IAAA6D,KAAAub,QAAA,MAAAvb,KAIA,QAFAlC,GAAAiB,KAAAC,IAAA,EAAAZ,UAAAN,OAAA,GACAqG,EAAAhE,MAAArC,GACAlC,EAAA,EAAmBA,EAAAkC,EAAYlC,IAAAuI,EAAAvI,GAAAwC,UAAAxC,EAAA,EAG/B,OADAqf,GAAA2B,EAAA5c,KAAAub,QAAApf,MAAA,GAAAgI,GACAnE,KAIA,IAAA4c,GAAA,SAAAC,EAAA1gB,EAAAia,EAAAjS,GACA,GAAA0Y,EAAA,CACA,GAAA3B,GAAA2B,EAAA1gB,GACA2gB,EAAAD,EAAArZ,GACA0X,IAAA4B,QAAA5d,SACAgc,GAAA6B,EAAA7B,EAAA/W,GACA2Y,GAAAC,EAAAD,GAAA3gB,GAAA+M,OAAA/E,IAEA,MAAA0Y,IAMAE,EAAA,SAAA7B,EAAA/W,GACA,GAAA6Y,GAAAphB,GAAA,EAAAC,EAAAqf,EAAApd,OAAAmf,EAAA9Y,EAAA,GAAA+Y,EAAA/Y,EAAA,GAAAgZ,EAAAhZ,EAAA,EACA,QAAAA,EAAArG,QACA,cAAAlC,EAAAC,IAAAmhB,EAAA9B,EAAAtf,IAAAwa,SAAAta,KAAAkhB,EAAA3G,IAAqE,OACrE,eAAAza,EAAAC,IAAAmhB,EAAA9B,EAAAtf,IAAAwa,SAAAta,KAAAkhB,EAAA3G,IAAA4G,EAAyE,OACzE,eAAArhB,EAAAC,IAAAmhB,EAAA9B,EAAAtf,IAAAwa,SAAAta,KAAAkhB,EAAA3G,IAAA4G,EAAAC,EAA6E,OAC7E,eAAAthB,EAAAC,IAAAmhB,EAAA9B,EAAAtf,IAAAwa,SAAAta,KAAAkhB,EAAA3G,IAAA4G,EAAAC,EAAAC,EAAiF,OACjF,gBAAAvhB,EAAAC,IAAAmhB,EAAA9B,EAAAtf,IAAAwa,SAAA9U,MAAA0b,EAAA3G,IAAAlS,EAA6E,SAK7E4W,GAAApa,KAAAoa,EAAAzF,GACAyF,EAAAqC,OAAArC,EAAAmB,IAIA/d,EAAA2N,OAAAmO,EAAAc,EAYA,IAAAsC,GAAApD,EAAAoD,MAAA,SAAAvC,EAAA7Q,GACA,GAAA1F,GAAAuW,KACA7Q,WACAjK,KAAAsd,IAAAnf,EAAA0R,SAAA7P,KAAAud,WACAvd,KAAA8a,cACA7Q,EAAA7I,aAAApB,KAAAoB,WAAA6I,EAAA7I,YACA6I,EAAAuT,QAAAjZ,EAAAvE,KAAAwd,MAAAjZ,EAAA0F,OACA,IAAAoC,GAAAlO,EAAA8D,OAAAjC,KAAA,WACAuE,GAAApG,EAAAkO,SAAAlO,EAAA2N,UAAkCO,EAAA9H,GAAA8H,GAClCrM,KAAA6E,IAAAN,EAAA0F,GACAjK,KAAAyd,WACAzd,KAAA0d,WAAApc,MAAAtB,KAAA5B,WAIAD,GAAA2N,OAAAuR,EAAAtgB,UAAAge,GAGA0C,QAAA,KAGAE,gBAAA,KAIAC,YAAA,KAIAL,UAAA,IAIAG,WAAA,aAGAjM,OAAA,SAAAxH,GACA,MAAA9L,GAAAoO,MAAAvM,KAAA8a,aAKA+C,KAAA,WACA,MAAA5D,GAAA4D,KAAAvc,MAAAtB,KAAA5B,YAIA1B,IAAA,SAAA+V,GACA,MAAAzS,MAAA8a,WAAArI,IAIAhD,OAAA,SAAAgD,GACA,MAAAtU,GAAAsR,OAAAzP,KAAAtD,IAAA+V,KAKA7S,IAAA,SAAA6S,GACA,aAAAzS,KAAAtD,IAAA+V,IAIAtE,QAAA,SAAA5J,GACA,QAAApG,EAAAT,SAAA6G,EAAAvE,WAAA8a,aAMAjW,IAAA,SAAA9C,EAAA+b,EAAA7T,GACA,SAAAlI,EAAA,MAAA/B,KAGA,IAAAuE,EAWA,IAVA,gBAAAxC,IACAwC,EAAAxC,EACAkI,EAAA6T,IAEAvZ,MAAmBxC,GAAA+b,EAGnB7T,WAGAjK,KAAA+d,UAAAxZ,EAAA0F,GAAA,QAGA,IAAA+T,GAAA/T,EAAA+T,MACAC,EAAAhU,EAAAgU,OACAC,KACAC,EAAAne,KAAAoe,SACApe,MAAAoe,WAAA,EAEAD,IACAne,KAAAqe,oBAAAlgB,EAAAoO,MAAAvM,KAAA8a,YACA9a,KAAAyd,WAGA,IAAAa,GAAAte,KAAA8a,WACA2C,EAAAzd,KAAAyd,QACAc,EAAAve,KAAAqe,mBAGA,QAAA5L,KAAAlO,GACAuZ,EAAAvZ,EAAAkO,GACAtU,EAAAgP,QAAAmR,EAAA7L,GAAAqL,IAAAI,EAAApe,KAAA2S,GACAtU,EAAAgP,QAAAoR,EAAA9L,GAAAqL,SAGAL,GAAAhL,GAFAgL,EAAAhL,GAAAqL,EAIAE,QAAAM,GAAA7L,GAAA6L,EAAA7L,GAAAqL,CAOA,IAHA9d,KAAA4d,cAAArZ,KAAAvE,KAAA+P,GAAA/P,KAAAtD,IAAAsD,KAAA4d,eAGAK,EAAA,CACAC,EAAApgB,SAAAkC,KAAAwe,SAAAvU,EACA,QAAArO,GAAA,EAAuBA,EAAAsiB,EAAApgB,OAAoBlC,IAC3CoE,KAAAgU,QAAA,UAAAkK,EAAAtiB,GAAAoE,KAAAse,EAAAJ,EAAAtiB,IAAAqO,GAMA,GAAAkU,EAAA,MAAAne,KACA,KAAAie,EACA,KAAAje,KAAAwe,UACAvU,EAAAjK,KAAAwe,SACAxe,KAAAwe,UAAA,EACAxe,KAAAgU,QAAA,SAAAhU,KAAAiK,EAKA,OAFAjK,MAAAwe,UAAA,EACAxe,KAAAoe,WAAA,EACApe,MAKAge,MAAA,SAAAvL,EAAAxI,GACA,MAAAjK,MAAA6E,IAAA4N,MAAA,GAAAtU,EAAA2N,UAA+C7B,GAAY+T,OAAA,MAI3DS,MAAA,SAAAxU,GACA,GAAA1F,KACA,QAAAxC,KAAA/B,MAAA8a,WAAAvW,EAAAxC,OAAA,EACA,OAAA/B,MAAA6E,IAAAN,EAAApG,EAAA2N,UAAwC7B,GAAY+T,OAAA,MAKpDU,WAAA,SAAAjM,GACA,aAAAA,GAAAtU,EAAAiP,QAAApN,KAAAyd,SACAtf,EAAAyB,IAAAI,KAAAyd,QAAAhL,IASAkM,kBAAA,SAAAC,GACA,IAAAA,EAAA,QAAA5e,KAAA0e,cAAAvgB,EAAAoO,MAAAvM,KAAAyd,QACA,IAAAxI,GAAAjV,KAAAoe,UAAApe,KAAAqe,oBAAAre,KAAA8a,WACA2C,IACA,QAAAhL,KAAAmM,GAAA,CACA,GAAAd,GAAAc,EAAAnM,EACAtU,GAAAgP,QAAA8H,EAAAxC,GAAAqL,KACAL,EAAAhL,GAAAqL,GAEA,QAAA3f,EAAA2H,KAAA2X,OAKAtT,SAAA,SAAAsI,GACA,aAAAA,GAAAzS,KAAAqe,oBACAre,KAAAqe,oBAAA5L,GADA,MAMAoM,mBAAA,WACA,MAAA1gB,GAAAoO,MAAAvM,KAAAqe,sBAKAS,MAAA,SAAA7U,GACAA,EAAA9L,EAAA2N,QAA0B0R,OAAA,GAAYvT,EACtC,IAAA4Q,GAAA7a,KACA+e,EAAA9U,EAAA8U,OAQA,OAPA9U,GAAA8U,QAAA,SAAAC,GACA,GAAAC,GAAAhV,EAAAuT,MAAA3C,EAAA2C,MAAAwB,EAAA/U,GAAA+U,CACA,KAAAnE,EAAAhW,IAAAoa,EAAAhV,GAAA,QACA8U,MAAAjjB,KAAAmO,EAAAjM,QAAA6c,EAAAmE,EAAA/U,GACA4Q,EAAA7G,QAAA,OAAA6G,EAAAmE,EAAA/U,IAEAiV,EAAAlf,KAAAiK,GACAjK,KAAA6d,KAAA,OAAA7d,KAAAiK,IAMAkV,KAAA,SAAApd,EAAA+b,EAAA7T,GAEA,GAAA1F,EACA,OAAAxC,GAAA,gBAAAA,IACAwC,EAAAxC,EACAkI,EAAA6T,IAEAvZ,MAAmBxC,GAAA+b,EAGnB7T,EAAA9L,EAAA2N,QAA0BsT,UAAA,EAAA5B,OAAA,GAA4BvT,EACtD,IAAAJ,GAAAI,EAAAJ,IAKA,IAAAtF,IAAAsF,GACA,IAAA7J,KAAA6E,IAAAN,EAAA0F,GAAA,aACO,KAAAjK,KAAA+d,UAAAxZ,EAAA0F,GACP,QAKA,IAAA4Q,GAAA7a,KACA+e,EAAA9U,EAAA8U,QACAjE,EAAA9a,KAAA8a,UACA7Q,GAAA8U,QAAA,SAAAC,GAEAnE,EAAAC,YACA,IAAAmE,GAAAhV,EAAAuT,MAAA3C,EAAA2C,MAAAwB,EAAA/U,GAAA+U,CAEA,IADAnV,IAAAoV,EAAA9gB,EAAA2N,UAA2CvH,EAAA0a,IAC3CA,IAAApE,EAAAhW,IAAAoa,EAAAhV,GAAA,QACA8U,MAAAjjB,KAAAmO,EAAAjM,QAAA6c,EAAAmE,EAAA/U,GACA4Q,EAAA7G,QAAA,OAAA6G,EAAAmE,EAAA/U,IAEAiV,EAAAlf,KAAAiK,GAGA1F,GAAAsF,IAAA7J,KAAA8a,WAAA3c,EAAA2N,UAAsDgP,EAAAvW,GAEtD,IAAAL,GAAAlE,KAAAqf,QAAA,SAAApV,EAAAqV,MAAA,gBACA,WAAApb,GAAA+F,EAAA1F,QAAA0F,EAAA1F,QACA,IAAAgb,GAAAvf,KAAA6d,KAAA3Z,EAAAlE,KAAAiK,EAKA,OAFAjK,MAAA8a,aAEAyE,GAMAC,QAAA,SAAAvV,GACAA,IAAA9L,EAAAoO,MAAAtC,KACA,IAAA4Q,GAAA7a,KACA+e,EAAA9U,EAAA8U,QACAlV,EAAAI,EAAAJ,KAEA2V,EAAA,WACA3E,EAAAwB,gBACAxB,EAAA7G,QAAA,UAAA6G,IAAAzZ,WAAA6I,GAGAA,GAAA8U,QAAA,SAAAC,GACAnV,GAAA2V,IACAT,KAAAjjB,KAAAmO,EAAAjM,QAAA6c,EAAAmE,EAAA/U,GACA4Q,EAAAwE,SAAAxE,EAAA7G,QAAA,OAAA6G,EAAAmE,EAAA/U,GAGA,IAAAsV,IAAA,CAQA,OAPAvf,MAAAqf,QACAlhB,EAAA4L,MAAAE,EAAA8U,UAEAG,EAAAlf,KAAAiK,GACAsV,EAAAvf,KAAA6d,KAAA,SAAA7d,KAAAiK,IAEAJ,GAAA2V,IACAD,GAMAE,IAAA,WACA,GAAAC,GACAvhB,EAAA8D,OAAAjC,KAAA,YACA7B,EAAA8D,OAAAjC,KAAAoB,WAAA,QACAue,GACA,IAAA3f,KAAAqf,QAAA,MAAAK,EACA,IAAA3P,GAAA/P,KAAAtD,IAAAsD,KAAA4d,YACA,OAAA8B,GAAAlQ,QAAA,gBAAAoQ,mBAAA7P,IAKAyN,MAAA,SAAAwB,EAAA/U,GACA,MAAA+U,IAIAzS,MAAA,WACA,UAAAvM,MAAAT,YAAAS,KAAA8a,aAIAuE,MAAA,WACA,OAAArf,KAAAJ,IAAAI,KAAA4d,cAIAiC,QAAA,SAAA5V,GACA,MAAAjK,MAAA+d,aAA8B5f,EAAA2N,UAAa7B,GAAYmV,UAAA,MAKvDrB,UAAA,SAAAxZ,EAAA0F,GACA,IAAAA,EAAAmV,WAAApf,KAAAof,SAAA,QACA7a,GAAApG,EAAA2N,UAAyB9L,KAAA8a,WAAAvW,EACzB,IAAA2T,GAAAlY,KAAA2d,gBAAA3d,KAAAof,SAAA7a,EAAA0F,IAAA,IACA,QAAAiO,IACAlY,KAAAgU,QAAA,UAAAhU,KAAAkY,EAAA/Z,EAAA2N,OAAA7B,GAA8D0T,gBAAAzF,MAC9D,MAWAuC,EAAA4C,GAJsBzf,KAAA,EAAAmG,OAAA,EAAA0H,MAAA,EAAAC,OAAA,EAAAO,KAAA,EACtBE,KAAA,EAAAiF,MAAA,EAAAhE,QAAA,GAGA,aAeA,IAAA0S,GAAA7F,EAAA6F,WAAA,SAAAC,EAAA9V,GACAA,UACAA,EAAA4Q,QAAA7a,KAAA6a,MAAA5Q,EAAA4Q,WACA,KAAA5Q,EAAA+V,aAAAhgB,KAAAggB,WAAA/V,EAAA+V,YACAhgB,KAAAigB,SACAjgB,KAAA0d,WAAApc,MAAAtB,KAAA5B,WACA2hB,GAAA/f,KAAAkgB,MAAAH,EAAA5hB,EAAA2N,QAA6CmS,QAAA,GAAahU,KAI1DkW,GAAoBC,KAAA,EAAAC,QAAA,EAAAC,OAAA,GACpBC,GAAoBH,KAAA,EAAAC,QAAA,GAGpBG,EAAA,SAAAliB,EAAAmiB,EAAAC,GACAA,EAAA3hB,KAAAE,IAAAF,KAAAC,IAAA0hB,EAAA,GAAApiB,EAAAR,OACA,IAEAlC,GAFA4K,EAAArG,MAAA7B,EAAAR,OAAA4iB,GACA5iB,EAAA2iB,EAAA3iB,MAEA,KAAAlC,EAAA,EAAeA,EAAA4K,EAAA1I,OAAiBlC,IAAA4K,EAAA5K,GAAA0C,EAAA1C,EAAA8kB,EAChC,KAAA9kB,EAAA,EAAeA,EAAAkC,EAAYlC,IAAA0C,EAAA1C,EAAA8kB,GAAAD,EAAA7kB,EAC3B,KAAAA,EAAA,EAAeA,EAAA4K,EAAA1I,OAAiBlC,IAAA0C,EAAA1C,EAAAkC,EAAA4iB,GAAAla,EAAA5K,GAIhCuC,GAAA2N,OAAAgU,EAAA/iB,UAAAge,GAIAF,MAAAwC,EAIAK,WAAA,aAIAjM,OAAA,SAAAxH,GACA,MAAAjK,MAAAsC,IAAA,SAAAuY,GAAuC,MAAAA,GAAApJ,OAAAxH,MAIvC4T,KAAA,WACA,MAAA5D,GAAA4D,KAAAvc,MAAAtB,KAAA5B,YAMAgiB,IAAA,SAAAL,EAAA9V,GACA,MAAAjK,MAAA6E,IAAAkb,EAAA5hB,EAAA2N,QAAwCwU,OAAA,GAAarW,EAAAsW,KAIrDF,OAAA,SAAAN,EAAA9V,GACAA,EAAA9L,EAAA2N,UAA2B7B,EAC3B,IAAA0W,IAAAxiB,EAAAqC,QAAAuf,EACAA,GAAAY,GAAAZ,KAAA7gB,OACA,IAAA0hB,GAAA5gB,KAAA6gB,cAAAd,EAAA9V,EAKA,QAJAA,EAAAgU,QAAA2C,EAAA9iB,SACAmM,EAAAiU,SAA2B4C,SAAAC,UAAAH,WAC3B5gB,KAAAgU,QAAA,SAAAhU,KAAAiK,IAEA0W,EAAAC,EAAA,GAAAA,GAOA/b,IAAA,SAAAkb,EAAA9V,GACA,SAAA8V,EAAA,CAEA9V,EAAA9L,EAAA2N,UAA2BqU,EAAAlW,GAC3BA,EAAAuT,QAAAxd,KAAA2a,SAAAoF,KACAA,EAAA/f,KAAAwd,MAAAuC,EAAA9V,OAGA,IAAA0W,IAAAxiB,EAAAqC,QAAAuf,EACAA,GAAAY,GAAAZ,KAAA7gB,OAEA,IAAAwhB,GAAAzW,EAAAyW,EACA,OAAAA,UACAA,EAAA1gB,KAAAlC,SAAA4iB,EAAA1gB,KAAAlC,QACA4iB,EAAA,IAAAA,GAAA1gB,KAAAlC,OAAA,EAEA,IAgBA+c,GAAAjf,EAhBAiJ,KACAmc,KACAC,KACAC,KACAC,KAEAf,EAAAnW,EAAAmW,IACAE,EAAArW,EAAAqW,MACAD,EAAApW,EAAAoW,OAEAlb,GAAA,EACAic,EAAAphB,KAAAggB,YAAA,MAAAU,IAAA,IAAAzW,EAAA9E,KACAkc,EAAAljB,EAAAkP,SAAArN,KAAAggB,YAAAhgB,KAAAggB,WAAA,IAKA,KAAApkB,EAAA,EAAiBA,EAAAmkB,EAAAjiB,OAAmBlC,IAAA,CACpCif,EAAAkF,EAAAnkB,EAIA,IAAA0lB,GAAAthB,KAAAtD,IAAAme,EACA,IAAAyG,EAAA,CACA,GAAAhB,GAAAzF,IAAAyG,EAAA,CACA,GAAA/c,GAAAvE,KAAA2a,SAAAE,KAAAC,WAAAD,CACA5Q,GAAAuT,QAAAjZ,EAAA+c,EAAA9D,MAAAjZ,EAAA0F,IACAqX,EAAAzc,IAAAN,EAAA0F,GACAgX,EAAAnhB,KAAAwhB,GACAF,IAAAjc,MAAAmc,EAAA5C,WAAA2C,IAEAF,EAAAG,EAAAhE,OACA6D,EAAAG,EAAAhE,MAAA,EACAzY,EAAA/E,KAAAwhB,IAEAvB,EAAAnkB,GAAA0lB,MAGSlB,KACTvF,EAAAkF,EAAAnkB,GAAAoE,KAAAuhB,cAAA1G,EAAA5Q,MAEA+W,EAAAlhB,KAAA+a,GACA7a,KAAAwhB,cAAA3G,EAAA5Q,GACAkX,EAAAtG,EAAAyC,MAAA,EACAzY,EAAA/E,KAAA+a,IAMA,GAAAwF,EAAA,CACA,IAAAzkB,EAAA,EAAmBA,EAAAoE,KAAAlC,OAAiBlC,IACpCif,EAAA7a,KAAA+f,OAAAnkB,GACAulB,EAAAtG,EAAAyC,MAAA4D,EAAAphB,KAAA+a,EAEAqG,GAAApjB,QAAAkC,KAAA6gB,cAAAK,EAAAjX,GAIA,GAAAwX,IAAA,EACAjS,GAAA4R,GAAAhB,GAAAC,CAkBA,IAjBAxb,EAAA/G,QAAA0R,GACAiS,EAAAzhB,KAAAlC,SAAA+G,EAAA/G,QAAAK,EAAAsF,KAAAzD,KAAA+f,OAAA,SAAAhkB,EAAA8B,GACA,MAAA9B,KAAA8I,EAAAhH,KAEAmC,KAAA+f,OAAAjiB,OAAA,EACA0iB,EAAAxgB,KAAA+f,OAAAlb,EAAA,GACA7E,KAAAlC,OAAAkC,KAAA+f,OAAAjiB,QACOkjB,EAAAljB,SACPsjB,IAAAjc,GAAA,GACAqb,EAAAxgB,KAAA+f,OAAAiB,EAAA,MAAAN,EAAA1gB,KAAAlC,OAAA4iB,GACA1gB,KAAAlC,OAAAkC,KAAA+f,OAAAjiB,QAIAqH,GAAAnF,KAAAmF,MAA2B8Y,QAAA,KAG3BhU,EAAAgU,OAAA,CACA,IAAAriB,EAAA,EAAmBA,EAAAolB,EAAAljB,OAAkBlC,IACrC,MAAA8kB,IAAAzW,EAAApM,MAAA6iB,EAAA9kB,GACAif,EAAAmG,EAAAplB,GACAif,EAAA7G,QAAA,MAAA6G,EAAA7a,KAAAiK,IAEA9E,GAAAsc,IAAAzhB,KAAAgU,QAAA,OAAAhU,KAAAiK,IACA+W,EAAAljB,QAAAojB,EAAApjB,QAAAmjB,EAAAnjB,UACAmM,EAAAiU,SACA4C,MAAAE,EACAJ,QAAAM,EACAH,OAAAE,GAEAjhB,KAAAgU,QAAA,SAAAhU,KAAAiK,IAKA,MAAA0W,GAAAZ,EAAA,GAAAA,IAOAG,MAAA,SAAAH,EAAA9V,GACAA,IAAA9L,EAAAoO,MAAAtC,KACA,QAAArO,GAAA,EAAqBA,EAAAoE,KAAA+f,OAAAjiB,OAAwBlC,IAC7CoE,KAAA0hB,iBAAA1hB,KAAA+f,OAAAnkB,GAAAqO,EAMA,OAJAA,GAAA0X,eAAA3hB,KAAA+f,OACA/f,KAAAigB,SACAF,EAAA/f,KAAAogB,IAAAL,EAAA5hB,EAAA2N,QAA0CmS,QAAA,GAAahU,IACvDA,EAAAgU,QAAAje,KAAAgU,QAAA,QAAAhU,KAAAiK,GACA8V,GAIAjgB,KAAA,SAAA+a,EAAA5Q,GACA,MAAAjK,MAAAogB,IAAAvF,EAAA1c,EAAA2N,QAAuC4U,GAAA1gB,KAAAlC,QAAgBmM,KAIvDiD,IAAA,SAAAjD,GACA,GAAA4Q,GAAA7a,KAAA0gB,GAAA1gB,KAAAlC,OAAA,EACA,OAAAkC,MAAAqgB,OAAAxF,EAAA5Q,IAIAuQ,QAAA,SAAAK,EAAA5Q,GACA,MAAAjK,MAAAogB,IAAAvF,EAAA1c,EAAA2N,QAAuC4U,GAAA,GAAMzW,KAI7CyN,MAAA,SAAAzN,GACA,GAAA4Q,GAAA7a,KAAA0gB,GAAA,EACA,OAAA1gB,MAAAqgB,OAAAxF,EAAA5Q,IAIA/K,MAAA,WACA,MAAAA,GAAAoC,MAAAtB,KAAA+f,OAAA3hB,YAKA1B,IAAA,SAAAe,GACA,SAAAA,EACA,MAAAuC,MAAA4hB,MAAAnkB,IACAuC,KAAA4hB,MAAA5hB,KAAA6hB,QAAApkB,EAAAqd,YAAArd,KACAA,EAAA6f,KAAAtd,KAAA4hB,MAAAnkB,EAAA6f,MAIA1d,IAAA,SAAAnC,GACA,aAAAuC,KAAAtD,IAAAe,IAIAijB,GAAA,SAAA7iB,GAEA,MADAA,GAAA,IAAAA,GAAAmC,KAAAlC,QACAkC,KAAA+f,OAAAliB,IAKAyG,MAAA,SAAAC,EAAA2B,GACA,MAAAlG,MAAAkG,EAAA,iBAAA3B,IAKAC,UAAA,SAAAD,GACA,MAAAvE,MAAAsE,MAAAC,GAAA,IAMAY,KAAA,SAAA8E,GACA,GAAA+V,GAAAhgB,KAAAggB,UACA,KAAAA,EAAA,SAAAzW,OAAA,yCACAU,UAEA,IAAAnM,GAAAkiB,EAAAliB,MAUA,OATAK,GAAAsB,WAAAugB,OAAA7hB,EAAAwC,KAAAqf,EAAAhgB,OAGA,IAAAlC,GAAAK,EAAAkP,SAAA2S,GACAhgB,KAAA+f,OAAA/f,KAAAiF,OAAA+a,GAEAhgB,KAAA+f,OAAA5a,KAAA6a,GAEA/V,EAAAgU,QAAAje,KAAAgU,QAAA,OAAAhU,KAAAiK,GACAjK,MAIAqE,MAAA,SAAAoO,GACA,MAAAzS,MAAAsC,IAAAmQ,EAAA,KAMAqM,MAAA,SAAA7U,GACAA,EAAA9L,EAAA2N,QAA0B0R,OAAA,GAAYvT,EACtC,IAAA8U,GAAA9U,EAAA8U,QACA3d,EAAApB,IAQA,OAPAiK,GAAA8U,QAAA,SAAAC,GACA,GAAA9a,GAAA+F,EAAAiW,MAAA,aACA9e,GAAA8C,GAAA8a,EAAA/U,GACA8U,KAAAjjB,KAAAmO,EAAAjM,QAAAoD,EAAA4d,EAAA/U,GACA7I,EAAA4S,QAAA,OAAA5S,EAAA4d,EAAA/U,IAEAiV,EAAAlf,KAAAiK,GACAjK,KAAA6d,KAAA,OAAA7d,KAAAiK,IAMApJ,OAAA,SAAAga,EAAA5Q,GACAA,IAAA9L,EAAAoO,MAAAtC,KACA,IAAAJ,GAAAI,EAAAJ,IAEA,MADAgR,EAAA7a,KAAAuhB,cAAA1G,EAAA5Q,IACA,QACAJ,IAAA7J,KAAAogB,IAAAvF,EAAA5Q,EACA,IAAA7I,GAAApB,KACA+e,EAAA9U,EAAA8U,OAMA,OALA9U,GAAA8U,QAAA,SAAAhjB,EAAAijB,EAAA8C,GACAjY,GAAAzI,EAAAgf,IAAArkB,EAAA+lB,GACA/C,KAAAjjB,KAAAgmB,EAAA9jB,QAAAjC,EAAAijB,EAAA8C,IAEAjH,EAAAsE,KAAA,KAAAlV,GACA4Q,GAKA2C,MAAA,SAAAwB,EAAA/U,GACA,MAAA+U,IAIAzS,MAAA,WACA,UAAAvM,MAAAT,YAAAS,KAAA+f,QACAlF,MAAA7a,KAAA6a,MACAmF,WAAAhgB,KAAAggB,cAKA6B,QAAA,SAAAtd,GACA,MAAAA,GAAAvE,KAAA6a,MAAA9d,UAAA6gB,aAAA,OAKAqC,OAAA,WACAjgB,KAAAlC,OAAA,EACAkC,KAAA+f,UACA/f,KAAA4hB,UAKAL,cAAA,SAAAhd,EAAA0F,GACA,GAAAjK,KAAA2a,SAAApW,GAEA,MADAA,GAAAnD,aAAAmD,EAAAnD,WAAApB,MACAuE,CAEA0F,KAAA9L,EAAAoO,MAAAtC,MACAA,EAAA7I,WAAApB,IACA,IAAA6a,GAAA,GAAA7a,MAAA6a,MAAAtW,EAAA0F,EACA,OAAA4Q,GAAA8C,iBACA3d,KAAAgU,QAAA,UAAAhU,KAAA6a,EAAA8C,gBAAA1T,IACA,GAFA4Q,GAMAgG,cAAA,SAAAd,EAAA9V,GAEA,OADA2W,MACAhlB,EAAA,EAAqBA,EAAAmkB,EAAAjiB,OAAmBlC,IAAA,CACxC,GAAAif,GAAA7a,KAAAtD,IAAAqjB,EAAAnkB,GACA,IAAAif,EAAA,CAEA,GAAAhd,GAAAmC,KAAAgE,QAAA6W,EACA7a,MAAA+f,OAAAS,OAAA3iB,EAAA,GACAmC,KAAAlC,eAIAkC,MAAA4hB,MAAA/G,EAAAyC,IACA,IAAAvN,GAAA/P,KAAA6hB,QAAAhH,EAAAC,WACA,OAAA/K,SAAA/P,MAAA4hB,MAAA7R,GAEA9F,EAAAgU,SACAhU,EAAApM,QACAgd,EAAA7G,QAAA,SAAA6G,EAAA7a,KAAAiK,IAGA2W,EAAA9gB,KAAA+a,GACA7a,KAAA0hB,iBAAA7G,EAAA5Q,IAEA,MAAA2W,IAKAjG,SAAA,SAAAE,GACA,MAAAA,aAAAwC,IAIAmE,cAAA,SAAA3G,EAAA5Q,GACAjK,KAAA4hB,MAAA/G,EAAAyC,KAAAzC,CACA,IAAA9K,GAAA/P,KAAA6hB,QAAAhH,EAAAC,WACA,OAAA/K,IAAA/P,KAAA4hB,MAAA7R,GAAA8K,GACAA,EAAAvF,GAAA,MAAAtV,KAAA+hB,cAAA/hB,OAIA0hB,iBAAA,SAAA7G,EAAA5Q,SACAjK,MAAA4hB,MAAA/G,EAAAyC,IACA,IAAAvN,GAAA/P,KAAA6hB,QAAAhH,EAAAC,WACA,OAAA/K,SAAA/P,MAAA4hB,MAAA7R,GACA/P,OAAA6a,EAAAzZ,kBAAAyZ,GAAAzZ,WACAyZ,EAAAqB,IAAA,MAAAlc,KAAA+hB,cAAA/hB,OAOA+hB,cAAA,SAAAC,EAAAnH,EAAAzZ,EAAA6I,GACA,GAAA4Q,EAAA,CACA,YAAAmH,GAAA,WAAAA,IAAA5gB,IAAApB,KAAA,MAEA,IADA,YAAAgiB,GAAAhiB,KAAAqgB,OAAAxF,EAAA5Q,GACA,WAAA+X,EAAA,CACA,GAAAC,GAAAjiB,KAAA6hB,QAAAhH,EAAAgE,sBACA9O,EAAA/P,KAAA6hB,QAAAhH,EAAAC,WACAmH,KAAAlS,IACA,MAAAkS,SAAAjiB,MAAA4hB,MAAAK,GACA,MAAAlS,IAAA/P,KAAA4hB,MAAA7R,GAAA8K,KAIA7a,KAAAgU,QAAA1S,MAAAtB,KAAA5B,cAkBAqc,EAAAqF,GAV2Bzd,QAAA,EAAAD,KAAA,EAAAE,IAAA,EAAAC,QAAA,EAAAE,OAAA,EAC3BC,MAAA,EAAAC,OAAA,EAAAC,YAAA,EAAAC,MAAA,EAAAC,KAAA,EAAAC,OAAA,EAAAG,OAAA,EACAC,OAAA,EAAAE,OAAA,EAAAE,MAAA,EAAAC,IAAA,EAAAC,KAAA,EAAAC,IAAA,EAAAE,QAAA,EAAAD,SAAA,EACA9D,SAAA,EAAAoE,OAAA,EAAAjF,IAAA,EAAAC,IAAA,EAAA4G,QAAA,EAAAC,KAAA,EAAAI,MAAA,EACAC,KAAA,EAAAC,KAAA,EAAAC,QAAA,EAAAE,KAAA,EAAAC,KAAA,EAAAC,KAAA,EAAAH,KAAA,EACAc,QAAA,EAAAC,WAAA,EAAArD,QAAA,EAAAW,QAAA,EAAA0D,YAAA,EACA+E,QAAA,EAAAgE,MAAA,EAAApM,OAAA,EAAAe,UAAA,EAAAL,QAAA,EAAAE,QAAA,EACAX,OAAA,EAAAU,QAAA,EAAA3C,UAAA,EAAAgF,cAAA,GAGA,SAeA,IAAAka,GAAAjI,EAAAiI,KAAA,SAAAjY,GACAjK,KAAAsd,IAAAnf,EAAA0R,SAAA,QACA1R,EAAA2N,OAAA9L,KAAA7B,EAAA8N,KAAAhC,EAAAkY,IACAniB,KAAAoiB,iBACApiB,KAAA0d,WAAApc,MAAAtB,KAAA5B,YAIAikB,EAAA,iBAGAF,GAAA,2EAGAhkB,GAAA2N,OAAAoW,EAAAnlB,UAAAge,GAGAuH,QAAA,MAIA1Q,EAAA,SAAA2Q,GACA,MAAAviB,MAAAwiB,IAAA1f,KAAAyf,IAKA7E,WAAA,aAKAzM,OAAA,WACA,MAAAjR,OAKAqgB,OAAA,WAGA,MAFArgB,MAAAyiB,iBACAziB,KAAAqc,gBACArc,MAMAyiB,eAAA,WACAziB,KAAAwiB,IAAAnC,UAKAqC,WAAA,SAAA1P,GAIA,MAHAhT,MAAA2iB,mBACA3iB,KAAA4iB,YAAA5P,GACAhT,KAAA6iB,iBACA7iB,MAQA4iB,YAAA,SAAAE,GACA9iB,KAAAwiB,IAAAM,YAAA7I,GAAArI,EAAAkR,EAAA7I,EAAArI,EAAAkR,GACA9iB,KAAA8iB,GAAA9iB,KAAAwiB,IAAA,IAgBAK,eAAA,SAAA3H,GAEA,GADAA,MAAA/c,EAAA8D,OAAAjC,KAAA,YACAkb,EAAA,MAAAlb,KACAA,MAAA2iB,kBACA,QAAA5gB,KAAAmZ,GAAA,CACA,GAAAhX,GAAAgX,EAAAnZ,EAEA,IADA5D,EAAAsB,WAAAyE,OAAAlE,KAAAkE,IACAA,EAAA,CACA,GAAA+K,GAAAlN,EAAAkN,MAAAoT,EACAriB,MAAA+iB,SAAA9T,EAAA,GAAAA,EAAA,GAAA9Q,EAAAwC,KAAAuD,EAAAlE,QAEA,MAAAA,OAMA+iB,SAAA,SAAAC,EAAAT,EAAAU,GAEA,MADAjjB,MAAAwiB,IAAAlN,GAAA0N,EAAA,kBAAAhjB,KAAAsd,IAAAiF,EAAAU,GACAjjB,MAMA2iB,iBAAA,WAEA,MADA3iB,MAAAwiB,KAAAxiB,KAAAwiB,IAAAtG,IAAA,kBAAAlc,KAAAsd,KACAtd,MAKAkjB,WAAA,SAAAF,EAAAT,EAAAU,GAEA,MADAjjB,MAAAwiB,IAAAtG,IAAA8G,EAAA,kBAAAhjB,KAAAsd,IAAAiF,EAAAU,GACAjjB,MAKAmjB,eAAA,SAAAb,GACA,MAAAjN,UAAA+N,cAAAd,IAOAF,eAAA,WACA,GAAApiB,KAAA8iB,GAOA9iB,KAAA0iB,WAAAvkB,EAAA8D,OAAAjC,KAAA,WAPA,CACA,GAAAuE,GAAApG,EAAA2N,UAA+B3N,EAAA8D,OAAAjC,KAAA,cAC/BA,MAAA+P,KAAAxL,EAAAwL,GAAA5R,EAAA8D,OAAAjC,KAAA,OACAA,KAAA8M,YAAAvI,EAAA,MAAApG,EAAA8D,OAAAjC,KAAA,cACAA,KAAA0iB,WAAA1iB,KAAAmjB,eAAAhlB,EAAA8D,OAAAjC,KAAA,aACAA,KAAAqjB,eAAA9e,KAQA8e,eAAA,SAAAvI,GACA9a,KAAAwiB,IAAA/P,KAAAqI,MAuBAb,EAAA4D,KAAA,SAAA3Z,EAAA2W,EAAA5Q,GACA,GAAAuD,GAAA8V,EAAApf,EAGA/F,GAAAkO,SAAApC,WACAkQ,YAAAF,EAAAE,YACAC,YAAAH,EAAAG,aAIA,IAAAmJ,IAAkB/V,OAAAgW,SAAA,OAqBlB,IAlBAvZ,EAAAwV,MACA8D,EAAA9D,IAAAthB,EAAA8D,OAAA4Y,EAAA,QAAA8E,KAIA,MAAA1V,EAAAkH,OAAA0J,GAAA,WAAA3W,GAAA,WAAAA,GAAA,UAAAA,IACAqf,EAAAE,YAAA,mBACAF,EAAApS,KAAAuS,KAAAC,UAAA1Z,EAAA1F,OAAAsW,EAAApJ,OAAAxH,KAIAA,EAAAmQ,cACAmJ,EAAAE,YAAA,oCACAF,EAAApS,KAAAoS,EAAApS,MAAmC0J,MAAA0I,EAAApS,UAKnClH,EAAAkQ,cAAA,QAAA3M,GAAA,WAAAA,GAAA,UAAAA,GAAA,CACA+V,EAAA/V,KAAA,OACAvD,EAAAmQ,cAAAmJ,EAAApS,KAAAyS,QAAApW,EACA,IAAAqW,GAAA5Z,EAAA4Z,UACA5Z,GAAA4Z,WAAA,SAAAtE,GAEA,GADAA,EAAAuE,iBAAA,yBAAAtW,GACAqW,EAAA,MAAAA,GAAAviB,MAAAtB,KAAA5B,YAKA,QAAAmlB,EAAA/V,MAAAvD,EAAAmQ,cACAmJ,EAAAQ,aAAA,EAIA,IAAA7L,GAAAjO,EAAAiO,KACAjO,GAAAiO,MAAA,SAAAqH,EAAAyE,EAAAC,GACAha,EAAA+Z,aACA/Z,EAAAga,cACA/L,KAAApc,KAAAmO,EAAAjM,QAAAuhB,EAAAyE,EAAAC,GAIA,IAAA1E,GAAAtV,EAAAsV,IAAAtF,EAAAiK,KAAA/lB,EAAA2N,OAAAyX,EAAAtZ,GAEA,OADA4Q,GAAA7G,QAAA,UAAA6G,EAAA0E,EAAAtV,GACAsV,EAIA,IAAA+D,IACAziB,OAAA,OACAsjB,OAAA,MACA7E,MAAA,QACA8E,OAAA,SACAC,KAAA,MAKApK,GAAAiK,KAAA,WACA,MAAAjK,GAAArI,EAAAsS,KAAA5iB,MAAA2Y,EAAArI,EAAAxT,WAQA,IAAAkmB,GAAArK,EAAAqK,OAAA,SAAAra,GACAA,UACAA,EAAAsa,SAAAvkB,KAAAukB,OAAAta,EAAAsa,QACAvkB,KAAAwkB,cACAxkB,KAAA0d,WAAApc,MAAAtB,KAAA5B,YAKAqmB,EAAA,aACAC,EAAA,eACAC,EAAA,SACAC,EAAA,0BAGAzmB,GAAA2N,OAAAwY,EAAAvnB,UAAAge,GAIA2C,WAAA,aAQAmH,MAAA,SAAAA,EAAA1oB,EAAAia,GACAjY,EAAA2mB,SAAAD,OAAA7kB,KAAA+kB,eAAAF,IACA1mB,EAAAsB,WAAAtD,KACAia,EAAAja,EACAA,EAAA,IAEAia,MAAApW,KAAA7D,GACA,IAAA6oB,GAAAhlB,IASA,OARAia,GAAAgL,QAAAJ,QAAA,SAAAK,GACA,GAAA/gB,GAAA6gB,EAAAG,mBAAAN,EAAAK,IACA,IAAAF,EAAAI,QAAAhP,EAAAjS,EAAAhI,KACA6oB,EAAAhR,QAAA1S,MAAA0jB,GAAA,SAAA7oB,GAAA+M,OAAA/E,IACA6gB,EAAAhR,QAAA,QAAA7X,EAAAgI,GACA8V,EAAAgL,QAAAjR,QAAA,QAAAgR,EAAA7oB,EAAAgI,MAGAnE,MAKAolB,QAAA,SAAAhP,EAAAjS,EAAAhI,GACAia,KAAA9U,MAAAtB,KAAAmE,IAIAkhB,SAAA,SAAAH,EAAAjb,GAEA,MADAgQ,GAAAgL,QAAAI,SAAAH,EAAAjb,GACAjK,MAMAwkB,YAAA,WACA,GAAAxkB,KAAAukB,OAAA,CACAvkB,KAAAukB,OAAApmB,EAAA8D,OAAAjC,KAAA,SAEA,KADA,GAAA6kB,GAAAN,EAAApmB,EAAAP,KAAAoC,KAAAukB,QACA,OAAAM,EAAAN,EAAArX,QACAlN,KAAA6kB,QAAA7kB,KAAAukB,OAAAM,MAMAE,eAAA,SAAAF,GAOA,MANAA,KAAArV,QAAAoV,EAAA,QACApV,QAAAiV,EAAA,WACAjV,QAAAkV,EAAA,SAAAzV,EAAAqW,GACA,MAAAA,GAAArW,EAAA,aAEAO,QAAAmV,EAAA,YACA,GAAAvV,QAAA,IAAAyV,EAAA,yBAMAM,mBAAA,SAAAN,EAAAK,GACA,GAAA3B,GAAAsB,EAAAU,KAAAL,GAAAhmB,MAAA,EACA,OAAAf,GAAAmE,IAAAihB,EAAA,SAAAiC,EAAA5pB,GAEA,MAAAA,KAAA2nB,EAAAzlB,OAAA,EAAA0nB,GAAA,KACAA,EAAAC,mBAAAD,GAAA,SAcA,IAAAE,GAAAzL,EAAAyL,QAAA,WACA1lB,KAAAic,YACAjc,KAAA2lB,SAAAxnB,EAAAwC,KAAAX,KAAA2lB,SAAA3lB,MAGA,mBAAA4lB,UACA5lB,KAAA6lB,SAAAD,OAAAC,SACA7lB,KAAAilB,QAAAW,OAAAX,UAKAa,EAAA,eAGAC,EAAA,aAGAC,EAAA,MAGAN,GAAAO,SAAA,EAGA9nB,EAAA2N,OAAA4Z,EAAA3oB,UAAAge,GAIAmL,SAAA,GAGAC,OAAA,WAEA,MADAnmB,MAAA6lB,SAAAO,SAAA5W,QAAA,kBACAxP,KAAAD,OAAAC,KAAAqmB,aAIAC,UAAA,WAGA,MAFAtmB,MAAAumB,eAAAvmB,KAAA6lB,SAAAO,UACAlnB,MAAA,EAAAc,KAAAD,KAAAjC,OAAA,SACAkC,KAAAD,MAMAwmB,eAAA,SAAArB,GACA,MAAAsB,WAAAtB,EAAA1V,QAAA,kBAKA6W,UAAA,WACA,GAAApX,GAAAjP,KAAA6lB,SAAAtT,KAAA/C,QAAA,UAAAP,MAAA,OACA,OAAAA,KAAA,OAKAwX,QAAA,SAAAb,GACA,GAAA3W,IAAA2W,GAAA5lB,MAAA6lB,SAAAtT,KAAAtD,MAAA,SACA,OAAAA,KAAA,OAIAyX,QAAA,WACA,GAAAC,GAAA3mB,KAAAumB,eACAvmB,KAAA6lB,SAAAO,SAAApmB,KAAAqmB,aACAnnB,MAAAc,KAAAD,KAAAjC,OAAA,EACA,aAAA6oB,EAAAC,OAAA,GAAAD,EAAAznB,MAAA,GAAAynB,GAIAE,YAAA,SAAA3B,GAQA,MAPA,OAAAA,IAEAA,EADAllB,KAAA8mB,gBAAA9mB,KAAA+mB,iBACA/mB,KAAA0mB,UAEA1mB,KAAAymB,WAGAvB,EAAA1V,QAAAsW,EAAA,KAKAvd,MAAA,SAAA0B,GACA,GAAAyb,EAAAO,QAAA,SAAA1c,OAAA,4CAoBA,IAnBAmc,EAAAO,SAAA,EAIAjmB,KAAAiK,QAAA9L,EAAA2N,QAAwC/L,KAAA,KAAUC,KAAAiK,WAClDjK,KAAAD,KAAAC,KAAAiK,QAAAlK,KACAC,KAAA+mB,kBAAA,IAAA/mB,KAAAiK,QAAA+c,WACAhnB,KAAAinB,eAAA,gBAAArB,cAAA,KAAAvQ,SAAA6R,cAAA7R,SAAA6R,aAAA,GACAlnB,KAAAmnB,eAAAnnB,KAAA+mB,kBAAA/mB,KAAAinB,eACAjnB,KAAAonB,kBAAApnB,KAAAiK,QAAAod,UACArnB,KAAAsnB,iBAAAtnB,KAAAilB,UAAAjlB,KAAAilB,QAAAoC,WACArnB,KAAA8mB,cAAA9mB,KAAAonB,iBAAApnB,KAAAsnB,cACAtnB,KAAAklB,SAAAllB,KAAA6mB,cAGA7mB,KAAAD,MAAA,IAAAC,KAAAD,KAAA,KAAAyP,QAAAuW,EAAA,KAIA/lB,KAAA+mB,kBAAA/mB,KAAAonB,gBAAA,CAIA,IAAApnB,KAAAsnB,gBAAAtnB,KAAAmmB,SAAA,CACA,GAAAoB,GAAAvnB,KAAAD,KAAAb,MAAA,UAGA,OAFAc,MAAA6lB,SAAArW,QAAA+X,EAAA,IAAAvnB,KAAA0mB,YAEA,EAIS1mB,KAAAsnB,eAAAtnB,KAAAmmB,UACTnmB,KAAAqlB,SAAArlB,KAAAymB,WAAyCjX,SAAA,IAQzC,IAAAxP,KAAAinB,gBAAAjnB,KAAA+mB,mBAAA/mB,KAAA8mB,cAAA,CACA9mB,KAAAwnB,OAAAnS,SAAA+N,cAAA,UACApjB,KAAAwnB,OAAAC,IAAA,eACAznB,KAAAwnB,OAAAE,MAAAC,QAAA,OACA3nB,KAAAwnB,OAAAI,UAAA,CACA,IAAA/R,GAAAR,SAAAQ,KAEAgS,EAAAhS,EAAAiS,aAAA9nB,KAAAwnB,OAAA3R,EAAAkS,YAAAC,aACAH,GAAAxS,SAAA4S,OACAJ,EAAAxS,SAAA6S,QACAL,EAAAhC,SAAAsC,KAAA,IAAAnoB,KAAAklB,SAIA,GAAAkD,GAAAxC,OAAAwC,kBAAA,SAAApF,EAAAC,GACA,MAAAoF,aAAA,KAAArF,EAAAC,GAaA,IARAjjB,KAAA8mB,cACAsB,EAAA,WAAApoB,KAAA2lB,UAAA,GACO3lB,KAAAmnB,iBAAAnnB,KAAAwnB,OACPY,EAAA,aAAApoB,KAAA2lB,UAAA,GACO3lB,KAAA+mB,mBACP/mB,KAAAsoB,kBAAAC,YAAAvoB,KAAA2lB,SAAA3lB,KAAAkmB,YAGAlmB,KAAAiK,QAAAgU,OAAA,MAAAje,MAAAwoB,WAKAhgB,KAAA,WAEA,GAAAigB,GAAA7C,OAAA6C,qBAAA,SAAAzF,EAAAC,GACA,MAAAyF,aAAA,KAAA1F,EAAAC,GAIAjjB,MAAA8mB,cACA2B,EAAA,WAAAzoB,KAAA2lB,UAAA,GACO3lB,KAAAmnB,iBAAAnnB,KAAAwnB,QACPiB,EAAA,aAAAzoB,KAAA2lB,UAAA,GAIA3lB,KAAAwnB,SACAnS,SAAAQ,KAAA8S,YAAA3oB,KAAAwnB,QACAxnB,KAAAwnB,OAAA,MAIAxnB,KAAAsoB,mBAAAM,cAAA5oB,KAAAsoB,mBACA5C,EAAAO,SAAA,GAKApB,MAAA,SAAAA,EAAAzO,GACApW,KAAAic,SAAAzB,SAA6BqK,QAAAzO,cAK7BuP,SAAA,SAAAzU,GACA,GAAAoN,GAAAte,KAAA6mB,aAQA,IAJAvI,IAAAte,KAAAklB,UAAAllB,KAAAwnB,SACAlJ,EAAAte,KAAAymB,QAAAzmB,KAAAwnB,OAAAQ,gBAGA1J,IAAAte,KAAAklB,SAAA,QACAllB,MAAAwnB,QAAAxnB,KAAAqlB,SAAA/G,GACAte,KAAAwoB,WAMAA,QAAA,SAAAtD,GAEA,QAAAllB,KAAAsmB,cACApB,EAAAllB,KAAAklB,SAAAllB,KAAA6mB,YAAA3B,GACA/mB,EAAAsF,KAAAzD,KAAAic,SAAA,SAAAM,GACA,GAAAA,EAAAsI,MAAAtV,KAAA2V,GAEA,MADA3I,GAAAnG,SAAA8O,IACA,MAYAG,SAAA,SAAAH,EAAAjb,GACA,IAAAyb,EAAAO,QAAA,QACAhc,KAAA,IAAAA,OAAmD+J,UAAA/J,IAGnDib,EAAAllB,KAAA6mB,YAAA3B,GAAA,GAGA,IAAAqC,GAAAvnB,KAAAD,IACA,MAAAmlB,GAAA,MAAAA,EAAA0B,OAAA,KACAW,IAAAroB,MAAA,WAEA,IAAAugB,GAAA8H,EAAArC,CAKA,IAFAA,EAAAllB,KAAAumB,eAAArB,EAAA1V,QAAAwW,EAAA,KAEAhmB,KAAAklB,aAAA,CAIA,GAHAllB,KAAAklB,WAGAllB,KAAA8mB,cACA9mB,KAAAilB,QAAAhb,EAAAuF,QAAA,+BAAuE6F,SAAAwT,MAAApJ,OAIhE,KAAAzf,KAAA+mB,iBAmBP,MAAA/mB,MAAA6lB,SAAA7Z,OAAAyT,EAjBA,IADAzf,KAAA8oB,YAAA9oB,KAAA6lB,SAAAX,EAAAjb,EAAAuF,SACAxP,KAAAwnB,QAAAtC,IAAAllB,KAAAymB,QAAAzmB,KAAAwnB,OAAAQ,eAAA,CACA,GAAAH,GAAA7nB,KAAAwnB,OAAAQ,aAKA/d,GAAAuF,UACAqY,EAAAxS,SAAA4S,OACAJ,EAAAxS,SAAA6S,SAGAloB,KAAA8oB,YAAAjB,EAAAhC,SAAAX,EAAAjb,EAAAuF,UAQA,MAAAvF,GAAA+J,QAAAhU,KAAAwoB,QAAAtD,OAAA,KAKA4D,YAAA,SAAAjD,EAAAX,EAAA1V,GACA,GAAAA,EAAA,CACA,GAAA+C,GAAAsT,EAAAtT,KAAA/C,QAAA,wBACAqW,GAAArW,QAAA+C,EAAA,IAAA2S,OAGAW,GAAAsC,KAAA,IAAAjD,KAOAjL,EAAAgL,QAAA,GAAAS,EAQA,IAAA5Z,GAAA,SAAAid,EAAAC,GACA,GACAC,GADA9V,EAAAnT,IAwBA,OAjBAipB,GADAF,GAAA5qB,EAAAyB,IAAAmpB,EAAA,eACAA,EAAAxpB,YAEA,WAAyB,MAAA4T,GAAA7R,MAAAtB,KAAA5B,YAIzBD,EAAA2N,OAAAmd,EAAA9V,EAAA6V,GAIAC,EAAAlsB,UAAAoB,EAAA0C,OAAAsS,EAAApW,UAAAgsB,GACAE,EAAAlsB,UAAAwC,YAAA0pB,EAIAA,EAAAC,UAAA/V,EAAApW,UAEAksB,EAIA5L,GAAAvR,OAAAgU,EAAAhU,OAAAwY,EAAAxY,OAAAoW,EAAApW,OAAA4Z,EAAA5Z,QAGA,IAAA6T,GAAA,WACA,SAAApW,OAAA,mDAIA2V,EAAA,SAAArE,EAAA5Q,GACA,GAAAiO,GAAAjO,EAAAiO,KACAjO,GAAAiO,MAAA,SAAA8G,GACA9G,KAAApc,KAAAmO,EAAAjM,QAAA6c,EAAAmE,EAAA/U,GACA4Q,EAAA7G,QAAA,QAAA6G,EAAAmE,EAAA/U,IAIA,OAAAgQ,OZ+3E6Bne,KAAKJ,EAASH,EAAoB,KAIzD4tB,GACA,SAAUxtB,EAAQD,EAASH,GAEjC,cAC4B,SAAS0e,EAAU9b,EAAGyT,GAElDtV,OAAOC,eAAeb,EAAS,cAC3BO,OAAO,GatwIX,IAAAmtB,GAAA7tB,EAAA,GAGM8tB,EAAgBpP,EAASiI,KAAKpW,QAChCoP,QACIoO,oBAAqB,sBAGzB5L,WALuC,SAK5BvC,GACP,GAAI9O,IACAkd,eAAgB,GAChBC,mBAAoB,eAGxBxpB,MAAKiK,QAAU9L,EAAE2N,OAAOO,EAAU8O,QAKtCsO,mBAhBuC,WAiBnC,GAAIC,GAAW1pB,KAAKwiB,IAAI1f,KAAK9C,KAAKiK,QAAQuf,oBAAoBzY,SAAS4Y,KACnE,EAAAP,EAAAQ,qBAAsBF,GACtB9X,EAAE,cAAciY,SACZC,UAAWJ,EAAW1pB,KAAKiK,QAAQsf,gBACpC,QAMXQ,EAAqB,SAACjH,GAAD,GAAK3H,GAAL/c,UAAAN,OAAA,OAAA4T,KAAAtT,UAAA,GAAAA,UAAA,YAAiB,IAAIirB,GAAclrB,EAAE2N,QAASgX,GAAIA,GAAM3H,Ib+wIjFzf,GAAQsuB,Qa7wIOD,Ib8wIcjuB,KAAKJ,EAASH,EAAoB,GAAIA,EAAoB,GAAIA,EAAoB,KAIzG0uB,EACA,SAAUtuB,EAAQD,GcrzIxB,GAAAwuB,EAGAA,GAAA,WACA,MAAAlqB,QAGA,KAEAkqB,KAAA7pB,SAAA,qBAAA8pB,MAAA,QACC,MAAAjZ,GAED,gBAAA0U,UACAsE,EAAAtE,QAOAjqB,EAAAD,QAAAwuB,Gd4zIME,EACA,SAAUzuB,EAAQD,EAASH,GAEjC,cAC4B,SAASwe,Gev0IrC,QAAAhC,GAAAJ,GACA0S,EAAAvsB,SACAwsB,IACAC,GAAA,GAGAF,IAAAvsB,QAAA6Z,EA0BA,QAAA6S,KACA,KAAA3sB,EAAAwsB,EAAAvsB,QAAA,CACA,GAAA2sB,GAAA5sB,CAUA,IAPAA,GAAA,EACAwsB,EAAAI,GAAA3uB,OAMA+B,EAAA6sB,EAAA,CAGA,OAAAC,GAAA,EAAAC,EAAAP,EAAAvsB,OAAAD,EAAgE8sB,EAAAC,EAAkBD,IAClFN,EAAAM,GAAAN,EAAAM,EAAA9sB,EAEAwsB,GAAAvsB,QAAAD,EACAA,EAAA,GAGAwsB,EAAAvsB,OAAA,EACAD,EAAA,EACA0sB,GAAA,EAyHA,QAAAtS,GAAA7B,GACA,kBAWA,QAAAyU,KAGArgB,aAAAsgB,GACAlC,cAAAmC,GACA3U,IAXA,GAAA0U,GAAAhhB,WAAA+gB,EAAA,GAIAE,EAAAxC,YAAAsC,EAAA,KA5LAlvB,EAAAD,QAAAqc,CAUA,IAOAuS,GAPAD,KAGAE,GAAA,EAQA1sB,EAAA,EAIA6sB,EAAA,KA6CAM,MAAA,KAAAjR,IAAAhR,KACAkiB,EAAAD,EAAAE,kBAAAF,EAAAG,sBAcAb,GADA,kBAAAW,GA2CA,SAAA7U,GACA,GAAArD,GAAA,EACAqY,EAAA,GAAAH,GAAA7U,GACAiV,EAAAhW,SAAAiW,eAAA,GAEA,OADAF,GAAAG,QAAAF,GAA4BG,eAAA,IAC5B,WACAzY,KACAsY,EAAAla,KAAA4B,IAjDAyX,GA8BAvS,EAAAuS,GAQAzS,EAAAuS,eAgFAvS,EAAAE,6Bf61I6Bnc,KAAKJ,EAASH,EAAoB,KAIzDkwB,GACA,SAAU9vB,EAAQD,EAASH,GAEjC,cAC4B,SAAS0e,EAAUrI,GgB3hJxC,QAAS8Z,GAAclJ,EAAK3H,EAAO8Q,GACtC,GAAIC,GAAY,GAAIC,GAAUF,EAAiB9Q,GAE/C,IAAIiR,IACAhJ,GAAIN,EACJ3H,MAAO+Q,IAIR,QAASG,GAAevJ,EAAKphB,EAAYuqB,GAC5C,GAAIK,GAAapa,EAAE,4FAmBnB,OAjBAoa,GAAWC,KACP7qB,EACKqB,OAAO,SAACypB,EAAKrR,GACV,GAAIsR,GAAWva,EAAE,uGAQjB,OANA8Z,GACIS,EACAtR,EACA8Q,GAGGQ,EAASF,OAASC,GAC1B,KAGX1J,EAAIyJ,KAAKD,GAEFxJ,EhBggJXlmB,OAAOC,eAAeb,EAAS,cAC3BO,OAAO,IAEXP,EgBhiJgBgwB,gBhBiiJhBhwB,EgBxhJgBqwB,iBA1ChBxwB,EAAQ,IACR,IAAM6wB,GAAW7wB,EAAQ,KAEnBswB,EAAY5R,EAASoD,MAAMvR,QAC7BO,UACI0D,GAAI,KACJ8Y,MAAO,KACPwD,QAAS,QAIXP,EAAiB7R,EAASiI,KAAKpW,QACjC6E,SAAUyb,EAEV1O,WAHwC,WAIpC1d,KAAKiR,UAGTA,OAPwC,WAQpCjR,KAAKwiB,IAAIyJ,KAAKjsB,KAAK2Q,SAAS3Q,KAAK6a,MAAMC,aACvC9a,KAAKwiB,IAAIrN,UACLpC,QAAQ,ShBsmJSjX,KAAKJ,EAASH,EAAoB,GAAIA,EAAoB,KAIjF+wB,EACA,SAAU3wB,EAAQD,EAASH,GAEjC,cAC4B,SAASqW,EAAGzT,GiB/nJjC,QAASouB,GAAmBpwB,EAAMsjB,GAChCA,IAAKA,EAAMmG,OAAOC,SAAStT,MAChCpW,EAAOA,EAAKqT,QAAQ,UAAW,OAC/B,IAAIgd,GAAQ,GAAIpd,QAAO,OAASjT,EAAO,qBACnCqG,EAAUgqB,EAAMjH,KAAK9F,EAEzB,OAAKjd,GACAA,EAAQ,GAENijB,mBAAmBjjB,EAAQ,GAAGgN,QAAQ,MAAO,MAF5B,GADH,KAWlB,QAASid,KACZ,MAAO7G,QAAOC,SAASsC,KAAOvC,OAAOC,SAASsC,KAAK3Y,QAAQ,IAAK,IAAM,KAUnE,QAASkd,GAAcxvB,EAAGP,GAA0B,GAAvBgwB,GAAuBvuB,UAAAN,OAAA,OAAA4T,KAAAtT,UAAA,GAAAA,UAAA,GAAP,MAC5CwuB,EAAQ1vB,EAAEke,MAAM,IAEpB,OAAIwR,GAAM9uB,QAAUnB,EACTO,EAGK0vB,EAAM1tB,MAAM,EAAGvC,GAAGuS,KAAK,KACpByd,EAUhB,QAASE,GAAmB3vB,EAAGP,GAA0B,GAAvBgwB,GAAuBvuB,UAAAN,OAAA,OAAA4T,KAAAtT,UAAA,GAAAA,UAAA,GAAP,KACrD,OAAIlB,GAAEY,QAAUnB,EACLO,EAGJA,EAAE4vB,UAAU,EAAGnwB,GAAKgwB,EAIxB,QAASI,GAAYC,GACxB,MAAOA,GAAIxd,QAAQ,SAAU,SAASyd,GAAK,MAAOA,GAAIrG,OAAO,GAAGsG,cAAgBD,EAAIE,OAAO,GAAGC,gBAS3F,QAASC,KAIZ,IAAK,GAJoB1wB,GAAMyB,UAAAN,OAAA,OAAA4T,KAAAtT,UAAA,GAAAA,UAAA,GAAJ,GACvBwS,EAAO,GACL0c,EAAW,iEAER1xB,EAAI,EAAGA,EAAIe,EAAGf,IACnBgV,GAAQ0c,EAAS1G,OAAO7nB,KAAKqJ,MAAMrJ,KAAKgG,SAAWuoB,EAASxvB,QAEhE,OAAO8S,GAaJ,QAASgZ,KACZ,MAAOhE,QAAO2H,aAAelY,SAASmY,gBAAgB1D,WAAazU,SAASQ,KAAKiU,WAAa,EAQ3F,QAAS2D,GAAaC,GACzB9b,EAAE,aAAa+b,IAAI,aAAcD,EAAO,OAAS,UAS9C,QAASE,KAA8B,GAAZ7c,GAAY3S,UAAAN,OAAA,OAAA4T,KAAAtT,UAAA,GAAAA,UAAA,GAAL,GACrC,OAAO,IAAI0T,GAAQ,SAACG,EAAS5O,GACzB,GAAIwqB,GAAW1vB,EAAE6L,SAAS,WAClB4f,KAAuB7Y,IACvB6U,OAAO6C,oBAAoB,SAAUoF,GACrC5b,MAEL,IAEH2T,QAAOwC,iBAAiB,SAAUyF,KjBghJ1CvxB,OAAOC,eAAeb,EAAS,cAC3BO,OAAO,IAEXP,EiBpoJgB6wB,qBjBqoJhB7wB,EiBpnJgB+wB,wBjBqnJhB/wB,EiB1mJgBgxB,gBjB2mJhBhxB,EiBzlJgBmxB,qBjB0lJhBnxB,EiBjlJgBqxB,cjBklJhBrxB,EiBxkJgB2xB,ejBykJhB3xB,EiBrjJgBkuB,oBjBsjJhBluB,EiB7iJgB+xB,ejB8iJhB/xB,EiBpiJgBkyB,mBA5GhB,IAAM9b,GAAUvW,EAAQ,KjBwwJKO,KAAKJ,EAASH,EAAoB,GAAIA,EAAoB,KAIjFuyB,GACA,SAAUnyB,EAAQD,GkB5wJxBC,EAAAD,SAAkBqyB,aAAA,aAAAC,yBAAA,yBAAAC,YAAA,YAAAC,YAAA,YAAAC,eAAA,eAAAC,YAAA,YAAAC,uBAAA,uBAAAC,yBAAA,yBAAAC,oBAAA,oBAAAC,WAAA,WAAAC,WAAA,WAAAC,WAAA,WAAAC,WAAA,WAAAC,WAAA,WAAAC,UAAA,UAAAC,YAAA,YAAAC,mBAAA,mBAAAC,oBAAA,oBAAAC,WAAA,WAAAC,aAAA,aAAAC,oBAAA,oBAAAC,YAAA,YAAAC,gBAAA,gBAAAC,mBAAA,mBAAAC,eAAA,eAAAC,YAAA,YAAAC,mBAAA,mBAAAC,aAAA,aAAAC,cAAA,cAAAC,eAAA,eAAAC,gBAAA,gBAAAC,YAAA,cAAAC,uBAAA,uBAAAC,gBAAA,gBAAAC,WAAA,WAAAC,gBAAA,gBAAAC,gBAAA,gBAAAC,gBAAA,gBAAAC,KAAA,OAAAC,YAAA,YAAAC,aAAA,aAAAC,iBAAA,iBAAAC,kBAAA,kBAAAC,mBAAA,mBAAAC,UAAA,UAAAC,cAAA,cAAAC,qBAAA,qBAAAC,YAAA,YAAAC,YAAA,YAAAC,eAAA,eAAAC,aAAA,aAAAC,QAAA,QAAAC,eAAA,eAAAC,mBAAA,mBAAAC,gBAAA,gBAAAC,iBAAA,iBAAAC,YAAA,YAAAC,0BAAA,0BAAAC,iBAAA,iBAAAC,aAAA,aAAAC,qBAAA,qBAAAC,WAAA,WAAAC,kBAAA,kBAAAC,QAAA,QAAAC,iBAAA,iBAAAC,GAAA,KAAAC,SAAA,SAAAC,aAAA,aAAAC,qBAAA,qBAAAC,UAAA,UAAAC,oBAAA,oBAAAC,eAAA,eAAAC,cAAA,cAAAC,YAAA,YAAAC,iBAAA,iBAAAC,SAAA,SAAAC,kBAAA,kBAAAC,mBAAA,mBAAAC,UAAA,UAAAC,WAAA,WAAAC,iBAAA,iBAAAC,cAAA,cAAAC,eAAA,eAAAC,QAAA,UAAAC,UAAA,UAAAC,mBAAA,mBAAAC,QAAA,QAAAC,gBAAA,gBAAAC,WAAA,WAAAC,UAAA,UAAAC,YAAA,YAAAC,iBAAA,iBAAAC,aAAA,aAAAC,gBAAA,gBAAAC,YAAA,YAAAC,iBAAA,iBAAAC,iBAAA,iBAAAC,cAAA,cAAAC,kBAAA,kBAAAC,cAAA,cAAAC,gBAAA,gBAAAC,QAAA,QAAAC,iBAAA,iBAAAC,kBAAA,kBAAAC,wBAAA,wBAAAC,WAAA,WAAAC,kBAAA,kBAAAC,qBAAA,qBAAAC,YAAA,YAAAC,sBAAA,sBAAAC,YAAA,cAAAC,eAAA,eAAAC,aAAA,aAAAC,kBAAA,kBAAAC,gBAAA,gBAAAC,oBAAA,oBAAAC,aAAA,aAAAC,qBAAA,qBAAAC,OAAA,SAAAC,qBAAA,qBAAAC,oBAAA,oBAAAC,WAAA,WAAAC,wBAAA,wBAAAC,aAAA,aAAAC,wBAAA,wBAAAC,kBAAA,kBAAAC,oBAAA,oBAAAC,cAAA,cAAAC,YAAA,YAAAC,YAAA,YAAAC,kBAAA,kBAAAC,UAAA,UAAAC,kBAAA,kBAAAC,QAAA,UAAAC,eAAA,eAAAC,YAAA,YAAAC,sBAAA,sBAAAC,YAAA,YAAAC,gBAAA,gBAAAC,UAAA,UAAAC,yBAAA,yBAAAC,eAAA,eAAAC,kBAAA,kBAAAC,YAAA,YAAAC,aAAA,aAAAC,iBAAA,iBAAAC,cAAA,cAAAC,uBAAA,uBAAAC,YAAA,YAAAC,yBAAA,yBAAAC,UAAA,UAAAC,kBAAA,kBAAAC,kBAAA,kBAAAC,kBAAA,kBAAAC,SAAA,SAAAC,UAAA,UAAAC,wBAAA,wBAAAC,QAAA,QAAAC,WAAA,WAAAC,aAAA,aAAAC,gBAAA,gBAAAC,UAAA,UAAAC,mBAAA,mBAAAC,QAAA,QAAAC,gBAAA,gBAAAC,WAAA,WAAAC,cAAA,cAAAC,aAAA,aAAAC,iBAAA,iBAAAC,uBAAA,uBAAAC,qBAAA,qBAAAC,gBAAA,gBAAAC,sBAAA,sBAAAC,oBAAA,oBAAAC,SAAA,SAAAC,cAAA,cAAAC,eAAA,eAAAC,kBAAA,kBAAAC,WAAA,WAAAC,mBAAA,mBAAAC,gBAAA,gBAAAC,QAAA,UAAAC,gBAAA,gBAAAC,YAAA,YAAAC,gBAAA,gBAAAC,gBAAA,gBAAAC,eAAA,iBAAAC,WAAA,WAAAC,YAAA,YAAAC,cAAA,cAAAC,QAAA,QAAAC,cAAA,cAAAC,cAAA,cAAAC,SAAA,SAAAC,kBAAA,kBAAAC,kBAAA,kBAAAC,WAAA,WAAAC,MAAA,QAAAC,gBAAA,gBAAAC,0BAAA,0BAAAC,WAAA,WAAAC,iBAAA,iBAAAC,YAAA,YAAAC,WAAA,WAAAC,gBAAA,gBAAAC,cAAA,cAAAC,YAAA,YAAAC,oBAAA,oBAAAC,YAAA,YAAAC,iBAAA,iBAAAC,iBAAA,iBAAAC,YAAA,YAAAC,UAAA,UAAAC,aAAA,aAAAC,UAAA,UAAAC,sBAAA,sBAAAC,YAAA,YAAAC,UAAA,UAAAC,gBAAA,gBAAAC,eAAA,eAAAC,WAAA,WAAAC,iBAAA,iBAAAC,gCAAA,gCAAAC,UAAA,UAAAC,oBAAA,oBAAAC,mBAAA,mBAAAC,mBAAA,mBAAAC,YAAA,YAAAC,aAAA,aAAAC,WAAA,WAAAC,SAAA,SAAAC,UAAA,UAAAC,YAAA,YAAAC,kBAAA,kBAAAC,UAAA,UAAAC,gBAAA,gBAAAC,SAAA,SAAAC,YAAA,YAAAC,iBAAA,iBAAAC,YAAA,YAAAC,cAAA,cAAAC,gBAAA,gBAAAC,0BAAA,0BAAAC,oBAAA,oBAAAC,gCAAA,gCAAAC,yCAAA,yCAAAC,mBAAA,mBAAAC,mBAAA,mBAAAC,uBAAA,uBAAAC,eAAA,eAAAC,YAAA,YAAAC,iBAAA,iBAAAC,wBAAA,wBAAAC,eAAA,eAAAC,YAAA,YAAAC,aAAA,aAAAC,QAAA,UAAAC,mBAAA,mBAAAC,iBAAA,iBAAAC,sBAAA,sBAAAC,gBAAA,gBAAAC,YAAA,YAAAC,UAAA,UAAAC,eAAA,eAAAC,gBAAA,gBAAAC,gBAAA,gBAAAC,kBAAA,kBAAAC,eAAA,eAAAC,QAAA,QAAAC,WAAA,WAAAC,sBAAA,sBAAAC,aAAA,aAAAC,aAAA,aAAAC,WAAA,aAAAC,iBAAA,iBAAAC,kBAAA,kBAAAC,eAAA,eAAAC,SAAA,SAAAC,SAAA,SAAAC,qBAAA,qBAAAC,UAAA,UAAAC,SAAA,SAAAC,gBAAA,gBAAAC,uBAAA,uBAAAC,aAAA,aAAAC,cAAA,cAAAC,YAAA,YAAAC,WAAA,WAAAC,kBAAA,kBAAAC,UAAA,UAAAC,WAAA,aAAAC,mBAAA,mBAAAC,qBAAA,qBAAAC,kBAAA,kBAAAC,aAAA,aAAAC,cAAA,cAAAC,aAAA,aAAAC,QAAA,QAAAC,YAAA,YAAAC,eAAA,eAAAC,mBAAA,mBAAAC,GAAA,KAAAC,uBAAA,uBAAAC,qBAAA,qBAAAC,WAAA,WAAAC,cAAA,gBAAAC,UAAA,YAAAC,YAAA,YAAAC,iBAAA,iBAAAC,eAAA,eAAAC,SAAA,SAAAC,QAAA,QAAAC,WAAA,WAAAC,YAAA,YAAAC,iBAAA,iBAAAC,kBAAA,kBAAAC,iBAAA,iBAAAC,cAAA,cAAAC,iBAAA,iBAAAC,iBAAA,iBAAAC,UAAA,UAAAC,IAAA,MAAAC,gBAAA,gBAAAC,oBAAA,oBAAAC,iBAAA,iBAAAC,cAAA,cAAAC,iBAAA,iBAAAC,YAAA,YAAAC,qBAAA,qBAAAC,SAAA,SAAAC,oBAAA,oBAAAC,UAAA,UAAAC,sBAAA,sBAAAC,UAAA,UAAAC,WAAA,WAAAC,QAAA,QAAAC,eAAA,eAAAC,kBAAA,kBAAAC,QAAA,QAAAC,gBAAA,gBAAAC,WAAA,WAAAC,aAAA,aAAAC,eAAA,eAAAC,cAAA,cAAAC,gBAAA,gBAAAC,oBAAA,oBAAAC,SAAA,SAAAC,SAAA,WAAAC,kBAAA,kBAAAC,kBAAA,kBAAAC,cAAA,cAAAC,iBAAA,iBAAAC,YAAA,YAAAC,mBAAA,mBAAAC,gBAAA,gBAAAC,iBAAA,iBAAAC,kBAAA,kBAAAC,WAAA,WAAAC,YAAA,YAAAC,eAAA,eAAAC,mBAAA,mBAAAC,cAAA,cAAAC,UAAA,UAAAC,WAAA,WAAAC,eAAA,eAAAC,aAAA,aAAAC,cAAA,cAAAC,cAAA,cAAAC,YAAA,YAAAC,cAAA,cAAAC,qBAAA,qBAAAC,aAAA,aAAAC,UAAA,UAAAC,WAAA,WAAAC,kBAAA,kBAAAC,oBAAA,oBAAAC,YAAA,YAAAC,UAAA,UAAAC,oBAAA,oBAAAC,eAAA,eAAAC,WAAA,WAAAC,oBAAA,oBAAAC,aAAA,aAAAC,SAAA,SAAAC,SAAA,SAAAC,YAAA,YAAAC,KAAA,OAAAC,YAAA,YAAAC,eAAA,eAAAC,QAAA,QAAAC,0BAAA,0BAAAC,WAAA,WAAAC,gBAAA,gBAAAC,mBAAA,mBAAAC,iBAAA,iBAAAC,mBAAA,mBAAAC,SAAA,WAAAC,YAAA,YAAAC,SAAA,SAAAC,gBAAA,gBAAAC,SAAA,SAAAC,UAAA,UAAAC,gBAAA,gBAAAC,eAAA,eAAAC,eAAA,eAAAC,SAAA,WAAAC,qBAAA,qBAAAC,OAAA,SAAAC,mBAAA,mBAAAC,aAAA,aAAAC,iBAAA,iBAAAC,cAAA,cAAAC,oBAAA,oBAAAC,4BAAA,4BAAAC,cAAA,cAAAC,WAAA,WAAAC,YAAA,YAAAC,iBAAA,iBAAAC,aAAA,aAAAC,QAAA,QAAAC,oBAAA,oBAAAC,YAAA,YAAAC,eAAA,eAAAC,eAAA,eAAAC,oBAAA,oBAAAC,eAAA,eAAAC,eAAA,eAAAC,WAAA,WAAAC,iBAAA,iBAAAC,cAAA,cAAAC,gBAAA,gBAAAC,SAAA,SAAAC,aAAA,aAAAC,mBAAA,mBAAAC,yBAAA,yBAAAC,iBAAA,iBAAAC,oBAAA,oBAAAC,YAAA,YAAAC,kBAAA,kBAAAC,aAAA,aAAAC,UAAA,UAAAC,eAAA,eAAAC,oBAAA,oBAAAC,YAAA,YAAAC,aAAA,aAAAC,iCAAA,iCAAAC,qBAAA,qBAAAC,gBAAA,gBAAAC,uBAAA,uBAAAC,WAAA,WAAAC,YAAA,YAAAC,SAAA,SAAAC,aAAA,aAAAC,2BAAA,2BAAAC,GAAA,KAAAC,UAAA,UAAAC,iBAAA,iBAAAC,cAAA,cAAAC,oBAAA,oBAAAC,aAAA,aAAAC,iBAAA,iBAAAC,aAAA,aAAAC,SAAA,WAAAC,UAAA,UAAAC,WAAA,WAAAC,WAAA,WAAAC,kBAAA,kBAAAC,gBAAA,gBAAAC,uBAAA,uBAAAC,eAAA,eAAAC,cAAA,cAAAC,MAAA,QAAAC,GAAA,KAAAC,MAAA,QAAAC,WAAA,WAAAC,qBAAA,qBAAAC,kBAAA,kBAAAC,aAAA,aAAAC,cAAA,cAAAC,yBAAA,yBAAAC,wBAAA,wBAAAC,oBAAA,oBAAAC,aAAA,aAAAC,iBAAA,iBAAAC,SAAA,SAAAC,WAAA,WAAAC,SAAA,SAAAC,YAAA,YAAAC,mBAAA,mBAAAC,iBAAA,iBAAAC,kBAAA,kBAAAC,aAAA,aAAAC,aAAA,aAAAC,IAAA,MAAAC,aAAA,aAAAC,aAAA,aAAAC,WAAA,WAAAC,mBAAA,mBAAAC,YAAA,YAAAC,iBAAA,iBAAAC,sBAAA,sBAAAC,WAAA,WAAAC,YAAA,YAAAC,QAAA,UAAAC,eAAA,eAAAC,gBAAA,gBAAAC,UAAA,UAAAC,sBAAA,sBAAAC,YAAA,YAAAC,aAAA,aAAAC,aAAA,aAAAC,gBAAA,gBAAAC,WAAA,WAAAC,gBAAA,gBAAAC,mBAAA,mBAAAC,WAAA,WAAAC,kBAAA,kBAAAC,YAAA,YAAAC,IAAA,MAAAC,WAAA,WAAAC,aAAA,aAAAC,sCAAA,wCAAAC,gBAAA,gBAAAC,iBAAA,iBAAAC,uBAAA,uBAAAC,gBAAA,gBAAAC,YAAA,YAAAC,YAAA,YAAAC,0BAAA,0BAAAC,YAAA,YAAAC,oBAAA,oBAAAC,UAAA,UAAAC,eAAA,eAAAC,kBAAA,kBAAAC,cAAA,cAAAC,iBAAA,iBAAAC,eAAA,eAAAC,UAAA,UAAAC,sBAAA,sBAAAC,iBAAA,iBAAAC,yBAAA,yBAAAC,WAAA,WAAAC,QAAA,UAAAC,SAAA,SAAAC,aAAA,aAAAC,cAAA,cAAAC,WAAA,WAAAC,WAAA,WAAAC,eAAA,eAAAC,eAAA,eAAAC,mBAAA,mBAAAC,gBAAA,gBAAAC,QAAA,QAAAroB,MAAA,QAAAsoB,UAAA,UAAAC,YAAA,YAAAC,gBAAA,gBAAAC,qBAAA,qBAAAC,WAAA,WAAAC,UAAA,UAAAC,UAAA,UAAAC,gBAAA,gBAAAC,WAAA,WAAAC,cAAA,cAAAC,2BAAA,2BAAAC,cAAA,cAAAC,iBAAA,iBAAAC,WAAA,aAAAC,eAAA,eAAAC,uBAAA,uBAAAC,mBAAA,mBAAAC,kBAAA,kBAAAC,WAAA,WAAAC,kBAAA,kBAAAhoC,QAAA,UAAAioC,kBAAA,kBAAAC,gBAAA,gBAAAC,eAAA,eAAAC,oBAAA,oBAAAC,SAAA,SAAAC,kBAAA,kBAAAC,eAAA,eAAAC,qBAAA,qBAAAC,UAAA,UAAAC,qBAAA,qBAAAC,qBAAA,qBAAAC,gBAAA,gBAAAtqB,KAAA,OAAAuqB,cAAA,cAAAC,aAAA,aAAAC,YAAA,YAAAC,WAAA,WAAAC,eAAA,eAAAC,UAAA,UAAAC,kBAAA,kBAAAC,UAAA,UAAAC,gBAAA,gBAAAC,qBAAA,qBAAAC,MAAA,QAAAC,UAAA,UAAAC,UAAA,UAAAC,cAAA,cAAAC,mBAAA,mBAAAC,eAAA,eAAAC,aAAA,aAAAC,YAAA,YAAAC,gBAAA,gBAAAC,aAAA,aAAAC,cAAA,cAAAC,aAAA,aAAAC,cAAA,cAAAC,aAAA,aAAAC,WAAA,WAAAC,UAAA,UAAAC,UAAA,UAAAC,kBAAA,kBAAAC,cAAA,cAAAC,eAAA,eAAAC,wBAAA,wBAAAC,cAAA,cAAAC,eAAA,eAAAC,oBAAA,oBAAAC,YAAA,YAAAC,UAAA,UAAAC,mBAAA,mBAAAC,YAAA,YAAAC,oBAAA,oBAAAC,eAAA,eAAAC,WAAA,WAAAC,SAAA,SAAAC,qBAAA,qBAAAC,WAAA,WAAAC,0BAAA,0BAAAC,aAAA,aAAAC,UAAA,UAAAC,iBAAA,iBAAAC,yBAAA,yBAAAC,eAAA,eAAAC,QAAA,QAAAC,eAAA,eAAAC,iBAAA,iBAAAC,cAAA,cAAAC,YAAA,YAAAC,aAAA,aAAAC,qBAAA,qBAAAC,kBAAA,kBAAAC,eAAA,eAAAC,YAAA,YAAAC,mBAAA,mBAAAC,WAAA,WAAAC,aAAA,aAAAC,eAAA,eAAAC,eAAA,eAAAC,aAAA,aAAAC,WAAA,WAAAC,cAAA,cAAAC,uBAAA,uBAAAC,eAAA,eAAAC,mBAAA,mBAAAC,uBAAA,uBAAAC,cAAA,cAAAC,SAAA,SAAAC,WAAA,WAAAC,0BAAA,0BAAAC,gBAAA,gBAAAC,kBAAA,kBAAAC,YAAA,YAAAC,cAAA,cAAAC,mBAAA,mBAAAC,kBAAA,kBAAAC,cAAA,cAAAC,aAAA,aAAAC,gBAAA,gBAAAC,cAAA,cAAAC,uBAAA,uBAAAC,qBAAA,qBAAAC,eAAA,eAAAtkC,KAAA,OAAAukC,gBAAA,gBAAAC,cAAA,cAAAC,UAAA,UAAAC,YAAA,YAAAC,gBAAA,gBAAAC,YAAA,YAAAC,cAAA,cAAAC,eAAA,eAAAC,gBAAA,gBAAAC,sBAAA,sBAAAC,cAAA,cAAAC,iBAAA,iBAAAC,YAAA,YAAAC,cAAA,cAAAC,kBAAA,kBAAAC,kBAAA,kBAAAC,kBAAA,kBAAAC,iBAAA,iBAAAC,eAAA,eAAAC,UAAA,UAAAC,kBAAA,kBAAAC,iBAAA,iBAAAC,oBAAA,oBAAAC,YAAA,YAAAC,WAAA,WAAAC,oBAAA,oBAAAC,mBAAA,mBAAAC,GAAA,KAAAC,mBAAA,mBAAAC,uBAAA,uBAAAC,cAAA,cAAAC,aAAA,aAAAC,YAAA,cAAAC,aAAA,aAAAC,YAAA,YAAAC,kBAAA,kBAAAC,sBAAA,sBAAAC,mBAAA,mBAAAC,GAAA,KAAAC,WAAA,WAAAC,eAAA,eAAAC,gBAAA,gBAAAC,eAAA,eAAAC,WAAA,WAAAC,cAAA,cAAAC,iBAAA,iBAAAC,SAAA,SAAAC,gBAAA,gBAAAC,YAAA,YAAAC,kBAAA,kBAAAC,sBAAA,sBAAAC,YAAA,YAAAC,eAAA,eAAAC,mBAAA,mBAAAC,SAAA,SAAAC,eAAA,eAAAC,aAAA,aAAAC,UAAA,UAAAC,aAAA,aAAAC,kBAAA,kBAAAC,uBAAA,uBAAAC,iBAAA,iBAAAC,SAAA,SAAAC,YAAA,YAAAC,UAAA,UAAAC,gBAAA,gBAAAC,uBAAA,uBAAAC,aAAA,aAAAC,YAAA,YAAAC,kBAAA,kBAAAC,mBAAA,mBAAAC,kBAAA,kBAAAC,kBAAA,kBAAAC,kBAAA,kBAAAC,gBAAA,gBAAAC,qBAAA,qBAAAC,YAAA,YAAAC,aAAA,aAAAC,SAAA,SAAAC,UAAA,UAAAC,aAAA,aAAAC,gBAAA,gBAAAC,YAAA,YAAAC,UAAA,UAAAC,SAAA,SAAAC,YAAA,YAAAC,sBAAA,sBAAAC,0BAAA,0BAAAC,mBAAA,mBAAAC,YAAA,YAAAC,mBAAA,mBAAAC,iBAAA,iBAAAC,mBAAA,mBAAAC,mBAAA,mBAAAC,gBAAA,gBAAAC,qBAAA,qBAAAC,eAAA,eAAAC,QAAA,QAAAC,YAAA,YAAAC,eAAA,eAAAC,kBAAA,kBAAAC,yBAAA,yBAAAC,mBAAA,mBAAAC,iBAAA,iBAAAC,aAAA,aAAAC,mBAAA,mBAAAC,YAAA,YAAAC,UAAA,UAAAC,SAAA,SAAAC,iBAAA,iBAAAC,kBAAA,kBAAAC,YAAA,YAAAC,IAAA,MAAAC,YAAA,YAAAC,cAAA,cAAAC,eAAA,eAAAC,sBAAA,sBAAAC,aAAA,aAAAC,qBAAA,qBAAAC,cAAA,cAAAC,cAAA,cAAAC,iBAAA,iBAAAC,qBAAA,qBAAAC,aAAA,aAAAC,SAAA,SAAAC,UAAA,UAAAC,cAAA,cAAAC,mBAAA,mBAAAC,mBAAA,mBAAAC,UAAA,UAAAC,UAAA,UAAAC,cAAA,cAAAC,cAAA,cAAAC,oBAAA,oBAAAC,iBAAA,iBAAAC,WAAA,WAAAC,aAAA,aAAAC,gBAAA,gBAAAC,eAAA,eAAAC,eAAA,eAAAC,oBAAA,oBAAAC,UAAA,UAAAC,yBAAA,yBAAAC,iBAAA,iBAAAC,UAAA,UAAAC,gBAAA,gBAAAC,UAAA,YAAAC,WAAA,WAAAC,WAAA,WAAAC,SAAA,SAAAC,YAAA,YAAAC,gBAAA,gBAAAC,SAAA,WAAAC,YAAA,YAAAC,cAAA,cAAAC,gBAAA,gBAAAC,SAAA,SAAAC,SAAA,WAAAC,oBAAA,oBAAAC,oBAAA,oBAAAC,YAAA,YAAAC,iBAAA,iBAAAC,eAAA,eAAAC,YAAA,YAAAC,MAAA,QAAAC,mBAAA,mBAAAC,iBAAA,iBAAAC,WAAA,WAAAC,iBAAA,iBAAAC,oBAAA,oBAAAC,kBAAA,kBAAAC,yBAAA,yBAAAC,QAAA,QAAAC,cAAA,cAAAC,UAAA,UAAAC,aAAA,aAAAC,sBAAA,sBAAAC,oBAAA,oBAAAC,YAAA,YAAAC,qBAAA,qBAAAC,yBAAA,yBAAAC,WAAA,WAAAC,iBAAA,iBAAAC,UAAA,UAAAC,mBAAA,mBAAAC,cAAA,cAAAC,kBAAA,kBAAAC,aAAA,aAAAC,qBAAA,qBAAAC,gBAAA,gBAAAC,eAAA,eAAAC,OAAA,SAAAC,wBAAA,wBAAAC,UAAA,UAAAC,gBAAA,gBAAAC,kBAAA,kBAAAC,wBAAA,wBAAAC,uBAAA,uBAAAC,UAAA,UAAAC,iBAAA,iBAAAC,aAAA,aAAAC,aAAA,aAAAC,kBAAA,kBAAAC,0BAAA,0BAAAC,gBAAA,gBAAAC,UAAA,UAAAC,WAAA,WAAAC,aAAA,aAAAC,iBAAA,iBAAAC,mBAAA,mBAAAC,WAAA,WAAAC,WAAA,WAAAC,SAAA,SAAAC,uBAAA,uBAAAC,aAAA,aAAAC,kCAAA,kCAAAC,IAAA,MAAAC,oBAAA,oBAAAC,SAAA,SAAAC,iBAAA,iBAAAC,SAAA,SAAAC,GAAA,KAAAC,sBAAA,sBAAAC,sBAAA,sBAAAC,eAAA,eAAAC,qBAAA,qBAAAC,iBAAA,iBAAAC,gBAAA,gBAAAC,sBAAA,sBAAAC,mBAAA,mBAAAC,kBAAA,kBAAAC,WAAA,WAAAC,UAAA,UAAAC,sBAAA,sBAAAC,cAAA,cAAAC,iBAAA,iBAAAC,gBAAA,gBAAAC,iBAAA,iBAAAC,mBAAA,mBAAAC,gBAAA,gBAAAC,WAAA,WAAAC,cAAA,cAAAC,aAAA,aAAAC,gBAAA,gBAAAC,kBAAA,kBAAAC,WAAA,WAAAC,WAAA,WAAAC,eAAA,eAAAC,aAAA,aAAAC,UAAA,UAAAC,qBAAA,qBAAAC,WAAA,WAAAC,cAAA,cAAAC,iBAAA,iBAAAC,WAAA,WAAAC,gBAAA,gBAAAC,cAAA,cAAAC,WAAA,WAAAC,QAAA,UAAAC,+BAAA,+BAAAC,cAAA,cAAAC,sBAAA,sBAAAC,UAAA,UAAAC,aAAA,aAAAC,kBAAA,kBAAAC,gBAAA,gBAAAC,cAAA,cAAAC,UAAA,UAAAC,aAAA,aAAAC,YAAA,YAAAC,oBAAA,oBAAAC,aAAA,aAAAC,UAAA,UAAAC,UAAA,UAAAC,cAAA,cAAAC,gBAAA,gBAAAC,YAAA,YAAAC,cAAA,cAAAC,aAAA,aAAAC,sBAAA,sBAAAC,UAAA,UAAAC,cAAA,cAAAC,WAAA,WAAAC,qBAAA,qBAAAC,iBAAA,iBAAAC,iBAAA,iBAAAC,QAAA,UAAAC,cAAA,cAAAC,iBAAA,iBAAAC,GAAA,KAAAC,YAAA,YAAAC,wBAAA,wBAAAC,oBAAA,oBAAAC,eAAA,eAAAC,gBAAA,gBAAAC,gBAAA,gBAAAC,WAAA,WAAAC,cAAA,cAAAC,gBAAA,gBAAAC,eAAA,eAAAC,4BAAA,4BAAAC,sBAAA,sBAAAC,mBAAA,mBAAAC,QAAA,QAAAC,iBAAA,iBAAAC,UAAA,UAAAC,YAAA,YAAAC,mBAAA,mBAAAC,gBAAA,gBAAAC,kBAAA,kBAAAC,WAAA,WAAAC,yBAAA,yBAAAC,iBAAA,iBAAAC,cAAA,cAAAC,qBAAA,uBlBmxJZC,EACA,SAAUjwD,EAAQD,EAASH,GAEjC,YmBrxJAI,GAAAD,QAAAH,EAAA,KnB6xJMswD,EACA,SAAUlwD,EAAQD,EAASH,GAEjC,YoBhyJA,IAAAuW,GAAAvW,EAAA,EAEAI,GAAAD,QAAAoW,EACAA,EAAA/U,UAAA4c,KAAA,SAAAb,EAAAC,IACA3a,UAAAN,OAAAkC,KAAAgS,KAAA1Q,MAAAtB,KAAA5B,WAAA4B,MACAgS,KAAA,cAAAE,GACApI,WAAA,WACA,KAAAoI,IACK,OpB0yJC45C,EACA,SAAUnwD,EAAQD,EAASH,GAEjC,YqBtyJA,SAAAwwD,GAAA9vD,GACA,GAAAgB,GAAA,GAAA6U,KAAA+H,IAGA,OAFA5c,GAAAka,IAAA,EACAla,EAAAma,IAAAnb,EACAgB,EAjBA,GAAA6U,GAAAvW,EAAA,EAEAI,GAAAD,QAAAoW,CAIA,IAAAk6C,GAAAD,GAAA,GACAE,EAAAF,GAAA,GACAG,EAAAH,EAAA,MACAI,EAAAJ,MAAAr6C,IACA06C,EAAAL,EAAA,GACAM,EAAAN,EAAA,GAQAj6C,GAAAG,QAAA,SAAAhW,GACA,GAAAA,YAAA6V,GAAA,MAAA7V,EAEA,WAAAA,EAAA,MAAAiwD,EACA,QAAAx6C,KAAAzV,EAAA,MAAAkwD,EACA,SAAAlwD,EAAA,MAAA+vD,EACA,SAAA/vD,EAAA,MAAAgwD,EACA,QAAAhwD,EAAA,MAAAmwD,EACA,SAAAnwD,EAAA,MAAAowD,EAEA,oBAAApwD,IAAA,kBAAAA,GACA,IACA,GAAA+V,GAAA/V,EAAA+V,IACA,sBAAAA,GACA,UAAAF,GAAAE,EAAArR,KAAA1E,IAEK,MAAAqa,GACL,UAAAxE,GAAA,SAAAG,EAAA5O,GACAA,EAAAiT,KAIA,MAAAy1C,GAAA9vD,IAGA6V,EAAAtO,IAAA,SAAA8oD,GACA,GAAAnoD,GAAAhE,MAAApD,UAAAmC,MAAApD,KAAAwwD,EAEA,WAAAx6C,GAAA,SAAAG,EAAA5O,GAGA,QAAA2V,GAAApd,EAAAkiB,GACA,GAAAA,IAAA,gBAAAA,IAAA,kBAAAA,IAAA,CACA,GAAAA,YAAAhM,IAAAgM,EAAA9L,OAAAF,EAAA/U,UAAAiV,KAAA,CACA,SAAA8L,EAAA3G,KACA2G,IAAA1G,GAEA,YAAA0G,EAAA3G,IAAA6B,EAAApd,EAAAkiB,EAAA1G,MACA,IAAA0G,EAAA3G,KAAA9T,EAAAya,EAAA1G,SACA0G,GAAA9L,KAAA,SAAA8L,GACA9E,EAAApd,EAAAkiB,IACWza,IAGX,GAAA2O,GAAA8L,EAAA9L,IACA,sBAAAA,GAAA,CAKA,WAJA,IAAAF,GAAAE,EAAArR,KAAAmd,IACA9L,KAAA,SAAA8L,GACA9E,EAAApd,EAAAkiB,IACaza,IAKbc,EAAAvI,GAAAkiB,EACA,KAAAvT,GACA0H,EAAA9N,GA3BA,OAAAA,EAAArG,OAAA,MAAAmU,MA8BA,QA7BA1H,GAAApG,EAAArG,OA6BAlC,EAAA,EAAmBA,EAAAuI,EAAArG,OAAiBlC,IACpCod,EAAApd,EAAAuI,EAAAvI,OAKAkW,EAAAzO,OAAA,SAAApH,GACA,UAAA6V,GAAA,SAAAG,EAAA5O,GACAA,EAAApH,MAIA6V,EAAAy6C,KAAA,SAAAxoD,GACA,UAAA+N,GAAA,SAAAG,EAAA5O,GACAU,EAAA1B,QAAA,SAAApG,GACA6V,EAAAG,QAAAhW,GAAA+V,KAAAC,EAAA5O,QAOAyO,EAAA/U,UAAA,eAAAgc,GACA,MAAA/Y,MAAAgS,KAAA,KAAA+G,KrB8zJMyzC,GACA,SAAU7wD,EAAQD,EAASH,GAEjC,cAC4B,SAAS0e,EAAU9b,EAAGyT,GsBz6JlD,GAAA66C,GAAAlxD,EAAA,IACAmxD,EAAAnxD,EAAA,ItB86JIoxD,EAEJ,SAAgClvD,GAAO,MAAOA,IAAOA,EAAIb,WAAaa,GAAQusB,QAASvsB,IAF5CivD,EsBj7J3CnxD,GAAQ,GAMR,IAAMqxD,GAAM3yC,EAASoD,MAAMvR,QACvBO,UACI0D,GAAI,KACJ8Y,MAAO,KACPgkC,WAAY,KACZhnC,YACApG,IAAK,KACLqtC,WAAY,SAcT,IAVE7yC,EAAS6F,WAAWhU,QAC7B+O,MAAO+xC,EAEPpvC,MAHoC,SAG9BwB,GACF,MAAOA,GAAA,MAGXS,IAAK,2CAKJX,OACDC,QADO,SACC3d,GACJ,GAAI2rD,GAAU5uD,EAAEwS,SAASiB,EAAE,uBAAuBqa,QAC9C+gC,EAAgB5rD,EAAWsE,QAAQ,SAAAwB,GAAA,MAAKA,GAAExK,IAAI,YAAYuwD,QAE9D,EAAAR,EAAA1gC,gBACIna,EAAE,qCACFzT,EAAEP,KAAKovD,GAAe7nD,OAAO+nD,UAC7B,SAAAD,GAAA,OAAWl9C,GAAIi9C,EAAcC,GAAM,GAAGvwD,IAAI,MAAOmsB,MAAOokC,EAAM5gC,QAAS0gC,GAAUI,KAAMH,EAAcC,QAGzGr7C,EAAE,4CAA4CxP,KAAK,YAAa,EAAAuqD,EAAA3iC,SAAmBpY,EAAE5R,ctBu7JhElE,KAAKJ,EAASH,EAAoB,GAAIA,EAAoB,GAAIA,EAAoB","file":"employment-bef109a214aa0e57ba54.bundle.js","sourcesContent":["/******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n/******/\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n/******/\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId]) {\n/******/ \t\t\treturn installedModules[moduleId].exports;\n/******/ \t\t}\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\ti: moduleId,\n/******/ \t\t\tl: false,\n/******/ \t\t\texports: {}\n/******/ \t\t};\n/******/\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n/******/\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.l = true;\n/******/\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n/******/\n/******/\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n/******/\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n/******/\n/******/ \t// identity function for calling harmony imports with the correct context\n/******/ \t__webpack_require__.i = function(value) { return value; };\n/******/\n/******/ \t// define getter function for harmony exports\n/******/ \t__webpack_require__.d = function(exports, name, getter) {\n/******/ \t\tif(!__webpack_require__.o(exports, name)) {\n/******/ \t\t\tObject.defineProperty(exports, name, {\n/******/ \t\t\t\tconfigurable: false,\n/******/ \t\t\t\tenumerable: true,\n/******/ \t\t\t\tget: getter\n/******/ \t\t\t});\n/******/ \t\t}\n/******/ \t};\n/******/\n/******/ \t// getDefaultExport function for compatibility with non-harmony modules\n/******/ \t__webpack_require__.n = function(module) {\n/******/ \t\tvar getter = module && module.__esModule ?\n/******/ \t\t\tfunction getDefault() { return module['default']; } :\n/******/ \t\t\tfunction getModuleExports() { return module; };\n/******/ \t\t__webpack_require__.d(getter, 'a', getter);\n/******/ \t\treturn getter;\n/******/ \t};\n/******/\n/******/ \t// Object.prototype.hasOwnProperty.call\n/******/ \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n/******/\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(__webpack_require__.s = 91);\n/******/ })\n/************************************************************************/\n/******/ ({\n\n/***/ 0:\n/***/ (function(module, exports, __webpack_require__) {\n\nvar __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;//     Underscore.js 1.8.3\n//     http://underscorejs.org\n//     (c) 2009-2015 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n//     Underscore may be freely distributed under the MIT license.\n\n(function() {\n\n  // Baseline setup\n  // --------------\n\n  // Establish the root object, `window` in the browser, or `exports` on the server.\n  var root = this;\n\n  // Save the previous value of the `_` variable.\n  var previousUnderscore = root._;\n\n  // Save bytes in the minified (but not gzipped) version:\n  var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype;\n\n  // Create quick reference variables for speed access to core prototypes.\n  var\n    push             = ArrayProto.push,\n    slice            = ArrayProto.slice,\n    toString         = ObjProto.toString,\n    hasOwnProperty   = ObjProto.hasOwnProperty;\n\n  // All **ECMAScript 5** native function implementations that we hope to use\n  // are declared here.\n  var\n    nativeIsArray      = Array.isArray,\n    nativeKeys         = Object.keys,\n    nativeBind         = FuncProto.bind,\n    nativeCreate       = Object.create;\n\n  // Naked function reference for surrogate-prototype-swapping.\n  var Ctor = function(){};\n\n  // Create a safe reference to the Underscore object for use below.\n  var _ = function(obj) {\n    if (obj instanceof _) return obj;\n    if (!(this instanceof _)) return new _(obj);\n    this._wrapped = obj;\n  };\n\n  // Export the Underscore object for **Node.js**, with\n  // backwards-compatibility for the old `require()` API. If we're in\n  // the browser, add `_` as a global object.\n  if (true) {\n    if (typeof module !== 'undefined' && module.exports) {\n      exports = module.exports = _;\n    }\n    exports._ = _;\n  } else {\n    root._ = _;\n  }\n\n  // Current version.\n  _.VERSION = '1.8.3';\n\n  // Internal function that returns an efficient (for current engines) version\n  // of the passed-in callback, to be repeatedly applied in other Underscore\n  // functions.\n  var optimizeCb = function(func, context, argCount) {\n    if (context === void 0) return func;\n    switch (argCount == null ? 3 : argCount) {\n      case 1: return function(value) {\n        return func.call(context, value);\n      };\n      case 2: return function(value, other) {\n        return func.call(context, value, other);\n      };\n      case 3: return function(value, index, collection) {\n        return func.call(context, value, index, collection);\n      };\n      case 4: return function(accumulator, value, index, collection) {\n        return func.call(context, accumulator, value, index, collection);\n      };\n    }\n    return function() {\n      return func.apply(context, arguments);\n    };\n  };\n\n  // A mostly-internal function to generate callbacks that can be applied\n  // to each element in a collection, returning the desired result — either\n  // identity, an arbitrary callback, a property matcher, or a property accessor.\n  var cb = function(value, context, argCount) {\n    if (value == null) return _.identity;\n    if (_.isFunction(value)) return optimizeCb(value, context, argCount);\n    if (_.isObject(value)) return _.matcher(value);\n    return _.property(value);\n  };\n  _.iteratee = function(value, context) {\n    return cb(value, context, Infinity);\n  };\n\n  // An internal function for creating assigner functions.\n  var createAssigner = function(keysFunc, undefinedOnly) {\n    return function(obj) {\n      var length = arguments.length;\n      if (length < 2 || obj == null) return obj;\n      for (var index = 1; index < length; index++) {\n        var source = arguments[index],\n            keys = keysFunc(source),\n            l = keys.length;\n        for (var i = 0; i < l; i++) {\n          var key = keys[i];\n          if (!undefinedOnly || obj[key] === void 0) obj[key] = source[key];\n        }\n      }\n      return obj;\n    };\n  };\n\n  // An internal function for creating a new object that inherits from another.\n  var baseCreate = function(prototype) {\n    if (!_.isObject(prototype)) return {};\n    if (nativeCreate) return nativeCreate(prototype);\n    Ctor.prototype = prototype;\n    var result = new Ctor;\n    Ctor.prototype = null;\n    return result;\n  };\n\n  var property = function(key) {\n    return function(obj) {\n      return obj == null ? void 0 : obj[key];\n    };\n  };\n\n  // Helper for collection methods to determine whether a collection\n  // should be iterated as an array or as an object\n  // Related: http://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength\n  // Avoids a very nasty iOS 8 JIT bug on ARM-64. #2094\n  var MAX_ARRAY_INDEX = Math.pow(2, 53) - 1;\n  var getLength = property('length');\n  var isArrayLike = function(collection) {\n    var length = getLength(collection);\n    return typeof length == 'number' && length >= 0 && length <= MAX_ARRAY_INDEX;\n  };\n\n  // Collection Functions\n  // --------------------\n\n  // The cornerstone, an `each` implementation, aka `forEach`.\n  // Handles raw objects in addition to array-likes. Treats all\n  // sparse array-likes as if they were dense.\n  _.each = _.forEach = function(obj, iteratee, context) {\n    iteratee = optimizeCb(iteratee, context);\n    var i, length;\n    if (isArrayLike(obj)) {\n      for (i = 0, length = obj.length; i < length; i++) {\n        iteratee(obj[i], i, obj);\n      }\n    } else {\n      var keys = _.keys(obj);\n      for (i = 0, length = keys.length; i < length; i++) {\n        iteratee(obj[keys[i]], keys[i], obj);\n      }\n    }\n    return obj;\n  };\n\n  // Return the results of applying the iteratee to each element.\n  _.map = _.collect = function(obj, iteratee, context) {\n    iteratee = cb(iteratee, context);\n    var keys = !isArrayLike(obj) && _.keys(obj),\n        length = (keys || obj).length,\n        results = Array(length);\n    for (var index = 0; index < length; index++) {\n      var currentKey = keys ? keys[index] : index;\n      results[index] = iteratee(obj[currentKey], currentKey, obj);\n    }\n    return results;\n  };\n\n  // Create a reducing function iterating left or right.\n  function createReduce(dir) {\n    // Optimized iterator function as using arguments.length\n    // in the main function will deoptimize the, see #1991.\n    function iterator(obj, iteratee, memo, keys, index, length) {\n      for (; index >= 0 && index < length; index += dir) {\n        var currentKey = keys ? keys[index] : index;\n        memo = iteratee(memo, obj[currentKey], currentKey, obj);\n      }\n      return memo;\n    }\n\n    return function(obj, iteratee, memo, context) {\n      iteratee = optimizeCb(iteratee, context, 4);\n      var keys = !isArrayLike(obj) && _.keys(obj),\n          length = (keys || obj).length,\n          index = dir > 0 ? 0 : length - 1;\n      // Determine the initial value if none is provided.\n      if (arguments.length < 3) {\n        memo = obj[keys ? keys[index] : index];\n        index += dir;\n      }\n      return iterator(obj, iteratee, memo, keys, index, length);\n    };\n  }\n\n  // **Reduce** builds up a single result from a list of values, aka `inject`,\n  // or `foldl`.\n  _.reduce = _.foldl = _.inject = createReduce(1);\n\n  // The right-associative version of reduce, also known as `foldr`.\n  _.reduceRight = _.foldr = createReduce(-1);\n\n  // Return the first value which passes a truth test. Aliased as `detect`.\n  _.find = _.detect = function(obj, predicate, context) {\n    var key;\n    if (isArrayLike(obj)) {\n      key = _.findIndex(obj, predicate, context);\n    } else {\n      key = _.findKey(obj, predicate, context);\n    }\n    if (key !== void 0 && key !== -1) return obj[key];\n  };\n\n  // Return all the elements that pass a truth test.\n  // Aliased as `select`.\n  _.filter = _.select = function(obj, predicate, context) {\n    var results = [];\n    predicate = cb(predicate, context);\n    _.each(obj, function(value, index, list) {\n      if (predicate(value, index, list)) results.push(value);\n    });\n    return results;\n  };\n\n  // Return all the elements for which a truth test fails.\n  _.reject = function(obj, predicate, context) {\n    return _.filter(obj, _.negate(cb(predicate)), context);\n  };\n\n  // Determine whether all of the elements match a truth test.\n  // Aliased as `all`.\n  _.every = _.all = function(obj, predicate, context) {\n    predicate = cb(predicate, context);\n    var keys = !isArrayLike(obj) && _.keys(obj),\n        length = (keys || obj).length;\n    for (var index = 0; index < length; index++) {\n      var currentKey = keys ? keys[index] : index;\n      if (!predicate(obj[currentKey], currentKey, obj)) return false;\n    }\n    return true;\n  };\n\n  // Determine if at least one element in the object matches a truth test.\n  // Aliased as `any`.\n  _.some = _.any = function(obj, predicate, context) {\n    predicate = cb(predicate, context);\n    var keys = !isArrayLike(obj) && _.keys(obj),\n        length = (keys || obj).length;\n    for (var index = 0; index < length; index++) {\n      var currentKey = keys ? keys[index] : index;\n      if (predicate(obj[currentKey], currentKey, obj)) return true;\n    }\n    return false;\n  };\n\n  // Determine if the array or object contains a given item (using `===`).\n  // Aliased as `includes` and `include`.\n  _.contains = _.includes = _.include = function(obj, item, fromIndex, guard) {\n    if (!isArrayLike(obj)) obj = _.values(obj);\n    if (typeof fromIndex != 'number' || guard) fromIndex = 0;\n    return _.indexOf(obj, item, fromIndex) >= 0;\n  };\n\n  // Invoke a method (with arguments) on every item in a collection.\n  _.invoke = function(obj, method) {\n    var args = slice.call(arguments, 2);\n    var isFunc = _.isFunction(method);\n    return _.map(obj, function(value) {\n      var func = isFunc ? method : value[method];\n      return func == null ? func : func.apply(value, args);\n    });\n  };\n\n  // Convenience version of a common use case of `map`: fetching a property.\n  _.pluck = function(obj, key) {\n    return _.map(obj, _.property(key));\n  };\n\n  // Convenience version of a common use case of `filter`: selecting only objects\n  // containing specific `key:value` pairs.\n  _.where = function(obj, attrs) {\n    return _.filter(obj, _.matcher(attrs));\n  };\n\n  // Convenience version of a common use case of `find`: getting the first object\n  // containing specific `key:value` pairs.\n  _.findWhere = function(obj, attrs) {\n    return _.find(obj, _.matcher(attrs));\n  };\n\n  // Return the maximum element (or element-based computation).\n  _.max = function(obj, iteratee, context) {\n    var result = -Infinity, lastComputed = -Infinity,\n        value, computed;\n    if (iteratee == null && obj != null) {\n      obj = isArrayLike(obj) ? obj : _.values(obj);\n      for (var i = 0, length = obj.length; i < length; i++) {\n        value = obj[i];\n        if (value > result) {\n          result = value;\n        }\n      }\n    } else {\n      iteratee = cb(iteratee, context);\n      _.each(obj, function(value, index, list) {\n        computed = iteratee(value, index, list);\n        if (computed > lastComputed || computed === -Infinity && result === -Infinity) {\n          result = value;\n          lastComputed = computed;\n        }\n      });\n    }\n    return result;\n  };\n\n  // Return the minimum element (or element-based computation).\n  _.min = function(obj, iteratee, context) {\n    var result = Infinity, lastComputed = Infinity,\n        value, computed;\n    if (iteratee == null && obj != null) {\n      obj = isArrayLike(obj) ? obj : _.values(obj);\n      for (var i = 0, length = obj.length; i < length; i++) {\n        value = obj[i];\n        if (value < result) {\n          result = value;\n        }\n      }\n    } else {\n      iteratee = cb(iteratee, context);\n      _.each(obj, function(value, index, list) {\n        computed = iteratee(value, index, list);\n        if (computed < lastComputed || computed === Infinity && result === Infinity) {\n          result = value;\n          lastComputed = computed;\n        }\n      });\n    }\n    return result;\n  };\n\n  // Shuffle a collection, using the modern version of the\n  // [Fisher-Yates shuffle](http://en.wikipedia.org/wiki/Fisher–Yates_shuffle).\n  _.shuffle = function(obj) {\n    var set = isArrayLike(obj) ? obj : _.values(obj);\n    var length = set.length;\n    var shuffled = Array(length);\n    for (var index = 0, rand; index < length; index++) {\n      rand = _.random(0, index);\n      if (rand !== index) shuffled[index] = shuffled[rand];\n      shuffled[rand] = set[index];\n    }\n    return shuffled;\n  };\n\n  // Sample **n** random values from a collection.\n  // If **n** is not specified, returns a single random element.\n  // The internal `guard` argument allows it to work with `map`.\n  _.sample = function(obj, n, guard) {\n    if (n == null || guard) {\n      if (!isArrayLike(obj)) obj = _.values(obj);\n      return obj[_.random(obj.length - 1)];\n    }\n    return _.shuffle(obj).slice(0, Math.max(0, n));\n  };\n\n  // Sort the object's values by a criterion produced by an iteratee.\n  _.sortBy = function(obj, iteratee, context) {\n    iteratee = cb(iteratee, context);\n    return _.pluck(_.map(obj, function(value, index, list) {\n      return {\n        value: value,\n        index: index,\n        criteria: iteratee(value, index, list)\n      };\n    }).sort(function(left, right) {\n      var a = left.criteria;\n      var b = right.criteria;\n      if (a !== b) {\n        if (a > b || a === void 0) return 1;\n        if (a < b || b === void 0) return -1;\n      }\n      return left.index - right.index;\n    }), 'value');\n  };\n\n  // An internal function used for aggregate \"group by\" operations.\n  var group = function(behavior) {\n    return function(obj, iteratee, context) {\n      var result = {};\n      iteratee = cb(iteratee, context);\n      _.each(obj, function(value, index) {\n        var key = iteratee(value, index, obj);\n        behavior(result, value, key);\n      });\n      return result;\n    };\n  };\n\n  // Groups the object's values by a criterion. Pass either a string attribute\n  // to group by, or a function that returns the criterion.\n  _.groupBy = group(function(result, value, key) {\n    if (_.has(result, key)) result[key].push(value); else result[key] = [value];\n  });\n\n  // Indexes the object's values by a criterion, similar to `groupBy`, but for\n  // when you know that your index values will be unique.\n  _.indexBy = group(function(result, value, key) {\n    result[key] = value;\n  });\n\n  // Counts instances of an object that group by a certain criterion. Pass\n  // either a string attribute to count by, or a function that returns the\n  // criterion.\n  _.countBy = group(function(result, value, key) {\n    if (_.has(result, key)) result[key]++; else result[key] = 1;\n  });\n\n  // Safely create a real, live array from anything iterable.\n  _.toArray = function(obj) {\n    if (!obj) return [];\n    if (_.isArray(obj)) return slice.call(obj);\n    if (isArrayLike(obj)) return _.map(obj, _.identity);\n    return _.values(obj);\n  };\n\n  // Return the number of elements in an object.\n  _.size = function(obj) {\n    if (obj == null) return 0;\n    return isArrayLike(obj) ? obj.length : _.keys(obj).length;\n  };\n\n  // Split a collection into two arrays: one whose elements all satisfy the given\n  // predicate, and one whose elements all do not satisfy the predicate.\n  _.partition = function(obj, predicate, context) {\n    predicate = cb(predicate, context);\n    var pass = [], fail = [];\n    _.each(obj, function(value, key, obj) {\n      (predicate(value, key, obj) ? pass : fail).push(value);\n    });\n    return [pass, fail];\n  };\n\n  // Array Functions\n  // ---------------\n\n  // Get the first element of an array. Passing **n** will return the first N\n  // values in the array. Aliased as `head` and `take`. The **guard** check\n  // allows it to work with `_.map`.\n  _.first = _.head = _.take = function(array, n, guard) {\n    if (array == null) return void 0;\n    if (n == null || guard) return array[0];\n    return _.initial(array, array.length - n);\n  };\n\n  // Returns everything but the last entry of the array. Especially useful on\n  // the arguments object. Passing **n** will return all the values in\n  // the array, excluding the last N.\n  _.initial = function(array, n, guard) {\n    return slice.call(array, 0, Math.max(0, array.length - (n == null || guard ? 1 : n)));\n  };\n\n  // Get the last element of an array. Passing **n** will return the last N\n  // values in the array.\n  _.last = function(array, n, guard) {\n    if (array == null) return void 0;\n    if (n == null || guard) return array[array.length - 1];\n    return _.rest(array, Math.max(0, array.length - n));\n  };\n\n  // Returns everything but the first entry of the array. Aliased as `tail` and `drop`.\n  // Especially useful on the arguments object. Passing an **n** will return\n  // the rest N values in the array.\n  _.rest = _.tail = _.drop = function(array, n, guard) {\n    return slice.call(array, n == null || guard ? 1 : n);\n  };\n\n  // Trim out all falsy values from an array.\n  _.compact = function(array) {\n    return _.filter(array, _.identity);\n  };\n\n  // Internal implementation of a recursive `flatten` function.\n  var flatten = function(input, shallow, strict, startIndex) {\n    var output = [], idx = 0;\n    for (var i = startIndex || 0, length = getLength(input); i < length; i++) {\n      var value = input[i];\n      if (isArrayLike(value) && (_.isArray(value) || _.isArguments(value))) {\n        //flatten current level of array or arguments object\n        if (!shallow) value = flatten(value, shallow, strict);\n        var j = 0, len = value.length;\n        output.length += len;\n        while (j < len) {\n          output[idx++] = value[j++];\n        }\n      } else if (!strict) {\n        output[idx++] = value;\n      }\n    }\n    return output;\n  };\n\n  // Flatten out an array, either recursively (by default), or just one level.\n  _.flatten = function(array, shallow) {\n    return flatten(array, shallow, false);\n  };\n\n  // Return a version of the array that does not contain the specified value(s).\n  _.without = function(array) {\n    return _.difference(array, slice.call(arguments, 1));\n  };\n\n  // Produce a duplicate-free version of the array. If the array has already\n  // been sorted, you have the option of using a faster algorithm.\n  // Aliased as `unique`.\n  _.uniq = _.unique = function(array, isSorted, iteratee, context) {\n    if (!_.isBoolean(isSorted)) {\n      context = iteratee;\n      iteratee = isSorted;\n      isSorted = false;\n    }\n    if (iteratee != null) iteratee = cb(iteratee, context);\n    var result = [];\n    var seen = [];\n    for (var i = 0, length = getLength(array); i < length; i++) {\n      var value = array[i],\n          computed = iteratee ? iteratee(value, i, array) : value;\n      if (isSorted) {\n        if (!i || seen !== computed) result.push(value);\n        seen = computed;\n      } else if (iteratee) {\n        if (!_.contains(seen, computed)) {\n          seen.push(computed);\n          result.push(value);\n        }\n      } else if (!_.contains(result, value)) {\n        result.push(value);\n      }\n    }\n    return result;\n  };\n\n  // Produce an array that contains the union: each distinct element from all of\n  // the passed-in arrays.\n  _.union = function() {\n    return _.uniq(flatten(arguments, true, true));\n  };\n\n  // Produce an array that contains every item shared between all the\n  // passed-in arrays.\n  _.intersection = function(array) {\n    var result = [];\n    var argsLength = arguments.length;\n    for (var i = 0, length = getLength(array); i < length; i++) {\n      var item = array[i];\n      if (_.contains(result, item)) continue;\n      for (var j = 1; j < argsLength; j++) {\n        if (!_.contains(arguments[j], item)) break;\n      }\n      if (j === argsLength) result.push(item);\n    }\n    return result;\n  };\n\n  // Take the difference between one array and a number of other arrays.\n  // Only the elements present in just the first array will remain.\n  _.difference = function(array) {\n    var rest = flatten(arguments, true, true, 1);\n    return _.filter(array, function(value){\n      return !_.contains(rest, value);\n    });\n  };\n\n  // Zip together multiple lists into a single array -- elements that share\n  // an index go together.\n  _.zip = function() {\n    return _.unzip(arguments);\n  };\n\n  // Complement of _.zip. Unzip accepts an array of arrays and groups\n  // each array's elements on shared indices\n  _.unzip = function(array) {\n    var length = array && _.max(array, getLength).length || 0;\n    var result = Array(length);\n\n    for (var index = 0; index < length; index++) {\n      result[index] = _.pluck(array, index);\n    }\n    return result;\n  };\n\n  // Converts lists into objects. Pass either a single array of `[key, value]`\n  // pairs, or two parallel arrays of the same length -- one of keys, and one of\n  // the corresponding values.\n  _.object = function(list, values) {\n    var result = {};\n    for (var i = 0, length = getLength(list); i < length; i++) {\n      if (values) {\n        result[list[i]] = values[i];\n      } else {\n        result[list[i][0]] = list[i][1];\n      }\n    }\n    return result;\n  };\n\n  // Generator function to create the findIndex and findLastIndex functions\n  function createPredicateIndexFinder(dir) {\n    return function(array, predicate, context) {\n      predicate = cb(predicate, context);\n      var length = getLength(array);\n      var index = dir > 0 ? 0 : length - 1;\n      for (; index >= 0 && index < length; index += dir) {\n        if (predicate(array[index], index, array)) return index;\n      }\n      return -1;\n    };\n  }\n\n  // Returns the first index on an array-like that passes a predicate test\n  _.findIndex = createPredicateIndexFinder(1);\n  _.findLastIndex = createPredicateIndexFinder(-1);\n\n  // Use a comparator function to figure out the smallest index at which\n  // an object should be inserted so as to maintain order. Uses binary search.\n  _.sortedIndex = function(array, obj, iteratee, context) {\n    iteratee = cb(iteratee, context, 1);\n    var value = iteratee(obj);\n    var low = 0, high = getLength(array);\n    while (low < high) {\n      var mid = Math.floor((low + high) / 2);\n      if (iteratee(array[mid]) < value) low = mid + 1; else high = mid;\n    }\n    return low;\n  };\n\n  // Generator function to create the indexOf and lastIndexOf functions\n  function createIndexFinder(dir, predicateFind, sortedIndex) {\n    return function(array, item, idx) {\n      var i = 0, length = getLength(array);\n      if (typeof idx == 'number') {\n        if (dir > 0) {\n            i = idx >= 0 ? idx : Math.max(idx + length, i);\n        } else {\n            length = idx >= 0 ? Math.min(idx + 1, length) : idx + length + 1;\n        }\n      } else if (sortedIndex && idx && length) {\n        idx = sortedIndex(array, item);\n        return array[idx] === item ? idx : -1;\n      }\n      if (item !== item) {\n        idx = predicateFind(slice.call(array, i, length), _.isNaN);\n        return idx >= 0 ? idx + i : -1;\n      }\n      for (idx = dir > 0 ? i : length - 1; idx >= 0 && idx < length; idx += dir) {\n        if (array[idx] === item) return idx;\n      }\n      return -1;\n    };\n  }\n\n  // Return the position of the first occurrence of an item in an array,\n  // or -1 if the item is not included in the array.\n  // If the array is large and already in sort order, pass `true`\n  // for **isSorted** to use binary search.\n  _.indexOf = createIndexFinder(1, _.findIndex, _.sortedIndex);\n  _.lastIndexOf = createIndexFinder(-1, _.findLastIndex);\n\n  // Generate an integer Array containing an arithmetic progression. A port of\n  // the native Python `range()` function. See\n  // [the Python documentation](http://docs.python.org/library/functions.html#range).\n  _.range = function(start, stop, step) {\n    if (stop == null) {\n      stop = start || 0;\n      start = 0;\n    }\n    step = step || 1;\n\n    var length = Math.max(Math.ceil((stop - start) / step), 0);\n    var range = Array(length);\n\n    for (var idx = 0; idx < length; idx++, start += step) {\n      range[idx] = start;\n    }\n\n    return range;\n  };\n\n  // Function (ahem) Functions\n  // ------------------\n\n  // Determines whether to execute a function as a constructor\n  // or a normal function with the provided arguments\n  var executeBound = function(sourceFunc, boundFunc, context, callingContext, args) {\n    if (!(callingContext instanceof boundFunc)) return sourceFunc.apply(context, args);\n    var self = baseCreate(sourceFunc.prototype);\n    var result = sourceFunc.apply(self, args);\n    if (_.isObject(result)) return result;\n    return self;\n  };\n\n  // Create a function bound to a given object (assigning `this`, and arguments,\n  // optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if\n  // available.\n  _.bind = function(func, context) {\n    if (nativeBind && func.bind === nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));\n    if (!_.isFunction(func)) throw new TypeError('Bind must be called on a function');\n    var args = slice.call(arguments, 2);\n    var bound = function() {\n      return executeBound(func, bound, context, this, args.concat(slice.call(arguments)));\n    };\n    return bound;\n  };\n\n  // Partially apply a function by creating a version that has had some of its\n  // arguments pre-filled, without changing its dynamic `this` context. _ acts\n  // as a placeholder, allowing any combination of arguments to be pre-filled.\n  _.partial = function(func) {\n    var boundArgs = slice.call(arguments, 1);\n    var bound = function() {\n      var position = 0, length = boundArgs.length;\n      var args = Array(length);\n      for (var i = 0; i < length; i++) {\n        args[i] = boundArgs[i] === _ ? arguments[position++] : boundArgs[i];\n      }\n      while (position < arguments.length) args.push(arguments[position++]);\n      return executeBound(func, bound, this, this, args);\n    };\n    return bound;\n  };\n\n  // Bind a number of an object's methods to that object. Remaining arguments\n  // are the method names to be bound. Useful for ensuring that all callbacks\n  // defined on an object belong to it.\n  _.bindAll = function(obj) {\n    var i, length = arguments.length, key;\n    if (length <= 1) throw new Error('bindAll must be passed function names');\n    for (i = 1; i < length; i++) {\n      key = arguments[i];\n      obj[key] = _.bind(obj[key], obj);\n    }\n    return obj;\n  };\n\n  // Memoize an expensive function by storing its results.\n  _.memoize = function(func, hasher) {\n    var memoize = function(key) {\n      var cache = memoize.cache;\n      var address = '' + (hasher ? hasher.apply(this, arguments) : key);\n      if (!_.has(cache, address)) cache[address] = func.apply(this, arguments);\n      return cache[address];\n    };\n    memoize.cache = {};\n    return memoize;\n  };\n\n  // Delays a function for the given number of milliseconds, and then calls\n  // it with the arguments supplied.\n  _.delay = function(func, wait) {\n    var args = slice.call(arguments, 2);\n    return setTimeout(function(){\n      return func.apply(null, args);\n    }, wait);\n  };\n\n  // Defers a function, scheduling it to run after the current call stack has\n  // cleared.\n  _.defer = _.partial(_.delay, _, 1);\n\n  // Returns a function, that, when invoked, will only be triggered at most once\n  // during a given window of time. Normally, the throttled function will run\n  // as much as it can, without ever going more than once per `wait` duration;\n  // but if you'd like to disable the execution on the leading edge, pass\n  // `{leading: false}`. To disable execution on the trailing edge, ditto.\n  _.throttle = function(func, wait, options) {\n    var context, args, result;\n    var timeout = null;\n    var previous = 0;\n    if (!options) options = {};\n    var later = function() {\n      previous = options.leading === false ? 0 : _.now();\n      timeout = null;\n      result = func.apply(context, args);\n      if (!timeout) context = args = null;\n    };\n    return function() {\n      var now = _.now();\n      if (!previous && options.leading === false) previous = now;\n      var remaining = wait - (now - previous);\n      context = this;\n      args = arguments;\n      if (remaining <= 0 || remaining > wait) {\n        if (timeout) {\n          clearTimeout(timeout);\n          timeout = null;\n        }\n        previous = now;\n        result = func.apply(context, args);\n        if (!timeout) context = args = null;\n      } else if (!timeout && options.trailing !== false) {\n        timeout = setTimeout(later, remaining);\n      }\n      return result;\n    };\n  };\n\n  // Returns a function, that, as long as it continues to be invoked, will not\n  // be triggered. The function will be called after it stops being called for\n  // N milliseconds. If `immediate` is passed, trigger the function on the\n  // leading edge, instead of the trailing.\n  _.debounce = function(func, wait, immediate) {\n    var timeout, args, context, timestamp, result;\n\n    var later = function() {\n      var last = _.now() - timestamp;\n\n      if (last < wait && last >= 0) {\n        timeout = setTimeout(later, wait - last);\n      } else {\n        timeout = null;\n        if (!immediate) {\n          result = func.apply(context, args);\n          if (!timeout) context = args = null;\n        }\n      }\n    };\n\n    return function() {\n      context = this;\n      args = arguments;\n      timestamp = _.now();\n      var callNow = immediate && !timeout;\n      if (!timeout) timeout = setTimeout(later, wait);\n      if (callNow) {\n        result = func.apply(context, args);\n        context = args = null;\n      }\n\n      return result;\n    };\n  };\n\n  // Returns the first function passed as an argument to the second,\n  // allowing you to adjust arguments, run code before and after, and\n  // conditionally execute the original function.\n  _.wrap = function(func, wrapper) {\n    return _.partial(wrapper, func);\n  };\n\n  // Returns a negated version of the passed-in predicate.\n  _.negate = function(predicate) {\n    return function() {\n      return !predicate.apply(this, arguments);\n    };\n  };\n\n  // Returns a function that is the composition of a list of functions, each\n  // consuming the return value of the function that follows.\n  _.compose = function() {\n    var args = arguments;\n    var start = args.length - 1;\n    return function() {\n      var i = start;\n      var result = args[start].apply(this, arguments);\n      while (i--) result = args[i].call(this, result);\n      return result;\n    };\n  };\n\n  // Returns a function that will only be executed on and after the Nth call.\n  _.after = function(times, func) {\n    return function() {\n      if (--times < 1) {\n        return func.apply(this, arguments);\n      }\n    };\n  };\n\n  // Returns a function that will only be executed up to (but not including) the Nth call.\n  _.before = function(times, func) {\n    var memo;\n    return function() {\n      if (--times > 0) {\n        memo = func.apply(this, arguments);\n      }\n      if (times <= 1) func = null;\n      return memo;\n    };\n  };\n\n  // Returns a function that will be executed at most one time, no matter how\n  // often you call it. Useful for lazy initialization.\n  _.once = _.partial(_.before, 2);\n\n  // Object Functions\n  // ----------------\n\n  // Keys in IE < 9 that won't be iterated by `for key in ...` and thus missed.\n  var hasEnumBug = !{toString: null}.propertyIsEnumerable('toString');\n  var nonEnumerableProps = ['valueOf', 'isPrototypeOf', 'toString',\n                      'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];\n\n  function collectNonEnumProps(obj, keys) {\n    var nonEnumIdx = nonEnumerableProps.length;\n    var constructor = obj.constructor;\n    var proto = (_.isFunction(constructor) && constructor.prototype) || ObjProto;\n\n    // Constructor is a special case.\n    var prop = 'constructor';\n    if (_.has(obj, prop) && !_.contains(keys, prop)) keys.push(prop);\n\n    while (nonEnumIdx--) {\n      prop = nonEnumerableProps[nonEnumIdx];\n      if (prop in obj && obj[prop] !== proto[prop] && !_.contains(keys, prop)) {\n        keys.push(prop);\n      }\n    }\n  }\n\n  // Retrieve the names of an object's own properties.\n  // Delegates to **ECMAScript 5**'s native `Object.keys`\n  _.keys = function(obj) {\n    if (!_.isObject(obj)) return [];\n    if (nativeKeys) return nativeKeys(obj);\n    var keys = [];\n    for (var key in obj) if (_.has(obj, key)) keys.push(key);\n    // Ahem, IE < 9.\n    if (hasEnumBug) collectNonEnumProps(obj, keys);\n    return keys;\n  };\n\n  // Retrieve all the property names of an object.\n  _.allKeys = function(obj) {\n    if (!_.isObject(obj)) return [];\n    var keys = [];\n    for (var key in obj) keys.push(key);\n    // Ahem, IE < 9.\n    if (hasEnumBug) collectNonEnumProps(obj, keys);\n    return keys;\n  };\n\n  // Retrieve the values of an object's properties.\n  _.values = function(obj) {\n    var keys = _.keys(obj);\n    var length = keys.length;\n    var values = Array(length);\n    for (var i = 0; i < length; i++) {\n      values[i] = obj[keys[i]];\n    }\n    return values;\n  };\n\n  // Returns the results of applying the iteratee to each element of the object\n  // In contrast to _.map it returns an object\n  _.mapObject = function(obj, iteratee, context) {\n    iteratee = cb(iteratee, context);\n    var keys =  _.keys(obj),\n          length = keys.length,\n          results = {},\n          currentKey;\n      for (var index = 0; index < length; index++) {\n        currentKey = keys[index];\n        results[currentKey] = iteratee(obj[currentKey], currentKey, obj);\n      }\n      return results;\n  };\n\n  // Convert an object into a list of `[key, value]` pairs.\n  _.pairs = function(obj) {\n    var keys = _.keys(obj);\n    var length = keys.length;\n    var pairs = Array(length);\n    for (var i = 0; i < length; i++) {\n      pairs[i] = [keys[i], obj[keys[i]]];\n    }\n    return pairs;\n  };\n\n  // Invert the keys and values of an object. The values must be serializable.\n  _.invert = function(obj) {\n    var result = {};\n    var keys = _.keys(obj);\n    for (var i = 0, length = keys.length; i < length; i++) {\n      result[obj[keys[i]]] = keys[i];\n    }\n    return result;\n  };\n\n  // Return a sorted list of the function names available on the object.\n  // Aliased as `methods`\n  _.functions = _.methods = function(obj) {\n    var names = [];\n    for (var key in obj) {\n      if (_.isFunction(obj[key])) names.push(key);\n    }\n    return names.sort();\n  };\n\n  // Extend a given object with all the properties in passed-in object(s).\n  _.extend = createAssigner(_.allKeys);\n\n  // Assigns a given object with all the own properties in the passed-in object(s)\n  // (https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/assign)\n  _.extendOwn = _.assign = createAssigner(_.keys);\n\n  // Returns the first key on an object that passes a predicate test\n  _.findKey = function(obj, predicate, context) {\n    predicate = cb(predicate, context);\n    var keys = _.keys(obj), key;\n    for (var i = 0, length = keys.length; i < length; i++) {\n      key = keys[i];\n      if (predicate(obj[key], key, obj)) return key;\n    }\n  };\n\n  // Return a copy of the object only containing the whitelisted properties.\n  _.pick = function(object, oiteratee, context) {\n    var result = {}, obj = object, iteratee, keys;\n    if (obj == null) return result;\n    if (_.isFunction(oiteratee)) {\n      keys = _.allKeys(obj);\n      iteratee = optimizeCb(oiteratee, context);\n    } else {\n      keys = flatten(arguments, false, false, 1);\n      iteratee = function(value, key, obj) { return key in obj; };\n      obj = Object(obj);\n    }\n    for (var i = 0, length = keys.length; i < length; i++) {\n      var key = keys[i];\n      var value = obj[key];\n      if (iteratee(value, key, obj)) result[key] = value;\n    }\n    return result;\n  };\n\n   // Return a copy of the object without the blacklisted properties.\n  _.omit = function(obj, iteratee, context) {\n    if (_.isFunction(iteratee)) {\n      iteratee = _.negate(iteratee);\n    } else {\n      var keys = _.map(flatten(arguments, false, false, 1), String);\n      iteratee = function(value, key) {\n        return !_.contains(keys, key);\n      };\n    }\n    return _.pick(obj, iteratee, context);\n  };\n\n  // Fill in a given object with default properties.\n  _.defaults = createAssigner(_.allKeys, true);\n\n  // Creates an object that inherits from the given prototype object.\n  // If additional properties are provided then they will be added to the\n  // created object.\n  _.create = function(prototype, props) {\n    var result = baseCreate(prototype);\n    if (props) _.extendOwn(result, props);\n    return result;\n  };\n\n  // Create a (shallow-cloned) duplicate of an object.\n  _.clone = function(obj) {\n    if (!_.isObject(obj)) return obj;\n    return _.isArray(obj) ? obj.slice() : _.extend({}, obj);\n  };\n\n  // Invokes interceptor with the obj, and then returns obj.\n  // The primary purpose of this method is to \"tap into\" a method chain, in\n  // order to perform operations on intermediate results within the chain.\n  _.tap = function(obj, interceptor) {\n    interceptor(obj);\n    return obj;\n  };\n\n  // Returns whether an object has a given set of `key:value` pairs.\n  _.isMatch = function(object, attrs) {\n    var keys = _.keys(attrs), length = keys.length;\n    if (object == null) return !length;\n    var obj = Object(object);\n    for (var i = 0; i < length; i++) {\n      var key = keys[i];\n      if (attrs[key] !== obj[key] || !(key in obj)) return false;\n    }\n    return true;\n  };\n\n\n  // Internal recursive comparison function for `isEqual`.\n  var eq = function(a, b, aStack, bStack) {\n    // Identical objects are equal. `0 === -0`, but they aren't identical.\n    // See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal).\n    if (a === b) return a !== 0 || 1 / a === 1 / b;\n    // A strict comparison is necessary because `null == undefined`.\n    if (a == null || b == null) return a === b;\n    // Unwrap any wrapped objects.\n    if (a instanceof _) a = a._wrapped;\n    if (b instanceof _) b = b._wrapped;\n    // Compare `[[Class]]` names.\n    var className = toString.call(a);\n    if (className !== toString.call(b)) return false;\n    switch (className) {\n      // Strings, numbers, regular expressions, dates, and booleans are compared by value.\n      case '[object RegExp]':\n      // RegExps are coerced to strings for comparison (Note: '' + /a/i === '/a/i')\n      case '[object String]':\n        // Primitives and their corresponding object wrappers are equivalent; thus, `\"5\"` is\n        // equivalent to `new String(\"5\")`.\n        return '' + a === '' + b;\n      case '[object Number]':\n        // `NaN`s are equivalent, but non-reflexive.\n        // Object(NaN) is equivalent to NaN\n        if (+a !== +a) return +b !== +b;\n        // An `egal` comparison is performed for other numeric values.\n        return +a === 0 ? 1 / +a === 1 / b : +a === +b;\n      case '[object Date]':\n      case '[object Boolean]':\n        // Coerce dates and booleans to numeric primitive values. Dates are compared by their\n        // millisecond representations. Note that invalid dates with millisecond representations\n        // of `NaN` are not equivalent.\n        return +a === +b;\n    }\n\n    var areArrays = className === '[object Array]';\n    if (!areArrays) {\n      if (typeof a != 'object' || typeof b != 'object') return false;\n\n      // Objects with different constructors are not equivalent, but `Object`s or `Array`s\n      // from different frames are.\n      var aCtor = a.constructor, bCtor = b.constructor;\n      if (aCtor !== bCtor && !(_.isFunction(aCtor) && aCtor instanceof aCtor &&\n                               _.isFunction(bCtor) && bCtor instanceof bCtor)\n                          && ('constructor' in a && 'constructor' in b)) {\n        return false;\n      }\n    }\n    // Assume equality for cyclic structures. The algorithm for detecting cyclic\n    // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.\n\n    // Initializing stack of traversed objects.\n    // It's done here since we only need them for objects and arrays comparison.\n    aStack = aStack || [];\n    bStack = bStack || [];\n    var length = aStack.length;\n    while (length--) {\n      // Linear search. Performance is inversely proportional to the number of\n      // unique nested structures.\n      if (aStack[length] === a) return bStack[length] === b;\n    }\n\n    // Add the first object to the stack of traversed objects.\n    aStack.push(a);\n    bStack.push(b);\n\n    // Recursively compare objects and arrays.\n    if (areArrays) {\n      // Compare array lengths to determine if a deep comparison is necessary.\n      length = a.length;\n      if (length !== b.length) return false;\n      // Deep compare the contents, ignoring non-numeric properties.\n      while (length--) {\n        if (!eq(a[length], b[length], aStack, bStack)) return false;\n      }\n    } else {\n      // Deep compare objects.\n      var keys = _.keys(a), key;\n      length = keys.length;\n      // Ensure that both objects contain the same number of properties before comparing deep equality.\n      if (_.keys(b).length !== length) return false;\n      while (length--) {\n        // Deep compare each member\n        key = keys[length];\n        if (!(_.has(b, key) && eq(a[key], b[key], aStack, bStack))) return false;\n      }\n    }\n    // Remove the first object from the stack of traversed objects.\n    aStack.pop();\n    bStack.pop();\n    return true;\n  };\n\n  // Perform a deep comparison to check if two objects are equal.\n  _.isEqual = function(a, b) {\n    return eq(a, b);\n  };\n\n  // Is a given array, string, or object empty?\n  // An \"empty\" object has no enumerable own-properties.\n  _.isEmpty = function(obj) {\n    if (obj == null) return true;\n    if (isArrayLike(obj) && (_.isArray(obj) || _.isString(obj) || _.isArguments(obj))) return obj.length === 0;\n    return _.keys(obj).length === 0;\n  };\n\n  // Is a given value a DOM element?\n  _.isElement = function(obj) {\n    return !!(obj && obj.nodeType === 1);\n  };\n\n  // Is a given value an array?\n  // Delegates to ECMA5's native Array.isArray\n  _.isArray = nativeIsArray || function(obj) {\n    return toString.call(obj) === '[object Array]';\n  };\n\n  // Is a given variable an object?\n  _.isObject = function(obj) {\n    var type = typeof obj;\n    return type === 'function' || type === 'object' && !!obj;\n  };\n\n  // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp, isError.\n  _.each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp', 'Error'], function(name) {\n    _['is' + name] = function(obj) {\n      return toString.call(obj) === '[object ' + name + ']';\n    };\n  });\n\n  // Define a fallback version of the method in browsers (ahem, IE < 9), where\n  // there isn't any inspectable \"Arguments\" type.\n  if (!_.isArguments(arguments)) {\n    _.isArguments = function(obj) {\n      return _.has(obj, 'callee');\n    };\n  }\n\n  // Optimize `isFunction` if appropriate. Work around some typeof bugs in old v8,\n  // IE 11 (#1621), and in Safari 8 (#1929).\n  if (typeof /./ != 'function' && typeof Int8Array != 'object') {\n    _.isFunction = function(obj) {\n      return typeof obj == 'function' || false;\n    };\n  }\n\n  // Is a given object a finite number?\n  _.isFinite = function(obj) {\n    return isFinite(obj) && !isNaN(parseFloat(obj));\n  };\n\n  // Is the given value `NaN`? (NaN is the only number which does not equal itself).\n  _.isNaN = function(obj) {\n    return _.isNumber(obj) && obj !== +obj;\n  };\n\n  // Is a given value a boolean?\n  _.isBoolean = function(obj) {\n    return obj === true || obj === false || toString.call(obj) === '[object Boolean]';\n  };\n\n  // Is a given value equal to null?\n  _.isNull = function(obj) {\n    return obj === null;\n  };\n\n  // Is a given variable undefined?\n  _.isUndefined = function(obj) {\n    return obj === void 0;\n  };\n\n  // Shortcut function for checking if an object has a given property directly\n  // on itself (in other words, not on a prototype).\n  _.has = function(obj, key) {\n    return obj != null && hasOwnProperty.call(obj, key);\n  };\n\n  // Utility Functions\n  // -----------------\n\n  // Run Underscore.js in *noConflict* mode, returning the `_` variable to its\n  // previous owner. Returns a reference to the Underscore object.\n  _.noConflict = function() {\n    root._ = previousUnderscore;\n    return this;\n  };\n\n  // Keep the identity function around for default iteratees.\n  _.identity = function(value) {\n    return value;\n  };\n\n  // Predicate-generating functions. Often useful outside of Underscore.\n  _.constant = function(value) {\n    return function() {\n      return value;\n    };\n  };\n\n  _.noop = function(){};\n\n  _.property = property;\n\n  // Generates a function for a given object that returns a given property.\n  _.propertyOf = function(obj) {\n    return obj == null ? function(){} : function(key) {\n      return obj[key];\n    };\n  };\n\n  // Returns a predicate for checking whether an object has a given set of\n  // `key:value` pairs.\n  _.matcher = _.matches = function(attrs) {\n    attrs = _.extendOwn({}, attrs);\n    return function(obj) {\n      return _.isMatch(obj, attrs);\n    };\n  };\n\n  // Run a function **n** times.\n  _.times = function(n, iteratee, context) {\n    var accum = Array(Math.max(0, n));\n    iteratee = optimizeCb(iteratee, context, 1);\n    for (var i = 0; i < n; i++) accum[i] = iteratee(i);\n    return accum;\n  };\n\n  // Return a random integer between min and max (inclusive).\n  _.random = function(min, max) {\n    if (max == null) {\n      max = min;\n      min = 0;\n    }\n    return min + Math.floor(Math.random() * (max - min + 1));\n  };\n\n  // A (possibly faster) way to get the current timestamp as an integer.\n  _.now = Date.now || function() {\n    return new Date().getTime();\n  };\n\n   // List of HTML entities for escaping.\n  var escapeMap = {\n    '&': '&amp;',\n    '<': '&lt;',\n    '>': '&gt;',\n    '\"': '&quot;',\n    \"'\": '&#x27;',\n    '`': '&#x60;'\n  };\n  var unescapeMap = _.invert(escapeMap);\n\n  // Functions for escaping and unescaping strings to/from HTML interpolation.\n  var createEscaper = function(map) {\n    var escaper = function(match) {\n      return map[match];\n    };\n    // Regexes for identifying a key that needs to be escaped\n    var source = '(?:' + _.keys(map).join('|') + ')';\n    var testRegexp = RegExp(source);\n    var replaceRegexp = RegExp(source, 'g');\n    return function(string) {\n      string = string == null ? '' : '' + string;\n      return testRegexp.test(string) ? string.replace(replaceRegexp, escaper) : string;\n    };\n  };\n  _.escape = createEscaper(escapeMap);\n  _.unescape = createEscaper(unescapeMap);\n\n  // If the value of the named `property` is a function then invoke it with the\n  // `object` as context; otherwise, return it.\n  _.result = function(object, property, fallback) {\n    var value = object == null ? void 0 : object[property];\n    if (value === void 0) {\n      value = fallback;\n    }\n    return _.isFunction(value) ? value.call(object) : value;\n  };\n\n  // Generate a unique integer id (unique within the entire client session).\n  // Useful for temporary DOM ids.\n  var idCounter = 0;\n  _.uniqueId = function(prefix) {\n    var id = ++idCounter + '';\n    return prefix ? prefix + id : id;\n  };\n\n  // By default, Underscore uses ERB-style template delimiters, change the\n  // following template settings to use alternative delimiters.\n  _.templateSettings = {\n    evaluate    : /<%([\\s\\S]+?)%>/g,\n    interpolate : /<%=([\\s\\S]+?)%>/g,\n    escape      : /<%-([\\s\\S]+?)%>/g\n  };\n\n  // When customizing `templateSettings`, if you don't want to define an\n  // interpolation, evaluation or escaping regex, we need one that is\n  // guaranteed not to match.\n  var noMatch = /(.)^/;\n\n  // Certain characters need to be escaped so that they can be put into a\n  // string literal.\n  var escapes = {\n    \"'\":      \"'\",\n    '\\\\':     '\\\\',\n    '\\r':     'r',\n    '\\n':     'n',\n    '\\u2028': 'u2028',\n    '\\u2029': 'u2029'\n  };\n\n  var escaper = /\\\\|'|\\r|\\n|\\u2028|\\u2029/g;\n\n  var escapeChar = function(match) {\n    return '\\\\' + escapes[match];\n  };\n\n  // JavaScript micro-templating, similar to John Resig's implementation.\n  // Underscore templating handles arbitrary delimiters, preserves whitespace,\n  // and correctly escapes quotes within interpolated code.\n  // NB: `oldSettings` only exists for backwards compatibility.\n  _.template = function(text, settings, oldSettings) {\n    if (!settings && oldSettings) settings = oldSettings;\n    settings = _.defaults({}, settings, _.templateSettings);\n\n    // Combine delimiters into one regular expression via alternation.\n    var matcher = RegExp([\n      (settings.escape || noMatch).source,\n      (settings.interpolate || noMatch).source,\n      (settings.evaluate || noMatch).source\n    ].join('|') + '|$', 'g');\n\n    // Compile the template source, escaping string literals appropriately.\n    var index = 0;\n    var source = \"__p+='\";\n    text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {\n      source += text.slice(index, offset).replace(escaper, escapeChar);\n      index = offset + match.length;\n\n      if (escape) {\n        source += \"'+\\n((__t=(\" + escape + \"))==null?'':_.escape(__t))+\\n'\";\n      } else if (interpolate) {\n        source += \"'+\\n((__t=(\" + interpolate + \"))==null?'':__t)+\\n'\";\n      } else if (evaluate) {\n        source += \"';\\n\" + evaluate + \"\\n__p+='\";\n      }\n\n      // Adobe VMs need the match returned to produce the correct offest.\n      return match;\n    });\n    source += \"';\\n\";\n\n    // If a variable is not specified, place data values in local scope.\n    if (!settings.variable) source = 'with(obj||{}){\\n' + source + '}\\n';\n\n    source = \"var __t,__p='',__j=Array.prototype.join,\" +\n      \"print=function(){__p+=__j.call(arguments,'');};\\n\" +\n      source + 'return __p;\\n';\n\n    try {\n      var render = new Function(settings.variable || 'obj', '_', source);\n    } catch (e) {\n      e.source = source;\n      throw e;\n    }\n\n    var template = function(data) {\n      return render.call(this, data, _);\n    };\n\n    // Provide the compiled source as a convenience for precompilation.\n    var argument = settings.variable || 'obj';\n    template.source = 'function(' + argument + '){\\n' + source + '}';\n\n    return template;\n  };\n\n  // Add a \"chain\" function. Start chaining a wrapped Underscore object.\n  _.chain = function(obj) {\n    var instance = _(obj);\n    instance._chain = true;\n    return instance;\n  };\n\n  // OOP\n  // ---------------\n  // If Underscore is called as a function, it returns a wrapped object that\n  // can be used OO-style. This wrapper holds altered versions of all the\n  // underscore functions. Wrapped objects may be chained.\n\n  // Helper function to continue chaining intermediate results.\n  var result = function(instance, obj) {\n    return instance._chain ? _(obj).chain() : obj;\n  };\n\n  // Add your own custom functions to the Underscore object.\n  _.mixin = function(obj) {\n    _.each(_.functions(obj), function(name) {\n      var func = _[name] = obj[name];\n      _.prototype[name] = function() {\n        var args = [this._wrapped];\n        push.apply(args, arguments);\n        return result(this, func.apply(_, args));\n      };\n    });\n  };\n\n  // Add all of the Underscore functions to the wrapper object.\n  _.mixin(_);\n\n  // Add all mutator Array functions to the wrapper.\n  _.each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {\n    var method = ArrayProto[name];\n    _.prototype[name] = function() {\n      var obj = this._wrapped;\n      method.apply(obj, arguments);\n      if ((name === 'shift' || name === 'splice') && obj.length === 0) delete obj[0];\n      return result(this, obj);\n    };\n  });\n\n  // Add all accessor Array functions to the wrapper.\n  _.each(['concat', 'join', 'slice'], function(name) {\n    var method = ArrayProto[name];\n    _.prototype[name] = function() {\n      return result(this, method.apply(this._wrapped, arguments));\n    };\n  });\n\n  // Extracts the result from a wrapped and chained object.\n  _.prototype.value = function() {\n    return this._wrapped;\n  };\n\n  // Provide unwrapping proxy for some methods used in engine operations\n  // such as arithmetic and JSON stringification.\n  _.prototype.valueOf = _.prototype.toJSON = _.prototype.value;\n\n  _.prototype.toString = function() {\n    return '' + this._wrapped;\n  };\n\n  // AMD registration happens at the end for compatibility with AMD loaders\n  // that may not enforce next-turn semantics on modules. Even though general\n  // practice for AMD registration is to be anonymous, underscore registers\n  // as a named module because, like jQuery, it is a base library that is\n  // popular enough to be bundled in a third party lib, but not be part of\n  // an AMD load request. Those cases could generate an error when an\n  // anonymous define() is called outside of a loader request.\n  if (true) {\n    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = function() {\n      return _;\n    }.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n  }\n}.call(this));\n\n\n/***/ }),\n\n/***/ 1:\n/***/ (function(module, exports) {\n\nmodule.exports = $;\n\n/***/ }),\n\n/***/ 10:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar Promise = __webpack_require__(2);\n\nmodule.exports = Promise;\nPromise.prototype['finally'] = function (f) {\n  return this.then(function (value) {\n    return Promise.resolve(f()).then(function () {\n      return value;\n    });\n  }, function (err) {\n    return Promise.resolve(f()).then(function () {\n      throw err;\n    });\n  });\n};\n\n\n/***/ }),\n\n/***/ 105:\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(jQuery) {/* ========================================================================\n * Bootstrap: collapse.js v3.3.7\n * http://getbootstrap.com/javascript/#collapse\n * ========================================================================\n * Copyright 2011-2016 Twitter, Inc.\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)\n * ======================================================================== */\n\n/* jshint latedef: false */\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.7'\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/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1)))\n\n/***/ }),\n\n/***/ 11:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nmodule.exports = __webpack_require__(2);\n__webpack_require__(8);\n__webpack_require__(10);\n__webpack_require__(9);\n__webpack_require__(12);\n__webpack_require__(13);\n\n\n/***/ }),\n\n/***/ 12:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n// This file contains then/promise specific extensions that are only useful\n// for node.js interop\n\nvar Promise = __webpack_require__(2);\nvar asap = __webpack_require__(14);\n\nmodule.exports = Promise;\n\n/* Static Functions */\n\nPromise.denodeify = function (fn, argumentCount) {\n  if (\n    typeof argumentCount === 'number' && argumentCount !== Infinity\n  ) {\n    return denodeifyWithCount(fn, argumentCount);\n  } else {\n    return denodeifyWithoutCount(fn);\n  }\n};\n\nvar callbackFn = (\n  'function (err, res) {' +\n  'if (err) { rj(err); } else { rs(res); }' +\n  '}'\n);\nfunction denodeifyWithCount(fn, argumentCount) {\n  var args = [];\n  for (var i = 0; i < argumentCount; i++) {\n    args.push('a' + i);\n  }\n  var body = [\n    'return function (' + args.join(',') + ') {',\n    'var self = this;',\n    'return new Promise(function (rs, rj) {',\n    'var res = fn.call(',\n    ['self'].concat(args).concat([callbackFn]).join(','),\n    ');',\n    'if (res &&',\n    '(typeof res === \"object\" || typeof res === \"function\") &&',\n    'typeof res.then === \"function\"',\n    ') {rs(res);}',\n    '});',\n    '};'\n  ].join('');\n  return Function(['Promise', 'fn'], body)(Promise, fn);\n}\nfunction denodeifyWithoutCount(fn) {\n  var fnLength = Math.max(fn.length - 1, 3);\n  var args = [];\n  for (var i = 0; i < fnLength; i++) {\n    args.push('a' + i);\n  }\n  var body = [\n    'return function (' + args.join(',') + ') {',\n    'var self = this;',\n    'var args;',\n    'var argLength = arguments.length;',\n    'if (arguments.length > ' + fnLength + ') {',\n    'args = new Array(arguments.length + 1);',\n    'for (var i = 0; i < arguments.length; i++) {',\n    'args[i] = arguments[i];',\n    '}',\n    '}',\n    'return new Promise(function (rs, rj) {',\n    'var cb = ' + callbackFn + ';',\n    'var res;',\n    'switch (argLength) {',\n    args.concat(['extra']).map(function (_, index) {\n      return (\n        'case ' + (index) + ':' +\n        'res = fn.call(' + ['self'].concat(args.slice(0, index)).concat('cb').join(',') + ');' +\n        'break;'\n      );\n    }).join(''),\n    'default:',\n    'args[argLength] = cb;',\n    'res = fn.apply(self, args);',\n    '}',\n    \n    'if (res &&',\n    '(typeof res === \"object\" || typeof res === \"function\") &&',\n    'typeof res.then === \"function\"',\n    ') {rs(res);}',\n    '});',\n    '};'\n  ].join('');\n\n  return Function(\n    ['Promise', 'fn'],\n    body\n  )(Promise, fn);\n}\n\nPromise.nodeify = function (fn) {\n  return function () {\n    var args = Array.prototype.slice.call(arguments);\n    var callback =\n      typeof args[args.length - 1] === 'function' ? args.pop() : null;\n    var ctx = this;\n    try {\n      return fn.apply(this, arguments).nodeify(callback, ctx);\n    } catch (ex) {\n      if (callback === null || typeof callback == 'undefined') {\n        return new Promise(function (resolve, reject) {\n          reject(ex);\n        });\n      } else {\n        asap(function () {\n          callback.call(ctx, ex);\n        })\n      }\n    }\n  }\n};\n\nPromise.prototype.nodeify = function (callback, ctx) {\n  if (typeof callback != 'function') return this;\n\n  this.then(function (value) {\n    asap(function () {\n      callback.call(ctx, null, value);\n    });\n  }, function (err) {\n    asap(function () {\n      callback.call(ctx, err);\n    });\n  });\n};\n\n\n/***/ }),\n\n/***/ 120:\n/***/ (function(module, exports) {\n\nmodule.exports = function(obj){\nvar __t,__p='',__j=Array.prototype.join,print=function(){__p+=__j.call(arguments,'');};\nwith(obj||{}){\n__p+='\\n<!-- js/templates/slidedown.html -->\\n<div class=\"panel panel-default\">\\n    <div class=\"panel-heading\" role=\"tab\" id=\"heading'+\n((__t=( id ))==null?'':__t)+\n'\">\\n        <h4 class=\"panel-title\">\\n            <a role=\"button\" class=\"collapsed\" data-toggle=\"collapse\" data-parent=\"#accordion\" href=\"#collapse'+\n((__t=( id ))==null?'':__t)+\n'\" aria-expanded=\"false\" aria-controls=\"collapse'+\n((__t=( id ))==null?'':__t)+\n'\">\\n                '+\n((__t=( title ))==null?'':__t)+\n'\\n            </a>\\n        </h4>\\n    </div>\\n\\n    <div id=\"collapse'+\n((__t=( id ))==null?'':__t)+\n'\" class=\"panel-collapse collapse\" role=\"tabpanel\" aria-labelledby=\"heading'+\n((__t=( id ))==null?'':__t)+\n'\">\\n        <div class=\"panel-body\">\\n            '+\n((__t=( content ))==null?'':__t)+\n'\\n        </div>\\n    </div>\\n</div>';\n}\nreturn __p;\n};\n\n\n/***/ }),\n\n/***/ 13:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar Promise = __webpack_require__(2);\n\nmodule.exports = Promise;\nPromise.enableSynchronous = function () {\n  Promise.prototype.isPending = function() {\n    return this.getState() == 0;\n  };\n\n  Promise.prototype.isFulfilled = function() {\n    return this.getState() == 1;\n  };\n\n  Promise.prototype.isRejected = function() {\n    return this.getState() == 2;\n  };\n\n  Promise.prototype.getValue = function () {\n    if (this._65 === 3) {\n      return this._55.getValue();\n    }\n\n    if (!this.isFulfilled()) {\n      throw new Error('Cannot get a value of an unfulfilled promise.');\n    }\n\n    return this._55;\n  };\n\n  Promise.prototype.getReason = function () {\n    if (this._65 === 3) {\n      return this._55.getReason();\n    }\n\n    if (!this.isRejected()) {\n      throw new Error('Cannot get a rejection reason of a non-rejected promise.');\n    }\n\n    return this._55;\n  };\n\n  Promise.prototype.getState = function () {\n    if (this._65 === 3) {\n      return this._55.getState();\n    }\n    if (this._65 === -1 || this._65 === -2) {\n      return 0;\n    }\n\n    return this._65;\n  };\n};\n\nPromise.disableSynchronous = function() {\n  Promise.prototype.isPending = undefined;\n  Promise.prototype.isFulfilled = undefined;\n  Promise.prototype.isRejected = undefined;\n  Promise.prototype.getValue = undefined;\n  Promise.prototype.getReason = undefined;\n  Promise.prototype.getState = undefined;\n};\n\n\n/***/ }),\n\n/***/ 14:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n// rawAsap provides everything we need except exception management.\nvar rawAsap = __webpack_require__(5);\n// RawTasks are recycled to reduce GC churn.\nvar freeTasks = [];\n// We queue errors to ensure they are thrown in right order (FIFO).\n// Array-as-queue is good enough here, since we are just dealing with exceptions.\nvar pendingErrors = [];\nvar requestErrorThrow = rawAsap.makeRequestCallFromTimer(throwFirstError);\n\nfunction throwFirstError() {\n    if (pendingErrors.length) {\n        throw pendingErrors.shift();\n    }\n}\n\n/**\n * Calls a task as soon as possible after returning, in its own event, with priority\n * over other events like animation, reflow, and repaint. An error thrown from an\n * event will not interrupt, nor even substantially slow down the processing of\n * other events, but will be rather postponed to a lower priority event.\n * @param {{call}} task A callable object, typically a function that takes no\n * arguments.\n */\nmodule.exports = asap;\nfunction asap(task) {\n    var rawTask;\n    if (freeTasks.length) {\n        rawTask = freeTasks.pop();\n    } else {\n        rawTask = new RawTask();\n    }\n    rawTask.task = task;\n    rawAsap(rawTask);\n}\n\n// We wrap tasks with recyclable task objects.  A task object implements\n// `call`, just like a function.\nfunction RawTask() {\n    this.task = null;\n}\n\n// The sole purpose of wrapping the task is to catch the exception and recycle\n// the task object after its single use.\nRawTask.prototype.call = function () {\n    try {\n        this.task.call();\n    } catch (error) {\n        if (asap.onerror) {\n            // This hook exists purely for testing purposes.\n            // Its name will be periodically randomized to break any code that\n            // depends on its existence.\n            asap.onerror(error);\n        } else {\n            // In a web browser, exceptions are not fatal. However, to avoid\n            // slowing down the queue of pending tasks, we rethrow the error in a\n            // lower priority turn.\n            pendingErrors.push(error);\n            requestErrorThrow();\n        }\n    } finally {\n        this.task = null;\n        freeTasks[freeTasks.length] = this;\n    }\n};\n\n\n/***/ }),\n\n/***/ 2:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar asap = __webpack_require__(5);\n\nfunction noop() {}\n\n// States:\n//\n// 0 - pending\n// 1 - fulfilled with _value\n// 2 - rejected with _value\n// 3 - adopted the state of another promise, _value\n//\n// once the state is no longer pending (0) it is immutable\n\n// All `_` prefixed properties will be reduced to `_{random number}`\n// at build time to obfuscate them and discourage their use.\n// We don't use symbols or Object.defineProperty to fully hide them\n// because the performance isn't good enough.\n\n\n// to avoid using try/catch inside critical functions, we\n// extract them to here.\nvar LAST_ERROR = null;\nvar IS_ERROR = {};\nfunction getThen(obj) {\n  try {\n    return obj.then;\n  } catch (ex) {\n    LAST_ERROR = ex;\n    return IS_ERROR;\n  }\n}\n\nfunction tryCallOne(fn, a) {\n  try {\n    return fn(a);\n  } catch (ex) {\n    LAST_ERROR = ex;\n    return IS_ERROR;\n  }\n}\nfunction tryCallTwo(fn, a, b) {\n  try {\n    fn(a, b);\n  } catch (ex) {\n    LAST_ERROR = ex;\n    return IS_ERROR;\n  }\n}\n\nmodule.exports = Promise;\n\nfunction Promise(fn) {\n  if (typeof this !== 'object') {\n    throw new TypeError('Promises must be constructed via new');\n  }\n  if (typeof fn !== 'function') {\n    throw new TypeError('Promise constructor\\'s argument is not a function');\n  }\n  this._40 = 0;\n  this._65 = 0;\n  this._55 = null;\n  this._72 = null;\n  if (fn === noop) return;\n  doResolve(fn, this);\n}\nPromise._37 = null;\nPromise._87 = null;\nPromise._61 = noop;\n\nPromise.prototype.then = function(onFulfilled, onRejected) {\n  if (this.constructor !== Promise) {\n    return safeThen(this, onFulfilled, onRejected);\n  }\n  var res = new Promise(noop);\n  handle(this, new Handler(onFulfilled, onRejected, res));\n  return res;\n};\n\nfunction safeThen(self, onFulfilled, onRejected) {\n  return new self.constructor(function (resolve, reject) {\n    var res = new Promise(noop);\n    res.then(resolve, reject);\n    handle(self, new Handler(onFulfilled, onRejected, res));\n  });\n}\nfunction handle(self, deferred) {\n  while (self._65 === 3) {\n    self = self._55;\n  }\n  if (Promise._37) {\n    Promise._37(self);\n  }\n  if (self._65 === 0) {\n    if (self._40 === 0) {\n      self._40 = 1;\n      self._72 = deferred;\n      return;\n    }\n    if (self._40 === 1) {\n      self._40 = 2;\n      self._72 = [self._72, deferred];\n      return;\n    }\n    self._72.push(deferred);\n    return;\n  }\n  handleResolved(self, deferred);\n}\n\nfunction handleResolved(self, deferred) {\n  asap(function() {\n    var cb = self._65 === 1 ? deferred.onFulfilled : deferred.onRejected;\n    if (cb === null) {\n      if (self._65 === 1) {\n        resolve(deferred.promise, self._55);\n      } else {\n        reject(deferred.promise, self._55);\n      }\n      return;\n    }\n    var ret = tryCallOne(cb, self._55);\n    if (ret === IS_ERROR) {\n      reject(deferred.promise, LAST_ERROR);\n    } else {\n      resolve(deferred.promise, ret);\n    }\n  });\n}\nfunction resolve(self, newValue) {\n  // Promise Resolution Procedure: https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure\n  if (newValue === self) {\n    return reject(\n      self,\n      new TypeError('A promise cannot be resolved with itself.')\n    );\n  }\n  if (\n    newValue &&\n    (typeof newValue === 'object' || typeof newValue === 'function')\n  ) {\n    var then = getThen(newValue);\n    if (then === IS_ERROR) {\n      return reject(self, LAST_ERROR);\n    }\n    if (\n      then === self.then &&\n      newValue instanceof Promise\n    ) {\n      self._65 = 3;\n      self._55 = newValue;\n      finale(self);\n      return;\n    } else if (typeof then === 'function') {\n      doResolve(then.bind(newValue), self);\n      return;\n    }\n  }\n  self._65 = 1;\n  self._55 = newValue;\n  finale(self);\n}\n\nfunction reject(self, newValue) {\n  self._65 = 2;\n  self._55 = newValue;\n  if (Promise._87) {\n    Promise._87(self, newValue);\n  }\n  finale(self);\n}\nfunction finale(self) {\n  if (self._40 === 1) {\n    handle(self, self._72);\n    self._72 = null;\n  }\n  if (self._40 === 2) {\n    for (var i = 0; i < self._72.length; i++) {\n      handle(self, self._72[i]);\n    }\n    self._72 = null;\n  }\n}\n\nfunction Handler(onFulfilled, onRejected, promise){\n  this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null;\n  this.onRejected = typeof onRejected === 'function' ? onRejected : null;\n  this.promise = promise;\n}\n\n/**\n * Take a potentially misbehaving resolver function and make sure\n * onFulfilled and onRejected are only called once.\n *\n * Makes no guarantees about asynchrony.\n */\nfunction doResolve(fn, promise) {\n  var done = false;\n  var res = tryCallTwo(fn, function (value) {\n    if (done) return;\n    done = true;\n    resolve(promise, value);\n  }, function (reason) {\n    if (done) return;\n    done = true;\n    reject(promise, reason);\n  });\n  if (!done && res === IS_ERROR) {\n    done = true;\n    reject(promise, LAST_ERROR);\n  }\n}\n\n\n/***/ }),\n\n/***/ 3:\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(global) {var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;//     Backbone.js 1.3.3\n\n//     (c) 2010-2016 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n//     Backbone may be freely distributed under the MIT license.\n//     For all details and documentation:\n//     http://backbonejs.org\n\n(function(factory) {\n\n  // Establish the root object, `window` (`self`) in the browser, or `global` on the server.\n  // We use `self` instead of `window` for `WebWorker` support.\n  var root = (typeof self == 'object' && self.self === self && self) ||\n            (typeof global == 'object' && global.global === global && global);\n\n  // Set up Backbone appropriately for the environment. Start with AMD.\n  if (true) {\n    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(0), __webpack_require__(1), exports], __WEBPACK_AMD_DEFINE_RESULT__ = function(_, $, exports) {\n      // Export global even in AMD case in case this script is loaded with\n      // others that may still expect a global Backbone.\n      root.Backbone = factory(root, exports, _, $);\n    }.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\n  // Next for Node.js or CommonJS. jQuery may not be needed as a module.\n  } else if (typeof exports !== 'undefined') {\n    var _ = require('underscore'), $;\n    try { $ = require('jquery'); } catch (e) {}\n    factory(root, exports, _, $);\n\n  // Finally, as a browser global.\n  } else {\n    root.Backbone = factory(root, {}, root._, (root.jQuery || root.Zepto || root.ender || root.$));\n  }\n\n})(function(root, Backbone, _, $) {\n\n  // Initial Setup\n  // -------------\n\n  // Save the previous value of the `Backbone` variable, so that it can be\n  // restored later on, if `noConflict` is used.\n  var previousBackbone = root.Backbone;\n\n  // Create a local reference to a common array method we'll want to use later.\n  var slice = Array.prototype.slice;\n\n  // Current version of the library. Keep in sync with `package.json`.\n  Backbone.VERSION = '1.3.3';\n\n  // For Backbone's purposes, jQuery, Zepto, Ender, or My Library (kidding) owns\n  // the `$` variable.\n  Backbone.$ = $;\n\n  // Runs Backbone.js in *noConflict* mode, returning the `Backbone` variable\n  // to its previous owner. Returns a reference to this Backbone object.\n  Backbone.noConflict = function() {\n    root.Backbone = previousBackbone;\n    return this;\n  };\n\n  // Turn on `emulateHTTP` to support legacy HTTP servers. Setting this option\n  // will fake `\"PATCH\"`, `\"PUT\"` and `\"DELETE\"` requests via the `_method` parameter and\n  // set a `X-Http-Method-Override` header.\n  Backbone.emulateHTTP = false;\n\n  // Turn on `emulateJSON` to support legacy servers that can't deal with direct\n  // `application/json` requests ... this will encode the body as\n  // `application/x-www-form-urlencoded` instead and will send the model in a\n  // form param named `model`.\n  Backbone.emulateJSON = false;\n\n  // Proxy Backbone class methods to Underscore functions, wrapping the model's\n  // `attributes` object or collection's `models` array behind the scenes.\n  //\n  // collection.filter(function(model) { return model.get('age') > 10 });\n  // collection.each(this.addView);\n  //\n  // `Function#apply` can be slow so we use the method's arg count, if we know it.\n  var addMethod = function(length, method, attribute) {\n    switch (length) {\n      case 1: return function() {\n        return _[method](this[attribute]);\n      };\n      case 2: return function(value) {\n        return _[method](this[attribute], value);\n      };\n      case 3: return function(iteratee, context) {\n        return _[method](this[attribute], cb(iteratee, this), context);\n      };\n      case 4: return function(iteratee, defaultVal, context) {\n        return _[method](this[attribute], cb(iteratee, this), defaultVal, context);\n      };\n      default: return function() {\n        var args = slice.call(arguments);\n        args.unshift(this[attribute]);\n        return _[method].apply(_, args);\n      };\n    }\n  };\n  var addUnderscoreMethods = function(Class, methods, attribute) {\n    _.each(methods, function(length, method) {\n      if (_[method]) Class.prototype[method] = addMethod(length, method, attribute);\n    });\n  };\n\n  // Support `collection.sortBy('attr')` and `collection.findWhere({id: 1})`.\n  var cb = function(iteratee, instance) {\n    if (_.isFunction(iteratee)) return iteratee;\n    if (_.isObject(iteratee) && !instance._isModel(iteratee)) return modelMatcher(iteratee);\n    if (_.isString(iteratee)) return function(model) { return model.get(iteratee); };\n    return iteratee;\n  };\n  var modelMatcher = function(attrs) {\n    var matcher = _.matches(attrs);\n    return function(model) {\n      return matcher(model.attributes);\n    };\n  };\n\n  // Backbone.Events\n  // ---------------\n\n  // A module that can be mixed in to *any object* in order to provide it with\n  // a custom event channel. You may bind a callback to an event with `on` or\n  // remove with `off`; `trigger`-ing an event fires all callbacks in\n  // succession.\n  //\n  //     var object = {};\n  //     _.extend(object, Backbone.Events);\n  //     object.on('expand', function(){ alert('expanded'); });\n  //     object.trigger('expand');\n  //\n  var Events = Backbone.Events = {};\n\n  // Regular expression used to split event strings.\n  var eventSplitter = /\\s+/;\n\n  // Iterates over the standard `event, callback` (as well as the fancy multiple\n  // space-separated events `\"change blur\", callback` and jQuery-style event\n  // maps `{event: callback}`).\n  var eventsApi = function(iteratee, events, name, callback, opts) {\n    var i = 0, names;\n    if (name && typeof name === 'object') {\n      // Handle event maps.\n      if (callback !== void 0 && 'context' in opts && opts.context === void 0) opts.context = callback;\n      for (names = _.keys(name); i < names.length ; i++) {\n        events = eventsApi(iteratee, events, names[i], name[names[i]], opts);\n      }\n    } else if (name && eventSplitter.test(name)) {\n      // Handle space-separated event names by delegating them individually.\n      for (names = name.split(eventSplitter); i < names.length; i++) {\n        events = iteratee(events, names[i], callback, opts);\n      }\n    } else {\n      // Finally, standard events.\n      events = iteratee(events, name, callback, opts);\n    }\n    return events;\n  };\n\n  // Bind an event to a `callback` function. Passing `\"all\"` will bind\n  // the callback to all events fired.\n  Events.on = function(name, callback, context) {\n    return internalOn(this, name, callback, context);\n  };\n\n  // Guard the `listening` argument from the public API.\n  var internalOn = function(obj, name, callback, context, listening) {\n    obj._events = eventsApi(onApi, obj._events || {}, name, callback, {\n      context: context,\n      ctx: obj,\n      listening: listening\n    });\n\n    if (listening) {\n      var listeners = obj._listeners || (obj._listeners = {});\n      listeners[listening.id] = listening;\n    }\n\n    return obj;\n  };\n\n  // Inversion-of-control versions of `on`. Tell *this* object to listen to\n  // an event in another object... keeping track of what it's listening to\n  // for easier unbinding later.\n  Events.listenTo = function(obj, name, callback) {\n    if (!obj) return this;\n    var id = obj._listenId || (obj._listenId = _.uniqueId('l'));\n    var listeningTo = this._listeningTo || (this._listeningTo = {});\n    var listening = listeningTo[id];\n\n    // This object is not listening to any other events on `obj` yet.\n    // Setup the necessary references to track the listening callbacks.\n    if (!listening) {\n      var thisId = this._listenId || (this._listenId = _.uniqueId('l'));\n      listening = listeningTo[id] = {obj: obj, objId: id, id: thisId, listeningTo: listeningTo, count: 0};\n    }\n\n    // Bind callbacks on obj, and keep track of them on listening.\n    internalOn(obj, name, callback, this, listening);\n    return this;\n  };\n\n  // The reducing API that adds a callback to the `events` object.\n  var onApi = function(events, name, callback, options) {\n    if (callback) {\n      var handlers = events[name] || (events[name] = []);\n      var context = options.context, ctx = options.ctx, listening = options.listening;\n      if (listening) listening.count++;\n\n      handlers.push({callback: callback, context: context, ctx: context || ctx, listening: listening});\n    }\n    return events;\n  };\n\n  // Remove one or many callbacks. If `context` is null, removes all\n  // callbacks with that function. If `callback` is null, removes all\n  // callbacks for the event. If `name` is null, removes all bound\n  // callbacks for all events.\n  Events.off = function(name, callback, context) {\n    if (!this._events) return this;\n    this._events = eventsApi(offApi, this._events, name, callback, {\n      context: context,\n      listeners: this._listeners\n    });\n    return this;\n  };\n\n  // Tell this object to stop listening to either specific events ... or\n  // to every object it's currently listening to.\n  Events.stopListening = function(obj, name, callback) {\n    var listeningTo = this._listeningTo;\n    if (!listeningTo) return this;\n\n    var ids = obj ? [obj._listenId] : _.keys(listeningTo);\n\n    for (var i = 0; i < ids.length; i++) {\n      var listening = listeningTo[ids[i]];\n\n      // If listening doesn't exist, this object is not currently\n      // listening to obj. Break out early.\n      if (!listening) break;\n\n      listening.obj.off(name, callback, this);\n    }\n\n    return this;\n  };\n\n  // The reducing API that removes a callback from the `events` object.\n  var offApi = function(events, name, callback, options) {\n    if (!events) return;\n\n    var i = 0, listening;\n    var context = options.context, listeners = options.listeners;\n\n    // Delete all events listeners and \"drop\" events.\n    if (!name && !callback && !context) {\n      var ids = _.keys(listeners);\n      for (; i < ids.length; i++) {\n        listening = listeners[ids[i]];\n        delete listeners[listening.id];\n        delete listening.listeningTo[listening.objId];\n      }\n      return;\n    }\n\n    var names = name ? [name] : _.keys(events);\n    for (; i < names.length; i++) {\n      name = names[i];\n      var handlers = events[name];\n\n      // Bail out if there are no events stored.\n      if (!handlers) break;\n\n      // Replace events if there are any remaining.  Otherwise, clean up.\n      var remaining = [];\n      for (var j = 0; j < handlers.length; j++) {\n        var handler = handlers[j];\n        if (\n          callback && callback !== handler.callback &&\n            callback !== handler.callback._callback ||\n              context && context !== handler.context\n        ) {\n          remaining.push(handler);\n        } else {\n          listening = handler.listening;\n          if (listening && --listening.count === 0) {\n            delete listeners[listening.id];\n            delete listening.listeningTo[listening.objId];\n          }\n        }\n      }\n\n      // Update tail event if the list has any events.  Otherwise, clean up.\n      if (remaining.length) {\n        events[name] = remaining;\n      } else {\n        delete events[name];\n      }\n    }\n    return events;\n  };\n\n  // Bind an event to only be triggered a single time. After the first time\n  // the callback is invoked, its listener will be removed. If multiple events\n  // are passed in using the space-separated syntax, the handler will fire\n  // once for each event, not once for a combination of all events.\n  Events.once = function(name, callback, context) {\n    // Map the event into a `{event: once}` object.\n    var events = eventsApi(onceMap, {}, name, callback, _.bind(this.off, this));\n    if (typeof name === 'string' && context == null) callback = void 0;\n    return this.on(events, callback, context);\n  };\n\n  // Inversion-of-control versions of `once`.\n  Events.listenToOnce = function(obj, name, callback) {\n    // Map the event into a `{event: once}` object.\n    var events = eventsApi(onceMap, {}, name, callback, _.bind(this.stopListening, this, obj));\n    return this.listenTo(obj, events);\n  };\n\n  // Reduces the event callbacks into a map of `{event: onceWrapper}`.\n  // `offer` unbinds the `onceWrapper` after it has been called.\n  var onceMap = function(map, name, callback, offer) {\n    if (callback) {\n      var once = map[name] = _.once(function() {\n        offer(name, once);\n        callback.apply(this, arguments);\n      });\n      once._callback = callback;\n    }\n    return map;\n  };\n\n  // Trigger one or many events, firing all bound callbacks. Callbacks are\n  // passed the same arguments as `trigger` is, apart from the event name\n  // (unless you're listening on `\"all\"`, which will cause your callback to\n  // receive the true name of the event as the first argument).\n  Events.trigger = function(name) {\n    if (!this._events) return this;\n\n    var length = Math.max(0, arguments.length - 1);\n    var args = Array(length);\n    for (var i = 0; i < length; i++) args[i] = arguments[i + 1];\n\n    eventsApi(triggerApi, this._events, name, void 0, args);\n    return this;\n  };\n\n  // Handles triggering the appropriate event callbacks.\n  var triggerApi = function(objEvents, name, callback, args) {\n    if (objEvents) {\n      var events = objEvents[name];\n      var allEvents = objEvents.all;\n      if (events && allEvents) allEvents = allEvents.slice();\n      if (events) triggerEvents(events, args);\n      if (allEvents) triggerEvents(allEvents, [name].concat(args));\n    }\n    return objEvents;\n  };\n\n  // A difficult-to-believe, but optimized internal dispatch function for\n  // triggering events. Tries to keep the usual cases speedy (most internal\n  // Backbone events have 3 arguments).\n  var triggerEvents = function(events, args) {\n    var ev, i = -1, l = events.length, a1 = args[0], a2 = args[1], a3 = args[2];\n    switch (args.length) {\n      case 0: while (++i < l) (ev = events[i]).callback.call(ev.ctx); return;\n      case 1: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1); return;\n      case 2: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2); return;\n      case 3: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2, a3); return;\n      default: while (++i < l) (ev = events[i]).callback.apply(ev.ctx, args); return;\n    }\n  };\n\n  // Aliases for backwards compatibility.\n  Events.bind   = Events.on;\n  Events.unbind = Events.off;\n\n  // Allow the `Backbone` object to serve as a global event bus, for folks who\n  // want global \"pubsub\" in a convenient place.\n  _.extend(Backbone, Events);\n\n  // Backbone.Model\n  // --------------\n\n  // Backbone **Models** are the basic data object in the framework --\n  // frequently representing a row in a table in a database on your server.\n  // A discrete chunk of data and a bunch of useful, related methods for\n  // performing computations and transformations on that data.\n\n  // Create a new model with the specified attributes. A client id (`cid`)\n  // is automatically generated and assigned for you.\n  var Model = Backbone.Model = function(attributes, options) {\n    var attrs = attributes || {};\n    options || (options = {});\n    this.cid = _.uniqueId(this.cidPrefix);\n    this.attributes = {};\n    if (options.collection) this.collection = options.collection;\n    if (options.parse) attrs = this.parse(attrs, options) || {};\n    var defaults = _.result(this, 'defaults');\n    attrs = _.defaults(_.extend({}, defaults, attrs), defaults);\n    this.set(attrs, options);\n    this.changed = {};\n    this.initialize.apply(this, arguments);\n  };\n\n  // Attach all inheritable methods to the Model prototype.\n  _.extend(Model.prototype, Events, {\n\n    // A hash of attributes whose current and previous value differ.\n    changed: null,\n\n    // The value returned during the last failed validation.\n    validationError: null,\n\n    // The default name for the JSON `id` attribute is `\"id\"`. MongoDB and\n    // CouchDB users may want to set this to `\"_id\"`.\n    idAttribute: 'id',\n\n    // The prefix is used to create the client id which is used to identify models locally.\n    // You may want to override this if you're experiencing name clashes with model ids.\n    cidPrefix: 'c',\n\n    // Initialize is an empty function by default. Override it with your own\n    // initialization logic.\n    initialize: function(){},\n\n    // Return a copy of the model's `attributes` object.\n    toJSON: function(options) {\n      return _.clone(this.attributes);\n    },\n\n    // Proxy `Backbone.sync` by default -- but override this if you need\n    // custom syncing semantics for *this* particular model.\n    sync: function() {\n      return Backbone.sync.apply(this, arguments);\n    },\n\n    // Get the value of an attribute.\n    get: function(attr) {\n      return this.attributes[attr];\n    },\n\n    // Get the HTML-escaped value of an attribute.\n    escape: function(attr) {\n      return _.escape(this.get(attr));\n    },\n\n    // Returns `true` if the attribute contains a value that is not null\n    // or undefined.\n    has: function(attr) {\n      return this.get(attr) != null;\n    },\n\n    // Special-cased proxy to underscore's `_.matches` method.\n    matches: function(attrs) {\n      return !!_.iteratee(attrs, this)(this.attributes);\n    },\n\n    // Set a hash of model attributes on the object, firing `\"change\"`. This is\n    // the core primitive operation of a model, updating the data and notifying\n    // anyone who needs to know about the change in state. The heart of the beast.\n    set: function(key, val, options) {\n      if (key == null) return this;\n\n      // Handle both `\"key\", value` and `{key: value}` -style arguments.\n      var attrs;\n      if (typeof key === 'object') {\n        attrs = key;\n        options = val;\n      } else {\n        (attrs = {})[key] = val;\n      }\n\n      options || (options = {});\n\n      // Run validation.\n      if (!this._validate(attrs, options)) return false;\n\n      // Extract attributes and options.\n      var unset      = options.unset;\n      var silent     = options.silent;\n      var changes    = [];\n      var changing   = this._changing;\n      this._changing = true;\n\n      if (!changing) {\n        this._previousAttributes = _.clone(this.attributes);\n        this.changed = {};\n      }\n\n      var current = this.attributes;\n      var changed = this.changed;\n      var prev    = this._previousAttributes;\n\n      // For each `set` attribute, update or delete the current value.\n      for (var attr in attrs) {\n        val = attrs[attr];\n        if (!_.isEqual(current[attr], val)) changes.push(attr);\n        if (!_.isEqual(prev[attr], val)) {\n          changed[attr] = val;\n        } else {\n          delete changed[attr];\n        }\n        unset ? delete current[attr] : current[attr] = val;\n      }\n\n      // Update the `id`.\n      if (this.idAttribute in attrs) this.id = this.get(this.idAttribute);\n\n      // Trigger all relevant attribute changes.\n      if (!silent) {\n        if (changes.length) this._pending = options;\n        for (var i = 0; i < changes.length; i++) {\n          this.trigger('change:' + changes[i], this, current[changes[i]], options);\n        }\n      }\n\n      // You might be wondering why there's a `while` loop here. Changes can\n      // be recursively nested within `\"change\"` events.\n      if (changing) return this;\n      if (!silent) {\n        while (this._pending) {\n          options = this._pending;\n          this._pending = false;\n          this.trigger('change', this, options);\n        }\n      }\n      this._pending = false;\n      this._changing = false;\n      return this;\n    },\n\n    // Remove an attribute from the model, firing `\"change\"`. `unset` is a noop\n    // if the attribute doesn't exist.\n    unset: function(attr, options) {\n      return this.set(attr, void 0, _.extend({}, options, {unset: true}));\n    },\n\n    // Clear all attributes on the model, firing `\"change\"`.\n    clear: function(options) {\n      var attrs = {};\n      for (var key in this.attributes) attrs[key] = void 0;\n      return this.set(attrs, _.extend({}, options, {unset: true}));\n    },\n\n    // Determine if the model has changed since the last `\"change\"` event.\n    // If you specify an attribute name, determine if that attribute has changed.\n    hasChanged: function(attr) {\n      if (attr == null) return !_.isEmpty(this.changed);\n      return _.has(this.changed, attr);\n    },\n\n    // Return an object containing all the attributes that have changed, or\n    // false if there are no changed attributes. Useful for determining what\n    // parts of a view need to be updated and/or what attributes need to be\n    // persisted to the server. Unset attributes will be set to undefined.\n    // You can also pass an attributes object to diff against the model,\n    // determining if there *would be* a change.\n    changedAttributes: function(diff) {\n      if (!diff) return this.hasChanged() ? _.clone(this.changed) : false;\n      var old = this._changing ? this._previousAttributes : this.attributes;\n      var changed = {};\n      for (var attr in diff) {\n        var val = diff[attr];\n        if (_.isEqual(old[attr], val)) continue;\n        changed[attr] = val;\n      }\n      return _.size(changed) ? changed : false;\n    },\n\n    // Get the previous value of an attribute, recorded at the time the last\n    // `\"change\"` event was fired.\n    previous: function(attr) {\n      if (attr == null || !this._previousAttributes) return null;\n      return this._previousAttributes[attr];\n    },\n\n    // Get all of the attributes of the model at the time of the previous\n    // `\"change\"` event.\n    previousAttributes: function() {\n      return _.clone(this._previousAttributes);\n    },\n\n    // Fetch the model from the server, merging the response with the model's\n    // local attributes. Any changed attributes will trigger a \"change\" event.\n    fetch: function(options) {\n      options = _.extend({parse: true}, options);\n      var model = this;\n      var success = options.success;\n      options.success = function(resp) {\n        var serverAttrs = options.parse ? model.parse(resp, options) : resp;\n        if (!model.set(serverAttrs, options)) return false;\n        if (success) success.call(options.context, model, resp, options);\n        model.trigger('sync', model, resp, options);\n      };\n      wrapError(this, options);\n      return this.sync('read', this, options);\n    },\n\n    // Set a hash of model attributes, and sync the model to the server.\n    // If the server returns an attributes hash that differs, the model's\n    // state will be `set` again.\n    save: function(key, val, options) {\n      // Handle both `\"key\", value` and `{key: value}` -style arguments.\n      var attrs;\n      if (key == null || typeof key === 'object') {\n        attrs = key;\n        options = val;\n      } else {\n        (attrs = {})[key] = val;\n      }\n\n      options = _.extend({validate: true, parse: true}, options);\n      var wait = options.wait;\n\n      // If we're not waiting and attributes exist, save acts as\n      // `set(attr).save(null, opts)` with validation. Otherwise, check if\n      // the model will be valid when the attributes, if any, are set.\n      if (attrs && !wait) {\n        if (!this.set(attrs, options)) return false;\n      } else if (!this._validate(attrs, options)) {\n        return false;\n      }\n\n      // After a successful server-side save, the client is (optionally)\n      // updated with the server-side state.\n      var model = this;\n      var success = options.success;\n      var attributes = this.attributes;\n      options.success = function(resp) {\n        // Ensure attributes are restored during synchronous saves.\n        model.attributes = attributes;\n        var serverAttrs = options.parse ? model.parse(resp, options) : resp;\n        if (wait) serverAttrs = _.extend({}, attrs, serverAttrs);\n        if (serverAttrs && !model.set(serverAttrs, options)) return false;\n        if (success) success.call(options.context, model, resp, options);\n        model.trigger('sync', model, resp, options);\n      };\n      wrapError(this, options);\n\n      // Set temporary attributes if `{wait: true}` to properly find new ids.\n      if (attrs && wait) this.attributes = _.extend({}, attributes, attrs);\n\n      var method = this.isNew() ? 'create' : (options.patch ? 'patch' : 'update');\n      if (method === 'patch' && !options.attrs) options.attrs = attrs;\n      var xhr = this.sync(method, this, options);\n\n      // Restore attributes.\n      this.attributes = attributes;\n\n      return xhr;\n    },\n\n    // Destroy this model on the server if it was already persisted.\n    // Optimistically removes the model from its collection, if it has one.\n    // If `wait: true` is passed, waits for the server to respond before removal.\n    destroy: function(options) {\n      options = options ? _.clone(options) : {};\n      var model = this;\n      var success = options.success;\n      var wait = options.wait;\n\n      var destroy = function() {\n        model.stopListening();\n        model.trigger('destroy', model, model.collection, options);\n      };\n\n      options.success = function(resp) {\n        if (wait) destroy();\n        if (success) success.call(options.context, model, resp, options);\n        if (!model.isNew()) model.trigger('sync', model, resp, options);\n      };\n\n      var xhr = false;\n      if (this.isNew()) {\n        _.defer(options.success);\n      } else {\n        wrapError(this, options);\n        xhr = this.sync('delete', this, options);\n      }\n      if (!wait) destroy();\n      return xhr;\n    },\n\n    // Default URL for the model's representation on the server -- if you're\n    // using Backbone's restful methods, override this to change the endpoint\n    // that will be called.\n    url: function() {\n      var base =\n        _.result(this, 'urlRoot') ||\n        _.result(this.collection, 'url') ||\n        urlError();\n      if (this.isNew()) return base;\n      var id = this.get(this.idAttribute);\n      return base.replace(/[^\\/]$/, '$&/') + encodeURIComponent(id);\n    },\n\n    // **parse** converts a response into the hash of attributes to be `set` on\n    // the model. The default implementation is just to pass the response along.\n    parse: function(resp, options) {\n      return resp;\n    },\n\n    // Create a new model with identical attributes to this one.\n    clone: function() {\n      return new this.constructor(this.attributes);\n    },\n\n    // A model is new if it has never been saved to the server, and lacks an id.\n    isNew: function() {\n      return !this.has(this.idAttribute);\n    },\n\n    // Check if the model is currently in a valid state.\n    isValid: function(options) {\n      return this._validate({}, _.extend({}, options, {validate: true}));\n    },\n\n    // Run validation against the next complete set of model attributes,\n    // returning `true` if all is well. Otherwise, fire an `\"invalid\"` event.\n    _validate: function(attrs, options) {\n      if (!options.validate || !this.validate) return true;\n      attrs = _.extend({}, this.attributes, attrs);\n      var error = this.validationError = this.validate(attrs, options) || null;\n      if (!error) return true;\n      this.trigger('invalid', this, error, _.extend(options, {validationError: error}));\n      return false;\n    }\n\n  });\n\n  // Underscore methods that we want to implement on the Model, mapped to the\n  // number of arguments they take.\n  var modelMethods = {keys: 1, values: 1, pairs: 1, invert: 1, pick: 0,\n      omit: 0, chain: 1, isEmpty: 1};\n\n  // Mix in each Underscore method as a proxy to `Model#attributes`.\n  addUnderscoreMethods(Model, modelMethods, 'attributes');\n\n  // Backbone.Collection\n  // -------------------\n\n  // If models tend to represent a single row of data, a Backbone Collection is\n  // more analogous to a table full of data ... or a small slice or page of that\n  // table, or a collection of rows that belong together for a particular reason\n  // -- all of the messages in this particular folder, all of the documents\n  // belonging to this particular author, and so on. Collections maintain\n  // indexes of their models, both in order, and for lookup by `id`.\n\n  // Create a new **Collection**, perhaps to contain a specific type of `model`.\n  // If a `comparator` is specified, the Collection will maintain\n  // its models in sort order, as they're added and removed.\n  var Collection = Backbone.Collection = function(models, options) {\n    options || (options = {});\n    if (options.model) this.model = options.model;\n    if (options.comparator !== void 0) this.comparator = options.comparator;\n    this._reset();\n    this.initialize.apply(this, arguments);\n    if (models) this.reset(models, _.extend({silent: true}, options));\n  };\n\n  // Default options for `Collection#set`.\n  var setOptions = {add: true, remove: true, merge: true};\n  var addOptions = {add: true, remove: false};\n\n  // Splices `insert` into `array` at index `at`.\n  var splice = function(array, insert, at) {\n    at = Math.min(Math.max(at, 0), array.length);\n    var tail = Array(array.length - at);\n    var length = insert.length;\n    var i;\n    for (i = 0; i < tail.length; i++) tail[i] = array[i + at];\n    for (i = 0; i < length; i++) array[i + at] = insert[i];\n    for (i = 0; i < tail.length; i++) array[i + length + at] = tail[i];\n  };\n\n  // Define the Collection's inheritable methods.\n  _.extend(Collection.prototype, Events, {\n\n    // The default model for a collection is just a **Backbone.Model**.\n    // This should be overridden in most cases.\n    model: Model,\n\n    // Initialize is an empty function by default. Override it with your own\n    // initialization logic.\n    initialize: function(){},\n\n    // The JSON representation of a Collection is an array of the\n    // models' attributes.\n    toJSON: function(options) {\n      return this.map(function(model) { return model.toJSON(options); });\n    },\n\n    // Proxy `Backbone.sync` by default.\n    sync: function() {\n      return Backbone.sync.apply(this, arguments);\n    },\n\n    // Add a model, or list of models to the set. `models` may be Backbone\n    // Models or raw JavaScript objects to be converted to Models, or any\n    // combination of the two.\n    add: function(models, options) {\n      return this.set(models, _.extend({merge: false}, options, addOptions));\n    },\n\n    // Remove a model, or a list of models from the set.\n    remove: function(models, options) {\n      options = _.extend({}, options);\n      var singular = !_.isArray(models);\n      models = singular ? [models] : models.slice();\n      var removed = this._removeModels(models, options);\n      if (!options.silent && removed.length) {\n        options.changes = {added: [], merged: [], removed: removed};\n        this.trigger('update', this, options);\n      }\n      return singular ? removed[0] : removed;\n    },\n\n    // Update a collection by `set`-ing a new list of models, adding new ones,\n    // removing models that are no longer present, and merging models that\n    // already exist in the collection, as necessary. Similar to **Model#set**,\n    // the core operation for updating the data contained by the collection.\n    set: function(models, options) {\n      if (models == null) return;\n\n      options = _.extend({}, setOptions, options);\n      if (options.parse && !this._isModel(models)) {\n        models = this.parse(models, options) || [];\n      }\n\n      var singular = !_.isArray(models);\n      models = singular ? [models] : models.slice();\n\n      var at = options.at;\n      if (at != null) at = +at;\n      if (at > this.length) at = this.length;\n      if (at < 0) at += this.length + 1;\n\n      var set = [];\n      var toAdd = [];\n      var toMerge = [];\n      var toRemove = [];\n      var modelMap = {};\n\n      var add = options.add;\n      var merge = options.merge;\n      var remove = options.remove;\n\n      var sort = false;\n      var sortable = this.comparator && at == null && options.sort !== false;\n      var sortAttr = _.isString(this.comparator) ? this.comparator : null;\n\n      // Turn bare objects into model references, and prevent invalid models\n      // from being added.\n      var model, i;\n      for (i = 0; i < models.length; i++) {\n        model = models[i];\n\n        // If a duplicate is found, prevent it from being added and\n        // optionally merge it into the existing model.\n        var existing = this.get(model);\n        if (existing) {\n          if (merge && model !== existing) {\n            var attrs = this._isModel(model) ? model.attributes : model;\n            if (options.parse) attrs = existing.parse(attrs, options);\n            existing.set(attrs, options);\n            toMerge.push(existing);\n            if (sortable && !sort) sort = existing.hasChanged(sortAttr);\n          }\n          if (!modelMap[existing.cid]) {\n            modelMap[existing.cid] = true;\n            set.push(existing);\n          }\n          models[i] = existing;\n\n        // If this is a new, valid model, push it to the `toAdd` list.\n        } else if (add) {\n          model = models[i] = this._prepareModel(model, options);\n          if (model) {\n            toAdd.push(model);\n            this._addReference(model, options);\n            modelMap[model.cid] = true;\n            set.push(model);\n          }\n        }\n      }\n\n      // Remove stale models.\n      if (remove) {\n        for (i = 0; i < this.length; i++) {\n          model = this.models[i];\n          if (!modelMap[model.cid]) toRemove.push(model);\n        }\n        if (toRemove.length) this._removeModels(toRemove, options);\n      }\n\n      // See if sorting is needed, update `length` and splice in new models.\n      var orderChanged = false;\n      var replace = !sortable && add && remove;\n      if (set.length && replace) {\n        orderChanged = this.length !== set.length || _.some(this.models, function(m, index) {\n          return m !== set[index];\n        });\n        this.models.length = 0;\n        splice(this.models, set, 0);\n        this.length = this.models.length;\n      } else if (toAdd.length) {\n        if (sortable) sort = true;\n        splice(this.models, toAdd, at == null ? this.length : at);\n        this.length = this.models.length;\n      }\n\n      // Silently sort the collection if appropriate.\n      if (sort) this.sort({silent: true});\n\n      // Unless silenced, it's time to fire all appropriate add/sort/update events.\n      if (!options.silent) {\n        for (i = 0; i < toAdd.length; i++) {\n          if (at != null) options.index = at + i;\n          model = toAdd[i];\n          model.trigger('add', model, this, options);\n        }\n        if (sort || orderChanged) this.trigger('sort', this, options);\n        if (toAdd.length || toRemove.length || toMerge.length) {\n          options.changes = {\n            added: toAdd,\n            removed: toRemove,\n            merged: toMerge\n          };\n          this.trigger('update', this, options);\n        }\n      }\n\n      // Return the added (or merged) model (or models).\n      return singular ? models[0] : models;\n    },\n\n    // When you have more items than you want to add or remove individually,\n    // you can reset the entire set with a new list of models, without firing\n    // any granular `add` or `remove` events. Fires `reset` when finished.\n    // Useful for bulk operations and optimizations.\n    reset: function(models, options) {\n      options = options ? _.clone(options) : {};\n      for (var i = 0; i < this.models.length; i++) {\n        this._removeReference(this.models[i], options);\n      }\n      options.previousModels = this.models;\n      this._reset();\n      models = this.add(models, _.extend({silent: true}, options));\n      if (!options.silent) this.trigger('reset', this, options);\n      return models;\n    },\n\n    // Add a model to the end of the collection.\n    push: function(model, options) {\n      return this.add(model, _.extend({at: this.length}, options));\n    },\n\n    // Remove a model from the end of the collection.\n    pop: function(options) {\n      var model = this.at(this.length - 1);\n      return this.remove(model, options);\n    },\n\n    // Add a model to the beginning of the collection.\n    unshift: function(model, options) {\n      return this.add(model, _.extend({at: 0}, options));\n    },\n\n    // Remove a model from the beginning of the collection.\n    shift: function(options) {\n      var model = this.at(0);\n      return this.remove(model, options);\n    },\n\n    // Slice out a sub-array of models from the collection.\n    slice: function() {\n      return slice.apply(this.models, arguments);\n    },\n\n    // Get a model from the set by id, cid, model object with id or cid\n    // properties, or an attributes object that is transformed through modelId.\n    get: function(obj) {\n      if (obj == null) return void 0;\n      return this._byId[obj] ||\n        this._byId[this.modelId(obj.attributes || obj)] ||\n        obj.cid && this._byId[obj.cid];\n    },\n\n    // Returns `true` if the model is in the collection.\n    has: function(obj) {\n      return this.get(obj) != null;\n    },\n\n    // Get the model at the given index.\n    at: function(index) {\n      if (index < 0) index += this.length;\n      return this.models[index];\n    },\n\n    // Return models with matching attributes. Useful for simple cases of\n    // `filter`.\n    where: function(attrs, first) {\n      return this[first ? 'find' : 'filter'](attrs);\n    },\n\n    // Return the first model with matching attributes. Useful for simple cases\n    // of `find`.\n    findWhere: function(attrs) {\n      return this.where(attrs, true);\n    },\n\n    // Force the collection to re-sort itself. You don't need to call this under\n    // normal circumstances, as the set will maintain sort order as each item\n    // is added.\n    sort: function(options) {\n      var comparator = this.comparator;\n      if (!comparator) throw new Error('Cannot sort a set without a comparator');\n      options || (options = {});\n\n      var length = comparator.length;\n      if (_.isFunction(comparator)) comparator = _.bind(comparator, this);\n\n      // Run sort based on type of `comparator`.\n      if (length === 1 || _.isString(comparator)) {\n        this.models = this.sortBy(comparator);\n      } else {\n        this.models.sort(comparator);\n      }\n      if (!options.silent) this.trigger('sort', this, options);\n      return this;\n    },\n\n    // Pluck an attribute from each model in the collection.\n    pluck: function(attr) {\n      return this.map(attr + '');\n    },\n\n    // Fetch the default set of models for this collection, resetting the\n    // collection when they arrive. If `reset: true` is passed, the response\n    // data will be passed through the `reset` method instead of `set`.\n    fetch: function(options) {\n      options = _.extend({parse: true}, options);\n      var success = options.success;\n      var collection = this;\n      options.success = function(resp) {\n        var method = options.reset ? 'reset' : 'set';\n        collection[method](resp, options);\n        if (success) success.call(options.context, collection, resp, options);\n        collection.trigger('sync', collection, resp, options);\n      };\n      wrapError(this, options);\n      return this.sync('read', this, options);\n    },\n\n    // Create a new instance of a model in this collection. Add the model to the\n    // collection immediately, unless `wait: true` is passed, in which case we\n    // wait for the server to agree.\n    create: function(model, options) {\n      options = options ? _.clone(options) : {};\n      var wait = options.wait;\n      model = this._prepareModel(model, options);\n      if (!model) return false;\n      if (!wait) this.add(model, options);\n      var collection = this;\n      var success = options.success;\n      options.success = function(m, resp, callbackOpts) {\n        if (wait) collection.add(m, callbackOpts);\n        if (success) success.call(callbackOpts.context, m, resp, callbackOpts);\n      };\n      model.save(null, options);\n      return model;\n    },\n\n    // **parse** converts a response into a list of models to be added to the\n    // collection. The default implementation is just to pass it through.\n    parse: function(resp, options) {\n      return resp;\n    },\n\n    // Create a new collection with an identical list of models as this one.\n    clone: function() {\n      return new this.constructor(this.models, {\n        model: this.model,\n        comparator: this.comparator\n      });\n    },\n\n    // Define how to uniquely identify models in the collection.\n    modelId: function(attrs) {\n      return attrs[this.model.prototype.idAttribute || 'id'];\n    },\n\n    // Private method to reset all internal state. Called when the collection\n    // is first initialized or reset.\n    _reset: function() {\n      this.length = 0;\n      this.models = [];\n      this._byId  = {};\n    },\n\n    // Prepare a hash of attributes (or other model) to be added to this\n    // collection.\n    _prepareModel: function(attrs, options) {\n      if (this._isModel(attrs)) {\n        if (!attrs.collection) attrs.collection = this;\n        return attrs;\n      }\n      options = options ? _.clone(options) : {};\n      options.collection = this;\n      var model = new this.model(attrs, options);\n      if (!model.validationError) return model;\n      this.trigger('invalid', this, model.validationError, options);\n      return false;\n    },\n\n    // Internal method called by both remove and set.\n    _removeModels: function(models, options) {\n      var removed = [];\n      for (var i = 0; i < models.length; i++) {\n        var model = this.get(models[i]);\n        if (!model) continue;\n\n        var index = this.indexOf(model);\n        this.models.splice(index, 1);\n        this.length--;\n\n        // Remove references before triggering 'remove' event to prevent an\n        // infinite loop. #3693\n        delete this._byId[model.cid];\n        var id = this.modelId(model.attributes);\n        if (id != null) delete this._byId[id];\n\n        if (!options.silent) {\n          options.index = index;\n          model.trigger('remove', model, this, options);\n        }\n\n        removed.push(model);\n        this._removeReference(model, options);\n      }\n      return removed;\n    },\n\n    // Method for checking whether an object should be considered a model for\n    // the purposes of adding to the collection.\n    _isModel: function(model) {\n      return model instanceof Model;\n    },\n\n    // Internal method to create a model's ties to a collection.\n    _addReference: function(model, options) {\n      this._byId[model.cid] = model;\n      var id = this.modelId(model.attributes);\n      if (id != null) this._byId[id] = model;\n      model.on('all', this._onModelEvent, this);\n    },\n\n    // Internal method to sever a model's ties to a collection.\n    _removeReference: function(model, options) {\n      delete this._byId[model.cid];\n      var id = this.modelId(model.attributes);\n      if (id != null) delete this._byId[id];\n      if (this === model.collection) delete model.collection;\n      model.off('all', this._onModelEvent, this);\n    },\n\n    // Internal method called every time a model in the set fires an event.\n    // Sets need to update their indexes when models change ids. All other\n    // events simply proxy through. \"add\" and \"remove\" events that originate\n    // in other collections are ignored.\n    _onModelEvent: function(event, model, collection, options) {\n      if (model) {\n        if ((event === 'add' || event === 'remove') && collection !== this) return;\n        if (event === 'destroy') this.remove(model, options);\n        if (event === 'change') {\n          var prevId = this.modelId(model.previousAttributes());\n          var id = this.modelId(model.attributes);\n          if (prevId !== id) {\n            if (prevId != null) delete this._byId[prevId];\n            if (id != null) this._byId[id] = model;\n          }\n        }\n      }\n      this.trigger.apply(this, arguments);\n    }\n\n  });\n\n  // Underscore methods that we want to implement on the Collection.\n  // 90% of the core usefulness of Backbone Collections is actually implemented\n  // right here:\n  var collectionMethods = {forEach: 3, each: 3, map: 3, collect: 3, reduce: 0,\n      foldl: 0, inject: 0, reduceRight: 0, foldr: 0, find: 3, detect: 3, filter: 3,\n      select: 3, reject: 3, every: 3, all: 3, some: 3, any: 3, include: 3, includes: 3,\n      contains: 3, invoke: 0, max: 3, min: 3, toArray: 1, size: 1, first: 3,\n      head: 3, take: 3, initial: 3, rest: 3, tail: 3, drop: 3, last: 3,\n      without: 0, difference: 0, indexOf: 3, shuffle: 1, lastIndexOf: 3,\n      isEmpty: 1, chain: 1, sample: 3, partition: 3, groupBy: 3, countBy: 3,\n      sortBy: 3, indexBy: 3, findIndex: 3, findLastIndex: 3};\n\n  // Mix in each Underscore method as a proxy to `Collection#models`.\n  addUnderscoreMethods(Collection, collectionMethods, 'models');\n\n  // Backbone.View\n  // -------------\n\n  // Backbone Views are almost more convention than they are actual code. A View\n  // is simply a JavaScript object that represents a logical chunk of UI in the\n  // DOM. This might be a single item, an entire list, a sidebar or panel, or\n  // even the surrounding frame which wraps your whole app. Defining a chunk of\n  // UI as a **View** allows you to define your DOM events declaratively, without\n  // having to worry about render order ... and makes it easy for the view to\n  // react to specific changes in the state of your models.\n\n  // Creating a Backbone.View creates its initial element outside of the DOM,\n  // if an existing element is not provided...\n  var View = Backbone.View = function(options) {\n    this.cid = _.uniqueId('view');\n    _.extend(this, _.pick(options, viewOptions));\n    this._ensureElement();\n    this.initialize.apply(this, arguments);\n  };\n\n  // Cached regex to split keys for `delegate`.\n  var delegateEventSplitter = /^(\\S+)\\s*(.*)$/;\n\n  // List of view options to be set as properties.\n  var viewOptions = ['model', 'collection', 'el', 'id', 'attributes', 'className', 'tagName', 'events'];\n\n  // Set up all inheritable **Backbone.View** properties and methods.\n  _.extend(View.prototype, Events, {\n\n    // The default `tagName` of a View's element is `\"div\"`.\n    tagName: 'div',\n\n    // jQuery delegate for element lookup, scoped to DOM elements within the\n    // current view. This should be preferred to global lookups where possible.\n    $: function(selector) {\n      return this.$el.find(selector);\n    },\n\n    // Initialize is an empty function by default. Override it with your own\n    // initialization logic.\n    initialize: function(){},\n\n    // **render** is the core function that your view should override, in order\n    // to populate its element (`this.el`), with the appropriate HTML. The\n    // convention is for **render** to always return `this`.\n    render: function() {\n      return this;\n    },\n\n    // Remove this view by taking the element out of the DOM, and removing any\n    // applicable Backbone.Events listeners.\n    remove: function() {\n      this._removeElement();\n      this.stopListening();\n      return this;\n    },\n\n    // Remove this view's element from the document and all event listeners\n    // attached to it. Exposed for subclasses using an alternative DOM\n    // manipulation API.\n    _removeElement: function() {\n      this.$el.remove();\n    },\n\n    // Change the view's element (`this.el` property) and re-delegate the\n    // view's events on the new element.\n    setElement: function(element) {\n      this.undelegateEvents();\n      this._setElement(element);\n      this.delegateEvents();\n      return this;\n    },\n\n    // Creates the `this.el` and `this.$el` references for this view using the\n    // given `el`. `el` can be a CSS selector or an HTML string, a jQuery\n    // context or an element. Subclasses can override this to utilize an\n    // alternative DOM manipulation API and are only required to set the\n    // `this.el` property.\n    _setElement: function(el) {\n      this.$el = el instanceof Backbone.$ ? el : Backbone.$(el);\n      this.el = this.$el[0];\n    },\n\n    // Set callbacks, where `this.events` is a hash of\n    //\n    // *{\"event selector\": \"callback\"}*\n    //\n    //     {\n    //       'mousedown .title':  'edit',\n    //       'click .button':     'save',\n    //       'click .open':       function(e) { ... }\n    //     }\n    //\n    // pairs. Callbacks will be bound to the view, with `this` set properly.\n    // Uses event delegation for efficiency.\n    // Omitting the selector binds the event to `this.el`.\n    delegateEvents: function(events) {\n      events || (events = _.result(this, 'events'));\n      if (!events) return this;\n      this.undelegateEvents();\n      for (var key in events) {\n        var method = events[key];\n        if (!_.isFunction(method)) method = this[method];\n        if (!method) continue;\n        var match = key.match(delegateEventSplitter);\n        this.delegate(match[1], match[2], _.bind(method, this));\n      }\n      return this;\n    },\n\n    // Add a single event listener to the view's element (or a child element\n    // using `selector`). This only works for delegate-able events: not `focus`,\n    // `blur`, and not `change`, `submit`, and `reset` in Internet Explorer.\n    delegate: function(eventName, selector, listener) {\n      this.$el.on(eventName + '.delegateEvents' + this.cid, selector, listener);\n      return this;\n    },\n\n    // Clears all callbacks previously bound to the view by `delegateEvents`.\n    // You usually don't need to use this, but may wish to if you have multiple\n    // Backbone views attached to the same DOM element.\n    undelegateEvents: function() {\n      if (this.$el) this.$el.off('.delegateEvents' + this.cid);\n      return this;\n    },\n\n    // A finer-grained `undelegateEvents` for removing a single delegated event.\n    // `selector` and `listener` are both optional.\n    undelegate: function(eventName, selector, listener) {\n      this.$el.off(eventName + '.delegateEvents' + this.cid, selector, listener);\n      return this;\n    },\n\n    // Produces a DOM element to be assigned to your view. Exposed for\n    // subclasses using an alternative DOM manipulation API.\n    _createElement: function(tagName) {\n      return document.createElement(tagName);\n    },\n\n    // Ensure that the View has a DOM element to render into.\n    // If `this.el` is a string, pass it through `$()`, take the first\n    // matching element, and re-assign it to `el`. Otherwise, create\n    // an element from the `id`, `className` and `tagName` properties.\n    _ensureElement: function() {\n      if (!this.el) {\n        var attrs = _.extend({}, _.result(this, 'attributes'));\n        if (this.id) attrs.id = _.result(this, 'id');\n        if (this.className) attrs['class'] = _.result(this, 'className');\n        this.setElement(this._createElement(_.result(this, 'tagName')));\n        this._setAttributes(attrs);\n      } else {\n        this.setElement(_.result(this, 'el'));\n      }\n    },\n\n    // Set attributes from a hash on this view's element.  Exposed for\n    // subclasses using an alternative DOM manipulation API.\n    _setAttributes: function(attributes) {\n      this.$el.attr(attributes);\n    }\n\n  });\n\n  // Backbone.sync\n  // -------------\n\n  // Override this function to change the manner in which Backbone persists\n  // models to the server. You will be passed the type of request, and the\n  // model in question. By default, makes a RESTful Ajax request\n  // to the model's `url()`. Some possible customizations could be:\n  //\n  // * Use `setTimeout` to batch rapid-fire updates into a single request.\n  // * Send up the models as XML instead of JSON.\n  // * Persist models via WebSockets instead of Ajax.\n  //\n  // Turn on `Backbone.emulateHTTP` in order to send `PUT` and `DELETE` requests\n  // as `POST`, with a `_method` parameter containing the true HTTP method,\n  // as well as all requests with the body as `application/x-www-form-urlencoded`\n  // instead of `application/json` with the model in a param named `model`.\n  // Useful when interfacing with server-side languages like **PHP** that make\n  // it difficult to read the body of `PUT` requests.\n  Backbone.sync = function(method, model, options) {\n    var type = methodMap[method];\n\n    // Default options, unless specified.\n    _.defaults(options || (options = {}), {\n      emulateHTTP: Backbone.emulateHTTP,\n      emulateJSON: Backbone.emulateJSON\n    });\n\n    // Default JSON-request options.\n    var params = {type: type, dataType: 'json'};\n\n    // Ensure that we have a URL.\n    if (!options.url) {\n      params.url = _.result(model, 'url') || urlError();\n    }\n\n    // Ensure that we have the appropriate request data.\n    if (options.data == null && model && (method === 'create' || method === 'update' || method === 'patch')) {\n      params.contentType = 'application/json';\n      params.data = JSON.stringify(options.attrs || model.toJSON(options));\n    }\n\n    // For older servers, emulate JSON by encoding the request into an HTML-form.\n    if (options.emulateJSON) {\n      params.contentType = 'application/x-www-form-urlencoded';\n      params.data = params.data ? {model: params.data} : {};\n    }\n\n    // For older servers, emulate HTTP by mimicking the HTTP method with `_method`\n    // And an `X-HTTP-Method-Override` header.\n    if (options.emulateHTTP && (type === 'PUT' || type === 'DELETE' || type === 'PATCH')) {\n      params.type = 'POST';\n      if (options.emulateJSON) params.data._method = type;\n      var beforeSend = options.beforeSend;\n      options.beforeSend = function(xhr) {\n        xhr.setRequestHeader('X-HTTP-Method-Override', type);\n        if (beforeSend) return beforeSend.apply(this, arguments);\n      };\n    }\n\n    // Don't process data on a non-GET request.\n    if (params.type !== 'GET' && !options.emulateJSON) {\n      params.processData = false;\n    }\n\n    // Pass along `textStatus` and `errorThrown` from jQuery.\n    var error = options.error;\n    options.error = function(xhr, textStatus, errorThrown) {\n      options.textStatus = textStatus;\n      options.errorThrown = errorThrown;\n      if (error) error.call(options.context, xhr, textStatus, errorThrown);\n    };\n\n    // Make the request, allowing the user to override any Ajax options.\n    var xhr = options.xhr = Backbone.ajax(_.extend(params, options));\n    model.trigger('request', model, xhr, options);\n    return xhr;\n  };\n\n  // Map from CRUD to HTTP for our default `Backbone.sync` implementation.\n  var methodMap = {\n    'create': 'POST',\n    'update': 'PUT',\n    'patch': 'PATCH',\n    'delete': 'DELETE',\n    'read': 'GET'\n  };\n\n  // Set the default implementation of `Backbone.ajax` to proxy through to `$`.\n  // Override this if you'd like to use a different library.\n  Backbone.ajax = function() {\n    return Backbone.$.ajax.apply(Backbone.$, arguments);\n  };\n\n  // Backbone.Router\n  // ---------------\n\n  // Routers map faux-URLs to actions, and fire events when routes are\n  // matched. Creating a new one sets its `routes` hash, if not set statically.\n  var Router = Backbone.Router = function(options) {\n    options || (options = {});\n    if (options.routes) this.routes = options.routes;\n    this._bindRoutes();\n    this.initialize.apply(this, arguments);\n  };\n\n  // Cached regular expressions for matching named param parts and splatted\n  // parts of route strings.\n  var optionalParam = /\\((.*?)\\)/g;\n  var namedParam    = /(\\(\\?)?:\\w+/g;\n  var splatParam    = /\\*\\w+/g;\n  var escapeRegExp  = /[\\-{}\\[\\]+?.,\\\\\\^$|#\\s]/g;\n\n  // Set up all inheritable **Backbone.Router** properties and methods.\n  _.extend(Router.prototype, Events, {\n\n    // Initialize is an empty function by default. Override it with your own\n    // initialization logic.\n    initialize: function(){},\n\n    // Manually bind a single named route to a callback. For example:\n    //\n    //     this.route('search/:query/p:num', 'search', function(query, num) {\n    //       ...\n    //     });\n    //\n    route: function(route, name, callback) {\n      if (!_.isRegExp(route)) route = this._routeToRegExp(route);\n      if (_.isFunction(name)) {\n        callback = name;\n        name = '';\n      }\n      if (!callback) callback = this[name];\n      var router = this;\n      Backbone.history.route(route, function(fragment) {\n        var args = router._extractParameters(route, fragment);\n        if (router.execute(callback, args, name) !== false) {\n          router.trigger.apply(router, ['route:' + name].concat(args));\n          router.trigger('route', name, args);\n          Backbone.history.trigger('route', router, name, args);\n        }\n      });\n      return this;\n    },\n\n    // Execute a route handler with the provided parameters.  This is an\n    // excellent place to do pre-route setup or post-route cleanup.\n    execute: function(callback, args, name) {\n      if (callback) callback.apply(this, args);\n    },\n\n    // Simple proxy to `Backbone.history` to save a fragment into the history.\n    navigate: function(fragment, options) {\n      Backbone.history.navigate(fragment, options);\n      return this;\n    },\n\n    // Bind all defined routes to `Backbone.history`. We have to reverse the\n    // order of the routes here to support behavior where the most general\n    // routes can be defined at the bottom of the route map.\n    _bindRoutes: function() {\n      if (!this.routes) return;\n      this.routes = _.result(this, 'routes');\n      var route, routes = _.keys(this.routes);\n      while ((route = routes.pop()) != null) {\n        this.route(route, this.routes[route]);\n      }\n    },\n\n    // Convert a route string into a regular expression, suitable for matching\n    // against the current location hash.\n    _routeToRegExp: function(route) {\n      route = route.replace(escapeRegExp, '\\\\$&')\n                   .replace(optionalParam, '(?:$1)?')\n                   .replace(namedParam, function(match, optional) {\n                     return optional ? match : '([^/?]+)';\n                   })\n                   .replace(splatParam, '([^?]*?)');\n      return new RegExp('^' + route + '(?:\\\\?([\\\\s\\\\S]*))?$');\n    },\n\n    // Given a route, and a URL fragment that it matches, return the array of\n    // extracted decoded parameters. Empty or unmatched parameters will be\n    // treated as `null` to normalize cross-browser behavior.\n    _extractParameters: function(route, fragment) {\n      var params = route.exec(fragment).slice(1);\n      return _.map(params, function(param, i) {\n        // Don't decode the search params.\n        if (i === params.length - 1) return param || null;\n        return param ? decodeURIComponent(param) : null;\n      });\n    }\n\n  });\n\n  // Backbone.History\n  // ----------------\n\n  // Handles cross-browser history management, based on either\n  // [pushState](http://diveintohtml5.info/history.html) and real URLs, or\n  // [onhashchange](https://developer.mozilla.org/en-US/docs/DOM/window.onhashchange)\n  // and URL fragments. If the browser supports neither (old IE, natch),\n  // falls back to polling.\n  var History = Backbone.History = function() {\n    this.handlers = [];\n    this.checkUrl = _.bind(this.checkUrl, this);\n\n    // Ensure that `History` can be used outside of the browser.\n    if (typeof window !== 'undefined') {\n      this.location = window.location;\n      this.history = window.history;\n    }\n  };\n\n  // Cached regex for stripping a leading hash/slash and trailing space.\n  var routeStripper = /^[#\\/]|\\s+$/g;\n\n  // Cached regex for stripping leading and trailing slashes.\n  var rootStripper = /^\\/+|\\/+$/g;\n\n  // Cached regex for stripping urls of hash.\n  var pathStripper = /#.*$/;\n\n  // Has the history handling already been started?\n  History.started = false;\n\n  // Set up all inheritable **Backbone.History** properties and methods.\n  _.extend(History.prototype, Events, {\n\n    // The default interval to poll for hash changes, if necessary, is\n    // twenty times a second.\n    interval: 50,\n\n    // Are we at the app root?\n    atRoot: function() {\n      var path = this.location.pathname.replace(/[^\\/]$/, '$&/');\n      return path === this.root && !this.getSearch();\n    },\n\n    // Does the pathname match the root?\n    matchRoot: function() {\n      var path = this.decodeFragment(this.location.pathname);\n      var rootPath = path.slice(0, this.root.length - 1) + '/';\n      return rootPath === this.root;\n    },\n\n    // Unicode characters in `location.pathname` are percent encoded so they're\n    // decoded for comparison. `%25` should not be decoded since it may be part\n    // of an encoded parameter.\n    decodeFragment: function(fragment) {\n      return decodeURI(fragment.replace(/%25/g, '%2525'));\n    },\n\n    // In IE6, the hash fragment and search params are incorrect if the\n    // fragment contains `?`.\n    getSearch: function() {\n      var match = this.location.href.replace(/#.*/, '').match(/\\?.+/);\n      return match ? match[0] : '';\n    },\n\n    // Gets the true hash value. Cannot use location.hash directly due to bug\n    // in Firefox where location.hash will always be decoded.\n    getHash: function(window) {\n      var match = (window || this).location.href.match(/#(.*)$/);\n      return match ? match[1] : '';\n    },\n\n    // Get the pathname and search params, without the root.\n    getPath: function() {\n      var path = this.decodeFragment(\n        this.location.pathname + this.getSearch()\n      ).slice(this.root.length - 1);\n      return path.charAt(0) === '/' ? path.slice(1) : path;\n    },\n\n    // Get the cross-browser normalized URL fragment from the path or hash.\n    getFragment: function(fragment) {\n      if (fragment == null) {\n        if (this._usePushState || !this._wantsHashChange) {\n          fragment = this.getPath();\n        } else {\n          fragment = this.getHash();\n        }\n      }\n      return fragment.replace(routeStripper, '');\n    },\n\n    // Start the hash change handling, returning `true` if the current URL matches\n    // an existing route, and `false` otherwise.\n    start: function(options) {\n      if (History.started) throw new Error('Backbone.history has already been started');\n      History.started = true;\n\n      // Figure out the initial configuration. Do we need an iframe?\n      // Is pushState desired ... is it available?\n      this.options          = _.extend({root: '/'}, this.options, options);\n      this.root             = this.options.root;\n      this._wantsHashChange = this.options.hashChange !== false;\n      this._hasHashChange   = 'onhashchange' in window && (document.documentMode === void 0 || document.documentMode > 7);\n      this._useHashChange   = this._wantsHashChange && this._hasHashChange;\n      this._wantsPushState  = !!this.options.pushState;\n      this._hasPushState    = !!(this.history && this.history.pushState);\n      this._usePushState    = this._wantsPushState && this._hasPushState;\n      this.fragment         = this.getFragment();\n\n      // Normalize root to always include a leading and trailing slash.\n      this.root = ('/' + this.root + '/').replace(rootStripper, '/');\n\n      // Transition from hashChange to pushState or vice versa if both are\n      // requested.\n      if (this._wantsHashChange && this._wantsPushState) {\n\n        // If we've started off with a route from a `pushState`-enabled\n        // browser, but we're currently in a browser that doesn't support it...\n        if (!this._hasPushState && !this.atRoot()) {\n          var rootPath = this.root.slice(0, -1) || '/';\n          this.location.replace(rootPath + '#' + this.getPath());\n          // Return immediately as browser will do redirect to new url\n          return true;\n\n        // Or if we've started out with a hash-based route, but we're currently\n        // in a browser where it could be `pushState`-based instead...\n        } else if (this._hasPushState && this.atRoot()) {\n          this.navigate(this.getHash(), {replace: true});\n        }\n\n      }\n\n      // Proxy an iframe to handle location events if the browser doesn't\n      // support the `hashchange` event, HTML5 history, or the user wants\n      // `hashChange` but not `pushState`.\n      if (!this._hasHashChange && this._wantsHashChange && !this._usePushState) {\n        this.iframe = document.createElement('iframe');\n        this.iframe.src = 'javascript:0';\n        this.iframe.style.display = 'none';\n        this.iframe.tabIndex = -1;\n        var body = document.body;\n        // Using `appendChild` will throw on IE < 9 if the document is not ready.\n        var iWindow = body.insertBefore(this.iframe, body.firstChild).contentWindow;\n        iWindow.document.open();\n        iWindow.document.close();\n        iWindow.location.hash = '#' + this.fragment;\n      }\n\n      // Add a cross-platform `addEventListener` shim for older browsers.\n      var addEventListener = window.addEventListener || function(eventName, listener) {\n        return attachEvent('on' + eventName, listener);\n      };\n\n      // Depending on whether we're using pushState or hashes, and whether\n      // 'onhashchange' is supported, determine how we check the URL state.\n      if (this._usePushState) {\n        addEventListener('popstate', this.checkUrl, false);\n      } else if (this._useHashChange && !this.iframe) {\n        addEventListener('hashchange', this.checkUrl, false);\n      } else if (this._wantsHashChange) {\n        this._checkUrlInterval = setInterval(this.checkUrl, this.interval);\n      }\n\n      if (!this.options.silent) return this.loadUrl();\n    },\n\n    // Disable Backbone.history, perhaps temporarily. Not useful in a real app,\n    // but possibly useful for unit testing Routers.\n    stop: function() {\n      // Add a cross-platform `removeEventListener` shim for older browsers.\n      var removeEventListener = window.removeEventListener || function(eventName, listener) {\n        return detachEvent('on' + eventName, listener);\n      };\n\n      // Remove window listeners.\n      if (this._usePushState) {\n        removeEventListener('popstate', this.checkUrl, false);\n      } else if (this._useHashChange && !this.iframe) {\n        removeEventListener('hashchange', this.checkUrl, false);\n      }\n\n      // Clean up the iframe if necessary.\n      if (this.iframe) {\n        document.body.removeChild(this.iframe);\n        this.iframe = null;\n      }\n\n      // Some environments will throw when clearing an undefined interval.\n      if (this._checkUrlInterval) clearInterval(this._checkUrlInterval);\n      History.started = false;\n    },\n\n    // Add a route to be tested when the fragment changes. Routes added later\n    // may override previous routes.\n    route: function(route, callback) {\n      this.handlers.unshift({route: route, callback: callback});\n    },\n\n    // Checks the current URL to see if it has changed, and if it has,\n    // calls `loadUrl`, normalizing across the hidden iframe.\n    checkUrl: function(e) {\n      var current = this.getFragment();\n\n      // If the user pressed the back button, the iframe's hash will have\n      // changed and we should use that for comparison.\n      if (current === this.fragment && this.iframe) {\n        current = this.getHash(this.iframe.contentWindow);\n      }\n\n      if (current === this.fragment) return false;\n      if (this.iframe) this.navigate(current);\n      this.loadUrl();\n    },\n\n    // Attempt to load the current URL fragment. If a route succeeds with a\n    // match, returns `true`. If no defined routes matches the fragment,\n    // returns `false`.\n    loadUrl: function(fragment) {\n      // If the root doesn't match, no routes can match either.\n      if (!this.matchRoot()) return false;\n      fragment = this.fragment = this.getFragment(fragment);\n      return _.some(this.handlers, function(handler) {\n        if (handler.route.test(fragment)) {\n          handler.callback(fragment);\n          return true;\n        }\n      });\n    },\n\n    // Save a fragment into the hash history, or replace the URL state if the\n    // 'replace' option is passed. You are responsible for properly URL-encoding\n    // the fragment in advance.\n    //\n    // The options object can contain `trigger: true` if you wish to have the\n    // route callback be fired (not usually desirable), or `replace: true`, if\n    // you wish to modify the current URL without adding an entry to the history.\n    navigate: function(fragment, options) {\n      if (!History.started) return false;\n      if (!options || options === true) options = {trigger: !!options};\n\n      // Normalize the fragment.\n      fragment = this.getFragment(fragment || '');\n\n      // Don't include a trailing slash on the root.\n      var rootPath = this.root;\n      if (fragment === '' || fragment.charAt(0) === '?') {\n        rootPath = rootPath.slice(0, -1) || '/';\n      }\n      var url = rootPath + fragment;\n\n      // Strip the hash and decode for matching.\n      fragment = this.decodeFragment(fragment.replace(pathStripper, ''));\n\n      if (this.fragment === fragment) return;\n      this.fragment = fragment;\n\n      // If pushState is available, we use it to set the fragment as a real URL.\n      if (this._usePushState) {\n        this.history[options.replace ? 'replaceState' : 'pushState']({}, document.title, url);\n\n      // If hash changes haven't been explicitly disabled, update the hash\n      // fragment to store history.\n      } else if (this._wantsHashChange) {\n        this._updateHash(this.location, fragment, options.replace);\n        if (this.iframe && fragment !== this.getHash(this.iframe.contentWindow)) {\n          var iWindow = this.iframe.contentWindow;\n\n          // Opening and closing the iframe tricks IE7 and earlier to push a\n          // history entry on hash-tag change.  When replace is true, we don't\n          // want this.\n          if (!options.replace) {\n            iWindow.document.open();\n            iWindow.document.close();\n          }\n\n          this._updateHash(iWindow.location, fragment, options.replace);\n        }\n\n      // If you've told us that you explicitly don't want fallback hashchange-\n      // based history, then `navigate` becomes a page refresh.\n      } else {\n        return this.location.assign(url);\n      }\n      if (options.trigger) return this.loadUrl(fragment);\n    },\n\n    // Update the hash location, either replacing the current entry, or adding\n    // a new one to the browser history.\n    _updateHash: function(location, fragment, replace) {\n      if (replace) {\n        var href = location.href.replace(/(javascript:|#).*$/, '');\n        location.replace(href + '#' + fragment);\n      } else {\n        // Some browsers require that `hash` contains a leading #.\n        location.hash = '#' + fragment;\n      }\n    }\n\n  });\n\n  // Create the default Backbone.history.\n  Backbone.history = new History;\n\n  // Helpers\n  // -------\n\n  // Helper function to correctly set up the prototype chain for subclasses.\n  // Similar to `goog.inherits`, but uses a hash of prototype properties and\n  // class properties to be extended.\n  var extend = function(protoProps, staticProps) {\n    var parent = this;\n    var child;\n\n    // The constructor function for the new subclass is either defined by you\n    // (the \"constructor\" property in your `extend` definition), or defaulted\n    // by us to simply call the parent constructor.\n    if (protoProps && _.has(protoProps, 'constructor')) {\n      child = protoProps.constructor;\n    } else {\n      child = function(){ return parent.apply(this, arguments); };\n    }\n\n    // Add static properties to the constructor function, if supplied.\n    _.extend(child, parent, staticProps);\n\n    // Set the prototype chain to inherit from `parent`, without calling\n    // `parent`'s constructor function and add the prototype properties.\n    child.prototype = _.create(parent.prototype, protoProps);\n    child.prototype.constructor = child;\n\n    // Set a convenience property in case the parent's prototype is needed\n    // later.\n    child.__super__ = parent.prototype;\n\n    return child;\n  };\n\n  // Set up inheritance for the model, collection, router, view and history.\n  Model.extend = Collection.extend = Router.extend = View.extend = History.extend = extend;\n\n  // Throw an error when a URL is needed, and none is supplied.\n  var urlError = function() {\n    throw new Error('A \"url\" property or function must be specified');\n  };\n\n  // Wrap an optional error callback with a fallback error event.\n  var wrapError = function(model, options) {\n    var error = options.error;\n    options.error = function(resp) {\n      if (error) error.call(options.context, model, resp, options);\n      model.trigger('error', model, resp, options);\n    };\n  };\n\n  return Backbone;\n});\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))\n\n/***/ }),\n\n/***/ 38:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(Backbone, _, $) {\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\n\nvar _helpers = __webpack_require__(6);\n\nvar MMCollapsible = Backbone.View.extend({\n    events: {\n        'shown.bs.collapse': 'maybeScrollToTitle'\n    },\n\n    initialize: function initialize(opts) {\n        var defaults = {\n            scrollUpBuffer: 60, // the default amount of space to scroll up (past the start of the header) in the case that scroll up is required,\n            panelTitleSelector: '.panel-title' // the selector for the title of the collapsible\n        };\n\n        this.options = _.extend(defaults, opts || {});\n    },\n\n\n    // after showing a collapsible (specifically on mobile), if the panel header isn't visible, make sure to pull the viewport up\n    // to show the header\n    maybeScrollToTitle: function maybeScrollToTitle() {\n        var panelTop = this.$el.find(this.options.panelTitleSelector).offset().top;\n        if ((0, _helpers.scrollTopDistance)() > panelTop) {\n            $('html, body').animate({\n                scrollTop: panelTop - this.options.scrollUpBuffer\n            }, 500);\n        }\n    }\n}); /** we augment the default behavior of collapsibles. For instance, when opening a collapsible, if the result of the open\n     is that the title goes above the top of the screen, we scroll up to reveal the title **/\n\n\nvar collapsibleFactory = function collapsibleFactory(el) {\n    var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    return new MMCollapsible(_.extend({ el: el }, opts));\n};\n\nexports.default = collapsibleFactory;\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3), __webpack_require__(0), __webpack_require__(1)))\n\n/***/ }),\n\n/***/ 4:\n/***/ (function(module, exports) {\n\nvar g;\r\n\r\n// This works in non-strict mode\r\ng = (function() {\r\n\treturn this;\r\n})();\r\n\r\ntry {\r\n\t// This works if eval is allowed (see CSP)\r\n\tg = g || Function(\"return this\")() || (1,eval)(\"this\");\r\n} catch(e) {\r\n\t// This works if the window reference is available\r\n\tif(typeof window === \"object\")\r\n\t\tg = window;\r\n}\r\n\r\n// g can still be undefined, but nothing to do about it...\r\n// We return undefined, instead of nothing here, so it's\r\n// easier to handle this case. if(!global) { ...}\r\n\r\nmodule.exports = g;\r\n\n\n/***/ }),\n\n/***/ 5:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global) {\n\n// Use the fastest means possible to execute a task in its own turn, with\n// priority over other events including IO, animation, reflow, and redraw\n// events in browsers.\n//\n// An exception thrown by a task will permanently interrupt the processing of\n// subsequent tasks. The higher level `asap` function ensures that if an\n// exception is thrown by a task, that the task queue will continue flushing as\n// soon as possible, but if you use `rawAsap` directly, you are responsible to\n// either ensure that no exceptions are thrown from your task, or to manually\n// call `rawAsap.requestFlush` if an exception is thrown.\nmodule.exports = rawAsap;\nfunction rawAsap(task) {\n    if (!queue.length) {\n        requestFlush();\n        flushing = true;\n    }\n    // Equivalent to push, but avoids a function call.\n    queue[queue.length] = task;\n}\n\nvar queue = [];\n// Once a flush has been requested, no further calls to `requestFlush` are\n// necessary until the next `flush` completes.\nvar flushing = false;\n// `requestFlush` is an implementation-specific method that attempts to kick\n// off a `flush` event as quickly as possible. `flush` will attempt to exhaust\n// the event queue before yielding to the browser's own event loop.\nvar requestFlush;\n// The position of the next task to execute in the task queue. This is\n// preserved between calls to `flush` so that it can be resumed if\n// a task throws an exception.\nvar index = 0;\n// If a task schedules additional tasks recursively, the task queue can grow\n// unbounded. To prevent memory exhaustion, the task queue will periodically\n// truncate already-completed tasks.\nvar capacity = 1024;\n\n// The flush function processes all tasks that have been scheduled with\n// `rawAsap` unless and until one of those tasks throws an exception.\n// If a task throws an exception, `flush` ensures that its state will remain\n// consistent and will resume where it left off when called again.\n// However, `flush` does not make any arrangements to be called again if an\n// exception is thrown.\nfunction flush() {\n    while (index < queue.length) {\n        var currentIndex = index;\n        // Advance the index before calling the task. This ensures that we will\n        // begin flushing on the next task the task throws an error.\n        index = index + 1;\n        queue[currentIndex].call();\n        // Prevent leaking memory for long chains of recursive calls to `asap`.\n        // If we call `asap` within tasks scheduled by `asap`, the queue will\n        // grow, but to avoid an O(n) walk for every task we execute, we don't\n        // shift tasks off the queue after they have been executed.\n        // Instead, we periodically shift 1024 tasks off the queue.\n        if (index > capacity) {\n            // Manually shift all values starting at the index back to the\n            // beginning of the queue.\n            for (var scan = 0, newLength = queue.length - index; scan < newLength; scan++) {\n                queue[scan] = queue[scan + index];\n            }\n            queue.length -= index;\n            index = 0;\n        }\n    }\n    queue.length = 0;\n    index = 0;\n    flushing = false;\n}\n\n// `requestFlush` is implemented using a strategy based on data collected from\n// every available SauceLabs Selenium web driver worker at time of writing.\n// https://docs.google.com/spreadsheets/d/1mG-5UYGup5qxGdEMWkhP6BWCz053NUb2E1QoUTU16uA/edit#gid=783724593\n\n// Safari 6 and 6.1 for desktop, iPad, and iPhone are the only browsers that\n// have WebKitMutationObserver but not un-prefixed MutationObserver.\n// Must use `global` or `self` instead of `window` to work in both frames and web\n// workers. `global` is a provision of Browserify, Mr, Mrs, or Mop.\n\n/* globals self */\nvar scope = typeof global !== \"undefined\" ? global : self;\nvar BrowserMutationObserver = scope.MutationObserver || scope.WebKitMutationObserver;\n\n// MutationObservers are desirable because they have high priority and work\n// reliably everywhere they are implemented.\n// They are implemented in all modern browsers.\n//\n// - Android 4-4.3\n// - Chrome 26-34\n// - Firefox 14-29\n// - Internet Explorer 11\n// - iPad Safari 6-7.1\n// - iPhone Safari 7-7.1\n// - Safari 6-7\nif (typeof BrowserMutationObserver === \"function\") {\n    requestFlush = makeRequestCallFromMutationObserver(flush);\n\n// MessageChannels are desirable because they give direct access to the HTML\n// task queue, are implemented in Internet Explorer 10, Safari 5.0-1, and Opera\n// 11-12, and in web workers in many engines.\n// Although message channels yield to any queued rendering and IO tasks, they\n// would be better than imposing the 4ms delay of timers.\n// However, they do not work reliably in Internet Explorer or Safari.\n\n// Internet Explorer 10 is the only browser that has setImmediate but does\n// not have MutationObservers.\n// Although setImmediate yields to the browser's renderer, it would be\n// preferrable to falling back to setTimeout since it does not have\n// the minimum 4ms penalty.\n// Unfortunately there appears to be a bug in Internet Explorer 10 Mobile (and\n// Desktop to a lesser extent) that renders both setImmediate and\n// MessageChannel useless for the purposes of ASAP.\n// https://github.com/kriskowal/q/issues/396\n\n// Timers are implemented universally.\n// We fall back to timers in workers in most engines, and in foreground\n// contexts in the following browsers.\n// However, note that even this simple case requires nuances to operate in a\n// broad spectrum of browsers.\n//\n// - Firefox 3-13\n// - Internet Explorer 6-9\n// - iPad Safari 4.3\n// - Lynx 2.8.7\n} else {\n    requestFlush = makeRequestCallFromTimer(flush);\n}\n\n// `requestFlush` requests that the high priority event queue be flushed as\n// soon as possible.\n// This is useful to prevent an error thrown in a task from stalling the event\n// queue if the exception handled by Node.js’s\n// `process.on(\"uncaughtException\")` or by a domain.\nrawAsap.requestFlush = requestFlush;\n\n// To request a high priority event, we induce a mutation observer by toggling\n// the text of a text node between \"1\" and \"-1\".\nfunction makeRequestCallFromMutationObserver(callback) {\n    var toggle = 1;\n    var observer = new BrowserMutationObserver(callback);\n    var node = document.createTextNode(\"\");\n    observer.observe(node, {characterData: true});\n    return function requestCall() {\n        toggle = -toggle;\n        node.data = toggle;\n    };\n}\n\n// The message channel technique was discovered by Malte Ubl and was the\n// original foundation for this library.\n// http://www.nonblocking.io/2011/06/windownexttick.html\n\n// Safari 6.0.5 (at least) intermittently fails to create message ports on a\n// page's first load. Thankfully, this version of Safari supports\n// MutationObservers, so we don't need to fall back in that case.\n\n// function makeRequestCallFromMessageChannel(callback) {\n//     var channel = new MessageChannel();\n//     channel.port1.onmessage = callback;\n//     return function requestCall() {\n//         channel.port2.postMessage(0);\n//     };\n// }\n\n// For reasons explained above, we are also unable to use `setImmediate`\n// under any circumstances.\n// Even if we were, there is another bug in Internet Explorer 10.\n// It is not sufficient to assign `setImmediate` to `requestFlush` because\n// `setImmediate` must be called *by name* and therefore must be wrapped in a\n// closure.\n// Never forget.\n\n// function makeRequestCallFromSetImmediate(callback) {\n//     return function requestCall() {\n//         setImmediate(callback);\n//     };\n// }\n\n// Safari 6.0 has a problem where timers will get lost while the user is\n// scrolling. This problem does not impact ASAP because Safari 6.0 supports\n// mutation observers, so that implementation is used instead.\n// However, if we ever elect to use timers in Safari, the prevalent work-around\n// is to add a scroll event listener that calls for a flush.\n\n// `setTimeout` does not call the passed callback if the delay is less than\n// approximately 7 in web workers in Firefox 8 through 18, and sometimes not\n// even then.\n\nfunction makeRequestCallFromTimer(callback) {\n    return function requestCall() {\n        // We dispatch a timeout with a specified delay of 0 for engines that\n        // can reliably accommodate that request. This will usually be snapped\n        // to a 4 milisecond delay, but once we're flushing, there's no delay\n        // between events.\n        var timeoutHandle = setTimeout(handleTimer, 0);\n        // However, since this timer gets frequently dropped in Firefox\n        // workers, we enlist an interval handle that will try to fire\n        // an event 20 times per second until it succeeds.\n        var intervalHandle = setInterval(handleTimer, 50);\n\n        function handleTimer() {\n            // Whichever timer succeeds will cancel both timers and\n            // execute the callback.\n            clearTimeout(timeoutHandle);\n            clearInterval(intervalHandle);\n            callback();\n        }\n    };\n}\n\n// This is for `asap.js` only.\n// Its name will be periodically randomized to break any code that depends on\n// its existence.\nrawAsap.makeRequestCallFromTimer = makeRequestCallFromTimer;\n\n// ASAP was originally a nextTick shim included in Q. This was factored out\n// into this ASAP package. It was later adapted to RSVP which made further\n// amendments. These decisions, particularly to marginalize MessageChannel and\n// to capture the MutationObserver implementation in a closure, were integrated\n// back into ASAP proper.\n// https://github.com/tildeio/rsvp.js/blob/cddf7232546a9cf858524b75cde6f9edf72620a7/lib/rsvp/asap.js\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))\n\n/***/ }),\n\n/***/ 55:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(Backbone, $) {\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.makeSlidedown = makeSlidedown;\nexports.makeSlidedowns = makeSlidedowns;\n__webpack_require__(105);\nvar panelTpl = __webpack_require__(120);\n\nvar Slidedown = Backbone.Model.extend({\n    defaults: {\n        id: null,\n        title: null,\n        content: null\n    }\n});\n\nvar SlidedownPanel = Backbone.View.extend({\n    template: panelTpl,\n\n    initialize: function initialize() {\n        this.render();\n    },\n    render: function render() {\n        this.$el.html(this.template(this.model.attributes));\n        this.$el.collapse({\n            toggle: false\n        });\n    }\n});\n\n/**\n * construct a slidedown (bootstrap) element.\n * @param $el\n * @param model {Backbone.Model} instance to create a slidedown for\n * @param modelTransformer {Function} taking the backbone model as an argument, and returning an object containing the\n * data to set on a new {Slidedown} instance\n */\nfunction makeSlidedown($el, model, modelTransformer) {\n    var slidedown = new Slidedown(modelTransformer(model));\n\n    new SlidedownPanel({\n        el: $el,\n        model: slidedown\n    });\n}\n\nfunction makeSlidedowns($el, collection, modelTransformer) {\n    var $container = $('<div class=\"panel-group\" id=\"accordion\" role=\"tablist\" aria-multiselectable=\"true\"></div>');\n\n    $container.html(collection.reduce(function (acc, model) {\n        var $panelEl = $('<div><div class=\"panel-group\" id=\"accordion\" role=\"tablist\" aria-multiselectable=\"true\"></div></div>');\n\n        makeSlidedown($panelEl, model, modelTransformer);\n\n        return $panelEl.html() + acc;\n    }, ''));\n\n    $el.html($container);\n\n    return $el;\n}\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3), __webpack_require__(1)))\n\n/***/ }),\n\n/***/ 6:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function($, _) {\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.getParameterByName = getParameterByName;\nexports.getHashFromCurrentUrl = getHashFromCurrentUrl;\nexports.truncateWords = truncateWords;\nexports.truncateCharacters = truncateCharacters;\nexports.toTitleCase = toTitleCase;\nexports.randomString = randomString;\nexports.scrollTopDistance = scrollTopDistance;\nexports.toggleScroll = toggleScroll;\nexports.whenScrollReached = whenScrollReached;\nvar Promise = __webpack_require__(7);\n\n// http://stackoverflow.com/questions/901115/how-can-i-get-query-string-values-in-javascript\nfunction getParameterByName(name, url) {\n    if (!url) url = window.location.href;\n    name = name.replace(/[\\[\\]]/g, '\\\\$&');\n    var regex = new RegExp('[?&]' + name + '(=([^&#]*)|&|#|$)'),\n        results = regex.exec(url);\n\n    if (!results) return null;\n    if (!results[2]) return '';\n\n    return decodeURIComponent(results[2].replace(/\\+/g, ' '));\n}\n\n/**\n * get the current value of the hash in the URL - if it exists\n * @return @{String}\n */\nfunction getHashFromCurrentUrl() {\n    return window.location.hash ? window.location.hash.replace('#', '') : null;\n}\n\n/**\n * truncate the given string after `n` words\n * @param s\n * @param n\n * @param truncationChars @{String} the value to append to the truncated value (if truncation occurs)\n */\nfunction truncateWords(s, n) {\n    var truncationChars = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '...';\n\n    var words = s.split(' ');\n\n    if (words.length <= n) {\n        return s;\n    }\n\n    var truncated = words.slice(0, n).join(' ');\n    return truncated + truncationChars;\n}\n\n/**\n * truncate the given string after `n` characters\n * @param s\n * @param n\n * @param truncationChars\n */\nfunction truncateCharacters(s, n) {\n    var truncationChars = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '...';\n\n    if (s.length <= n) {\n        return s;\n    }\n\n    return s.substring(0, n) + truncationChars;\n}\n\nfunction toTitleCase(str) {\n    return str.replace(/\\w\\S*/g, function (txt) {\n        return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();\n    });\n}\n\n/**\n * generate a random string of size n (wripped from https://stackoverflow.com/questions/1349404/generate-random-string-characters-in-javascript)\n * @param n\n * @returns {string}\n */\nfunction randomString() {\n    var n = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 10;\n\n    var text = '';\n    var possible = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';\n\n    for (var i = 0; i < n; i++) {\n        text += possible.charAt(Math.floor(Math.random() * possible.length));\n    }return text;\n}\n\n/**\n * browsers handle calculating the scroll distance from the top of the page differently. This method reconciles the different\n * ways browsers handle getting this value and returns the distance scrolled from the top:\n *\n * https://stackoverflow.com/questions/28633221/document-body-scrolltop-firefox-returns-0-only-js\n *\n * @returns {Number|number}\n */\nfunction scrollTopDistance() {\n    return window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0;\n}\n\n/**\n * toggle the ability to scroll in the page\n * @param flag {Boolean}\n */\nfunction toggleScroll(flag) {\n    $('html,body').css('overflow-y', flag ? 'auto' : 'hidden');\n}\n\n/**\n * listen for the window being scrolled to the given `limit` pixels down.\n * @param offset {Number} offset - in pixels - to reach\n * @return {Promise} resolving when the given offset is reached\n */\nfunction whenScrollReached() {\n    var offset = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 100;\n\n    return new Promise(function (resolve, reject) {\n        var onScroll = _.throttle(function () {\n            if (scrollTopDistance() >= offset) {\n                window.removeEventListener('scroll', onScroll);\n                resolve();\n            }\n        }, 100);\n\n        window.addEventListener('scroll', onScroll);\n    });\n}\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(1), __webpack_require__(0)))\n\n/***/ }),\n\n/***/ 66:\n/***/ (function(module, exports) {\n\n// removed by extract-text-webpack-plugin\nmodule.exports = {\"fa-cc-visa\":\"fa-cc-visa\",\"desktop-search-overlay\":\"desktop-search-overlay\",\"fa-sheqel\":\"fa-sheqel\",\"fa-rocket\":\"fa-rocket\",\"fa-battery-1\":\"fa-battery-1\",\"fa-scribd\":\"fa-scribd\",\"fa-sort-numeric-desc\":\"fa-sort-numeric-desc\",\"fa-arrow-circle-o-down\":\"fa-arrow-circle-o-down\",\"fa-hand-pointer-o\":\"fa-hand-pointer-o\",\"fa-meh-o\":\"fa-meh-o\",\"fa-blind\":\"fa-blind\",\"fa-globe\":\"fa-globe\",\"fa-yahoo\":\"fa-yahoo\",\"fa-map-o\":\"fa-map-o\",\"fa-feed\":\"fa-feed\",\"fa-moon-o\":\"fa-moon-o\",\"fa-hand-lizard-o\":\"fa-hand-lizard-o\",\"social-share-flat\":\"social-share-flat\",\"hs-input\":\"hs-input\",\"fa-sort-up\":\"fa-sort-up\",\"fa-cc-diners-club\":\"fa-cc-diners-club\",\"fa-anchor\":\"fa-anchor\",\"fa-bell-slash\":\"fa-bell-slash\",\"fa-birthday-cake\":\"fa-birthday-cake\",\"fa-sort-desc\":\"fa-sort-desc\",\"fa-mobile\":\"fa-mobile\",\"fa-optin-monster\":\"fa-optin-monster\",\"fa-columns\":\"fa-columns\",\"fa-facebook\":\"fa-facebook\",\"fa-fonticons\":\"fa-fonticons\",\"fa-github-alt\":\"fa-github-alt\",\"highlighted\":\"highlighted\",\"fa-angle-double-down\":\"fa-angle-double-down\",\"ctc-container\":\"ctc-container\",\"fa-paste\":\"fa-paste\",\"fa-git-square\":\"fa-git-square\",\"fa-calculator\":\"fa-calculator\",\"fa-registered\":\"fa-registered\",\"wide\":\"wide\",\"fa-dollar\":\"fa-dollar\",\"fa-hashtag\":\"fa-hashtag\",\"fa-play-circle\":\"fa-play-circle\",\"fa-chevron-down\":\"fa-chevron-down\",\"fa-sticky-note-o\":\"fa-sticky-note-o\",\"fa-mars\":\"fa-mars\",\"hero-header\":\"hero-header\",\"fa-window-minimize\":\"fa-window-minimize\",\"fa-amazon\":\"fa-amazon\",\"fa-square\":\"fa-square\",\"fa-code-fork\":\"fa-code-fork\",\"fa-navicon\":\"fa-navicon\",\"fa-qq\":\"fa-qq\",\"fa-map-signs\":\"fa-map-signs\",\"fa-play-circle-o\":\"fa-play-circle-o\",\"navbar-toggle\":\"navbar-toggle\",\"footer-contact\":\"footer-contact\",\"fa-weixin\":\"fa-weixin\",\"fa-caret-square-o-right\":\"fa-caret-square-o-right\",\"fa-superscript\":\"fa-superscript\",\"fa-recycle\":\"fa-recycle\",\"fa-question-circle\":\"fa-question-circle\",\"side-bar\":\"side-bar\",\"fa-file-movie-o\":\"fa-file-movie-o\",\"fa-ra\":\"fa-ra\",\"fa-hourglass-3\":\"fa-hourglass-3\",\"li\":\"li\",\"fa-gbp\":\"fa-gbp\",\"fa-inverse\":\"fa-inverse\",\"fa-credit-card-alt\":\"fa-credit-card-alt\",\"fa-edit\":\"fa-edit\",\"fa-hourglass-half\":\"fa-hourglass-half\",\"fa-paperclip\":\"fa-paperclip\",\"fa-download\":\"fa-download\",\"fa-flickr\":\"fa-flickr\",\"fa-thumbs-down\":\"fa-thumbs-down\",\"fa-git\":\"fa-git\",\"fa-hand-paper-o\":\"fa-hand-paper-o\",\"fa-plus-square-o\":\"fa-plus-square-o\",\"fa-bank\":\"fa-bank\",\"fa-hotel\":\"fa-hotel\",\"fa-sticky-note\":\"fa-sticky-note\",\"fa-sort-asc\":\"fa-sort-asc\",\"fa-share-alt\":\"fa-share-alt\",\"section\":\"section\",\"fa-euro\":\"fa-euro\",\"fa-thermometer-3\":\"fa-thermometer-3\",\"fa-li\":\"fa-li\",\"fa-pied-piper\":\"fa-pied-piper\",\"fa-close\":\"fa-close\",\"fa-gear\":\"fa-gear\",\"fa-adjust\":\"fa-adjust\",\"fa-stumbleupon\":\"fa-stumbleupon\",\"fa-wpforms\":\"fa-wpforms\",\"dropdown-mega\":\"dropdown-mega\",\"fa-paypal\":\"fa-paypal\",\"fa-toggle-left\":\"fa-toggle-left\",\"card-top-alert\":\"card-top-alert\",\"fa-id-badge\":\"fa-id-badge\",\"fa-hand-o-right\":\"fa-hand-o-right\",\"fa-exchange\":\"fa-exchange\",\"fa-binoculars\":\"fa-binoculars\",\"fa-gg\":\"fa-gg\",\"fa-plus-circle\":\"fa-plus-circle\",\"fa-toggle-right\":\"fa-toggle-right\",\"dropdown-florida-list\":\"dropdown-florida-list\",\"no-float\":\"no-float\",\"input-container\":\"input-container\",\"fa-facebook-square\":\"fa-facebook-square\",\"fa-indent\":\"fa-indent\",\"fa-calendar-minus-o\":\"fa-calendar-minus-o\",\"placeholder\":\"placeholder\",\"fa-heartbeat\":\"fa-heartbeat\",\"fa-windows\":\"fa-windows\",\"fa-vimeo-square\":\"fa-vimeo-square\",\"nav-email-col\":\"nav-email-col\",\"nav-ctc-container\":\"nav-ctc-container\",\"fa-viacoin\":\"fa-viacoin\",\"fa-drivers-license\":\"fa-drivers-license\",\"navbar\":\"navbar\",\"fa-long-arrow-left\":\"fa-long-arrow-left\",\"results-container\":\"results-container\",\"fa-money\":\"fa-money\",\"recent-firm-news-item\":\"recent-firm-news-item\",\"fa-sign-in\":\"fa-sign-in\",\"fa-arrow-circle-right\":\"fa-arrow-circle-right\",\"fa-puzzle-piece\":\"fa-puzzle-piece\",\"sr-only-focusable\":\"sr-only-focusable\",\"fa-codiepie\":\"fa-codiepie\",\"btn-black\":\"btn-black\",\"fa-openid\":\"fa-openid\",\"fa-shopping-bag\":\"fa-shopping-bag\",\"fa-info\":\"fa-info\",\"fa-check-square\":\"fa-check-square\",\"pointer\":\"pointer\",\"fa-cc-paypal\":\"fa-cc-paypal\",\"fa-circle\":\"fa-circle\",\"mm-recent-firm-news\":\"mm-recent-firm-news\",\"fa-eraser\":\"fa-eraser\",\"fa-chevron-up\":\"fa-chevron-up\",\"fa-copy\":\"fa-copy\",\"fa-chevron-circle-down\":\"fa-chevron-circle-down\",\"fa-bluetooth\":\"fa-bluetooth\",\"fa-share-square\":\"fa-share-square\",\"fa-repeat\":\"fa-repeat\",\"fa-desktop\":\"fa-desktop\",\"fa-hand-rock-o\":\"fa-hand-rock-o\",\"fa-th-large\":\"fa-th-large\",\"fa-arrow-circle-o-up\":\"fa-arrow-circle-o-up\",\"fa-google\":\"fa-google\",\"social-share-expanding\":\"social-share-expanding\",\"fa-bold\":\"fa-bold\",\"pullquote-right\":\"pullquote-right\",\"fa-video-camera\":\"fa-video-camera\",\"fa-file-audio-o\":\"fa-file-audio-o\",\"fa-bus\":\"fa-bus\",\"btn-ctc\":\"btn-ctc\",\"fa-stumbleupon-circle\":\"fa-stumbleupon-circle\",\"fa-yc\":\"fa-yc\",\"fa-heart\":\"fa-heart\",\"fa-frown-o\":\"fa-frown-o\",\"fa-mail-reply\":\"fa-mail-reply\",\"fa-vine\":\"fa-vine\",\"fa-sign-language\":\"fa-sign-language\",\"fa-tv\":\"fa-tv\",\"fa-user-times\":\"fa-user-times\",\"faq-card\":\"faq-card\",\"fa-database\":\"fa-database\",\"fa-codepen\":\"fa-codepen\",\"fa-simplybuilt\":\"fa-simplybuilt\",\"experiment-semaphore\":\"experiment-semaphore\",\"fa-window-maximize\":\"fa-window-maximize\",\"fa-map-marker\":\"fa-map-marker\",\"fa-sort-amount-desc\":\"fa-sort-amount-desc\",\"fa-file-picture-o\":\"fa-file-picture-o\",\"fa-usb\":\"fa-usb\",\"fa-terminal\":\"fa-terminal\",\"fa-bar-chart\":\"fa-bar-chart\",\"fa-product-hunt\":\"fa-product-hunt\",\"fa-image\":\"fa-image\",\"fa-stop-circle-o\":\"fa-stop-circle-o\",\"fa-venus-mars\":\"fa-venus-mars\",\"benefit\":\"benefit\",\"fa-commenting\":\"fa-commenting\",\"fa-trophy\":\"fa-trophy\",\"fa-rotate-270\":\"fa-rotate-270\",\"fa-soundcloud\":\"fa-soundcloud\",\"highlighteable\":\"highlighteable\",\"fa-gavel\":\"fa-gavel\",\"fa-random\":\"fa-random\",\"fa-stack-2x\":\"fa-stack-2x\",\"fa-ul\":\"fa-ul\",\"fa-asterisk\":\"fa-asterisk\",\"fa-arrows-h\":\"fa-arrows-h\",\"fa-jpy\":\"fa-jpy\",\"fa-y-combinator\":\"fa-y-combinator\",\"fa-mail-forward\":\"fa-mail-forward\",\"fa-legal\":\"fa-legal\",\"email\":\"email\",\"fa-volume-off\":\"fa-volume-off\",\"fa-external-link-square\":\"fa-external-link-square\",\"fa-opera\":\"fa-opera\",\"fa-superpowers\":\"fa-superpowers\",\"fa-maxcdn\":\"fa-maxcdn\",\"fa-apple\":\"fa-apple\",\"fa-foursquare\":\"fa-foursquare\",\"fa-scissors\":\"fa-scissors\",\"sub-title\":\"sub-title\",\"fa-cloud-download\":\"fa-cloud-download\",\"fa-twitch\":\"fa-twitch\",\"pullquote-left\":\"pullquote-left\",\"fa-snowflake-o\":\"fa-snowflake-o\",\"fa-tablet\":\"fa-tablet\",\"fa-star\":\"fa-star\",\"fa-leanpub\":\"fa-leanpub\",\"fa-play\":\"fa-play\",\"fa-creative-commons\":\"fa-creative-commons\",\"fa-wechat\":\"fa-wechat\",\"fa-stop\":\"fa-stop\",\"fa-tachometer\":\"fa-tachometer\",\"fa-ambulance\":\"fa-ambulance\",\"fa-weibo\":\"fa-weibo\",\"btn-pagination\":\"btn-pagination\",\"recent-firm-news-more-results\":\"recent-firm-news-more-results\",\"fa-wifi\":\"fa-wifi\",\"fa-mail-reply-all\":\"fa-mail-reply-all\",\"fa-space-shuttle\":\"fa-space-shuttle\",\"fa-soccer-ball-o\":\"fa-soccer-ball-o\",\"fa-user-o\":\"fa-user-o\",\"modal-body\":\"modal-body\",\"fa-trash\":\"fa-trash\",\"fa-paw\":\"fa-paw\",\"items-3\":\"items-3\",\"fa-ticket\":\"fa-ticket\",\"fa-times-circle\":\"fa-times-circle\",\"fa-grav\":\"fa-grav\",\"fa-angle-left\":\"fa-angle-left\",\"fa-btc\":\"fa-btc\",\"fa-medkit\":\"fa-medkit\",\"fa-user-circle\":\"fa-user-circle\",\"fa-unlock\":\"fa-unlock\",\"fa-linkedin\":\"fa-linkedin\",\"fa-area-chart\":\"fa-area-chart\",\"fa-arrow-circle-o-right\":\"fa-arrow-circle-o-right\",\"fa-address-book-o\":\"fa-address-book-o\",\"fa-thermometer-three-quarters\":\"fa-thermometer-three-quarters\",\"fa-american-sign-language-interpreting\":\"fa-american-sign-language-interpreting\",\"fa-fast-backward\":\"fa-fast-backward\",\"fa-github-square\":\"fa-github-square\",\"fa-times-rectangle-o\":\"fa-times-rectangle-o\",\"nav-call-col\":\"nav-call-col\",\"fa-subway\":\"fa-subway\",\"fa-newspaper-o\":\"fa-newspaper-o\",\"fa-google-plus-circle\":\"fa-google-plus-circle\",\"fa-bitbucket\":\"fa-bitbucket\",\"mm-search\":\"mm-search\",\"fa-reorder\":\"fa-reorder\",\"focused\":\"focused\",\"fa-thumbs-o-down\":\"fa-thumbs-o-down\",\"fa-street-view\":\"fa-street-view\",\"fa-calendar-times-o\":\"fa-calendar-times-o\",\"fa-keyboard-o\":\"fa-keyboard-o\",\"fa-magnet\":\"fa-magnet\",\"fa-ship\":\"fa-ship\",\"general-form\":\"general-form\",\"fa-automobile\":\"fa-automobile\",\"fa-wpbeginner\":\"fa-wpbeginner\",\"fa-battery-half\":\"fa-battery-half\",\"fa-pinterest\":\"fa-pinterest\",\"fa-th\":\"fa-th\",\"fa-share\":\"fa-share\",\"fa-sort-numeric-asc\":\"fa-sort-numeric-asc\",\"fa-percent\":\"fa-percent\",\"fa-mercury\":\"fa-mercury\",\"breadcrumb\":\"breadcrumb\",\"fa-thermometer\":\"fa-thermometer\",\"fa-mortar-board\":\"fa-mortar-board\",\"header-title\":\"header-title\",\"fa-key\":\"fa-key\",\"fa-s15\":\"fa-s15\",\"dropdown-locations\":\"dropdown-locations\",\"btn-red\":\"btn-red\",\"fa-cab\":\"fa-cab\",\"fa-slideshare\":\"fa-slideshare\",\"fa-angle-double-left\":\"fa-angle-double-left\",\"fa-ravelry\":\"fa-ravelry\",\"fb-comments\":\"fb-comments\",\"fa-lastfm\":\"fa-lastfm\",\"fa-rebel\":\"fa-rebel\",\"fa-chain-broken\":\"fa-chain-broken\",\"items-1\":\"items-1\",\"employment\":\"employment\",\"fa-strikethrough\":\"fa-strikethrough\",\"fa-sort-alpha-desc\":\"fa-sort-alpha-desc\",\"fa-phone-square\":\"fa-phone-square\",\"pull-right\":\"pull-right\",\"fa-envelope\":\"fa-envelope\",\"fa-th-list\":\"fa-th-list\",\"fa-at\":\"fa-at\",\"fa-remove\":\"fa-remove\",\"fa-life-bouy\":\"fa-life-bouy\",\"fa-battery-empty\":\"fa-battery-empty\",\"yt\":\"yt\",\"fa-arrow-circle-left\":\"fa-arrow-circle-left\",\"fa-arrow-circle-up\":\"fa-arrow-circle-up\",\"fa-pulse\":\"fa-pulse\",\"advertisement\":\"advertisement\",\"collapsed\":\"collapsed\",\"fa-expand\":\"fa-expand\",\"fa-mars-double\":\"fa-mars-double\",\"fa-comment-o\":\"fa-comment-o\",\"fa-adn\":\"fa-adn\",\"fa-vk\":\"fa-vk\",\"fa-ruble\":\"fa-ruble\",\"fa-laptop\":\"fa-laptop\",\"fa-xing-square\":\"fa-xing-square\",\"fa-expeditedssl\":\"fa-expeditedssl\",\"fa-first-order\":\"fa-first-order\",\"btn-twitter\":\"btn-twitter\",\"fa-google-plus\":\"fa-google-plus\",\"fa-caret-right\":\"fa-caret-right\",\"fa-code\":\"fa-code\",\"btn\":\"btn\",\"fa-building-o\":\"fa-building-o\",\"fa-check-circle-o\":\"fa-check-circle-o\",\"fa-circle-thin\":\"fa-circle-thin\",\"fa-angle-up\":\"fa-angle-up\",\"fa-text-height\":\"fa-text-height\",\"fa-gittip\":\"fa-gittip\",\"fa-angle-double-up\":\"fa-angle-double-up\",\"fa-usd\":\"fa-usd\",\"fa-file-archive-o\":\"fa-file-archive-o\",\"fa-gift\":\"fa-gift\",\"fa-thermometer-full\":\"fa-thermometer-full\",\"sr-only\":\"sr-only\",\"fa-steam\":\"fa-steam\",\"fa-3x\":\"fa-3x\",\"fa-battery-4\":\"fa-battery-4\",\"fa-address-card\":\"fa-address-card\",\"fa-fw\":\"fa-fw\",\"fa-motorcycle\":\"fa-motorcycle\",\"fa-times\":\"fa-times\",\"fa-list-ol\":\"fa-list-ol\",\"fa-black-tie\":\"fa-black-tie\",\"footer-form\":\"footer-form\",\"hs-error-msgs\":\"hs-error-msgs\",\"fa-address-card-o\":\"fa-address-card-o\",\"fa-map\":\"fa-map\",\"selected\":\"selected\",\"btn-ghost-black\":\"btn-ghost-black\",\"fa-file-sound-o\":\"fa-file-sound-o\",\"fa-meanpath\":\"fa-meanpath\",\"fa-info-circle\":\"fa-info-circle\",\"fa-dedent\":\"fa-dedent\",\"search-expand-lg\":\"search-expand-lg\",\"fa-toggle-off\":\"fa-toggle-off\",\"fa-certificate\":\"fa-certificate\",\"fa-font-awesome\":\"fa-font-awesome\",\"mm-table\":\"mm-table\",\"fa-camera\":\"fa-camera\",\"fa-sort-down\":\"fa-sort-down\",\"fa-thermometer-2\":\"fa-thermometer-2\",\"footer-logo\":\"footer-logo\",\"fa-user\":\"fa-user\",\"fa-group\":\"fa-group\",\"fa-power-off\":\"fa-power-off\",\"fa-android\":\"fa-android\",\"fa-futbol-o\":\"fa-futbol-o\",\"fa-circle-o\":\"fa-circle-o\",\"fa-pencil\":\"fa-pencil\",\"fa-sign-out\":\"fa-sign-out\",\"fa-sort-amount-asc\":\"fa-sort-amount-asc\",\"nav-search\":\"nav-search\",\"fa-spin\":\"fa-spin\",\"fa-users\":\"fa-users\",\"fa-align-center\":\"fa-align-center\",\"fa-connectdevelop\":\"fa-connectdevelop\",\"fa-qrcode\":\"fa-qrcode\",\"fa-tags\":\"fa-tags\",\"fa-minus-square-o\":\"fa-minus-square-o\",\"fa-star-half\":\"fa-star-half\",\"fa-eject\":\"fa-eject\",\"fa-stack-overflow\":\"fa-stack-overflow\",\"fa-bicycle\":\"fa-bicycle\",\"fa-cut\":\"fa-cut\",\"fa-rss\":\"fa-rss\",\"fa-joomla\":\"fa-joomla\",\"more\":\"more\",\"fa-server\":\"fa-server\",\"modal-header\":\"modal-header\",\"fa-4x\":\"fa-4x\",\"fa-chevron-circle-right\":\"fa-chevron-circle-right\",\"fa-clone\":\"fa-clone\",\"fa-align-left\":\"fa-align-left\",\"fa-mouse-pointer\":\"fa-mouse-pointer\",\"fa-hourglass-o\":\"fa-hourglass-o\",\"result-container\":\"result-container\",\"metadata\":\"metadata\",\"fa-linode\":\"fa-linode\",\"fa-bug\":\"fa-bug\",\"fa-thumb-tack\":\"fa-thumb-tack\",\"fa-bed\":\"fa-bed\",\"fa-link\":\"fa-link\",\"dropdown-menu\":\"dropdown-menu\",\"fa-reply-all\":\"fa-reply-all\",\"fa-subscript\":\"fa-subscript\",\"masthead\":\"masthead\",\"card-content-alert\":\"card-content-alert\",\"mobile\":\"mobile\",\"fa-align-justify\":\"fa-align-justify\",\"fa-ioxhost\":\"fa-ioxhost\",\"fa-credit-card\":\"fa-credit-card\",\"social-card\":\"social-card\",\"fa-youtube-square\":\"fa-youtube-square\",\"fa-battery-three-quarters\":\"fa-battery-three-quarters\",\"fa-bullhorn\":\"fa-bullhorn\",\"fa-tasks\":\"fa-tasks\",\"fa-filter\":\"fa-filter\",\"fa-pinterest-p\":\"fa-pinterest-p\",\"fa-bathtub\":\"fa-bathtub\",\"fa-2x\":\"fa-2x\",\"fa-share-square-o\":\"fa-share-square-o\",\"fa-flag-o\":\"fa-flag-o\",\"fa-thumbs-up\":\"fa-thumbs-up\",\"fa-underline\":\"fa-underline\",\"fa-star-half-full\":\"fa-star-half-full\",\"fa-delicious\":\"fa-delicious\",\"fa-gg-circle\":\"fa-gg-circle\",\"fa-vcard\":\"fa-vcard\",\"fa-hand-o-left\":\"fa-hand-o-left\",\"fa-i-cursor\":\"fa-i-cursor\",\"fa-arrow-left\":\"fa-arrow-left\",\"fa-won\":\"fa-won\",\"panel-body\":\"panel-body\",\"fa-odnoklassniki\":\"fa-odnoklassniki\",\"fa-caret-square-o-left\":\"fa-caret-square-o-left\",\"fa-search-plus\":\"fa-search-plus\",\"fa-pied-piper-alt\":\"fa-pied-piper-alt\",\"fa-chrome\":\"fa-chrome\",\"fa-youtube-play\":\"fa-youtube-play\",\"fa-bitcoin\":\"fa-bitcoin\",\"fa-crop\":\"fa-crop\",\"form-control\":\"form-control\",\"fa-object-ungroup\":\"fa-object-ungroup\",\"fa-neuter\":\"fa-neuter\",\"fa-dropbox\":\"fa-dropbox\",\"fa-assistive-listening-systems\":\"fa-assistive-listening-systems\",\"fa-linkedin-square\":\"fa-linkedin-square\",\"fa-ellipsis-v\":\"fa-ellipsis-v\",\"fa-caret-square-o-up\":\"fa-caret-square-o-up\",\"fa-glide\":\"fa-glide\",\"btn-close\":\"btn-close\",\"fa-eye\":\"fa-eye\",\"fa-list-ul\":\"fa-list-ul\",\"facebook-comment-wrapper\":\"facebook-comment-wrapper\",\"rt\":\"rt\",\"fa-cogs\":\"fa-cogs\",\"fa-bar-chart-o\":\"fa-bar-chart-o\",\"fa-question\":\"fa-question\",\"fa-pause-circle-o\":\"fa-pause-circle-o\",\"btn-social\":\"btn-social\",\"fa-volume-down\":\"fa-volume-down\",\"fa-map-pin\":\"fa-map-pin\",\"expander\":\"expander\",\"fa-file\":\"fa-file\",\"fa-check\":\"fa-check\",\"fa-reply\":\"fa-reply\",\"fa-hand-spock-o\":\"fa-hand-spock-o\",\"fa-unlock-alt\":\"fa-unlock-alt\",\"fa-drivers-license-o\":\"fa-drivers-license-o\",\"card-content\":\"card-content\",\"fa-compress\":\"fa-compress\",\"panel\":\"panel\",\"gp\":\"gp\",\"affix\":\"affix\",\"fa-inbox\":\"fa-inbox\",\"fa-cart-arrow-down\":\"fa-cart-arrow-down\",\"fa-reddit-alien\":\"fa-reddit-alien\",\"fa-behance\":\"fa-behance\",\"fa-calendar\":\"fa-calendar\",\"recent-firm-news-title\":\"recent-firm-news-title\",\"fa-google-plus-square\":\"fa-google-plus-square\",\"fa-wheelchair-alt\":\"fa-wheelchair-alt\",\"follow-row\":\"follow-row\",\"fa-folder-open\":\"fa-folder-open\",\"fa-yen\":\"fa-yen\",\"fa-spoon\":\"fa-spoon\",\"fa-ils\":\"fa-ils\",\"fa-trello\":\"fa-trello\",\"fa-envelope-open\":\"fa-envelope-open\",\"fa-cc-discover\":\"fa-cc-discover\",\"fa-mobile-phone\":\"fa-mobile-phone\",\"fa-comment\":\"fa-comment\",\"fa-eercast\":\"fa-eercast\",\"nav\":\"nav\",\"fa-cc-amex\":\"fa-cc-amex\",\"fa-archive\":\"fa-archive\",\"fa-sun-o\":\"fa-sun-o\",\"fa-thermometer-1\":\"fa-thermometer-1\",\"fa-arrows\":\"fa-arrows\",\"fa-quote-right\":\"fa-quote-right\",\"fa-universal-access\":\"fa-universal-access\",\"fa-train\":\"fa-train\",\"hidden-lg\":\"hidden-lg\",\"network\":\"network\",\"fa-pie-chart\":\"fa-pie-chart\",\"fa-buysellads\":\"fa-buysellads\",\"fa-taxi\":\"fa-taxi\",\"footer-subnav-links\":\"footer-subnav-links\",\"fa-sellsy\":\"fa-sellsy\",\"fa-glide-g\":\"fa-glide-g\",\"fa-retweet\":\"fa-retweet\",\"fa-text-width\":\"fa-text-width\",\"fa-rupee\":\"fa-rupee\",\"fa-ellipsis-h\":\"fa-ellipsis-h\",\"fa-folder-open-o\":\"fa-folder-open-o\",\"fa-photo\":\"fa-photo\",\"fa-object-group\":\"fa-object-group\",\"fa-unlink\":\"fa-unlink\",\"pin\":\"pin\",\"fa-slack\":\"fa-slack\",\"fa-twitter\":\"fa-twitter\",\"hs_yes_sign_me_up_for_the_newsletter_\":\"hs_yes_sign_me_up_for_the_newsletter_\",\"fa-caret-left\":\"fa-caret-left\",\"fa-exclamation\":\"fa-exclamation\",\"fa-file-powerpoint-o\":\"fa-file-powerpoint-o\",\"fa-eyedropper\":\"fa-eyedropper\",\"fa-contao\":\"fa-contao\",\"fa-search\":\"fa-search\",\"fa-exclamation-triangle\":\"fa-exclamation-triangle\",\"hero-unit\":\"hero-unit\",\"fa-twitter-square\":\"fa-twitter-square\",\"fa-plug\":\"fa-plug\",\"fa-dashboard\":\"fa-dashboard\",\"dropdown-toggle\":\"dropdown-toggle\",\"panel-title\":\"panel-title\",\"fa-file-word-o\":\"fa-file-word-o\",\"fa-eye-slash\":\"fa-eye-slash\",\"fa-xing\":\"fa-xing\",\"fa-thermometer-half\":\"fa-thermometer-half\",\"fa-handshake-o\":\"fa-handshake-o\",\"fa-chevron-circle-left\":\"fa-chevron-circle-left\",\"fa-glass\":\"fa-glass\",\"desktop\":\"desktop\",\"fa-eur\":\"fa-eur\",\"fa-braille\":\"fa-braille\",\"fa-floppy-o\":\"fa-floppy-o\",\"card-top\":\"card-top\",\"fa-skype\":\"fa-skype\",\"fa-volume-up\":\"fa-volume-up\",\"fa-cc-stripe\":\"fa-cc-stripe\",\"fa-hourglass-end\":\"fa-hourglass-end\",\"fa-microphone\":\"fa-microphone\",\"fa-5x\":\"fa-5x\",\"close\":\"close\",\"fa-font\":\"fa-font\",\"fa-meetup\":\"fa-meetup\",\"fa-arrows-alt\":\"fa-arrows-alt\",\"fa-pencil-square-o\":\"fa-pencil-square-o\",\"fa-hdd-o\":\"fa-hdd-o\",\"fa-home\":\"fa-home\",\"fa-road\":\"fa-road\",\"fa-crosshairs\":\"fa-crosshairs\",\"nav-logo\":\"nav-logo\",\"fa-building\":\"fa-building\",\"recent-firm-news-details\":\"recent-firm-news-details\",\"fa-level-up\":\"fa-level-up\",\"fa-stop-circle\":\"fa-stop-circle\",\"expandable\":\"expandable\",\"fa-id-card-o\":\"fa-id-card-o\",\"fa-thermometer-empty\":\"fa-thermometer-empty\",\"fa-chevron-right\":\"fa-chevron-right\",\"fa-file-excel-o\":\"fa-file-excel-o\",\"fa-plane\":\"fa-plane\",\"fa-venus-double\":\"fa-venus-double\",\"address\":\"address\",\"fa-check-circle\":\"fa-check-circle\",\"fa-envelope-o\":\"fa-envelope-o\",\"fa-toggle-up\":\"fa-toggle-up\",\"fa-snapchat-ghost\":\"fa-snapchat-ghost\",\"fa-try\":\"fa-try\",\"fa-file-photo-o\":\"fa-file-photo-o\",\"image-column\":\"image-column\",\"fa-long-arrow-down\":\"fa-long-arrow-down\",\"fa-plus\":\"fa-plus\",\"fa-battery-quarter\":\"fa-battery-quarter\",\"fa-hourglass-start\":\"fa-hourglass-start\",\"fa-line-chart\":\"fa-line-chart\",\"open\":\"open\",\"double-wide\":\"double-wide\",\"fa-history\":\"fa-history\",\"fa-folder\":\"fa-folder\",\"btn-dark\":\"btn-dark\",\"fa-microchip\":\"fa-microchip\",\"fa-bomb\":\"fa-bomb\",\"pointer-wrapper\":\"pointer-wrapper\",\"fa-tint\":\"fa-tint\",\"fa-low-vision\":\"fa-low-vision\",\"fa-snapchat-square\":\"fa-snapchat-square\",\"caret\":\"caret\",\"fa-bolt\":\"fa-bolt\",\"fa-undo\":\"fa-undo\",\"fa-arrow-up\":\"fa-arrow-up\",\"search-expand-md\":\"search-expand-md\",\"fa-pagelines\":\"fa-pagelines\",\"fa-heart-o\":\"fa-heart-o\",\"fa-send-o\":\"fa-send-o\",\"fa-television\":\"fa-television\",\"fa-support\":\"fa-support\",\"fa-opencart\":\"fa-opencart\",\"fa-diamond\":\"fa-diamond\",\"modal-title\":\"modal-title\",\"fa-battery\":\"fa-battery\",\"fa-500px\":\"fa-500px\",\"fa-film\":\"fa-film\",\"fa-book\":\"fa-book\",\"fa-window-close\":\"fa-window-close\",\"fa-comments\":\"fa-comments\",\"fa-themeisle\":\"fa-themeisle\",\"more-related-articles\":\"more-related-articles\",\"fa-suitcase\":\"fa-suitcase\",\"fa-clipboard\":\"fa-clipboard\",\"fa-check-square-o\":\"fa-check-square-o\",\"links-row\":\"links-row\",\"fa-tree\":\"fa-tree\",\"search-expand-sm\":\"search-expand-sm\",\"fa-medium\":\"fa-medium\",\"fa-location-arrow\":\"fa-location-arrow\",\"fa-user-plus\":\"fa-user-plus\",\"fa-stack\":\"fa-stack\",\"fa-krw\":\"fa-krw\",\"fa-hand-scissors-o\":\"fa-hand-scissors-o\",\"fa-houzz\":\"fa-houzz\",\"fa-volume-control-phone\":\"fa-volume-control-phone\",\"fa-clock-o\":\"fa-clock-o\",\"fa-fire\":\"fa-fire\",\"fa-file-text-o\":\"fa-file-text-o\",\"fa-arrow-circle-o-left\":\"fa-arrow-circle-o-left\",\"fa-hand-o-up\":\"fa-hand-o-up\",\"fa-lg\":\"fa-lg\",\"fa-life-buoy\":\"fa-life-buoy\",\"fa-align-right\":\"fa-align-right\",\"fa-arrows-v\":\"fa-arrows-v\",\"fa-viadeo\":\"fa-viadeo\",\"fa-vcard-o\":\"fa-vcard-o\",\"testimonials-items\":\"testimonials-items\",\"fa-hand-peace-o\":\"fa-hand-peace-o\",\"sidebar-form\":\"sidebar-form\",\"fa-safari\":\"fa-safari\",\"fa-reddit-square\":\"fa-reddit-square\",\"fa-vimeo\":\"fa-vimeo\",\"fa-files-o\":\"fa-files-o\",\"fa-file-text\":\"fa-file-text\",\"fa-copyright\":\"fa-copyright\",\"fa-id-card\":\"fa-id-card\",\"fa-chain\":\"fa-chain\",\"fa-dashcube\":\"fa-dashcube\",\"fa-facebook-official\":\"fa-facebook-official\",\"fa-pull-left\":\"fa-pull-left\",\"fa-pied-piper-pp\":\"fa-pied-piper-pp\",\"fa-audio-description\":\"fa-audio-description\",\"has-results\":\"has-results\",\"fa-cog\":\"fa-cog\",\"fa-venus\":\"fa-venus\",\"fa-odnoklassniki-square\":\"fa-odnoklassniki-square\",\"fa-angle-down\":\"fa-angle-down\",\"fa-minus-circle\":\"fa-minus-circle\",\"fa-drupal\":\"fa-drupal\",\"fa-dribbble\":\"fa-dribbble\",\"btn-red-centered\":\"btn-red-centered\",\"fa-file-video-o\":\"fa-file-video-o\",\"fa-industry\":\"fa-industry\",\"fa-user-md\":\"fa-user-md\",\"fa-pull-right\":\"fa-pull-right\",\"fa-folder-o\":\"fa-folder-o\",\"fa-fire-extinguisher\":\"fa-fire-extinguisher\",\"fa-shopping-basket\":\"fa-shopping-basket\",\"fa-yc-square\":\"fa-yc-square\",\"show\":\"show\",\"fa-life-saver\":\"fa-life-saver\",\"fa-square-o\":\"fa-square-o\",\"fa-etsy\":\"fa-etsy\",\"pull-left\":\"pull-left\",\"fa-resistance\":\"fa-resistance\",\"fa-bell-o\":\"fa-bell-o\",\"fa-skyatlas\":\"fa-skyatlas\",\"fa-battery-3\":\"fa-battery-3\",\"fa-quote-left\":\"fa-quote-left\",\"mm-header-container\":\"mm-header-container\",\"nav-desktop\":\"nav-desktop\",\"fa-toggle-down\":\"fa-toggle-down\",\"fa-shield\":\"fa-shield\",\"panel-group\":\"panel-group\",\"fa-step-forward\":\"fa-step-forward\",\"fa-commenting-o\":\"fa-commenting-o\",\"fa-camera-retro\":\"fa-camera-retro\",\"fa-paper-plane\":\"fa-paper-plane\",\"fa-briefcase\":\"fa-briefcase\",\"fa-digg\":\"fa-digg\",\"centered-button\":\"centered-button\",\"fa-thumbs-o-up\":\"fa-thumbs-o-up\",\"fa-behance-square\":\"fa-behance-square\",\"fa-italic\":\"fa-italic\",\"col-md-4\":\"col-md-4\",\"fa-sort-alpha-asc\":\"fa-sort-alpha-asc\",\"fa-step-backward\":\"fa-step-backward\",\"fb\":\"fb\",\"fa-flip-vertical\":\"fa-flip-vertical\",\"employment-locations\":\"employment-locations\",\"fa-stack-1x\":\"fa-stack-1x\",\"fa-sitemap\":\"fa-sitemap\",\"clicktocall\":\"clicktocall\",\"header-bar\":\"header-bar\",\"fa-border\":\"fa-border\",\"fa-file-image-o\":\"fa-file-image-o\",\"fa-asl-interpreting\":\"fa-asl-interpreting\",\"fa-pencil-square\":\"fa-pencil-square\",\"tw\":\"tw\",\"fa-linux\":\"fa-linux\",\"fa-wordpress\":\"fa-wordpress\",\"fa-comments-o\":\"fa-comments-o\",\"fa-toggle-on\":\"fa-toggle-on\",\"fa-cloud\":\"fa-cloud\",\"inputs-list\":\"inputs-list\",\"fa-user-secret\":\"fa-user-secret\",\"btn-fb\":\"btn-fb\",\"fa-deviantart\":\"fa-deviantart\",\"fa-signal\":\"fa-signal\",\"fa-rotate-right\":\"fa-rotate-right\",\"testimonials-header\":\"testimonials-header\",\"fa-star-o\":\"fa-star-o\",\"fa-angellist\":\"fa-angellist\",\"fa-tumblr-square\":\"fa-tumblr-square\",\"fa-cny\":\"fa-cny\",\"fa-battery-0\":\"fa-battery-0\",\"visible-lg\":\"visible-lg\",\"fa-list\":\"fa-list\",\"fa-lemon-o\":\"fa-lemon-o\",\"fa-fort-awesome\":\"fa-fort-awesome\",\"fa-chevron-circle-up\":\"fa-chevron-circle-up\",\"fa-fighter-jet\":\"fa-fighter-jet\",\"btn-yt\":\"btn-yt\",\"fa-cc-jcb\":\"fa-cc-jcb\",\"fa-deaf\":\"fa-deaf\",\"fa-bookmark-o\":\"fa-bookmark-o\",\"fa-arrow-circle-down\":\"fa-arrow-circle-down\",\"fa-warning\":\"fa-warning\",\"fa-empire\":\"fa-empire\",\"fa-turkish-lira\":\"fa-turkish-lira\",\"fa-long-arrow-up\":\"fa-long-arrow-up\",\"mm-search-input\":\"mm-search-input\",\"fa-steam-square\":\"fa-steam-square\",\"fa-chevron-left\":\"fa-chevron-left\",\"fa-facebook-f\":\"fa-facebook-f\",\"fa-transgender-alt\":\"fa-transgender-alt\",\"btn-ghost\":\"btn-ghost\",\"form-blurb\":\"form-blurb\",\"fa-tag\":\"fa-tag\",\"fa-bath\":\"fa-bath\",\"fa-cutlery\":\"fa-cutlery\",\"footer-subnav\":\"footer-subnav\",\"fa-shekel\":\"fa-shekel\",\"fa-flag\":\"fa-flag\",\"fa-fax\":\"fa-fax\",\"fa-envira\":\"fa-envira\",\"go-to-top-container\":\"go-to-top-container\",\"recent-firm-news-header\":\"recent-firm-news-header\",\"fa-shopping-cart\":\"fa-shopping-cart\",\"fa-file-o\":\"fa-file-o\",\"fa-thermometer-4\":\"fa-thermometer-4\",\"fa-angle-right\":\"fa-angle-right\",\"fa-mars-stroke-h\":\"fa-mars-stroke-h\",\"fa-user-circle-o\":\"fa-user-circle-o\",\"fa-arrow-down\":\"fa-arrow-down\",\"popup-contact-form\":\"popup-contact-form\",\"fa-life-ring\":\"fa-life-ring\",\"fa-ge\":\"fa-ge\",\"hs-button\":\"hs-button\",\"fa-battery-2\":\"fa-battery-2\",\"fa-address-book\":\"fa-address-book\",\"fa-caret-square-o-down\":\"fa-caret-square-o-down\",\"fa-google-wallet\":\"fa-google-wallet\",\"fa-hand-grab-o\":\"fa-hand-grab-o\",\"fa-barcode\":\"fa-barcode\",\"fa-thermometer-0\":\"fa-thermometer-0\",\"fa-header\":\"fa-header\",\"fa-beer\":\"fa-beer\",\"fa-inr\":\"fa-inr\",\"fa-hourglass-1\":\"fa-hourglass-1\",\"fa-minus-square\":\"fa-minus-square\",\"fa-reddit\":\"fa-reddit\",\"num\":\"num\",\"fa-renren\":\"fa-renren\",\"fa-backward\":\"fa-backward\",\"contact-card\":\"contact-card\",\"fa-calendar-check-o\":\"fa-calendar-check-o\",\"fa-gamepad\":\"fa-gamepad\",\"fa-calendar-plus-o\":\"fa-calendar-plus-o\",\"hs-richtext\":\"hs-richtext\",\"fa-caret-up\":\"fa-caret-up\",\"fa-file-code-o\":\"fa-file-code-o\",\"fa-star-half-empty\":\"fa-star-half-empty\",\"fa-youtube\":\"fa-youtube\",\"go-top\":\"go-top\",\"fa-bell\":\"fa-bell\",\"fa-telegram\":\"fa-telegram\",\"fa-viadeo-square\":\"fa-viadeo-square\",\"fa-external-link\":\"fa-external-link\",\"call-us\":\"call-us\",\"fa-cube\":\"fa-cube\",\"fa-forumbee\":\"fa-forumbee\",\"fa-snapchat\":\"fa-snapchat\",\"fa-graduation-cap\":\"fa-graduation-cap\",\"fa-arrow-right\":\"fa-arrow-right\",\"fa-flash\":\"fa-flash\",\"fa-smile-o\":\"fa-smile-o\",\"fa-headphones\":\"fa-headphones\",\"fa-instagram\":\"fa-instagram\",\"most-popular\":\"most-popular\",\"mm-sortable-table\":\"mm-sortable-table\",\"fa-yelp\":\"fa-yelp\",\"fa-y-combinator-square\":\"fa-y-combinator-square\",\"fa-hand-stop-o\":\"fa-hand-stop-o\",\"fa-edge\":\"fa-edge\",\"hs-form-field\":\"hs-form-field\",\"hs_submit\":\"hs_submit\",\"fa-cubes\":\"fa-cubes\",\"fa-pause\":\"fa-pause\",\"fa-ban\":\"fa-ban\",\"fa-rouble\":\"fa-rouble\",\"featured-link\":\"featured-link\",\"dropdown\":\"dropdown\",\"fa-tumblr\":\"fa-tumblr\",\"fa-unsorted\":\"fa-unsorted\",\"navbar-header\":\"navbar-header\",\"fa-rmb\":\"fa-rmb\",\"expanded\":\"expanded\",\"fa-window-close-o\":\"fa-window-close-o\",\"fa-circle-o-notch\":\"fa-circle-o-notch\",\"fa-coffee\":\"fa-coffee\",\"fa-hand-o-down\":\"fa-hand-o-down\",\"fa-paragraph\":\"fa-paragraph\",\"fa-gitlab\":\"fa-gitlab\",\"phone\":\"phone\",\"fa-mars-stroke-v\":\"fa-mars-stroke-v\",\"fa-stethoscope\":\"fa-stethoscope\",\"fa-quora\":\"fa-quora\",\"fa-institution\":\"fa-institution\",\"fa-stack-exchange\":\"fa-stack-exchange\",\"fa-shirtsinbulk\":\"fa-shirtsinbulk\",\"fa-thermometer-quarter\":\"fa-thermometer-quarter\",\"fa-cc\":\"fa-cc\",\"fa-h-square\":\"fa-h-square\",\"fa-leaf\":\"fa-leaf\",\"fa-compass\":\"fa-compass\",\"related-article-box\":\"related-article-box\",\"fa-window-restore\":\"fa-window-restore\",\"fa-github\":\"fa-github\",\"fa-times-rectangle\":\"fa-times-rectangle\",\"mm-news-articles-basic\":\"mm-news-articles-basic\",\"fa-print\":\"fa-print\",\"fa-wikipedia-w\":\"fa-wikipedia-w\",\"fa-css3\":\"fa-css3\",\"row-testimonials\":\"row-testimonials\",\"fa-intersex\":\"fa-intersex\",\"fa-bell-slash-o\":\"fa-bell-slash-o\",\"fa-firefox\":\"fa-firefox\",\"fa-hard-of-hearing\":\"fa-hard-of-hearing\",\"fa-wheelchair\":\"fa-wheelchair\",\"fa-picture-o\":\"fa-picture-o\",\"social\":\"social\",\"testimonials-see-more\":\"testimonials-see-more\",\"fa-bars\":\"fa-bars\",\"fa-get-pocket\":\"fa-get-pocket\",\"fa-pause-circle\":\"fa-pause-circle\",\"fa-exclamation-circle\":\"fa-exclamation-circle\",\"fa-question-circle-o\":\"fa-question-circle-o\",\"fa-modx\":\"fa-modx\",\"fa-hacker-news\":\"fa-hacker-news\",\"fa-trash-o\":\"fa-trash-o\",\"fa-forward\":\"fa-forward\",\"fa-fast-forward\":\"fa-fast-forward\",\"fa-google-plus-official\":\"fa-google-plus-official\",\"fa-rss-square\":\"fa-rss-square\",\"ca-logo\":\"ca-logo\",\"fa-child\":\"fa-child\",\"fa-spinner\":\"fa-spinner\",\"fa-rotate-left\":\"fa-rotate-left\",\"fa-balance-scale\":\"fa-balance-scale\",\"btn-play\":\"btn-play\",\"fa-music\":\"fa-music\",\"fa-rub\":\"fa-rub\",\"fa-internet-explorer\":\"fa-internet-explorer\",\"fa-sliders\":\"fa-sliders\",\"more-related-articles-container\":\"more-related-articles-container\",\"row\":\"row\",\"fa-times-circle-o\":\"fa-times-circle-o\",\"fa-car\":\"fa-car\",\"fa-paint-brush\":\"fa-paint-brush\",\"fa-tty\":\"fa-tty\",\"in\":\"in\",\"fa-bitbucket-square\":\"fa-bitbucket-square\",\"employment-benefits\":\"employment-benefits\",\"fa-rotate-90\":\"fa-rotate-90\",\"fa-envelope-square\":\"fa-envelope-square\",\"fa-lightbulb-o\":\"fa-lightbulb-o\",\"fa-file-zip-o\":\"fa-file-zip-o\",\"footer-form-wrapper\":\"footer-form-wrapper\",\"fa-tencent-weibo\":\"fa-tencent-weibo\",\"fa-dot-circle-o\":\"fa-dot-circle-o\",\"fa-truck\":\"fa-truck\",\"fa-male\":\"fa-male\",\"fa-microphone-slash\":\"fa-microphone-slash\",\"fa-umbrella\":\"fa-umbrella\",\"fa-hourglass-2\":\"fa-hourglass-2\",\"fa-genderless\":\"fa-genderless\",\"basic-see-more\":\"basic-see-more\",\"fa-lastfm-square\":\"fa-lastfm-square\",\"panel-heading\":\"panel-heading\",\"fa-phone\":\"fa-phone\",\"fa-whatsapp\":\"fa-whatsapp\",\"fa-signing\":\"fa-signing\",\"fa-university\":\"fa-university\",\"fa-battery-full\":\"fa-battery-full\",\"fa-magic\":\"fa-magic\",\"fa-html5\":\"fa-html5\",\"fa-trademark\":\"fa-trademark\",\"star-black\":\"star-black\",\"fa-sort\":\"fa-sort\",\"fa-envelope-open-o\":\"fa-envelope-open-o\",\"fa-gears\":\"fa-gears\",\"star-orange\":\"star-orange\",\"fa-bluetooth-b\":\"fa-bluetooth-b\",\"icon-bar\":\"icon-bar\",\"fa-file-pdf-o\":\"fa-file-pdf-o\",\"fa-list-alt\":\"fa-list-alt\",\"fa-yoast\":\"fa-yoast\",\"grouped\":\"grouped\",\"recent-firm-news-description\":\"recent-firm-news-description\",\"fa-language\":\"fa-language\",\"fa-long-arrow-right\":\"fa-long-arrow-right\",\"fa-send\":\"fa-send\",\"fa-refresh\":\"fa-refresh\",\"fa-search-minus\":\"fa-search-minus\",\"fa-hospital-o\":\"fa-hospital-o\",\"fa-jsfiddle\":\"fa-jsfiddle\",\"items-2\":\"items-2\",\"fa-spotify\":\"fa-spotify\",\"fa-shower\":\"fa-shower\",\"fa-flag-checkered\":\"fa-flag-checkered\",\"fa-podcast\":\"fa-podcast\",\"see-all\":\"see-all\",\"fa-imdb\":\"fa-imdb\",\"fa-bookmark\":\"fa-bookmark\",\"fa-level-down\":\"fa-level-down\",\"fa-wrench\":\"fa-wrench\",\"fa-mixcloud\":\"fa-mixcloud\",\"fa-outdent\":\"fa-outdent\",\"fa-share-alt-square\":\"fa-share-alt-square\",\"fa-lock\":\"fa-lock\",\"fa-gratipay\":\"fa-gratipay\",\"fa-table\":\"fa-table\",\"fa-flip-horizontal\":\"fa-flip-horizontal\",\"fa-plus-square\":\"fa-plus-square\",\"fa-transgender\":\"fa-transgender\",\"actions\":\"actions\",\"fa-bullseye\":\"fa-bullseye\",\"fa-star-half-o\":\"fa-star-half-o\",\"fa\":\"fa\",\"fa-female\":\"fa-female\",\"fa-angle-double-right\":\"fa-angle-double-right\",\"fa-free-code-camp\":\"fa-free-code-camp\",\"fa-cart-plus\":\"fa-cart-plus\",\"fa-rotate-180\":\"fa-rotate-180\",\"fa-calendar-o\":\"fa-calendar-o\",\"fa-flask\":\"fa-flask\",\"fa-bandcamp\":\"fa-bandcamp\",\"fa-caret-down\":\"fa-caret-down\",\"fa-hourglass\":\"fa-hourglass\",\"social-share-flat-wrapper\":\"social-share-flat-wrapper\",\"fa-pinterest-square\":\"fa-pinterest-square\",\"fa-paper-plane-o\":\"fa-paper-plane-o\",\"fa-fa\":\"fa-fa\",\"fa-mars-stroke\":\"fa-mars-stroke\",\"fa-save\":\"fa-save\",\"fa-upload\":\"fa-upload\",\"fa-cc-mastercard\":\"fa-cc-mastercard\",\"fa-wpexplorer\":\"fa-wpexplorer\",\"fa-cloud-upload\":\"fa-cloud-upload\",\"fa-minus\":\"fa-minus\",\"recent-firm-news-image\":\"recent-firm-news-image\",\"fa-tripadvisor\":\"fa-tripadvisor\",\"fa-deafness\":\"fa-deafness\",\"btn-close-expander\":\"btn-close-expander\"};\n\n/***/ }),\n\n/***/ 7:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nmodule.exports = __webpack_require__(11)\n\n\n/***/ }),\n\n/***/ 8:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar Promise = __webpack_require__(2);\n\nmodule.exports = Promise;\nPromise.prototype.done = function (onFulfilled, onRejected) {\n  var self = arguments.length ? this.then.apply(this, arguments) : this;\n  self.then(null, function (err) {\n    setTimeout(function () {\n      throw err;\n    }, 0);\n  });\n};\n\n\n/***/ }),\n\n/***/ 9:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n//This file contains the ES6 extensions to the core Promises/A+ API\n\nvar Promise = __webpack_require__(2);\n\nmodule.exports = Promise;\n\n/* Static Functions */\n\nvar TRUE = valuePromise(true);\nvar FALSE = valuePromise(false);\nvar NULL = valuePromise(null);\nvar UNDEFINED = valuePromise(undefined);\nvar ZERO = valuePromise(0);\nvar EMPTYSTRING = valuePromise('');\n\nfunction valuePromise(value) {\n  var p = new Promise(Promise._61);\n  p._65 = 1;\n  p._55 = value;\n  return p;\n}\nPromise.resolve = function (value) {\n  if (value instanceof Promise) return value;\n\n  if (value === null) return NULL;\n  if (value === undefined) return UNDEFINED;\n  if (value === true) return TRUE;\n  if (value === false) return FALSE;\n  if (value === 0) return ZERO;\n  if (value === '') return EMPTYSTRING;\n\n  if (typeof value === 'object' || typeof value === 'function') {\n    try {\n      var then = value.then;\n      if (typeof then === 'function') {\n        return new Promise(then.bind(value));\n      }\n    } catch (ex) {\n      return new Promise(function (resolve, reject) {\n        reject(ex);\n      });\n    }\n  }\n  return valuePromise(value);\n};\n\nPromise.all = function (arr) {\n  var args = Array.prototype.slice.call(arr);\n\n  return new Promise(function (resolve, reject) {\n    if (args.length === 0) return resolve([]);\n    var remaining = args.length;\n    function res(i, val) {\n      if (val && (typeof val === 'object' || typeof val === 'function')) {\n        if (val instanceof Promise && val.then === Promise.prototype.then) {\n          while (val._65 === 3) {\n            val = val._55;\n          }\n          if (val._65 === 1) return res(i, val._55);\n          if (val._65 === 2) reject(val._55);\n          val.then(function (val) {\n            res(i, val);\n          }, reject);\n          return;\n        } else {\n          var then = val.then;\n          if (typeof then === 'function') {\n            var p = new Promise(then.bind(val));\n            p.then(function (val) {\n              res(i, val);\n            }, reject);\n            return;\n          }\n        }\n      }\n      args[i] = val;\n      if (--remaining === 0) {\n        resolve(args);\n      }\n    }\n    for (var i = 0; i < args.length; i++) {\n      res(i, args[i]);\n    }\n  });\n};\n\nPromise.reject = function (value) {\n  return new Promise(function (resolve, reject) {\n    reject(value);\n  });\n};\n\nPromise.race = function (values) {\n  return new Promise(function (resolve, reject) {\n    values.forEach(function(value){\n      Promise.resolve(value).then(resolve, reject);\n    });\n  });\n};\n\n/* Prototype Methods */\n\nPromise.prototype['catch'] = function (onRejected) {\n  return this.then(null, onRejected);\n};\n\n\n/***/ }),\n\n/***/ 91:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(Backbone, _, $) {\n\nvar _slidedown = __webpack_require__(55);\n\nvar _collapsible = __webpack_require__(38);\n\nvar _collapsible2 = _interopRequireDefault(_collapsible);\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n__webpack_require__(66);\n\nvar Job = Backbone.Model.extend({\n    defaults: {\n        id: null,\n        title: null,\n        full_title: null,\n        location: {},\n        url: null,\n        department: null\n    }\n});\n\nvar Jobs = Backbone.Collection.extend({\n    model: Job,\n\n    parse: function parse(resp) {\n        return resp['jobs'];\n    },\n\n\n    url: '//proxypool.forthepeople.com/careers'\n});\n\nvar jobs = new Jobs();\n\njobs.fetch({\n    success: function success(collection) {\n        var jobsTpl = _.template($('#city-jobs-template').html());\n        var groupedByCity = collection.groupBy(function (j) {\n            return j.get('location').city;\n        });\n\n        (0, _slidedown.makeSlidedowns)($('.employment .employment-locations'), _.keys(groupedByCity).sort().reverse(), function (city) {\n            return { id: groupedByCity[city][0].get('id'), title: city, content: jobsTpl({ jobs: groupedByCity[city] }) };\n        });\n\n        $('.employment .employment-locations .panel').each(function () {\n            (0, _collapsible2.default)($(this));\n        });\n    }\n});\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(3), __webpack_require__(0), __webpack_require__(1)))\n\n/***/ })\n\n/******/ });\n\n\n// WEBPACK FOOTER //\n// employment-bef109a214aa0e57ba54.bundle.js"," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// identity function for calling harmony imports with the correct context\n \t__webpack_require__.i = function(value) { return value; };\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, {\n \t\t\t\tconfigurable: false,\n \t\t\t\tenumerable: true,\n \t\t\t\tget: getter\n \t\t\t});\n \t\t}\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 91);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap bef109a214aa0e57ba54","//     Underscore.js 1.8.3\n//     http://underscorejs.org\n//     (c) 2009-2015 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n//     Underscore may be freely distributed under the MIT license.\n\n(function() {\n\n  // Baseline setup\n  // --------------\n\n  // Establish the root object, `window` in the browser, or `exports` on the server.\n  var root = this;\n\n  // Save the previous value of the `_` variable.\n  var previousUnderscore = root._;\n\n  // Save bytes in the minified (but not gzipped) version:\n  var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype;\n\n  // Create quick reference variables for speed access to core prototypes.\n  var\n    push             = ArrayProto.push,\n    slice            = ArrayProto.slice,\n    toString         = ObjProto.toString,\n    hasOwnProperty   = ObjProto.hasOwnProperty;\n\n  // All **ECMAScript 5** native function implementations that we hope to use\n  // are declared here.\n  var\n    nativeIsArray      = Array.isArray,\n    nativeKeys         = Object.keys,\n    nativeBind         = FuncProto.bind,\n    nativeCreate       = Object.create;\n\n  // Naked function reference for surrogate-prototype-swapping.\n  var Ctor = function(){};\n\n  // Create a safe reference to the Underscore object for use below.\n  var _ = function(obj) {\n    if (obj instanceof _) return obj;\n    if (!(this instanceof _)) return new _(obj);\n    this._wrapped = obj;\n  };\n\n  // Export the Underscore object for **Node.js**, with\n  // backwards-compatibility for the old `require()` API. If we're in\n  // the browser, add `_` as a global object.\n  if (typeof exports !== 'undefined') {\n    if (typeof module !== 'undefined' && module.exports) {\n      exports = module.exports = _;\n    }\n    exports._ = _;\n  } else {\n    root._ = _;\n  }\n\n  // Current version.\n  _.VERSION = '1.8.3';\n\n  // Internal function that returns an efficient (for current engines) version\n  // of the passed-in callback, to be repeatedly applied in other Underscore\n  // functions.\n  var optimizeCb = function(func, context, argCount) {\n    if (context === void 0) return func;\n    switch (argCount == null ? 3 : argCount) {\n      case 1: return function(value) {\n        return func.call(context, value);\n      };\n      case 2: return function(value, other) {\n        return func.call(context, value, other);\n      };\n      case 3: return function(value, index, collection) {\n        return func.call(context, value, index, collection);\n      };\n      case 4: return function(accumulator, value, index, collection) {\n        return func.call(context, accumulator, value, index, collection);\n      };\n    }\n    return function() {\n      return func.apply(context, arguments);\n    };\n  };\n\n  // A mostly-internal function to generate callbacks that can be applied\n  // to each element in a collection, returning the desired result — either\n  // identity, an arbitrary callback, a property matcher, or a property accessor.\n  var cb = function(value, context, argCount) {\n    if (value == null) return _.identity;\n    if (_.isFunction(value)) return optimizeCb(value, context, argCount);\n    if (_.isObject(value)) return _.matcher(value);\n    return _.property(value);\n  };\n  _.iteratee = function(value, context) {\n    return cb(value, context, Infinity);\n  };\n\n  // An internal function for creating assigner functions.\n  var createAssigner = function(keysFunc, undefinedOnly) {\n    return function(obj) {\n      var length = arguments.length;\n      if (length < 2 || obj == null) return obj;\n      for (var index = 1; index < length; index++) {\n        var source = arguments[index],\n            keys = keysFunc(source),\n            l = keys.length;\n        for (var i = 0; i < l; i++) {\n          var key = keys[i];\n          if (!undefinedOnly || obj[key] === void 0) obj[key] = source[key];\n        }\n      }\n      return obj;\n    };\n  };\n\n  // An internal function for creating a new object that inherits from another.\n  var baseCreate = function(prototype) {\n    if (!_.isObject(prototype)) return {};\n    if (nativeCreate) return nativeCreate(prototype);\n    Ctor.prototype = prototype;\n    var result = new Ctor;\n    Ctor.prototype = null;\n    return result;\n  };\n\n  var property = function(key) {\n    return function(obj) {\n      return obj == null ? void 0 : obj[key];\n    };\n  };\n\n  // Helper for collection methods to determine whether a collection\n  // should be iterated as an array or as an object\n  // Related: http://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength\n  // Avoids a very nasty iOS 8 JIT bug on ARM-64. #2094\n  var MAX_ARRAY_INDEX = Math.pow(2, 53) - 1;\n  var getLength = property('length');\n  var isArrayLike = function(collection) {\n    var length = getLength(collection);\n    return typeof length == 'number' && length >= 0 && length <= MAX_ARRAY_INDEX;\n  };\n\n  // Collection Functions\n  // --------------------\n\n  // The cornerstone, an `each` implementation, aka `forEach`.\n  // Handles raw objects in addition to array-likes. Treats all\n  // sparse array-likes as if they were dense.\n  _.each = _.forEach = function(obj, iteratee, context) {\n    iteratee = optimizeCb(iteratee, context);\n    var i, length;\n    if (isArrayLike(obj)) {\n      for (i = 0, length = obj.length; i < length; i++) {\n        iteratee(obj[i], i, obj);\n      }\n    } else {\n      var keys = _.keys(obj);\n      for (i = 0, length = keys.length; i < length; i++) {\n        iteratee(obj[keys[i]], keys[i], obj);\n      }\n    }\n    return obj;\n  };\n\n  // Return the results of applying the iteratee to each element.\n  _.map = _.collect = function(obj, iteratee, context) {\n    iteratee = cb(iteratee, context);\n    var keys = !isArrayLike(obj) && _.keys(obj),\n        length = (keys || obj).length,\n        results = Array(length);\n    for (var index = 0; index < length; index++) {\n      var currentKey = keys ? keys[index] : index;\n      results[index] = iteratee(obj[currentKey], currentKey, obj);\n    }\n    return results;\n  };\n\n  // Create a reducing function iterating left or right.\n  function createReduce(dir) {\n    // Optimized iterator function as using arguments.length\n    // in the main function will deoptimize the, see #1991.\n    function iterator(obj, iteratee, memo, keys, index, length) {\n      for (; index >= 0 && index < length; index += dir) {\n        var currentKey = keys ? keys[index] : index;\n        memo = iteratee(memo, obj[currentKey], currentKey, obj);\n      }\n      return memo;\n    }\n\n    return function(obj, iteratee, memo, context) {\n      iteratee = optimizeCb(iteratee, context, 4);\n      var keys = !isArrayLike(obj) && _.keys(obj),\n          length = (keys || obj).length,\n          index = dir > 0 ? 0 : length - 1;\n      // Determine the initial value if none is provided.\n      if (arguments.length < 3) {\n        memo = obj[keys ? keys[index] : index];\n        index += dir;\n      }\n      return iterator(obj, iteratee, memo, keys, index, length);\n    };\n  }\n\n  // **Reduce** builds up a single result from a list of values, aka `inject`,\n  // or `foldl`.\n  _.reduce = _.foldl = _.inject = createReduce(1);\n\n  // The right-associative version of reduce, also known as `foldr`.\n  _.reduceRight = _.foldr = createReduce(-1);\n\n  // Return the first value which passes a truth test. Aliased as `detect`.\n  _.find = _.detect = function(obj, predicate, context) {\n    var key;\n    if (isArrayLike(obj)) {\n      key = _.findIndex(obj, predicate, context);\n    } else {\n      key = _.findKey(obj, predicate, context);\n    }\n    if (key !== void 0 && key !== -1) return obj[key];\n  };\n\n  // Return all the elements that pass a truth test.\n  // Aliased as `select`.\n  _.filter = _.select = function(obj, predicate, context) {\n    var results = [];\n    predicate = cb(predicate, context);\n    _.each(obj, function(value, index, list) {\n      if (predicate(value, index, list)) results.push(value);\n    });\n    return results;\n  };\n\n  // Return all the elements for which a truth test fails.\n  _.reject = function(obj, predicate, context) {\n    return _.filter(obj, _.negate(cb(predicate)), context);\n  };\n\n  // Determine whether all of the elements match a truth test.\n  // Aliased as `all`.\n  _.every = _.all = function(obj, predicate, context) {\n    predicate = cb(predicate, context);\n    var keys = !isArrayLike(obj) && _.keys(obj),\n        length = (keys || obj).length;\n    for (var index = 0; index < length; index++) {\n      var currentKey = keys ? keys[index] : index;\n      if (!predicate(obj[currentKey], currentKey, obj)) return false;\n    }\n    return true;\n  };\n\n  // Determine if at least one element in the object matches a truth test.\n  // Aliased as `any`.\n  _.some = _.any = function(obj, predicate, context) {\n    predicate = cb(predicate, context);\n    var keys = !isArrayLike(obj) && _.keys(obj),\n        length = (keys || obj).length;\n    for (var index = 0; index < length; index++) {\n      var currentKey = keys ? keys[index] : index;\n      if (predicate(obj[currentKey], currentKey, obj)) return true;\n    }\n    return false;\n  };\n\n  // Determine if the array or object contains a given item (using `===`).\n  // Aliased as `includes` and `include`.\n  _.contains = _.includes = _.include = function(obj, item, fromIndex, guard) {\n    if (!isArrayLike(obj)) obj = _.values(obj);\n    if (typeof fromIndex != 'number' || guard) fromIndex = 0;\n    return _.indexOf(obj, item, fromIndex) >= 0;\n  };\n\n  // Invoke a method (with arguments) on every item in a collection.\n  _.invoke = function(obj, method) {\n    var args = slice.call(arguments, 2);\n    var isFunc = _.isFunction(method);\n    return _.map(obj, function(value) {\n      var func = isFunc ? method : value[method];\n      return func == null ? func : func.apply(value, args);\n    });\n  };\n\n  // Convenience version of a common use case of `map`: fetching a property.\n  _.pluck = function(obj, key) {\n    return _.map(obj, _.property(key));\n  };\n\n  // Convenience version of a common use case of `filter`: selecting only objects\n  // containing specific `key:value` pairs.\n  _.where = function(obj, attrs) {\n    return _.filter(obj, _.matcher(attrs));\n  };\n\n  // Convenience version of a common use case of `find`: getting the first object\n  // containing specific `key:value` pairs.\n  _.findWhere = function(obj, attrs) {\n    return _.find(obj, _.matcher(attrs));\n  };\n\n  // Return the maximum element (or element-based computation).\n  _.max = function(obj, iteratee, context) {\n    var result = -Infinity, lastComputed = -Infinity,\n        value, computed;\n    if (iteratee == null && obj != null) {\n      obj = isArrayLike(obj) ? obj : _.values(obj);\n      for (var i = 0, length = obj.length; i < length; i++) {\n        value = obj[i];\n        if (value > result) {\n          result = value;\n        }\n      }\n    } else {\n      iteratee = cb(iteratee, context);\n      _.each(obj, function(value, index, list) {\n        computed = iteratee(value, index, list);\n        if (computed > lastComputed || computed === -Infinity && result === -Infinity) {\n          result = value;\n          lastComputed = computed;\n        }\n      });\n    }\n    return result;\n  };\n\n  // Return the minimum element (or element-based computation).\n  _.min = function(obj, iteratee, context) {\n    var result = Infinity, lastComputed = Infinity,\n        value, computed;\n    if (iteratee == null && obj != null) {\n      obj = isArrayLike(obj) ? obj : _.values(obj);\n      for (var i = 0, length = obj.length; i < length; i++) {\n        value = obj[i];\n        if (value < result) {\n          result = value;\n        }\n      }\n    } else {\n      iteratee = cb(iteratee, context);\n      _.each(obj, function(value, index, list) {\n        computed = iteratee(value, index, list);\n        if (computed < lastComputed || computed === Infinity && result === Infinity) {\n          result = value;\n          lastComputed = computed;\n        }\n      });\n    }\n    return result;\n  };\n\n  // Shuffle a collection, using the modern version of the\n  // [Fisher-Yates shuffle](http://en.wikipedia.org/wiki/Fisher–Yates_shuffle).\n  _.shuffle = function(obj) {\n    var set = isArrayLike(obj) ? obj : _.values(obj);\n    var length = set.length;\n    var shuffled = Array(length);\n    for (var index = 0, rand; index < length; index++) {\n      rand = _.random(0, index);\n      if (rand !== index) shuffled[index] = shuffled[rand];\n      shuffled[rand] = set[index];\n    }\n    return shuffled;\n  };\n\n  // Sample **n** random values from a collection.\n  // If **n** is not specified, returns a single random element.\n  // The internal `guard` argument allows it to work with `map`.\n  _.sample = function(obj, n, guard) {\n    if (n == null || guard) {\n      if (!isArrayLike(obj)) obj = _.values(obj);\n      return obj[_.random(obj.length - 1)];\n    }\n    return _.shuffle(obj).slice(0, Math.max(0, n));\n  };\n\n  // Sort the object's values by a criterion produced by an iteratee.\n  _.sortBy = function(obj, iteratee, context) {\n    iteratee = cb(iteratee, context);\n    return _.pluck(_.map(obj, function(value, index, list) {\n      return {\n        value: value,\n        index: index,\n        criteria: iteratee(value, index, list)\n      };\n    }).sort(function(left, right) {\n      var a = left.criteria;\n      var b = right.criteria;\n      if (a !== b) {\n        if (a > b || a === void 0) return 1;\n        if (a < b || b === void 0) return -1;\n      }\n      return left.index - right.index;\n    }), 'value');\n  };\n\n  // An internal function used for aggregate \"group by\" operations.\n  var group = function(behavior) {\n    return function(obj, iteratee, context) {\n      var result = {};\n      iteratee = cb(iteratee, context);\n      _.each(obj, function(value, index) {\n        var key = iteratee(value, index, obj);\n        behavior(result, value, key);\n      });\n      return result;\n    };\n  };\n\n  // Groups the object's values by a criterion. Pass either a string attribute\n  // to group by, or a function that returns the criterion.\n  _.groupBy = group(function(result, value, key) {\n    if (_.has(result, key)) result[key].push(value); else result[key] = [value];\n  });\n\n  // Indexes the object's values by a criterion, similar to `groupBy`, but for\n  // when you know that your index values will be unique.\n  _.indexBy = group(function(result, value, key) {\n    result[key] = value;\n  });\n\n  // Counts instances of an object that group by a certain criterion. Pass\n  // either a string attribute to count by, or a function that returns the\n  // criterion.\n  _.countBy = group(function(result, value, key) {\n    if (_.has(result, key)) result[key]++; else result[key] = 1;\n  });\n\n  // Safely create a real, live array from anything iterable.\n  _.toArray = function(obj) {\n    if (!obj) return [];\n    if (_.isArray(obj)) return slice.call(obj);\n    if (isArrayLike(obj)) return _.map(obj, _.identity);\n    return _.values(obj);\n  };\n\n  // Return the number of elements in an object.\n  _.size = function(obj) {\n    if (obj == null) return 0;\n    return isArrayLike(obj) ? obj.length : _.keys(obj).length;\n  };\n\n  // Split a collection into two arrays: one whose elements all satisfy the given\n  // predicate, and one whose elements all do not satisfy the predicate.\n  _.partition = function(obj, predicate, context) {\n    predicate = cb(predicate, context);\n    var pass = [], fail = [];\n    _.each(obj, function(value, key, obj) {\n      (predicate(value, key, obj) ? pass : fail).push(value);\n    });\n    return [pass, fail];\n  };\n\n  // Array Functions\n  // ---------------\n\n  // Get the first element of an array. Passing **n** will return the first N\n  // values in the array. Aliased as `head` and `take`. The **guard** check\n  // allows it to work with `_.map`.\n  _.first = _.head = _.take = function(array, n, guard) {\n    if (array == null) return void 0;\n    if (n == null || guard) return array[0];\n    return _.initial(array, array.length - n);\n  };\n\n  // Returns everything but the last entry of the array. Especially useful on\n  // the arguments object. Passing **n** will return all the values in\n  // the array, excluding the last N.\n  _.initial = function(array, n, guard) {\n    return slice.call(array, 0, Math.max(0, array.length - (n == null || guard ? 1 : n)));\n  };\n\n  // Get the last element of an array. Passing **n** will return the last N\n  // values in the array.\n  _.last = function(array, n, guard) {\n    if (array == null) return void 0;\n    if (n == null || guard) return array[array.length - 1];\n    return _.rest(array, Math.max(0, array.length - n));\n  };\n\n  // Returns everything but the first entry of the array. Aliased as `tail` and `drop`.\n  // Especially useful on the arguments object. Passing an **n** will return\n  // the rest N values in the array.\n  _.rest = _.tail = _.drop = function(array, n, guard) {\n    return slice.call(array, n == null || guard ? 1 : n);\n  };\n\n  // Trim out all falsy values from an array.\n  _.compact = function(array) {\n    return _.filter(array, _.identity);\n  };\n\n  // Internal implementation of a recursive `flatten` function.\n  var flatten = function(input, shallow, strict, startIndex) {\n    var output = [], idx = 0;\n    for (var i = startIndex || 0, length = getLength(input); i < length; i++) {\n      var value = input[i];\n      if (isArrayLike(value) && (_.isArray(value) || _.isArguments(value))) {\n        //flatten current level of array or arguments object\n        if (!shallow) value = flatten(value, shallow, strict);\n        var j = 0, len = value.length;\n        output.length += len;\n        while (j < len) {\n          output[idx++] = value[j++];\n        }\n      } else if (!strict) {\n        output[idx++] = value;\n      }\n    }\n    return output;\n  };\n\n  // Flatten out an array, either recursively (by default), or just one level.\n  _.flatten = function(array, shallow) {\n    return flatten(array, shallow, false);\n  };\n\n  // Return a version of the array that does not contain the specified value(s).\n  _.without = function(array) {\n    return _.difference(array, slice.call(arguments, 1));\n  };\n\n  // Produce a duplicate-free version of the array. If the array has already\n  // been sorted, you have the option of using a faster algorithm.\n  // Aliased as `unique`.\n  _.uniq = _.unique = function(array, isSorted, iteratee, context) {\n    if (!_.isBoolean(isSorted)) {\n      context = iteratee;\n      iteratee = isSorted;\n      isSorted = false;\n    }\n    if (iteratee != null) iteratee = cb(iteratee, context);\n    var result = [];\n    var seen = [];\n    for (var i = 0, length = getLength(array); i < length; i++) {\n      var value = array[i],\n          computed = iteratee ? iteratee(value, i, array) : value;\n      if (isSorted) {\n        if (!i || seen !== computed) result.push(value);\n        seen = computed;\n      } else if (iteratee) {\n        if (!_.contains(seen, computed)) {\n          seen.push(computed);\n          result.push(value);\n        }\n      } else if (!_.contains(result, value)) {\n        result.push(value);\n      }\n    }\n    return result;\n  };\n\n  // Produce an array that contains the union: each distinct element from all of\n  // the passed-in arrays.\n  _.union = function() {\n    return _.uniq(flatten(arguments, true, true));\n  };\n\n  // Produce an array that contains every item shared between all the\n  // passed-in arrays.\n  _.intersection = function(array) {\n    var result = [];\n    var argsLength = arguments.length;\n    for (var i = 0, length = getLength(array); i < length; i++) {\n      var item = array[i];\n      if (_.contains(result, item)) continue;\n      for (var j = 1; j < argsLength; j++) {\n        if (!_.contains(arguments[j], item)) break;\n      }\n      if (j === argsLength) result.push(item);\n    }\n    return result;\n  };\n\n  // Take the difference between one array and a number of other arrays.\n  // Only the elements present in just the first array will remain.\n  _.difference = function(array) {\n    var rest = flatten(arguments, true, true, 1);\n    return _.filter(array, function(value){\n      return !_.contains(rest, value);\n    });\n  };\n\n  // Zip together multiple lists into a single array -- elements that share\n  // an index go together.\n  _.zip = function() {\n    return _.unzip(arguments);\n  };\n\n  // Complement of _.zip. Unzip accepts an array of arrays and groups\n  // each array's elements on shared indices\n  _.unzip = function(array) {\n    var length = array && _.max(array, getLength).length || 0;\n    var result = Array(length);\n\n    for (var index = 0; index < length; index++) {\n      result[index] = _.pluck(array, index);\n    }\n    return result;\n  };\n\n  // Converts lists into objects. Pass either a single array of `[key, value]`\n  // pairs, or two parallel arrays of the same length -- one of keys, and one of\n  // the corresponding values.\n  _.object = function(list, values) {\n    var result = {};\n    for (var i = 0, length = getLength(list); i < length; i++) {\n      if (values) {\n        result[list[i]] = values[i];\n      } else {\n        result[list[i][0]] = list[i][1];\n      }\n    }\n    return result;\n  };\n\n  // Generator function to create the findIndex and findLastIndex functions\n  function createPredicateIndexFinder(dir) {\n    return function(array, predicate, context) {\n      predicate = cb(predicate, context);\n      var length = getLength(array);\n      var index = dir > 0 ? 0 : length - 1;\n      for (; index >= 0 && index < length; index += dir) {\n        if (predicate(array[index], index, array)) return index;\n      }\n      return -1;\n    };\n  }\n\n  // Returns the first index on an array-like that passes a predicate test\n  _.findIndex = createPredicateIndexFinder(1);\n  _.findLastIndex = createPredicateIndexFinder(-1);\n\n  // Use a comparator function to figure out the smallest index at which\n  // an object should be inserted so as to maintain order. Uses binary search.\n  _.sortedIndex = function(array, obj, iteratee, context) {\n    iteratee = cb(iteratee, context, 1);\n    var value = iteratee(obj);\n    var low = 0, high = getLength(array);\n    while (low < high) {\n      var mid = Math.floor((low + high) / 2);\n      if (iteratee(array[mid]) < value) low = mid + 1; else high = mid;\n    }\n    return low;\n  };\n\n  // Generator function to create the indexOf and lastIndexOf functions\n  function createIndexFinder(dir, predicateFind, sortedIndex) {\n    return function(array, item, idx) {\n      var i = 0, length = getLength(array);\n      if (typeof idx == 'number') {\n        if (dir > 0) {\n            i = idx >= 0 ? idx : Math.max(idx + length, i);\n        } else {\n            length = idx >= 0 ? Math.min(idx + 1, length) : idx + length + 1;\n        }\n      } else if (sortedIndex && idx && length) {\n        idx = sortedIndex(array, item);\n        return array[idx] === item ? idx : -1;\n      }\n      if (item !== item) {\n        idx = predicateFind(slice.call(array, i, length), _.isNaN);\n        return idx >= 0 ? idx + i : -1;\n      }\n      for (idx = dir > 0 ? i : length - 1; idx >= 0 && idx < length; idx += dir) {\n        if (array[idx] === item) return idx;\n      }\n      return -1;\n    };\n  }\n\n  // Return the position of the first occurrence of an item in an array,\n  // or -1 if the item is not included in the array.\n  // If the array is large and already in sort order, pass `true`\n  // for **isSorted** to use binary search.\n  _.indexOf = createIndexFinder(1, _.findIndex, _.sortedIndex);\n  _.lastIndexOf = createIndexFinder(-1, _.findLastIndex);\n\n  // Generate an integer Array containing an arithmetic progression. A port of\n  // the native Python `range()` function. See\n  // [the Python documentation](http://docs.python.org/library/functions.html#range).\n  _.range = function(start, stop, step) {\n    if (stop == null) {\n      stop = start || 0;\n      start = 0;\n    }\n    step = step || 1;\n\n    var length = Math.max(Math.ceil((stop - start) / step), 0);\n    var range = Array(length);\n\n    for (var idx = 0; idx < length; idx++, start += step) {\n      range[idx] = start;\n    }\n\n    return range;\n  };\n\n  // Function (ahem) Functions\n  // ------------------\n\n  // Determines whether to execute a function as a constructor\n  // or a normal function with the provided arguments\n  var executeBound = function(sourceFunc, boundFunc, context, callingContext, args) {\n    if (!(callingContext instanceof boundFunc)) return sourceFunc.apply(context, args);\n    var self = baseCreate(sourceFunc.prototype);\n    var result = sourceFunc.apply(self, args);\n    if (_.isObject(result)) return result;\n    return self;\n  };\n\n  // Create a function bound to a given object (assigning `this`, and arguments,\n  // optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if\n  // available.\n  _.bind = function(func, context) {\n    if (nativeBind && func.bind === nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));\n    if (!_.isFunction(func)) throw new TypeError('Bind must be called on a function');\n    var args = slice.call(arguments, 2);\n    var bound = function() {\n      return executeBound(func, bound, context, this, args.concat(slice.call(arguments)));\n    };\n    return bound;\n  };\n\n  // Partially apply a function by creating a version that has had some of its\n  // arguments pre-filled, without changing its dynamic `this` context. _ acts\n  // as a placeholder, allowing any combination of arguments to be pre-filled.\n  _.partial = function(func) {\n    var boundArgs = slice.call(arguments, 1);\n    var bound = function() {\n      var position = 0, length = boundArgs.length;\n      var args = Array(length);\n      for (var i = 0; i < length; i++) {\n        args[i] = boundArgs[i] === _ ? arguments[position++] : boundArgs[i];\n      }\n      while (position < arguments.length) args.push(arguments[position++]);\n      return executeBound(func, bound, this, this, args);\n    };\n    return bound;\n  };\n\n  // Bind a number of an object's methods to that object. Remaining arguments\n  // are the method names to be bound. Useful for ensuring that all callbacks\n  // defined on an object belong to it.\n  _.bindAll = function(obj) {\n    var i, length = arguments.length, key;\n    if (length <= 1) throw new Error('bindAll must be passed function names');\n    for (i = 1; i < length; i++) {\n      key = arguments[i];\n      obj[key] = _.bind(obj[key], obj);\n    }\n    return obj;\n  };\n\n  // Memoize an expensive function by storing its results.\n  _.memoize = function(func, hasher) {\n    var memoize = function(key) {\n      var cache = memoize.cache;\n      var address = '' + (hasher ? hasher.apply(this, arguments) : key);\n      if (!_.has(cache, address)) cache[address] = func.apply(this, arguments);\n      return cache[address];\n    };\n    memoize.cache = {};\n    return memoize;\n  };\n\n  // Delays a function for the given number of milliseconds, and then calls\n  // it with the arguments supplied.\n  _.delay = function(func, wait) {\n    var args = slice.call(arguments, 2);\n    return setTimeout(function(){\n      return func.apply(null, args);\n    }, wait);\n  };\n\n  // Defers a function, scheduling it to run after the current call stack has\n  // cleared.\n  _.defer = _.partial(_.delay, _, 1);\n\n  // Returns a function, that, when invoked, will only be triggered at most once\n  // during a given window of time. Normally, the throttled function will run\n  // as much as it can, without ever going more than once per `wait` duration;\n  // but if you'd like to disable the execution on the leading edge, pass\n  // `{leading: false}`. To disable execution on the trailing edge, ditto.\n  _.throttle = function(func, wait, options) {\n    var context, args, result;\n    var timeout = null;\n    var previous = 0;\n    if (!options) options = {};\n    var later = function() {\n      previous = options.leading === false ? 0 : _.now();\n      timeout = null;\n      result = func.apply(context, args);\n      if (!timeout) context = args = null;\n    };\n    return function() {\n      var now = _.now();\n      if (!previous && options.leading === false) previous = now;\n      var remaining = wait - (now - previous);\n      context = this;\n      args = arguments;\n      if (remaining <= 0 || remaining > wait) {\n        if (timeout) {\n          clearTimeout(timeout);\n          timeout = null;\n        }\n        previous = now;\n        result = func.apply(context, args);\n        if (!timeout) context = args = null;\n      } else if (!timeout && options.trailing !== false) {\n        timeout = setTimeout(later, remaining);\n      }\n      return result;\n    };\n  };\n\n  // Returns a function, that, as long as it continues to be invoked, will not\n  // be triggered. The function will be called after it stops being called for\n  // N milliseconds. If `immediate` is passed, trigger the function on the\n  // leading edge, instead of the trailing.\n  _.debounce = function(func, wait, immediate) {\n    var timeout, args, context, timestamp, result;\n\n    var later = function() {\n      var last = _.now() - timestamp;\n\n      if (last < wait && last >= 0) {\n        timeout = setTimeout(later, wait - last);\n      } else {\n        timeout = null;\n        if (!immediate) {\n          result = func.apply(context, args);\n          if (!timeout) context = args = null;\n        }\n      }\n    };\n\n    return function() {\n      context = this;\n      args = arguments;\n      timestamp = _.now();\n      var callNow = immediate && !timeout;\n      if (!timeout) timeout = setTimeout(later, wait);\n      if (callNow) {\n        result = func.apply(context, args);\n        context = args = null;\n      }\n\n      return result;\n    };\n  };\n\n  // Returns the first function passed as an argument to the second,\n  // allowing you to adjust arguments, run code before and after, and\n  // conditionally execute the original function.\n  _.wrap = function(func, wrapper) {\n    return _.partial(wrapper, func);\n  };\n\n  // Returns a negated version of the passed-in predicate.\n  _.negate = function(predicate) {\n    return function() {\n      return !predicate.apply(this, arguments);\n    };\n  };\n\n  // Returns a function that is the composition of a list of functions, each\n  // consuming the return value of the function that follows.\n  _.compose = function() {\n    var args = arguments;\n    var start = args.length - 1;\n    return function() {\n      var i = start;\n      var result = args[start].apply(this, arguments);\n      while (i--) result = args[i].call(this, result);\n      return result;\n    };\n  };\n\n  // Returns a function that will only be executed on and after the Nth call.\n  _.after = function(times, func) {\n    return function() {\n      if (--times < 1) {\n        return func.apply(this, arguments);\n      }\n    };\n  };\n\n  // Returns a function that will only be executed up to (but not including) the Nth call.\n  _.before = function(times, func) {\n    var memo;\n    return function() {\n      if (--times > 0) {\n        memo = func.apply(this, arguments);\n      }\n      if (times <= 1) func = null;\n      return memo;\n    };\n  };\n\n  // Returns a function that will be executed at most one time, no matter how\n  // often you call it. Useful for lazy initialization.\n  _.once = _.partial(_.before, 2);\n\n  // Object Functions\n  // ----------------\n\n  // Keys in IE < 9 that won't be iterated by `for key in ...` and thus missed.\n  var hasEnumBug = !{toString: null}.propertyIsEnumerable('toString');\n  var nonEnumerableProps = ['valueOf', 'isPrototypeOf', 'toString',\n                      'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];\n\n  function collectNonEnumProps(obj, keys) {\n    var nonEnumIdx = nonEnumerableProps.length;\n    var constructor = obj.constructor;\n    var proto = (_.isFunction(constructor) && constructor.prototype) || ObjProto;\n\n    // Constructor is a special case.\n    var prop = 'constructor';\n    if (_.has(obj, prop) && !_.contains(keys, prop)) keys.push(prop);\n\n    while (nonEnumIdx--) {\n      prop = nonEnumerableProps[nonEnumIdx];\n      if (prop in obj && obj[prop] !== proto[prop] && !_.contains(keys, prop)) {\n        keys.push(prop);\n      }\n    }\n  }\n\n  // Retrieve the names of an object's own properties.\n  // Delegates to **ECMAScript 5**'s native `Object.keys`\n  _.keys = function(obj) {\n    if (!_.isObject(obj)) return [];\n    if (nativeKeys) return nativeKeys(obj);\n    var keys = [];\n    for (var key in obj) if (_.has(obj, key)) keys.push(key);\n    // Ahem, IE < 9.\n    if (hasEnumBug) collectNonEnumProps(obj, keys);\n    return keys;\n  };\n\n  // Retrieve all the property names of an object.\n  _.allKeys = function(obj) {\n    if (!_.isObject(obj)) return [];\n    var keys = [];\n    for (var key in obj) keys.push(key);\n    // Ahem, IE < 9.\n    if (hasEnumBug) collectNonEnumProps(obj, keys);\n    return keys;\n  };\n\n  // Retrieve the values of an object's properties.\n  _.values = function(obj) {\n    var keys = _.keys(obj);\n    var length = keys.length;\n    var values = Array(length);\n    for (var i = 0; i < length; i++) {\n      values[i] = obj[keys[i]];\n    }\n    return values;\n  };\n\n  // Returns the results of applying the iteratee to each element of the object\n  // In contrast to _.map it returns an object\n  _.mapObject = function(obj, iteratee, context) {\n    iteratee = cb(iteratee, context);\n    var keys =  _.keys(obj),\n          length = keys.length,\n          results = {},\n          currentKey;\n      for (var index = 0; index < length; index++) {\n        currentKey = keys[index];\n        results[currentKey] = iteratee(obj[currentKey], currentKey, obj);\n      }\n      return results;\n  };\n\n  // Convert an object into a list of `[key, value]` pairs.\n  _.pairs = function(obj) {\n    var keys = _.keys(obj);\n    var length = keys.length;\n    var pairs = Array(length);\n    for (var i = 0; i < length; i++) {\n      pairs[i] = [keys[i], obj[keys[i]]];\n    }\n    return pairs;\n  };\n\n  // Invert the keys and values of an object. The values must be serializable.\n  _.invert = function(obj) {\n    var result = {};\n    var keys = _.keys(obj);\n    for (var i = 0, length = keys.length; i < length; i++) {\n      result[obj[keys[i]]] = keys[i];\n    }\n    return result;\n  };\n\n  // Return a sorted list of the function names available on the object.\n  // Aliased as `methods`\n  _.functions = _.methods = function(obj) {\n    var names = [];\n    for (var key in obj) {\n      if (_.isFunction(obj[key])) names.push(key);\n    }\n    return names.sort();\n  };\n\n  // Extend a given object with all the properties in passed-in object(s).\n  _.extend = createAssigner(_.allKeys);\n\n  // Assigns a given object with all the own properties in the passed-in object(s)\n  // (https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/assign)\n  _.extendOwn = _.assign = createAssigner(_.keys);\n\n  // Returns the first key on an object that passes a predicate test\n  _.findKey = function(obj, predicate, context) {\n    predicate = cb(predicate, context);\n    var keys = _.keys(obj), key;\n    for (var i = 0, length = keys.length; i < length; i++) {\n      key = keys[i];\n      if (predicate(obj[key], key, obj)) return key;\n    }\n  };\n\n  // Return a copy of the object only containing the whitelisted properties.\n  _.pick = function(object, oiteratee, context) {\n    var result = {}, obj = object, iteratee, keys;\n    if (obj == null) return result;\n    if (_.isFunction(oiteratee)) {\n      keys = _.allKeys(obj);\n      iteratee = optimizeCb(oiteratee, context);\n    } else {\n      keys = flatten(arguments, false, false, 1);\n      iteratee = function(value, key, obj) { return key in obj; };\n      obj = Object(obj);\n    }\n    for (var i = 0, length = keys.length; i < length; i++) {\n      var key = keys[i];\n      var value = obj[key];\n      if (iteratee(value, key, obj)) result[key] = value;\n    }\n    return result;\n  };\n\n   // Return a copy of the object without the blacklisted properties.\n  _.omit = function(obj, iteratee, context) {\n    if (_.isFunction(iteratee)) {\n      iteratee = _.negate(iteratee);\n    } else {\n      var keys = _.map(flatten(arguments, false, false, 1), String);\n      iteratee = function(value, key) {\n        return !_.contains(keys, key);\n      };\n    }\n    return _.pick(obj, iteratee, context);\n  };\n\n  // Fill in a given object with default properties.\n  _.defaults = createAssigner(_.allKeys, true);\n\n  // Creates an object that inherits from the given prototype object.\n  // If additional properties are provided then they will be added to the\n  // created object.\n  _.create = function(prototype, props) {\n    var result = baseCreate(prototype);\n    if (props) _.extendOwn(result, props);\n    return result;\n  };\n\n  // Create a (shallow-cloned) duplicate of an object.\n  _.clone = function(obj) {\n    if (!_.isObject(obj)) return obj;\n    return _.isArray(obj) ? obj.slice() : _.extend({}, obj);\n  };\n\n  // Invokes interceptor with the obj, and then returns obj.\n  // The primary purpose of this method is to \"tap into\" a method chain, in\n  // order to perform operations on intermediate results within the chain.\n  _.tap = function(obj, interceptor) {\n    interceptor(obj);\n    return obj;\n  };\n\n  // Returns whether an object has a given set of `key:value` pairs.\n  _.isMatch = function(object, attrs) {\n    var keys = _.keys(attrs), length = keys.length;\n    if (object == null) return !length;\n    var obj = Object(object);\n    for (var i = 0; i < length; i++) {\n      var key = keys[i];\n      if (attrs[key] !== obj[key] || !(key in obj)) return false;\n    }\n    return true;\n  };\n\n\n  // Internal recursive comparison function for `isEqual`.\n  var eq = function(a, b, aStack, bStack) {\n    // Identical objects are equal. `0 === -0`, but they aren't identical.\n    // See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal).\n    if (a === b) return a !== 0 || 1 / a === 1 / b;\n    // A strict comparison is necessary because `null == undefined`.\n    if (a == null || b == null) return a === b;\n    // Unwrap any wrapped objects.\n    if (a instanceof _) a = a._wrapped;\n    if (b instanceof _) b = b._wrapped;\n    // Compare `[[Class]]` names.\n    var className = toString.call(a);\n    if (className !== toString.call(b)) return false;\n    switch (className) {\n      // Strings, numbers, regular expressions, dates, and booleans are compared by value.\n      case '[object RegExp]':\n      // RegExps are coerced to strings for comparison (Note: '' + /a/i === '/a/i')\n      case '[object String]':\n        // Primitives and their corresponding object wrappers are equivalent; thus, `\"5\"` is\n        // equivalent to `new String(\"5\")`.\n        return '' + a === '' + b;\n      case '[object Number]':\n        // `NaN`s are equivalent, but non-reflexive.\n        // Object(NaN) is equivalent to NaN\n        if (+a !== +a) return +b !== +b;\n        // An `egal` comparison is performed for other numeric values.\n        return +a === 0 ? 1 / +a === 1 / b : +a === +b;\n      case '[object Date]':\n      case '[object Boolean]':\n        // Coerce dates and booleans to numeric primitive values. Dates are compared by their\n        // millisecond representations. Note that invalid dates with millisecond representations\n        // of `NaN` are not equivalent.\n        return +a === +b;\n    }\n\n    var areArrays = className === '[object Array]';\n    if (!areArrays) {\n      if (typeof a != 'object' || typeof b != 'object') return false;\n\n      // Objects with different constructors are not equivalent, but `Object`s or `Array`s\n      // from different frames are.\n      var aCtor = a.constructor, bCtor = b.constructor;\n      if (aCtor !== bCtor && !(_.isFunction(aCtor) && aCtor instanceof aCtor &&\n                               _.isFunction(bCtor) && bCtor instanceof bCtor)\n                          && ('constructor' in a && 'constructor' in b)) {\n        return false;\n      }\n    }\n    // Assume equality for cyclic structures. The algorithm for detecting cyclic\n    // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.\n\n    // Initializing stack of traversed objects.\n    // It's done here since we only need them for objects and arrays comparison.\n    aStack = aStack || [];\n    bStack = bStack || [];\n    var length = aStack.length;\n    while (length--) {\n      // Linear search. Performance is inversely proportional to the number of\n      // unique nested structures.\n      if (aStack[length] === a) return bStack[length] === b;\n    }\n\n    // Add the first object to the stack of traversed objects.\n    aStack.push(a);\n    bStack.push(b);\n\n    // Recursively compare objects and arrays.\n    if (areArrays) {\n      // Compare array lengths to determine if a deep comparison is necessary.\n      length = a.length;\n      if (length !== b.length) return false;\n      // Deep compare the contents, ignoring non-numeric properties.\n      while (length--) {\n        if (!eq(a[length], b[length], aStack, bStack)) return false;\n      }\n    } else {\n      // Deep compare objects.\n      var keys = _.keys(a), key;\n      length = keys.length;\n      // Ensure that both objects contain the same number of properties before comparing deep equality.\n      if (_.keys(b).length !== length) return false;\n      while (length--) {\n        // Deep compare each member\n        key = keys[length];\n        if (!(_.has(b, key) && eq(a[key], b[key], aStack, bStack))) return false;\n      }\n    }\n    // Remove the first object from the stack of traversed objects.\n    aStack.pop();\n    bStack.pop();\n    return true;\n  };\n\n  // Perform a deep comparison to check if two objects are equal.\n  _.isEqual = function(a, b) {\n    return eq(a, b);\n  };\n\n  // Is a given array, string, or object empty?\n  // An \"empty\" object has no enumerable own-properties.\n  _.isEmpty = function(obj) {\n    if (obj == null) return true;\n    if (isArrayLike(obj) && (_.isArray(obj) || _.isString(obj) || _.isArguments(obj))) return obj.length === 0;\n    return _.keys(obj).length === 0;\n  };\n\n  // Is a given value a DOM element?\n  _.isElement = function(obj) {\n    return !!(obj && obj.nodeType === 1);\n  };\n\n  // Is a given value an array?\n  // Delegates to ECMA5's native Array.isArray\n  _.isArray = nativeIsArray || function(obj) {\n    return toString.call(obj) === '[object Array]';\n  };\n\n  // Is a given variable an object?\n  _.isObject = function(obj) {\n    var type = typeof obj;\n    return type === 'function' || type === 'object' && !!obj;\n  };\n\n  // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp, isError.\n  _.each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp', 'Error'], function(name) {\n    _['is' + name] = function(obj) {\n      return toString.call(obj) === '[object ' + name + ']';\n    };\n  });\n\n  // Define a fallback version of the method in browsers (ahem, IE < 9), where\n  // there isn't any inspectable \"Arguments\" type.\n  if (!_.isArguments(arguments)) {\n    _.isArguments = function(obj) {\n      return _.has(obj, 'callee');\n    };\n  }\n\n  // Optimize `isFunction` if appropriate. Work around some typeof bugs in old v8,\n  // IE 11 (#1621), and in Safari 8 (#1929).\n  if (typeof /./ != 'function' && typeof Int8Array != 'object') {\n    _.isFunction = function(obj) {\n      return typeof obj == 'function' || false;\n    };\n  }\n\n  // Is a given object a finite number?\n  _.isFinite = function(obj) {\n    return isFinite(obj) && !isNaN(parseFloat(obj));\n  };\n\n  // Is the given value `NaN`? (NaN is the only number which does not equal itself).\n  _.isNaN = function(obj) {\n    return _.isNumber(obj) && obj !== +obj;\n  };\n\n  // Is a given value a boolean?\n  _.isBoolean = function(obj) {\n    return obj === true || obj === false || toString.call(obj) === '[object Boolean]';\n  };\n\n  // Is a given value equal to null?\n  _.isNull = function(obj) {\n    return obj === null;\n  };\n\n  // Is a given variable undefined?\n  _.isUndefined = function(obj) {\n    return obj === void 0;\n  };\n\n  // Shortcut function for checking if an object has a given property directly\n  // on itself (in other words, not on a prototype).\n  _.has = function(obj, key) {\n    return obj != null && hasOwnProperty.call(obj, key);\n  };\n\n  // Utility Functions\n  // -----------------\n\n  // Run Underscore.js in *noConflict* mode, returning the `_` variable to its\n  // previous owner. Returns a reference to the Underscore object.\n  _.noConflict = function() {\n    root._ = previousUnderscore;\n    return this;\n  };\n\n  // Keep the identity function around for default iteratees.\n  _.identity = function(value) {\n    return value;\n  };\n\n  // Predicate-generating functions. Often useful outside of Underscore.\n  _.constant = function(value) {\n    return function() {\n      return value;\n    };\n  };\n\n  _.noop = function(){};\n\n  _.property = property;\n\n  // Generates a function for a given object that returns a given property.\n  _.propertyOf = function(obj) {\n    return obj == null ? function(){} : function(key) {\n      return obj[key];\n    };\n  };\n\n  // Returns a predicate for checking whether an object has a given set of\n  // `key:value` pairs.\n  _.matcher = _.matches = function(attrs) {\n    attrs = _.extendOwn({}, attrs);\n    return function(obj) {\n      return _.isMatch(obj, attrs);\n    };\n  };\n\n  // Run a function **n** times.\n  _.times = function(n, iteratee, context) {\n    var accum = Array(Math.max(0, n));\n    iteratee = optimizeCb(iteratee, context, 1);\n    for (var i = 0; i < n; i++) accum[i] = iteratee(i);\n    return accum;\n  };\n\n  // Return a random integer between min and max (inclusive).\n  _.random = function(min, max) {\n    if (max == null) {\n      max = min;\n      min = 0;\n    }\n    return min + Math.floor(Math.random() * (max - min + 1));\n  };\n\n  // A (possibly faster) way to get the current timestamp as an integer.\n  _.now = Date.now || function() {\n    return new Date().getTime();\n  };\n\n   // List of HTML entities for escaping.\n  var escapeMap = {\n    '&': '&amp;',\n    '<': '&lt;',\n    '>': '&gt;',\n    '\"': '&quot;',\n    \"'\": '&#x27;',\n    '`': '&#x60;'\n  };\n  var unescapeMap = _.invert(escapeMap);\n\n  // Functions for escaping and unescaping strings to/from HTML interpolation.\n  var createEscaper = function(map) {\n    var escaper = function(match) {\n      return map[match];\n    };\n    // Regexes for identifying a key that needs to be escaped\n    var source = '(?:' + _.keys(map).join('|') + ')';\n    var testRegexp = RegExp(source);\n    var replaceRegexp = RegExp(source, 'g');\n    return function(string) {\n      string = string == null ? '' : '' + string;\n      return testRegexp.test(string) ? string.replace(replaceRegexp, escaper) : string;\n    };\n  };\n  _.escape = createEscaper(escapeMap);\n  _.unescape = createEscaper(unescapeMap);\n\n  // If the value of the named `property` is a function then invoke it with the\n  // `object` as context; otherwise, return it.\n  _.result = function(object, property, fallback) {\n    var value = object == null ? void 0 : object[property];\n    if (value === void 0) {\n      value = fallback;\n    }\n    return _.isFunction(value) ? value.call(object) : value;\n  };\n\n  // Generate a unique integer id (unique within the entire client session).\n  // Useful for temporary DOM ids.\n  var idCounter = 0;\n  _.uniqueId = function(prefix) {\n    var id = ++idCounter + '';\n    return prefix ? prefix + id : id;\n  };\n\n  // By default, Underscore uses ERB-style template delimiters, change the\n  // following template settings to use alternative delimiters.\n  _.templateSettings = {\n    evaluate    : /<%([\\s\\S]+?)%>/g,\n    interpolate : /<%=([\\s\\S]+?)%>/g,\n    escape      : /<%-([\\s\\S]+?)%>/g\n  };\n\n  // When customizing `templateSettings`, if you don't want to define an\n  // interpolation, evaluation or escaping regex, we need one that is\n  // guaranteed not to match.\n  var noMatch = /(.)^/;\n\n  // Certain characters need to be escaped so that they can be put into a\n  // string literal.\n  var escapes = {\n    \"'\":      \"'\",\n    '\\\\':     '\\\\',\n    '\\r':     'r',\n    '\\n':     'n',\n    '\\u2028': 'u2028',\n    '\\u2029': 'u2029'\n  };\n\n  var escaper = /\\\\|'|\\r|\\n|\\u2028|\\u2029/g;\n\n  var escapeChar = function(match) {\n    return '\\\\' + escapes[match];\n  };\n\n  // JavaScript micro-templating, similar to John Resig's implementation.\n  // Underscore templating handles arbitrary delimiters, preserves whitespace,\n  // and correctly escapes quotes within interpolated code.\n  // NB: `oldSettings` only exists for backwards compatibility.\n  _.template = function(text, settings, oldSettings) {\n    if (!settings && oldSettings) settings = oldSettings;\n    settings = _.defaults({}, settings, _.templateSettings);\n\n    // Combine delimiters into one regular expression via alternation.\n    var matcher = RegExp([\n      (settings.escape || noMatch).source,\n      (settings.interpolate || noMatch).source,\n      (settings.evaluate || noMatch).source\n    ].join('|') + '|$', 'g');\n\n    // Compile the template source, escaping string literals appropriately.\n    var index = 0;\n    var source = \"__p+='\";\n    text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {\n      source += text.slice(index, offset).replace(escaper, escapeChar);\n      index = offset + match.length;\n\n      if (escape) {\n        source += \"'+\\n((__t=(\" + escape + \"))==null?'':_.escape(__t))+\\n'\";\n      } else if (interpolate) {\n        source += \"'+\\n((__t=(\" + interpolate + \"))==null?'':__t)+\\n'\";\n      } else if (evaluate) {\n        source += \"';\\n\" + evaluate + \"\\n__p+='\";\n      }\n\n      // Adobe VMs need the match returned to produce the correct offest.\n      return match;\n    });\n    source += \"';\\n\";\n\n    // If a variable is not specified, place data values in local scope.\n    if (!settings.variable) source = 'with(obj||{}){\\n' + source + '}\\n';\n\n    source = \"var __t,__p='',__j=Array.prototype.join,\" +\n      \"print=function(){__p+=__j.call(arguments,'');};\\n\" +\n      source + 'return __p;\\n';\n\n    try {\n      var render = new Function(settings.variable || 'obj', '_', source);\n    } catch (e) {\n      e.source = source;\n      throw e;\n    }\n\n    var template = function(data) {\n      return render.call(this, data, _);\n    };\n\n    // Provide the compiled source as a convenience for precompilation.\n    var argument = settings.variable || 'obj';\n    template.source = 'function(' + argument + '){\\n' + source + '}';\n\n    return template;\n  };\n\n  // Add a \"chain\" function. Start chaining a wrapped Underscore object.\n  _.chain = function(obj) {\n    var instance = _(obj);\n    instance._chain = true;\n    return instance;\n  };\n\n  // OOP\n  // ---------------\n  // If Underscore is called as a function, it returns a wrapped object that\n  // can be used OO-style. This wrapper holds altered versions of all the\n  // underscore functions. Wrapped objects may be chained.\n\n  // Helper function to continue chaining intermediate results.\n  var result = function(instance, obj) {\n    return instance._chain ? _(obj).chain() : obj;\n  };\n\n  // Add your own custom functions to the Underscore object.\n  _.mixin = function(obj) {\n    _.each(_.functions(obj), function(name) {\n      var func = _[name] = obj[name];\n      _.prototype[name] = function() {\n        var args = [this._wrapped];\n        push.apply(args, arguments);\n        return result(this, func.apply(_, args));\n      };\n    });\n  };\n\n  // Add all of the Underscore functions to the wrapper object.\n  _.mixin(_);\n\n  // Add all mutator Array functions to the wrapper.\n  _.each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {\n    var method = ArrayProto[name];\n    _.prototype[name] = function() {\n      var obj = this._wrapped;\n      method.apply(obj, arguments);\n      if ((name === 'shift' || name === 'splice') && obj.length === 0) delete obj[0];\n      return result(this, obj);\n    };\n  });\n\n  // Add all accessor Array functions to the wrapper.\n  _.each(['concat', 'join', 'slice'], function(name) {\n    var method = ArrayProto[name];\n    _.prototype[name] = function() {\n      return result(this, method.apply(this._wrapped, arguments));\n    };\n  });\n\n  // Extracts the result from a wrapped and chained object.\n  _.prototype.value = function() {\n    return this._wrapped;\n  };\n\n  // Provide unwrapping proxy for some methods used in engine operations\n  // such as arithmetic and JSON stringification.\n  _.prototype.valueOf = _.prototype.toJSON = _.prototype.value;\n\n  _.prototype.toString = function() {\n    return '' + this._wrapped;\n  };\n\n  // AMD registration happens at the end for compatibility with AMD loaders\n  // that may not enforce next-turn semantics on modules. Even though general\n  // practice for AMD registration is to be anonymous, underscore registers\n  // as a named module because, like jQuery, it is a base library that is\n  // popular enough to be bundled in a third party lib, but not be part of\n  // an AMD load request. Those cases could generate an error when an\n  // anonymous define() is called outside of a loader request.\n  if (typeof define === 'function' && define.amd) {\n    define('underscore', [], function() {\n      return _;\n    });\n  }\n}.call(this));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/underscore/underscore.js\n// module id = 0\n// module chunks = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21","module.exports = $;\n\n\n//////////////////\n// WEBPACK FOOTER\n// external \"$\"\n// module id = 1\n// module chunks = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21","'use strict';\n\nvar Promise = require('./core.js');\n\nmodule.exports = Promise;\nPromise.prototype['finally'] = function (f) {\n  return this.then(function (value) {\n    return Promise.resolve(f()).then(function () {\n      return value;\n    });\n  }, function (err) {\n    return Promise.resolve(f()).then(function () {\n      throw err;\n    });\n  });\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/promise/lib/finally.js\n// module id = 10\n// module chunks = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19","/* ========================================================================\n * Bootstrap: collapse.js v3.3.7\n * http://getbootstrap.com/javascript/#collapse\n * ========================================================================\n * Copyright 2011-2016 Twitter, Inc.\n * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)\n * ======================================================================== */\n\n/* jshint latedef: false */\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.7'\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\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/bootstrap/js/collapse.js\n// module id = 105\n// module chunks = 14","'use strict';\n\nmodule.exports = require('./core.js');\nrequire('./done.js');\nrequire('./finally.js');\nrequire('./es6-extensions.js');\nrequire('./node-extensions.js');\nrequire('./synchronous.js');\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/promise/lib/index.js\n// module id = 11\n// module chunks = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19","'use strict';\n\n// This file contains then/promise specific extensions that are only useful\n// for node.js interop\n\nvar Promise = require('./core.js');\nvar asap = require('asap');\n\nmodule.exports = Promise;\n\n/* Static Functions */\n\nPromise.denodeify = function (fn, argumentCount) {\n  if (\n    typeof argumentCount === 'number' && argumentCount !== Infinity\n  ) {\n    return denodeifyWithCount(fn, argumentCount);\n  } else {\n    return denodeifyWithoutCount(fn);\n  }\n};\n\nvar callbackFn = (\n  'function (err, res) {' +\n  'if (err) { rj(err); } else { rs(res); }' +\n  '}'\n);\nfunction denodeifyWithCount(fn, argumentCount) {\n  var args = [];\n  for (var i = 0; i < argumentCount; i++) {\n    args.push('a' + i);\n  }\n  var body = [\n    'return function (' + args.join(',') + ') {',\n    'var self = this;',\n    'return new Promise(function (rs, rj) {',\n    'var res = fn.call(',\n    ['self'].concat(args).concat([callbackFn]).join(','),\n    ');',\n    'if (res &&',\n    '(typeof res === \"object\" || typeof res === \"function\") &&',\n    'typeof res.then === \"function\"',\n    ') {rs(res);}',\n    '});',\n    '};'\n  ].join('');\n  return Function(['Promise', 'fn'], body)(Promise, fn);\n}\nfunction denodeifyWithoutCount(fn) {\n  var fnLength = Math.max(fn.length - 1, 3);\n  var args = [];\n  for (var i = 0; i < fnLength; i++) {\n    args.push('a' + i);\n  }\n  var body = [\n    'return function (' + args.join(',') + ') {',\n    'var self = this;',\n    'var args;',\n    'var argLength = arguments.length;',\n    'if (arguments.length > ' + fnLength + ') {',\n    'args = new Array(arguments.length + 1);',\n    'for (var i = 0; i < arguments.length; i++) {',\n    'args[i] = arguments[i];',\n    '}',\n    '}',\n    'return new Promise(function (rs, rj) {',\n    'var cb = ' + callbackFn + ';',\n    'var res;',\n    'switch (argLength) {',\n    args.concat(['extra']).map(function (_, index) {\n      return (\n        'case ' + (index) + ':' +\n        'res = fn.call(' + ['self'].concat(args.slice(0, index)).concat('cb').join(',') + ');' +\n        'break;'\n      );\n    }).join(''),\n    'default:',\n    'args[argLength] = cb;',\n    'res = fn.apply(self, args);',\n    '}',\n    \n    'if (res &&',\n    '(typeof res === \"object\" || typeof res === \"function\") &&',\n    'typeof res.then === \"function\"',\n    ') {rs(res);}',\n    '});',\n    '};'\n  ].join('');\n\n  return Function(\n    ['Promise', 'fn'],\n    body\n  )(Promise, fn);\n}\n\nPromise.nodeify = function (fn) {\n  return function () {\n    var args = Array.prototype.slice.call(arguments);\n    var callback =\n      typeof args[args.length - 1] === 'function' ? args.pop() : null;\n    var ctx = this;\n    try {\n      return fn.apply(this, arguments).nodeify(callback, ctx);\n    } catch (ex) {\n      if (callback === null || typeof callback == 'undefined') {\n        return new Promise(function (resolve, reject) {\n          reject(ex);\n        });\n      } else {\n        asap(function () {\n          callback.call(ctx, ex);\n        })\n      }\n    }\n  }\n};\n\nPromise.prototype.nodeify = function (callback, ctx) {\n  if (typeof callback != 'function') return this;\n\n  this.then(function (value) {\n    asap(function () {\n      callback.call(ctx, null, value);\n    });\n  }, function (err) {\n    asap(function () {\n      callback.call(ctx, err);\n    });\n  });\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/promise/lib/node-extensions.js\n// module id = 12\n// module chunks = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19","module.exports = function(obj){\nvar __t,__p='',__j=Array.prototype.join,print=function(){__p+=__j.call(arguments,'');};\nwith(obj||{}){\n__p+='\\n<!-- js/templates/slidedown.html -->\\n<div class=\"panel panel-default\">\\n    <div class=\"panel-heading\" role=\"tab\" id=\"heading'+\n((__t=( id ))==null?'':__t)+\n'\">\\n        <h4 class=\"panel-title\">\\n            <a role=\"button\" class=\"collapsed\" data-toggle=\"collapse\" data-parent=\"#accordion\" href=\"#collapse'+\n((__t=( id ))==null?'':__t)+\n'\" aria-expanded=\"false\" aria-controls=\"collapse'+\n((__t=( id ))==null?'':__t)+\n'\">\\n                '+\n((__t=( title ))==null?'':__t)+\n'\\n            </a>\\n        </h4>\\n    </div>\\n\\n    <div id=\"collapse'+\n((__t=( id ))==null?'':__t)+\n'\" class=\"panel-collapse collapse\" role=\"tabpanel\" aria-labelledby=\"heading'+\n((__t=( id ))==null?'':__t)+\n'\">\\n        <div class=\"panel-body\">\\n            '+\n((__t=( content ))==null?'':__t)+\n'\\n        </div>\\n    </div>\\n</div>';\n}\nreturn __p;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./js/templates/slidedown.html\n// module id = 120\n// module chunks = 14","'use strict';\n\nvar Promise = require('./core.js');\n\nmodule.exports = Promise;\nPromise.enableSynchronous = function () {\n  Promise.prototype.isPending = function() {\n    return this.getState() == 0;\n  };\n\n  Promise.prototype.isFulfilled = function() {\n    return this.getState() == 1;\n  };\n\n  Promise.prototype.isRejected = function() {\n    return this.getState() == 2;\n  };\n\n  Promise.prototype.getValue = function () {\n    if (this._65 === 3) {\n      return this._55.getValue();\n    }\n\n    if (!this.isFulfilled()) {\n      throw new Error('Cannot get a value of an unfulfilled promise.');\n    }\n\n    return this._55;\n  };\n\n  Promise.prototype.getReason = function () {\n    if (this._65 === 3) {\n      return this._55.getReason();\n    }\n\n    if (!this.isRejected()) {\n      throw new Error('Cannot get a rejection reason of a non-rejected promise.');\n    }\n\n    return this._55;\n  };\n\n  Promise.prototype.getState = function () {\n    if (this._65 === 3) {\n      return this._55.getState();\n    }\n    if (this._65 === -1 || this._65 === -2) {\n      return 0;\n    }\n\n    return this._65;\n  };\n};\n\nPromise.disableSynchronous = function() {\n  Promise.prototype.isPending = undefined;\n  Promise.prototype.isFulfilled = undefined;\n  Promise.prototype.isRejected = undefined;\n  Promise.prototype.getValue = undefined;\n  Promise.prototype.getReason = undefined;\n  Promise.prototype.getState = undefined;\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/promise/lib/synchronous.js\n// module id = 13\n// module chunks = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19","\"use strict\";\n\n// rawAsap provides everything we need except exception management.\nvar rawAsap = require(\"./raw\");\n// RawTasks are recycled to reduce GC churn.\nvar freeTasks = [];\n// We queue errors to ensure they are thrown in right order (FIFO).\n// Array-as-queue is good enough here, since we are just dealing with exceptions.\nvar pendingErrors = [];\nvar requestErrorThrow = rawAsap.makeRequestCallFromTimer(throwFirstError);\n\nfunction throwFirstError() {\n    if (pendingErrors.length) {\n        throw pendingErrors.shift();\n    }\n}\n\n/**\n * Calls a task as soon as possible after returning, in its own event, with priority\n * over other events like animation, reflow, and repaint. An error thrown from an\n * event will not interrupt, nor even substantially slow down the processing of\n * other events, but will be rather postponed to a lower priority event.\n * @param {{call}} task A callable object, typically a function that takes no\n * arguments.\n */\nmodule.exports = asap;\nfunction asap(task) {\n    var rawTask;\n    if (freeTasks.length) {\n        rawTask = freeTasks.pop();\n    } else {\n        rawTask = new RawTask();\n    }\n    rawTask.task = task;\n    rawAsap(rawTask);\n}\n\n// We wrap tasks with recyclable task objects.  A task object implements\n// `call`, just like a function.\nfunction RawTask() {\n    this.task = null;\n}\n\n// The sole purpose of wrapping the task is to catch the exception and recycle\n// the task object after its single use.\nRawTask.prototype.call = function () {\n    try {\n        this.task.call();\n    } catch (error) {\n        if (asap.onerror) {\n            // This hook exists purely for testing purposes.\n            // Its name will be periodically randomized to break any code that\n            // depends on its existence.\n            asap.onerror(error);\n        } else {\n            // In a web browser, exceptions are not fatal. However, to avoid\n            // slowing down the queue of pending tasks, we rethrow the error in a\n            // lower priority turn.\n            pendingErrors.push(error);\n            requestErrorThrow();\n        }\n    } finally {\n        this.task = null;\n        freeTasks[freeTasks.length] = this;\n    }\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/promise/~/asap/browser-asap.js\n// module id = 14\n// module chunks = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19","'use strict';\n\nvar asap = require('asap/raw');\n\nfunction noop() {}\n\n// States:\n//\n// 0 - pending\n// 1 - fulfilled with _value\n// 2 - rejected with _value\n// 3 - adopted the state of another promise, _value\n//\n// once the state is no longer pending (0) it is immutable\n\n// All `_` prefixed properties will be reduced to `_{random number}`\n// at build time to obfuscate them and discourage their use.\n// We don't use symbols or Object.defineProperty to fully hide them\n// because the performance isn't good enough.\n\n\n// to avoid using try/catch inside critical functions, we\n// extract them to here.\nvar LAST_ERROR = null;\nvar IS_ERROR = {};\nfunction getThen(obj) {\n  try {\n    return obj.then;\n  } catch (ex) {\n    LAST_ERROR = ex;\n    return IS_ERROR;\n  }\n}\n\nfunction tryCallOne(fn, a) {\n  try {\n    return fn(a);\n  } catch (ex) {\n    LAST_ERROR = ex;\n    return IS_ERROR;\n  }\n}\nfunction tryCallTwo(fn, a, b) {\n  try {\n    fn(a, b);\n  } catch (ex) {\n    LAST_ERROR = ex;\n    return IS_ERROR;\n  }\n}\n\nmodule.exports = Promise;\n\nfunction Promise(fn) {\n  if (typeof this !== 'object') {\n    throw new TypeError('Promises must be constructed via new');\n  }\n  if (typeof fn !== 'function') {\n    throw new TypeError('Promise constructor\\'s argument is not a function');\n  }\n  this._40 = 0;\n  this._65 = 0;\n  this._55 = null;\n  this._72 = null;\n  if (fn === noop) return;\n  doResolve(fn, this);\n}\nPromise._37 = null;\nPromise._87 = null;\nPromise._61 = noop;\n\nPromise.prototype.then = function(onFulfilled, onRejected) {\n  if (this.constructor !== Promise) {\n    return safeThen(this, onFulfilled, onRejected);\n  }\n  var res = new Promise(noop);\n  handle(this, new Handler(onFulfilled, onRejected, res));\n  return res;\n};\n\nfunction safeThen(self, onFulfilled, onRejected) {\n  return new self.constructor(function (resolve, reject) {\n    var res = new Promise(noop);\n    res.then(resolve, reject);\n    handle(self, new Handler(onFulfilled, onRejected, res));\n  });\n}\nfunction handle(self, deferred) {\n  while (self._65 === 3) {\n    self = self._55;\n  }\n  if (Promise._37) {\n    Promise._37(self);\n  }\n  if (self._65 === 0) {\n    if (self._40 === 0) {\n      self._40 = 1;\n      self._72 = deferred;\n      return;\n    }\n    if (self._40 === 1) {\n      self._40 = 2;\n      self._72 = [self._72, deferred];\n      return;\n    }\n    self._72.push(deferred);\n    return;\n  }\n  handleResolved(self, deferred);\n}\n\nfunction handleResolved(self, deferred) {\n  asap(function() {\n    var cb = self._65 === 1 ? deferred.onFulfilled : deferred.onRejected;\n    if (cb === null) {\n      if (self._65 === 1) {\n        resolve(deferred.promise, self._55);\n      } else {\n        reject(deferred.promise, self._55);\n      }\n      return;\n    }\n    var ret = tryCallOne(cb, self._55);\n    if (ret === IS_ERROR) {\n      reject(deferred.promise, LAST_ERROR);\n    } else {\n      resolve(deferred.promise, ret);\n    }\n  });\n}\nfunction resolve(self, newValue) {\n  // Promise Resolution Procedure: https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure\n  if (newValue === self) {\n    return reject(\n      self,\n      new TypeError('A promise cannot be resolved with itself.')\n    );\n  }\n  if (\n    newValue &&\n    (typeof newValue === 'object' || typeof newValue === 'function')\n  ) {\n    var then = getThen(newValue);\n    if (then === IS_ERROR) {\n      return reject(self, LAST_ERROR);\n    }\n    if (\n      then === self.then &&\n      newValue instanceof Promise\n    ) {\n      self._65 = 3;\n      self._55 = newValue;\n      finale(self);\n      return;\n    } else if (typeof then === 'function') {\n      doResolve(then.bind(newValue), self);\n      return;\n    }\n  }\n  self._65 = 1;\n  self._55 = newValue;\n  finale(self);\n}\n\nfunction reject(self, newValue) {\n  self._65 = 2;\n  self._55 = newValue;\n  if (Promise._87) {\n    Promise._87(self, newValue);\n  }\n  finale(self);\n}\nfunction finale(self) {\n  if (self._40 === 1) {\n    handle(self, self._72);\n    self._72 = null;\n  }\n  if (self._40 === 2) {\n    for (var i = 0; i < self._72.length; i++) {\n      handle(self, self._72[i]);\n    }\n    self._72 = null;\n  }\n}\n\nfunction Handler(onFulfilled, onRejected, promise){\n  this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null;\n  this.onRejected = typeof onRejected === 'function' ? onRejected : null;\n  this.promise = promise;\n}\n\n/**\n * Take a potentially misbehaving resolver function and make sure\n * onFulfilled and onRejected are only called once.\n *\n * Makes no guarantees about asynchrony.\n */\nfunction doResolve(fn, promise) {\n  var done = false;\n  var res = tryCallTwo(fn, function (value) {\n    if (done) return;\n    done = true;\n    resolve(promise, value);\n  }, function (reason) {\n    if (done) return;\n    done = true;\n    reject(promise, reason);\n  });\n  if (!done && res === IS_ERROR) {\n    done = true;\n    reject(promise, LAST_ERROR);\n  }\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/promise/lib/core.js\n// module id = 2\n// module chunks = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19","//     Backbone.js 1.3.3\n\n//     (c) 2010-2016 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n//     Backbone may be freely distributed under the MIT license.\n//     For all details and documentation:\n//     http://backbonejs.org\n\n(function(factory) {\n\n  // Establish the root object, `window` (`self`) in the browser, or `global` on the server.\n  // We use `self` instead of `window` for `WebWorker` support.\n  var root = (typeof self == 'object' && self.self === self && self) ||\n            (typeof global == 'object' && global.global === global && global);\n\n  // Set up Backbone appropriately for the environment. Start with AMD.\n  if (typeof define === 'function' && define.amd) {\n    define(['underscore', 'jquery', 'exports'], function(_, $, exports) {\n      // Export global even in AMD case in case this script is loaded with\n      // others that may still expect a global Backbone.\n      root.Backbone = factory(root, exports, _, $);\n    });\n\n  // Next for Node.js or CommonJS. jQuery may not be needed as a module.\n  } else if (typeof exports !== 'undefined') {\n    var _ = require('underscore'), $;\n    try { $ = require('jquery'); } catch (e) {}\n    factory(root, exports, _, $);\n\n  // Finally, as a browser global.\n  } else {\n    root.Backbone = factory(root, {}, root._, (root.jQuery || root.Zepto || root.ender || root.$));\n  }\n\n})(function(root, Backbone, _, $) {\n\n  // Initial Setup\n  // -------------\n\n  // Save the previous value of the `Backbone` variable, so that it can be\n  // restored later on, if `noConflict` is used.\n  var previousBackbone = root.Backbone;\n\n  // Create a local reference to a common array method we'll want to use later.\n  var slice = Array.prototype.slice;\n\n  // Current version of the library. Keep in sync with `package.json`.\n  Backbone.VERSION = '1.3.3';\n\n  // For Backbone's purposes, jQuery, Zepto, Ender, or My Library (kidding) owns\n  // the `$` variable.\n  Backbone.$ = $;\n\n  // Runs Backbone.js in *noConflict* mode, returning the `Backbone` variable\n  // to its previous owner. Returns a reference to this Backbone object.\n  Backbone.noConflict = function() {\n    root.Backbone = previousBackbone;\n    return this;\n  };\n\n  // Turn on `emulateHTTP` to support legacy HTTP servers. Setting this option\n  // will fake `\"PATCH\"`, `\"PUT\"` and `\"DELETE\"` requests via the `_method` parameter and\n  // set a `X-Http-Method-Override` header.\n  Backbone.emulateHTTP = false;\n\n  // Turn on `emulateJSON` to support legacy servers that can't deal with direct\n  // `application/json` requests ... this will encode the body as\n  // `application/x-www-form-urlencoded` instead and will send the model in a\n  // form param named `model`.\n  Backbone.emulateJSON = false;\n\n  // Proxy Backbone class methods to Underscore functions, wrapping the model's\n  // `attributes` object or collection's `models` array behind the scenes.\n  //\n  // collection.filter(function(model) { return model.get('age') > 10 });\n  // collection.each(this.addView);\n  //\n  // `Function#apply` can be slow so we use the method's arg count, if we know it.\n  var addMethod = function(length, method, attribute) {\n    switch (length) {\n      case 1: return function() {\n        return _[method](this[attribute]);\n      };\n      case 2: return function(value) {\n        return _[method](this[attribute], value);\n      };\n      case 3: return function(iteratee, context) {\n        return _[method](this[attribute], cb(iteratee, this), context);\n      };\n      case 4: return function(iteratee, defaultVal, context) {\n        return _[method](this[attribute], cb(iteratee, this), defaultVal, context);\n      };\n      default: return function() {\n        var args = slice.call(arguments);\n        args.unshift(this[attribute]);\n        return _[method].apply(_, args);\n      };\n    }\n  };\n  var addUnderscoreMethods = function(Class, methods, attribute) {\n    _.each(methods, function(length, method) {\n      if (_[method]) Class.prototype[method] = addMethod(length, method, attribute);\n    });\n  };\n\n  // Support `collection.sortBy('attr')` and `collection.findWhere({id: 1})`.\n  var cb = function(iteratee, instance) {\n    if (_.isFunction(iteratee)) return iteratee;\n    if (_.isObject(iteratee) && !instance._isModel(iteratee)) return modelMatcher(iteratee);\n    if (_.isString(iteratee)) return function(model) { return model.get(iteratee); };\n    return iteratee;\n  };\n  var modelMatcher = function(attrs) {\n    var matcher = _.matches(attrs);\n    return function(model) {\n      return matcher(model.attributes);\n    };\n  };\n\n  // Backbone.Events\n  // ---------------\n\n  // A module that can be mixed in to *any object* in order to provide it with\n  // a custom event channel. You may bind a callback to an event with `on` or\n  // remove with `off`; `trigger`-ing an event fires all callbacks in\n  // succession.\n  //\n  //     var object = {};\n  //     _.extend(object, Backbone.Events);\n  //     object.on('expand', function(){ alert('expanded'); });\n  //     object.trigger('expand');\n  //\n  var Events = Backbone.Events = {};\n\n  // Regular expression used to split event strings.\n  var eventSplitter = /\\s+/;\n\n  // Iterates over the standard `event, callback` (as well as the fancy multiple\n  // space-separated events `\"change blur\", callback` and jQuery-style event\n  // maps `{event: callback}`).\n  var eventsApi = function(iteratee, events, name, callback, opts) {\n    var i = 0, names;\n    if (name && typeof name === 'object') {\n      // Handle event maps.\n      if (callback !== void 0 && 'context' in opts && opts.context === void 0) opts.context = callback;\n      for (names = _.keys(name); i < names.length ; i++) {\n        events = eventsApi(iteratee, events, names[i], name[names[i]], opts);\n      }\n    } else if (name && eventSplitter.test(name)) {\n      // Handle space-separated event names by delegating them individually.\n      for (names = name.split(eventSplitter); i < names.length; i++) {\n        events = iteratee(events, names[i], callback, opts);\n      }\n    } else {\n      // Finally, standard events.\n      events = iteratee(events, name, callback, opts);\n    }\n    return events;\n  };\n\n  // Bind an event to a `callback` function. Passing `\"all\"` will bind\n  // the callback to all events fired.\n  Events.on = function(name, callback, context) {\n    return internalOn(this, name, callback, context);\n  };\n\n  // Guard the `listening` argument from the public API.\n  var internalOn = function(obj, name, callback, context, listening) {\n    obj._events = eventsApi(onApi, obj._events || {}, name, callback, {\n      context: context,\n      ctx: obj,\n      listening: listening\n    });\n\n    if (listening) {\n      var listeners = obj._listeners || (obj._listeners = {});\n      listeners[listening.id] = listening;\n    }\n\n    return obj;\n  };\n\n  // Inversion-of-control versions of `on`. Tell *this* object to listen to\n  // an event in another object... keeping track of what it's listening to\n  // for easier unbinding later.\n  Events.listenTo = function(obj, name, callback) {\n    if (!obj) return this;\n    var id = obj._listenId || (obj._listenId = _.uniqueId('l'));\n    var listeningTo = this._listeningTo || (this._listeningTo = {});\n    var listening = listeningTo[id];\n\n    // This object is not listening to any other events on `obj` yet.\n    // Setup the necessary references to track the listening callbacks.\n    if (!listening) {\n      var thisId = this._listenId || (this._listenId = _.uniqueId('l'));\n      listening = listeningTo[id] = {obj: obj, objId: id, id: thisId, listeningTo: listeningTo, count: 0};\n    }\n\n    // Bind callbacks on obj, and keep track of them on listening.\n    internalOn(obj, name, callback, this, listening);\n    return this;\n  };\n\n  // The reducing API that adds a callback to the `events` object.\n  var onApi = function(events, name, callback, options) {\n    if (callback) {\n      var handlers = events[name] || (events[name] = []);\n      var context = options.context, ctx = options.ctx, listening = options.listening;\n      if (listening) listening.count++;\n\n      handlers.push({callback: callback, context: context, ctx: context || ctx, listening: listening});\n    }\n    return events;\n  };\n\n  // Remove one or many callbacks. If `context` is null, removes all\n  // callbacks with that function. If `callback` is null, removes all\n  // callbacks for the event. If `name` is null, removes all bound\n  // callbacks for all events.\n  Events.off = function(name, callback, context) {\n    if (!this._events) return this;\n    this._events = eventsApi(offApi, this._events, name, callback, {\n      context: context,\n      listeners: this._listeners\n    });\n    return this;\n  };\n\n  // Tell this object to stop listening to either specific events ... or\n  // to every object it's currently listening to.\n  Events.stopListening = function(obj, name, callback) {\n    var listeningTo = this._listeningTo;\n    if (!listeningTo) return this;\n\n    var ids = obj ? [obj._listenId] : _.keys(listeningTo);\n\n    for (var i = 0; i < ids.length; i++) {\n      var listening = listeningTo[ids[i]];\n\n      // If listening doesn't exist, this object is not currently\n      // listening to obj. Break out early.\n      if (!listening) break;\n\n      listening.obj.off(name, callback, this);\n    }\n\n    return this;\n  };\n\n  // The reducing API that removes a callback from the `events` object.\n  var offApi = function(events, name, callback, options) {\n    if (!events) return;\n\n    var i = 0, listening;\n    var context = options.context, listeners = options.listeners;\n\n    // Delete all events listeners and \"drop\" events.\n    if (!name && !callback && !context) {\n      var ids = _.keys(listeners);\n      for (; i < ids.length; i++) {\n        listening = listeners[ids[i]];\n        delete listeners[listening.id];\n        delete listening.listeningTo[listening.objId];\n      }\n      return;\n    }\n\n    var names = name ? [name] : _.keys(events);\n    for (; i < names.length; i++) {\n      name = names[i];\n      var handlers = events[name];\n\n      // Bail out if there are no events stored.\n      if (!handlers) break;\n\n      // Replace events if there are any remaining.  Otherwise, clean up.\n      var remaining = [];\n      for (var j = 0; j < handlers.length; j++) {\n        var handler = handlers[j];\n        if (\n          callback && callback !== handler.callback &&\n            callback !== handler.callback._callback ||\n              context && context !== handler.context\n        ) {\n          remaining.push(handler);\n        } else {\n          listening = handler.listening;\n          if (listening && --listening.count === 0) {\n            delete listeners[listening.id];\n            delete listening.listeningTo[listening.objId];\n          }\n        }\n      }\n\n      // Update tail event if the list has any events.  Otherwise, clean up.\n      if (remaining.length) {\n        events[name] = remaining;\n      } else {\n        delete events[name];\n      }\n    }\n    return events;\n  };\n\n  // Bind an event to only be triggered a single time. After the first time\n  // the callback is invoked, its listener will be removed. If multiple events\n  // are passed in using the space-separated syntax, the handler will fire\n  // once for each event, not once for a combination of all events.\n  Events.once = function(name, callback, context) {\n    // Map the event into a `{event: once}` object.\n    var events = eventsApi(onceMap, {}, name, callback, _.bind(this.off, this));\n    if (typeof name === 'string' && context == null) callback = void 0;\n    return this.on(events, callback, context);\n  };\n\n  // Inversion-of-control versions of `once`.\n  Events.listenToOnce = function(obj, name, callback) {\n    // Map the event into a `{event: once}` object.\n    var events = eventsApi(onceMap, {}, name, callback, _.bind(this.stopListening, this, obj));\n    return this.listenTo(obj, events);\n  };\n\n  // Reduces the event callbacks into a map of `{event: onceWrapper}`.\n  // `offer` unbinds the `onceWrapper` after it has been called.\n  var onceMap = function(map, name, callback, offer) {\n    if (callback) {\n      var once = map[name] = _.once(function() {\n        offer(name, once);\n        callback.apply(this, arguments);\n      });\n      once._callback = callback;\n    }\n    return map;\n  };\n\n  // Trigger one or many events, firing all bound callbacks. Callbacks are\n  // passed the same arguments as `trigger` is, apart from the event name\n  // (unless you're listening on `\"all\"`, which will cause your callback to\n  // receive the true name of the event as the first argument).\n  Events.trigger = function(name) {\n    if (!this._events) return this;\n\n    var length = Math.max(0, arguments.length - 1);\n    var args = Array(length);\n    for (var i = 0; i < length; i++) args[i] = arguments[i + 1];\n\n    eventsApi(triggerApi, this._events, name, void 0, args);\n    return this;\n  };\n\n  // Handles triggering the appropriate event callbacks.\n  var triggerApi = function(objEvents, name, callback, args) {\n    if (objEvents) {\n      var events = objEvents[name];\n      var allEvents = objEvents.all;\n      if (events && allEvents) allEvents = allEvents.slice();\n      if (events) triggerEvents(events, args);\n      if (allEvents) triggerEvents(allEvents, [name].concat(args));\n    }\n    return objEvents;\n  };\n\n  // A difficult-to-believe, but optimized internal dispatch function for\n  // triggering events. Tries to keep the usual cases speedy (most internal\n  // Backbone events have 3 arguments).\n  var triggerEvents = function(events, args) {\n    var ev, i = -1, l = events.length, a1 = args[0], a2 = args[1], a3 = args[2];\n    switch (args.length) {\n      case 0: while (++i < l) (ev = events[i]).callback.call(ev.ctx); return;\n      case 1: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1); return;\n      case 2: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2); return;\n      case 3: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2, a3); return;\n      default: while (++i < l) (ev = events[i]).callback.apply(ev.ctx, args); return;\n    }\n  };\n\n  // Aliases for backwards compatibility.\n  Events.bind   = Events.on;\n  Events.unbind = Events.off;\n\n  // Allow the `Backbone` object to serve as a global event bus, for folks who\n  // want global \"pubsub\" in a convenient place.\n  _.extend(Backbone, Events);\n\n  // Backbone.Model\n  // --------------\n\n  // Backbone **Models** are the basic data object in the framework --\n  // frequently representing a row in a table in a database on your server.\n  // A discrete chunk of data and a bunch of useful, related methods for\n  // performing computations and transformations on that data.\n\n  // Create a new model with the specified attributes. A client id (`cid`)\n  // is automatically generated and assigned for you.\n  var Model = Backbone.Model = function(attributes, options) {\n    var attrs = attributes || {};\n    options || (options = {});\n    this.cid = _.uniqueId(this.cidPrefix);\n    this.attributes = {};\n    if (options.collection) this.collection = options.collection;\n    if (options.parse) attrs = this.parse(attrs, options) || {};\n    var defaults = _.result(this, 'defaults');\n    attrs = _.defaults(_.extend({}, defaults, attrs), defaults);\n    this.set(attrs, options);\n    this.changed = {};\n    this.initialize.apply(this, arguments);\n  };\n\n  // Attach all inheritable methods to the Model prototype.\n  _.extend(Model.prototype, Events, {\n\n    // A hash of attributes whose current and previous value differ.\n    changed: null,\n\n    // The value returned during the last failed validation.\n    validationError: null,\n\n    // The default name for the JSON `id` attribute is `\"id\"`. MongoDB and\n    // CouchDB users may want to set this to `\"_id\"`.\n    idAttribute: 'id',\n\n    // The prefix is used to create the client id which is used to identify models locally.\n    // You may want to override this if you're experiencing name clashes with model ids.\n    cidPrefix: 'c',\n\n    // Initialize is an empty function by default. Override it with your own\n    // initialization logic.\n    initialize: function(){},\n\n    // Return a copy of the model's `attributes` object.\n    toJSON: function(options) {\n      return _.clone(this.attributes);\n    },\n\n    // Proxy `Backbone.sync` by default -- but override this if you need\n    // custom syncing semantics for *this* particular model.\n    sync: function() {\n      return Backbone.sync.apply(this, arguments);\n    },\n\n    // Get the value of an attribute.\n    get: function(attr) {\n      return this.attributes[attr];\n    },\n\n    // Get the HTML-escaped value of an attribute.\n    escape: function(attr) {\n      return _.escape(this.get(attr));\n    },\n\n    // Returns `true` if the attribute contains a value that is not null\n    // or undefined.\n    has: function(attr) {\n      return this.get(attr) != null;\n    },\n\n    // Special-cased proxy to underscore's `_.matches` method.\n    matches: function(attrs) {\n      return !!_.iteratee(attrs, this)(this.attributes);\n    },\n\n    // Set a hash of model attributes on the object, firing `\"change\"`. This is\n    // the core primitive operation of a model, updating the data and notifying\n    // anyone who needs to know about the change in state. The heart of the beast.\n    set: function(key, val, options) {\n      if (key == null) return this;\n\n      // Handle both `\"key\", value` and `{key: value}` -style arguments.\n      var attrs;\n      if (typeof key === 'object') {\n        attrs = key;\n        options = val;\n      } else {\n        (attrs = {})[key] = val;\n      }\n\n      options || (options = {});\n\n      // Run validation.\n      if (!this._validate(attrs, options)) return false;\n\n      // Extract attributes and options.\n      var unset      = options.unset;\n      var silent     = options.silent;\n      var changes    = [];\n      var changing   = this._changing;\n      this._changing = true;\n\n      if (!changing) {\n        this._previousAttributes = _.clone(this.attributes);\n        this.changed = {};\n      }\n\n      var current = this.attributes;\n      var changed = this.changed;\n      var prev    = this._previousAttributes;\n\n      // For each `set` attribute, update or delete the current value.\n      for (var attr in attrs) {\n        val = attrs[attr];\n        if (!_.isEqual(current[attr], val)) changes.push(attr);\n        if (!_.isEqual(prev[attr], val)) {\n          changed[attr] = val;\n        } else {\n          delete changed[attr];\n        }\n        unset ? delete current[attr] : current[attr] = val;\n      }\n\n      // Update the `id`.\n      if (this.idAttribute in attrs) this.id = this.get(this.idAttribute);\n\n      // Trigger all relevant attribute changes.\n      if (!silent) {\n        if (changes.length) this._pending = options;\n        for (var i = 0; i < changes.length; i++) {\n          this.trigger('change:' + changes[i], this, current[changes[i]], options);\n        }\n      }\n\n      // You might be wondering why there's a `while` loop here. Changes can\n      // be recursively nested within `\"change\"` events.\n      if (changing) return this;\n      if (!silent) {\n        while (this._pending) {\n          options = this._pending;\n          this._pending = false;\n          this.trigger('change', this, options);\n        }\n      }\n      this._pending = false;\n      this._changing = false;\n      return this;\n    },\n\n    // Remove an attribute from the model, firing `\"change\"`. `unset` is a noop\n    // if the attribute doesn't exist.\n    unset: function(attr, options) {\n      return this.set(attr, void 0, _.extend({}, options, {unset: true}));\n    },\n\n    // Clear all attributes on the model, firing `\"change\"`.\n    clear: function(options) {\n      var attrs = {};\n      for (var key in this.attributes) attrs[key] = void 0;\n      return this.set(attrs, _.extend({}, options, {unset: true}));\n    },\n\n    // Determine if the model has changed since the last `\"change\"` event.\n    // If you specify an attribute name, determine if that attribute has changed.\n    hasChanged: function(attr) {\n      if (attr == null) return !_.isEmpty(this.changed);\n      return _.has(this.changed, attr);\n    },\n\n    // Return an object containing all the attributes that have changed, or\n    // false if there are no changed attributes. Useful for determining what\n    // parts of a view need to be updated and/or what attributes need to be\n    // persisted to the server. Unset attributes will be set to undefined.\n    // You can also pass an attributes object to diff against the model,\n    // determining if there *would be* a change.\n    changedAttributes: function(diff) {\n      if (!diff) return this.hasChanged() ? _.clone(this.changed) : false;\n      var old = this._changing ? this._previousAttributes : this.attributes;\n      var changed = {};\n      for (var attr in diff) {\n        var val = diff[attr];\n        if (_.isEqual(old[attr], val)) continue;\n        changed[attr] = val;\n      }\n      return _.size(changed) ? changed : false;\n    },\n\n    // Get the previous value of an attribute, recorded at the time the last\n    // `\"change\"` event was fired.\n    previous: function(attr) {\n      if (attr == null || !this._previousAttributes) return null;\n      return this._previousAttributes[attr];\n    },\n\n    // Get all of the attributes of the model at the time of the previous\n    // `\"change\"` event.\n    previousAttributes: function() {\n      return _.clone(this._previousAttributes);\n    },\n\n    // Fetch the model from the server, merging the response with the model's\n    // local attributes. Any changed attributes will trigger a \"change\" event.\n    fetch: function(options) {\n      options = _.extend({parse: true}, options);\n      var model = this;\n      var success = options.success;\n      options.success = function(resp) {\n        var serverAttrs = options.parse ? model.parse(resp, options) : resp;\n        if (!model.set(serverAttrs, options)) return false;\n        if (success) success.call(options.context, model, resp, options);\n        model.trigger('sync', model, resp, options);\n      };\n      wrapError(this, options);\n      return this.sync('read', this, options);\n    },\n\n    // Set a hash of model attributes, and sync the model to the server.\n    // If the server returns an attributes hash that differs, the model's\n    // state will be `set` again.\n    save: function(key, val, options) {\n      // Handle both `\"key\", value` and `{key: value}` -style arguments.\n      var attrs;\n      if (key == null || typeof key === 'object') {\n        attrs = key;\n        options = val;\n      } else {\n        (attrs = {})[key] = val;\n      }\n\n      options = _.extend({validate: true, parse: true}, options);\n      var wait = options.wait;\n\n      // If we're not waiting and attributes exist, save acts as\n      // `set(attr).save(null, opts)` with validation. Otherwise, check if\n      // the model will be valid when the attributes, if any, are set.\n      if (attrs && !wait) {\n        if (!this.set(attrs, options)) return false;\n      } else if (!this._validate(attrs, options)) {\n        return false;\n      }\n\n      // After a successful server-side save, the client is (optionally)\n      // updated with the server-side state.\n      var model = this;\n      var success = options.success;\n      var attributes = this.attributes;\n      options.success = function(resp) {\n        // Ensure attributes are restored during synchronous saves.\n        model.attributes = attributes;\n        var serverAttrs = options.parse ? model.parse(resp, options) : resp;\n        if (wait) serverAttrs = _.extend({}, attrs, serverAttrs);\n        if (serverAttrs && !model.set(serverAttrs, options)) return false;\n        if (success) success.call(options.context, model, resp, options);\n        model.trigger('sync', model, resp, options);\n      };\n      wrapError(this, options);\n\n      // Set temporary attributes if `{wait: true}` to properly find new ids.\n      if (attrs && wait) this.attributes = _.extend({}, attributes, attrs);\n\n      var method = this.isNew() ? 'create' : (options.patch ? 'patch' : 'update');\n      if (method === 'patch' && !options.attrs) options.attrs = attrs;\n      var xhr = this.sync(method, this, options);\n\n      // Restore attributes.\n      this.attributes = attributes;\n\n      return xhr;\n    },\n\n    // Destroy this model on the server if it was already persisted.\n    // Optimistically removes the model from its collection, if it has one.\n    // If `wait: true` is passed, waits for the server to respond before removal.\n    destroy: function(options) {\n      options = options ? _.clone(options) : {};\n      var model = this;\n      var success = options.success;\n      var wait = options.wait;\n\n      var destroy = function() {\n        model.stopListening();\n        model.trigger('destroy', model, model.collection, options);\n      };\n\n      options.success = function(resp) {\n        if (wait) destroy();\n        if (success) success.call(options.context, model, resp, options);\n        if (!model.isNew()) model.trigger('sync', model, resp, options);\n      };\n\n      var xhr = false;\n      if (this.isNew()) {\n        _.defer(options.success);\n      } else {\n        wrapError(this, options);\n        xhr = this.sync('delete', this, options);\n      }\n      if (!wait) destroy();\n      return xhr;\n    },\n\n    // Default URL for the model's representation on the server -- if you're\n    // using Backbone's restful methods, override this to change the endpoint\n    // that will be called.\n    url: function() {\n      var base =\n        _.result(this, 'urlRoot') ||\n        _.result(this.collection, 'url') ||\n        urlError();\n      if (this.isNew()) return base;\n      var id = this.get(this.idAttribute);\n      return base.replace(/[^\\/]$/, '$&/') + encodeURIComponent(id);\n    },\n\n    // **parse** converts a response into the hash of attributes to be `set` on\n    // the model. The default implementation is just to pass the response along.\n    parse: function(resp, options) {\n      return resp;\n    },\n\n    // Create a new model with identical attributes to this one.\n    clone: function() {\n      return new this.constructor(this.attributes);\n    },\n\n    // A model is new if it has never been saved to the server, and lacks an id.\n    isNew: function() {\n      return !this.has(this.idAttribute);\n    },\n\n    // Check if the model is currently in a valid state.\n    isValid: function(options) {\n      return this._validate({}, _.extend({}, options, {validate: true}));\n    },\n\n    // Run validation against the next complete set of model attributes,\n    // returning `true` if all is well. Otherwise, fire an `\"invalid\"` event.\n    _validate: function(attrs, options) {\n      if (!options.validate || !this.validate) return true;\n      attrs = _.extend({}, this.attributes, attrs);\n      var error = this.validationError = this.validate(attrs, options) || null;\n      if (!error) return true;\n      this.trigger('invalid', this, error, _.extend(options, {validationError: error}));\n      return false;\n    }\n\n  });\n\n  // Underscore methods that we want to implement on the Model, mapped to the\n  // number of arguments they take.\n  var modelMethods = {keys: 1, values: 1, pairs: 1, invert: 1, pick: 0,\n      omit: 0, chain: 1, isEmpty: 1};\n\n  // Mix in each Underscore method as a proxy to `Model#attributes`.\n  addUnderscoreMethods(Model, modelMethods, 'attributes');\n\n  // Backbone.Collection\n  // -------------------\n\n  // If models tend to represent a single row of data, a Backbone Collection is\n  // more analogous to a table full of data ... or a small slice or page of that\n  // table, or a collection of rows that belong together for a particular reason\n  // -- all of the messages in this particular folder, all of the documents\n  // belonging to this particular author, and so on. Collections maintain\n  // indexes of their models, both in order, and for lookup by `id`.\n\n  // Create a new **Collection**, perhaps to contain a specific type of `model`.\n  // If a `comparator` is specified, the Collection will maintain\n  // its models in sort order, as they're added and removed.\n  var Collection = Backbone.Collection = function(models, options) {\n    options || (options = {});\n    if (options.model) this.model = options.model;\n    if (options.comparator !== void 0) this.comparator = options.comparator;\n    this._reset();\n    this.initialize.apply(this, arguments);\n    if (models) this.reset(models, _.extend({silent: true}, options));\n  };\n\n  // Default options for `Collection#set`.\n  var setOptions = {add: true, remove: true, merge: true};\n  var addOptions = {add: true, remove: false};\n\n  // Splices `insert` into `array` at index `at`.\n  var splice = function(array, insert, at) {\n    at = Math.min(Math.max(at, 0), array.length);\n    var tail = Array(array.length - at);\n    var length = insert.length;\n    var i;\n    for (i = 0; i < tail.length; i++) tail[i] = array[i + at];\n    for (i = 0; i < length; i++) array[i + at] = insert[i];\n    for (i = 0; i < tail.length; i++) array[i + length + at] = tail[i];\n  };\n\n  // Define the Collection's inheritable methods.\n  _.extend(Collection.prototype, Events, {\n\n    // The default model for a collection is just a **Backbone.Model**.\n    // This should be overridden in most cases.\n    model: Model,\n\n    // Initialize is an empty function by default. Override it with your own\n    // initialization logic.\n    initialize: function(){},\n\n    // The JSON representation of a Collection is an array of the\n    // models' attributes.\n    toJSON: function(options) {\n      return this.map(function(model) { return model.toJSON(options); });\n    },\n\n    // Proxy `Backbone.sync` by default.\n    sync: function() {\n      return Backbone.sync.apply(this, arguments);\n    },\n\n    // Add a model, or list of models to the set. `models` may be Backbone\n    // Models or raw JavaScript objects to be converted to Models, or any\n    // combination of the two.\n    add: function(models, options) {\n      return this.set(models, _.extend({merge: false}, options, addOptions));\n    },\n\n    // Remove a model, or a list of models from the set.\n    remove: function(models, options) {\n      options = _.extend({}, options);\n      var singular = !_.isArray(models);\n      models = singular ? [models] : models.slice();\n      var removed = this._removeModels(models, options);\n      if (!options.silent && removed.length) {\n        options.changes = {added: [], merged: [], removed: removed};\n        this.trigger('update', this, options);\n      }\n      return singular ? removed[0] : removed;\n    },\n\n    // Update a collection by `set`-ing a new list of models, adding new ones,\n    // removing models that are no longer present, and merging models that\n    // already exist in the collection, as necessary. Similar to **Model#set**,\n    // the core operation for updating the data contained by the collection.\n    set: function(models, options) {\n      if (models == null) return;\n\n      options = _.extend({}, setOptions, options);\n      if (options.parse && !this._isModel(models)) {\n        models = this.parse(models, options) || [];\n      }\n\n      var singular = !_.isArray(models);\n      models = singular ? [models] : models.slice();\n\n      var at = options.at;\n      if (at != null) at = +at;\n      if (at > this.length) at = this.length;\n      if (at < 0) at += this.length + 1;\n\n      var set = [];\n      var toAdd = [];\n      var toMerge = [];\n      var toRemove = [];\n      var modelMap = {};\n\n      var add = options.add;\n      var merge = options.merge;\n      var remove = options.remove;\n\n      var sort = false;\n      var sortable = this.comparator && at == null && options.sort !== false;\n      var sortAttr = _.isString(this.comparator) ? this.comparator : null;\n\n      // Turn bare objects into model references, and prevent invalid models\n      // from being added.\n      var model, i;\n      for (i = 0; i < models.length; i++) {\n        model = models[i];\n\n        // If a duplicate is found, prevent it from being added and\n        // optionally merge it into the existing model.\n        var existing = this.get(model);\n        if (existing) {\n          if (merge && model !== existing) {\n            var attrs = this._isModel(model) ? model.attributes : model;\n            if (options.parse) attrs = existing.parse(attrs, options);\n            existing.set(attrs, options);\n            toMerge.push(existing);\n            if (sortable && !sort) sort = existing.hasChanged(sortAttr);\n          }\n          if (!modelMap[existing.cid]) {\n            modelMap[existing.cid] = true;\n            set.push(existing);\n          }\n          models[i] = existing;\n\n        // If this is a new, valid model, push it to the `toAdd` list.\n        } else if (add) {\n          model = models[i] = this._prepareModel(model, options);\n          if (model) {\n            toAdd.push(model);\n            this._addReference(model, options);\n            modelMap[model.cid] = true;\n            set.push(model);\n          }\n        }\n      }\n\n      // Remove stale models.\n      if (remove) {\n        for (i = 0; i < this.length; i++) {\n          model = this.models[i];\n          if (!modelMap[model.cid]) toRemove.push(model);\n        }\n        if (toRemove.length) this._removeModels(toRemove, options);\n      }\n\n      // See if sorting is needed, update `length` and splice in new models.\n      var orderChanged = false;\n      var replace = !sortable && add && remove;\n      if (set.length && replace) {\n        orderChanged = this.length !== set.length || _.some(this.models, function(m, index) {\n          return m !== set[index];\n        });\n        this.models.length = 0;\n        splice(this.models, set, 0);\n        this.length = this.models.length;\n      } else if (toAdd.length) {\n        if (sortable) sort = true;\n        splice(this.models, toAdd, at == null ? this.length : at);\n        this.length = this.models.length;\n      }\n\n      // Silently sort the collection if appropriate.\n      if (sort) this.sort({silent: true});\n\n      // Unless silenced, it's time to fire all appropriate add/sort/update events.\n      if (!options.silent) {\n        for (i = 0; i < toAdd.length; i++) {\n          if (at != null) options.index = at + i;\n          model = toAdd[i];\n          model.trigger('add', model, this, options);\n        }\n        if (sort || orderChanged) this.trigger('sort', this, options);\n        if (toAdd.length || toRemove.length || toMerge.length) {\n          options.changes = {\n            added: toAdd,\n            removed: toRemove,\n            merged: toMerge\n          };\n          this.trigger('update', this, options);\n        }\n      }\n\n      // Return the added (or merged) model (or models).\n      return singular ? models[0] : models;\n    },\n\n    // When you have more items than you want to add or remove individually,\n    // you can reset the entire set with a new list of models, without firing\n    // any granular `add` or `remove` events. Fires `reset` when finished.\n    // Useful for bulk operations and optimizations.\n    reset: function(models, options) {\n      options = options ? _.clone(options) : {};\n      for (var i = 0; i < this.models.length; i++) {\n        this._removeReference(this.models[i], options);\n      }\n      options.previousModels = this.models;\n      this._reset();\n      models = this.add(models, _.extend({silent: true}, options));\n      if (!options.silent) this.trigger('reset', this, options);\n      return models;\n    },\n\n    // Add a model to the end of the collection.\n    push: function(model, options) {\n      return this.add(model, _.extend({at: this.length}, options));\n    },\n\n    // Remove a model from the end of the collection.\n    pop: function(options) {\n      var model = this.at(this.length - 1);\n      return this.remove(model, options);\n    },\n\n    // Add a model to the beginning of the collection.\n    unshift: function(model, options) {\n      return this.add(model, _.extend({at: 0}, options));\n    },\n\n    // Remove a model from the beginning of the collection.\n    shift: function(options) {\n      var model = this.at(0);\n      return this.remove(model, options);\n    },\n\n    // Slice out a sub-array of models from the collection.\n    slice: function() {\n      return slice.apply(this.models, arguments);\n    },\n\n    // Get a model from the set by id, cid, model object with id or cid\n    // properties, or an attributes object that is transformed through modelId.\n    get: function(obj) {\n      if (obj == null) return void 0;\n      return this._byId[obj] ||\n        this._byId[this.modelId(obj.attributes || obj)] ||\n        obj.cid && this._byId[obj.cid];\n    },\n\n    // Returns `true` if the model is in the collection.\n    has: function(obj) {\n      return this.get(obj) != null;\n    },\n\n    // Get the model at the given index.\n    at: function(index) {\n      if (index < 0) index += this.length;\n      return this.models[index];\n    },\n\n    // Return models with matching attributes. Useful for simple cases of\n    // `filter`.\n    where: function(attrs, first) {\n      return this[first ? 'find' : 'filter'](attrs);\n    },\n\n    // Return the first model with matching attributes. Useful for simple cases\n    // of `find`.\n    findWhere: function(attrs) {\n      return this.where(attrs, true);\n    },\n\n    // Force the collection to re-sort itself. You don't need to call this under\n    // normal circumstances, as the set will maintain sort order as each item\n    // is added.\n    sort: function(options) {\n      var comparator = this.comparator;\n      if (!comparator) throw new Error('Cannot sort a set without a comparator');\n      options || (options = {});\n\n      var length = comparator.length;\n      if (_.isFunction(comparator)) comparator = _.bind(comparator, this);\n\n      // Run sort based on type of `comparator`.\n      if (length === 1 || _.isString(comparator)) {\n        this.models = this.sortBy(comparator);\n      } else {\n        this.models.sort(comparator);\n      }\n      if (!options.silent) this.trigger('sort', this, options);\n      return this;\n    },\n\n    // Pluck an attribute from each model in the collection.\n    pluck: function(attr) {\n      return this.map(attr + '');\n    },\n\n    // Fetch the default set of models for this collection, resetting the\n    // collection when they arrive. If `reset: true` is passed, the response\n    // data will be passed through the `reset` method instead of `set`.\n    fetch: function(options) {\n      options = _.extend({parse: true}, options);\n      var success = options.success;\n      var collection = this;\n      options.success = function(resp) {\n        var method = options.reset ? 'reset' : 'set';\n        collection[method](resp, options);\n        if (success) success.call(options.context, collection, resp, options);\n        collection.trigger('sync', collection, resp, options);\n      };\n      wrapError(this, options);\n      return this.sync('read', this, options);\n    },\n\n    // Create a new instance of a model in this collection. Add the model to the\n    // collection immediately, unless `wait: true` is passed, in which case we\n    // wait for the server to agree.\n    create: function(model, options) {\n      options = options ? _.clone(options) : {};\n      var wait = options.wait;\n      model = this._prepareModel(model, options);\n      if (!model) return false;\n      if (!wait) this.add(model, options);\n      var collection = this;\n      var success = options.success;\n      options.success = function(m, resp, callbackOpts) {\n        if (wait) collection.add(m, callbackOpts);\n        if (success) success.call(callbackOpts.context, m, resp, callbackOpts);\n      };\n      model.save(null, options);\n      return model;\n    },\n\n    // **parse** converts a response into a list of models to be added to the\n    // collection. The default implementation is just to pass it through.\n    parse: function(resp, options) {\n      return resp;\n    },\n\n    // Create a new collection with an identical list of models as this one.\n    clone: function() {\n      return new this.constructor(this.models, {\n        model: this.model,\n        comparator: this.comparator\n      });\n    },\n\n    // Define how to uniquely identify models in the collection.\n    modelId: function(attrs) {\n      return attrs[this.model.prototype.idAttribute || 'id'];\n    },\n\n    // Private method to reset all internal state. Called when the collection\n    // is first initialized or reset.\n    _reset: function() {\n      this.length = 0;\n      this.models = [];\n      this._byId  = {};\n    },\n\n    // Prepare a hash of attributes (or other model) to be added to this\n    // collection.\n    _prepareModel: function(attrs, options) {\n      if (this._isModel(attrs)) {\n        if (!attrs.collection) attrs.collection = this;\n        return attrs;\n      }\n      options = options ? _.clone(options) : {};\n      options.collection = this;\n      var model = new this.model(attrs, options);\n      if (!model.validationError) return model;\n      this.trigger('invalid', this, model.validationError, options);\n      return false;\n    },\n\n    // Internal method called by both remove and set.\n    _removeModels: function(models, options) {\n      var removed = [];\n      for (var i = 0; i < models.length; i++) {\n        var model = this.get(models[i]);\n        if (!model) continue;\n\n        var index = this.indexOf(model);\n        this.models.splice(index, 1);\n        this.length--;\n\n        // Remove references before triggering 'remove' event to prevent an\n        // infinite loop. #3693\n        delete this._byId[model.cid];\n        var id = this.modelId(model.attributes);\n        if (id != null) delete this._byId[id];\n\n        if (!options.silent) {\n          options.index = index;\n          model.trigger('remove', model, this, options);\n        }\n\n        removed.push(model);\n        this._removeReference(model, options);\n      }\n      return removed;\n    },\n\n    // Method for checking whether an object should be considered a model for\n    // the purposes of adding to the collection.\n    _isModel: function(model) {\n      return model instanceof Model;\n    },\n\n    // Internal method to create a model's ties to a collection.\n    _addReference: function(model, options) {\n      this._byId[model.cid] = model;\n      var id = this.modelId(model.attributes);\n      if (id != null) this._byId[id] = model;\n      model.on('all', this._onModelEvent, this);\n    },\n\n    // Internal method to sever a model's ties to a collection.\n    _removeReference: function(model, options) {\n      delete this._byId[model.cid];\n      var id = this.modelId(model.attributes);\n      if (id != null) delete this._byId[id];\n      if (this === model.collection) delete model.collection;\n      model.off('all', this._onModelEvent, this);\n    },\n\n    // Internal method called every time a model in the set fires an event.\n    // Sets need to update their indexes when models change ids. All other\n    // events simply proxy through. \"add\" and \"remove\" events that originate\n    // in other collections are ignored.\n    _onModelEvent: function(event, model, collection, options) {\n      if (model) {\n        if ((event === 'add' || event === 'remove') && collection !== this) return;\n        if (event === 'destroy') this.remove(model, options);\n        if (event === 'change') {\n          var prevId = this.modelId(model.previousAttributes());\n          var id = this.modelId(model.attributes);\n          if (prevId !== id) {\n            if (prevId != null) delete this._byId[prevId];\n            if (id != null) this._byId[id] = model;\n          }\n        }\n      }\n      this.trigger.apply(this, arguments);\n    }\n\n  });\n\n  // Underscore methods that we want to implement on the Collection.\n  // 90% of the core usefulness of Backbone Collections is actually implemented\n  // right here:\n  var collectionMethods = {forEach: 3, each: 3, map: 3, collect: 3, reduce: 0,\n      foldl: 0, inject: 0, reduceRight: 0, foldr: 0, find: 3, detect: 3, filter: 3,\n      select: 3, reject: 3, every: 3, all: 3, some: 3, any: 3, include: 3, includes: 3,\n      contains: 3, invoke: 0, max: 3, min: 3, toArray: 1, size: 1, first: 3,\n      head: 3, take: 3, initial: 3, rest: 3, tail: 3, drop: 3, last: 3,\n      without: 0, difference: 0, indexOf: 3, shuffle: 1, lastIndexOf: 3,\n      isEmpty: 1, chain: 1, sample: 3, partition: 3, groupBy: 3, countBy: 3,\n      sortBy: 3, indexBy: 3, findIndex: 3, findLastIndex: 3};\n\n  // Mix in each Underscore method as a proxy to `Collection#models`.\n  addUnderscoreMethods(Collection, collectionMethods, 'models');\n\n  // Backbone.View\n  // -------------\n\n  // Backbone Views are almost more convention than they are actual code. A View\n  // is simply a JavaScript object that represents a logical chunk of UI in the\n  // DOM. This might be a single item, an entire list, a sidebar or panel, or\n  // even the surrounding frame which wraps your whole app. Defining a chunk of\n  // UI as a **View** allows you to define your DOM events declaratively, without\n  // having to worry about render order ... and makes it easy for the view to\n  // react to specific changes in the state of your models.\n\n  // Creating a Backbone.View creates its initial element outside of the DOM,\n  // if an existing element is not provided...\n  var View = Backbone.View = function(options) {\n    this.cid = _.uniqueId('view');\n    _.extend(this, _.pick(options, viewOptions));\n    this._ensureElement();\n    this.initialize.apply(this, arguments);\n  };\n\n  // Cached regex to split keys for `delegate`.\n  var delegateEventSplitter = /^(\\S+)\\s*(.*)$/;\n\n  // List of view options to be set as properties.\n  var viewOptions = ['model', 'collection', 'el', 'id', 'attributes', 'className', 'tagName', 'events'];\n\n  // Set up all inheritable **Backbone.View** properties and methods.\n  _.extend(View.prototype, Events, {\n\n    // The default `tagName` of a View's element is `\"div\"`.\n    tagName: 'div',\n\n    // jQuery delegate for element lookup, scoped to DOM elements within the\n    // current view. This should be preferred to global lookups where possible.\n    $: function(selector) {\n      return this.$el.find(selector);\n    },\n\n    // Initialize is an empty function by default. Override it with your own\n    // initialization logic.\n    initialize: function(){},\n\n    // **render** is the core function that your view should override, in order\n    // to populate its element (`this.el`), with the appropriate HTML. The\n    // convention is for **render** to always return `this`.\n    render: function() {\n      return this;\n    },\n\n    // Remove this view by taking the element out of the DOM, and removing any\n    // applicable Backbone.Events listeners.\n    remove: function() {\n      this._removeElement();\n      this.stopListening();\n      return this;\n    },\n\n    // Remove this view's element from the document and all event listeners\n    // attached to it. Exposed for subclasses using an alternative DOM\n    // manipulation API.\n    _removeElement: function() {\n      this.$el.remove();\n    },\n\n    // Change the view's element (`this.el` property) and re-delegate the\n    // view's events on the new element.\n    setElement: function(element) {\n      this.undelegateEvents();\n      this._setElement(element);\n      this.delegateEvents();\n      return this;\n    },\n\n    // Creates the `this.el` and `this.$el` references for this view using the\n    // given `el`. `el` can be a CSS selector or an HTML string, a jQuery\n    // context or an element. Subclasses can override this to utilize an\n    // alternative DOM manipulation API and are only required to set the\n    // `this.el` property.\n    _setElement: function(el) {\n      this.$el = el instanceof Backbone.$ ? el : Backbone.$(el);\n      this.el = this.$el[0];\n    },\n\n    // Set callbacks, where `this.events` is a hash of\n    //\n    // *{\"event selector\": \"callback\"}*\n    //\n    //     {\n    //       'mousedown .title':  'edit',\n    //       'click .button':     'save',\n    //       'click .open':       function(e) { ... }\n    //     }\n    //\n    // pairs. Callbacks will be bound to the view, with `this` set properly.\n    // Uses event delegation for efficiency.\n    // Omitting the selector binds the event to `this.el`.\n    delegateEvents: function(events) {\n      events || (events = _.result(this, 'events'));\n      if (!events) return this;\n      this.undelegateEvents();\n      for (var key in events) {\n        var method = events[key];\n        if (!_.isFunction(method)) method = this[method];\n        if (!method) continue;\n        var match = key.match(delegateEventSplitter);\n        this.delegate(match[1], match[2], _.bind(method, this));\n      }\n      return this;\n    },\n\n    // Add a single event listener to the view's element (or a child element\n    // using `selector`). This only works for delegate-able events: not `focus`,\n    // `blur`, and not `change`, `submit`, and `reset` in Internet Explorer.\n    delegate: function(eventName, selector, listener) {\n      this.$el.on(eventName + '.delegateEvents' + this.cid, selector, listener);\n      return this;\n    },\n\n    // Clears all callbacks previously bound to the view by `delegateEvents`.\n    // You usually don't need to use this, but may wish to if you have multiple\n    // Backbone views attached to the same DOM element.\n    undelegateEvents: function() {\n      if (this.$el) this.$el.off('.delegateEvents' + this.cid);\n      return this;\n    },\n\n    // A finer-grained `undelegateEvents` for removing a single delegated event.\n    // `selector` and `listener` are both optional.\n    undelegate: function(eventName, selector, listener) {\n      this.$el.off(eventName + '.delegateEvents' + this.cid, selector, listener);\n      return this;\n    },\n\n    // Produces a DOM element to be assigned to your view. Exposed for\n    // subclasses using an alternative DOM manipulation API.\n    _createElement: function(tagName) {\n      return document.createElement(tagName);\n    },\n\n    // Ensure that the View has a DOM element to render into.\n    // If `this.el` is a string, pass it through `$()`, take the first\n    // matching element, and re-assign it to `el`. Otherwise, create\n    // an element from the `id`, `className` and `tagName` properties.\n    _ensureElement: function() {\n      if (!this.el) {\n        var attrs = _.extend({}, _.result(this, 'attributes'));\n        if (this.id) attrs.id = _.result(this, 'id');\n        if (this.className) attrs['class'] = _.result(this, 'className');\n        this.setElement(this._createElement(_.result(this, 'tagName')));\n        this._setAttributes(attrs);\n      } else {\n        this.setElement(_.result(this, 'el'));\n      }\n    },\n\n    // Set attributes from a hash on this view's element.  Exposed for\n    // subclasses using an alternative DOM manipulation API.\n    _setAttributes: function(attributes) {\n      this.$el.attr(attributes);\n    }\n\n  });\n\n  // Backbone.sync\n  // -------------\n\n  // Override this function to change the manner in which Backbone persists\n  // models to the server. You will be passed the type of request, and the\n  // model in question. By default, makes a RESTful Ajax request\n  // to the model's `url()`. Some possible customizations could be:\n  //\n  // * Use `setTimeout` to batch rapid-fire updates into a single request.\n  // * Send up the models as XML instead of JSON.\n  // * Persist models via WebSockets instead of Ajax.\n  //\n  // Turn on `Backbone.emulateHTTP` in order to send `PUT` and `DELETE` requests\n  // as `POST`, with a `_method` parameter containing the true HTTP method,\n  // as well as all requests with the body as `application/x-www-form-urlencoded`\n  // instead of `application/json` with the model in a param named `model`.\n  // Useful when interfacing with server-side languages like **PHP** that make\n  // it difficult to read the body of `PUT` requests.\n  Backbone.sync = function(method, model, options) {\n    var type = methodMap[method];\n\n    // Default options, unless specified.\n    _.defaults(options || (options = {}), {\n      emulateHTTP: Backbone.emulateHTTP,\n      emulateJSON: Backbone.emulateJSON\n    });\n\n    // Default JSON-request options.\n    var params = {type: type, dataType: 'json'};\n\n    // Ensure that we have a URL.\n    if (!options.url) {\n      params.url = _.result(model, 'url') || urlError();\n    }\n\n    // Ensure that we have the appropriate request data.\n    if (options.data == null && model && (method === 'create' || method === 'update' || method === 'patch')) {\n      params.contentType = 'application/json';\n      params.data = JSON.stringify(options.attrs || model.toJSON(options));\n    }\n\n    // For older servers, emulate JSON by encoding the request into an HTML-form.\n    if (options.emulateJSON) {\n      params.contentType = 'application/x-www-form-urlencoded';\n      params.data = params.data ? {model: params.data} : {};\n    }\n\n    // For older servers, emulate HTTP by mimicking the HTTP method with `_method`\n    // And an `X-HTTP-Method-Override` header.\n    if (options.emulateHTTP && (type === 'PUT' || type === 'DELETE' || type === 'PATCH')) {\n      params.type = 'POST';\n      if (options.emulateJSON) params.data._method = type;\n      var beforeSend = options.beforeSend;\n      options.beforeSend = function(xhr) {\n        xhr.setRequestHeader('X-HTTP-Method-Override', type);\n        if (beforeSend) return beforeSend.apply(this, arguments);\n      };\n    }\n\n    // Don't process data on a non-GET request.\n    if (params.type !== 'GET' && !options.emulateJSON) {\n      params.processData = false;\n    }\n\n    // Pass along `textStatus` and `errorThrown` from jQuery.\n    var error = options.error;\n    options.error = function(xhr, textStatus, errorThrown) {\n      options.textStatus = textStatus;\n      options.errorThrown = errorThrown;\n      if (error) error.call(options.context, xhr, textStatus, errorThrown);\n    };\n\n    // Make the request, allowing the user to override any Ajax options.\n    var xhr = options.xhr = Backbone.ajax(_.extend(params, options));\n    model.trigger('request', model, xhr, options);\n    return xhr;\n  };\n\n  // Map from CRUD to HTTP for our default `Backbone.sync` implementation.\n  var methodMap = {\n    'create': 'POST',\n    'update': 'PUT',\n    'patch': 'PATCH',\n    'delete': 'DELETE',\n    'read': 'GET'\n  };\n\n  // Set the default implementation of `Backbone.ajax` to proxy through to `$`.\n  // Override this if you'd like to use a different library.\n  Backbone.ajax = function() {\n    return Backbone.$.ajax.apply(Backbone.$, arguments);\n  };\n\n  // Backbone.Router\n  // ---------------\n\n  // Routers map faux-URLs to actions, and fire events when routes are\n  // matched. Creating a new one sets its `routes` hash, if not set statically.\n  var Router = Backbone.Router = function(options) {\n    options || (options = {});\n    if (options.routes) this.routes = options.routes;\n    this._bindRoutes();\n    this.initialize.apply(this, arguments);\n  };\n\n  // Cached regular expressions for matching named param parts and splatted\n  // parts of route strings.\n  var optionalParam = /\\((.*?)\\)/g;\n  var namedParam    = /(\\(\\?)?:\\w+/g;\n  var splatParam    = /\\*\\w+/g;\n  var escapeRegExp  = /[\\-{}\\[\\]+?.,\\\\\\^$|#\\s]/g;\n\n  // Set up all inheritable **Backbone.Router** properties and methods.\n  _.extend(Router.prototype, Events, {\n\n    // Initialize is an empty function by default. Override it with your own\n    // initialization logic.\n    initialize: function(){},\n\n    // Manually bind a single named route to a callback. For example:\n    //\n    //     this.route('search/:query/p:num', 'search', function(query, num) {\n    //       ...\n    //     });\n    //\n    route: function(route, name, callback) {\n      if (!_.isRegExp(route)) route = this._routeToRegExp(route);\n      if (_.isFunction(name)) {\n        callback = name;\n        name = '';\n      }\n      if (!callback) callback = this[name];\n      var router = this;\n      Backbone.history.route(route, function(fragment) {\n        var args = router._extractParameters(route, fragment);\n        if (router.execute(callback, args, name) !== false) {\n          router.trigger.apply(router, ['route:' + name].concat(args));\n          router.trigger('route', name, args);\n          Backbone.history.trigger('route', router, name, args);\n        }\n      });\n      return this;\n    },\n\n    // Execute a route handler with the provided parameters.  This is an\n    // excellent place to do pre-route setup or post-route cleanup.\n    execute: function(callback, args, name) {\n      if (callback) callback.apply(this, args);\n    },\n\n    // Simple proxy to `Backbone.history` to save a fragment into the history.\n    navigate: function(fragment, options) {\n      Backbone.history.navigate(fragment, options);\n      return this;\n    },\n\n    // Bind all defined routes to `Backbone.history`. We have to reverse the\n    // order of the routes here to support behavior where the most general\n    // routes can be defined at the bottom of the route map.\n    _bindRoutes: function() {\n      if (!this.routes) return;\n      this.routes = _.result(this, 'routes');\n      var route, routes = _.keys(this.routes);\n      while ((route = routes.pop()) != null) {\n        this.route(route, this.routes[route]);\n      }\n    },\n\n    // Convert a route string into a regular expression, suitable for matching\n    // against the current location hash.\n    _routeToRegExp: function(route) {\n      route = route.replace(escapeRegExp, '\\\\$&')\n                   .replace(optionalParam, '(?:$1)?')\n                   .replace(namedParam, function(match, optional) {\n                     return optional ? match : '([^/?]+)';\n                   })\n                   .replace(splatParam, '([^?]*?)');\n      return new RegExp('^' + route + '(?:\\\\?([\\\\s\\\\S]*))?$');\n    },\n\n    // Given a route, and a URL fragment that it matches, return the array of\n    // extracted decoded parameters. Empty or unmatched parameters will be\n    // treated as `null` to normalize cross-browser behavior.\n    _extractParameters: function(route, fragment) {\n      var params = route.exec(fragment).slice(1);\n      return _.map(params, function(param, i) {\n        // Don't decode the search params.\n        if (i === params.length - 1) return param || null;\n        return param ? decodeURIComponent(param) : null;\n      });\n    }\n\n  });\n\n  // Backbone.History\n  // ----------------\n\n  // Handles cross-browser history management, based on either\n  // [pushState](http://diveintohtml5.info/history.html) and real URLs, or\n  // [onhashchange](https://developer.mozilla.org/en-US/docs/DOM/window.onhashchange)\n  // and URL fragments. If the browser supports neither (old IE, natch),\n  // falls back to polling.\n  var History = Backbone.History = function() {\n    this.handlers = [];\n    this.checkUrl = _.bind(this.checkUrl, this);\n\n    // Ensure that `History` can be used outside of the browser.\n    if (typeof window !== 'undefined') {\n      this.location = window.location;\n      this.history = window.history;\n    }\n  };\n\n  // Cached regex for stripping a leading hash/slash and trailing space.\n  var routeStripper = /^[#\\/]|\\s+$/g;\n\n  // Cached regex for stripping leading and trailing slashes.\n  var rootStripper = /^\\/+|\\/+$/g;\n\n  // Cached regex for stripping urls of hash.\n  var pathStripper = /#.*$/;\n\n  // Has the history handling already been started?\n  History.started = false;\n\n  // Set up all inheritable **Backbone.History** properties and methods.\n  _.extend(History.prototype, Events, {\n\n    // The default interval to poll for hash changes, if necessary, is\n    // twenty times a second.\n    interval: 50,\n\n    // Are we at the app root?\n    atRoot: function() {\n      var path = this.location.pathname.replace(/[^\\/]$/, '$&/');\n      return path === this.root && !this.getSearch();\n    },\n\n    // Does the pathname match the root?\n    matchRoot: function() {\n      var path = this.decodeFragment(this.location.pathname);\n      var rootPath = path.slice(0, this.root.length - 1) + '/';\n      return rootPath === this.root;\n    },\n\n    // Unicode characters in `location.pathname` are percent encoded so they're\n    // decoded for comparison. `%25` should not be decoded since it may be part\n    // of an encoded parameter.\n    decodeFragment: function(fragment) {\n      return decodeURI(fragment.replace(/%25/g, '%2525'));\n    },\n\n    // In IE6, the hash fragment and search params are incorrect if the\n    // fragment contains `?`.\n    getSearch: function() {\n      var match = this.location.href.replace(/#.*/, '').match(/\\?.+/);\n      return match ? match[0] : '';\n    },\n\n    // Gets the true hash value. Cannot use location.hash directly due to bug\n    // in Firefox where location.hash will always be decoded.\n    getHash: function(window) {\n      var match = (window || this).location.href.match(/#(.*)$/);\n      return match ? match[1] : '';\n    },\n\n    // Get the pathname and search params, without the root.\n    getPath: function() {\n      var path = this.decodeFragment(\n        this.location.pathname + this.getSearch()\n      ).slice(this.root.length - 1);\n      return path.charAt(0) === '/' ? path.slice(1) : path;\n    },\n\n    // Get the cross-browser normalized URL fragment from the path or hash.\n    getFragment: function(fragment) {\n      if (fragment == null) {\n        if (this._usePushState || !this._wantsHashChange) {\n          fragment = this.getPath();\n        } else {\n          fragment = this.getHash();\n        }\n      }\n      return fragment.replace(routeStripper, '');\n    },\n\n    // Start the hash change handling, returning `true` if the current URL matches\n    // an existing route, and `false` otherwise.\n    start: function(options) {\n      if (History.started) throw new Error('Backbone.history has already been started');\n      History.started = true;\n\n      // Figure out the initial configuration. Do we need an iframe?\n      // Is pushState desired ... is it available?\n      this.options          = _.extend({root: '/'}, this.options, options);\n      this.root             = this.options.root;\n      this._wantsHashChange = this.options.hashChange !== false;\n      this._hasHashChange   = 'onhashchange' in window && (document.documentMode === void 0 || document.documentMode > 7);\n      this._useHashChange   = this._wantsHashChange && this._hasHashChange;\n      this._wantsPushState  = !!this.options.pushState;\n      this._hasPushState    = !!(this.history && this.history.pushState);\n      this._usePushState    = this._wantsPushState && this._hasPushState;\n      this.fragment         = this.getFragment();\n\n      // Normalize root to always include a leading and trailing slash.\n      this.root = ('/' + this.root + '/').replace(rootStripper, '/');\n\n      // Transition from hashChange to pushState or vice versa if both are\n      // requested.\n      if (this._wantsHashChange && this._wantsPushState) {\n\n        // If we've started off with a route from a `pushState`-enabled\n        // browser, but we're currently in a browser that doesn't support it...\n        if (!this._hasPushState && !this.atRoot()) {\n          var rootPath = this.root.slice(0, -1) || '/';\n          this.location.replace(rootPath + '#' + this.getPath());\n          // Return immediately as browser will do redirect to new url\n          return true;\n\n        // Or if we've started out with a hash-based route, but we're currently\n        // in a browser where it could be `pushState`-based instead...\n        } else if (this._hasPushState && this.atRoot()) {\n          this.navigate(this.getHash(), {replace: true});\n        }\n\n      }\n\n      // Proxy an iframe to handle location events if the browser doesn't\n      // support the `hashchange` event, HTML5 history, or the user wants\n      // `hashChange` but not `pushState`.\n      if (!this._hasHashChange && this._wantsHashChange && !this._usePushState) {\n        this.iframe = document.createElement('iframe');\n        this.iframe.src = 'javascript:0';\n        this.iframe.style.display = 'none';\n        this.iframe.tabIndex = -1;\n        var body = document.body;\n        // Using `appendChild` will throw on IE < 9 if the document is not ready.\n        var iWindow = body.insertBefore(this.iframe, body.firstChild).contentWindow;\n        iWindow.document.open();\n        iWindow.document.close();\n        iWindow.location.hash = '#' + this.fragment;\n      }\n\n      // Add a cross-platform `addEventListener` shim for older browsers.\n      var addEventListener = window.addEventListener || function(eventName, listener) {\n        return attachEvent('on' + eventName, listener);\n      };\n\n      // Depending on whether we're using pushState or hashes, and whether\n      // 'onhashchange' is supported, determine how we check the URL state.\n      if (this._usePushState) {\n        addEventListener('popstate', this.checkUrl, false);\n      } else if (this._useHashChange && !this.iframe) {\n        addEventListener('hashchange', this.checkUrl, false);\n      } else if (this._wantsHashChange) {\n        this._checkUrlInterval = setInterval(this.checkUrl, this.interval);\n      }\n\n      if (!this.options.silent) return this.loadUrl();\n    },\n\n    // Disable Backbone.history, perhaps temporarily. Not useful in a real app,\n    // but possibly useful for unit testing Routers.\n    stop: function() {\n      // Add a cross-platform `removeEventListener` shim for older browsers.\n      var removeEventListener = window.removeEventListener || function(eventName, listener) {\n        return detachEvent('on' + eventName, listener);\n      };\n\n      // Remove window listeners.\n      if (this._usePushState) {\n        removeEventListener('popstate', this.checkUrl, false);\n      } else if (this._useHashChange && !this.iframe) {\n        removeEventListener('hashchange', this.checkUrl, false);\n      }\n\n      // Clean up the iframe if necessary.\n      if (this.iframe) {\n        document.body.removeChild(this.iframe);\n        this.iframe = null;\n      }\n\n      // Some environments will throw when clearing an undefined interval.\n      if (this._checkUrlInterval) clearInterval(this._checkUrlInterval);\n      History.started = false;\n    },\n\n    // Add a route to be tested when the fragment changes. Routes added later\n    // may override previous routes.\n    route: function(route, callback) {\n      this.handlers.unshift({route: route, callback: callback});\n    },\n\n    // Checks the current URL to see if it has changed, and if it has,\n    // calls `loadUrl`, normalizing across the hidden iframe.\n    checkUrl: function(e) {\n      var current = this.getFragment();\n\n      // If the user pressed the back button, the iframe's hash will have\n      // changed and we should use that for comparison.\n      if (current === this.fragment && this.iframe) {\n        current = this.getHash(this.iframe.contentWindow);\n      }\n\n      if (current === this.fragment) return false;\n      if (this.iframe) this.navigate(current);\n      this.loadUrl();\n    },\n\n    // Attempt to load the current URL fragment. If a route succeeds with a\n    // match, returns `true`. If no defined routes matches the fragment,\n    // returns `false`.\n    loadUrl: function(fragment) {\n      // If the root doesn't match, no routes can match either.\n      if (!this.matchRoot()) return false;\n      fragment = this.fragment = this.getFragment(fragment);\n      return _.some(this.handlers, function(handler) {\n        if (handler.route.test(fragment)) {\n          handler.callback(fragment);\n          return true;\n        }\n      });\n    },\n\n    // Save a fragment into the hash history, or replace the URL state if the\n    // 'replace' option is passed. You are responsible for properly URL-encoding\n    // the fragment in advance.\n    //\n    // The options object can contain `trigger: true` if you wish to have the\n    // route callback be fired (not usually desirable), or `replace: true`, if\n    // you wish to modify the current URL without adding an entry to the history.\n    navigate: function(fragment, options) {\n      if (!History.started) return false;\n      if (!options || options === true) options = {trigger: !!options};\n\n      // Normalize the fragment.\n      fragment = this.getFragment(fragment || '');\n\n      // Don't include a trailing slash on the root.\n      var rootPath = this.root;\n      if (fragment === '' || fragment.charAt(0) === '?') {\n        rootPath = rootPath.slice(0, -1) || '/';\n      }\n      var url = rootPath + fragment;\n\n      // Strip the hash and decode for matching.\n      fragment = this.decodeFragment(fragment.replace(pathStripper, ''));\n\n      if (this.fragment === fragment) return;\n      this.fragment = fragment;\n\n      // If pushState is available, we use it to set the fragment as a real URL.\n      if (this._usePushState) {\n        this.history[options.replace ? 'replaceState' : 'pushState']({}, document.title, url);\n\n      // If hash changes haven't been explicitly disabled, update the hash\n      // fragment to store history.\n      } else if (this._wantsHashChange) {\n        this._updateHash(this.location, fragment, options.replace);\n        if (this.iframe && fragment !== this.getHash(this.iframe.contentWindow)) {\n          var iWindow = this.iframe.contentWindow;\n\n          // Opening and closing the iframe tricks IE7 and earlier to push a\n          // history entry on hash-tag change.  When replace is true, we don't\n          // want this.\n          if (!options.replace) {\n            iWindow.document.open();\n            iWindow.document.close();\n          }\n\n          this._updateHash(iWindow.location, fragment, options.replace);\n        }\n\n      // If you've told us that you explicitly don't want fallback hashchange-\n      // based history, then `navigate` becomes a page refresh.\n      } else {\n        return this.location.assign(url);\n      }\n      if (options.trigger) return this.loadUrl(fragment);\n    },\n\n    // Update the hash location, either replacing the current entry, or adding\n    // a new one to the browser history.\n    _updateHash: function(location, fragment, replace) {\n      if (replace) {\n        var href = location.href.replace(/(javascript:|#).*$/, '');\n        location.replace(href + '#' + fragment);\n      } else {\n        // Some browsers require that `hash` contains a leading #.\n        location.hash = '#' + fragment;\n      }\n    }\n\n  });\n\n  // Create the default Backbone.history.\n  Backbone.history = new History;\n\n  // Helpers\n  // -------\n\n  // Helper function to correctly set up the prototype chain for subclasses.\n  // Similar to `goog.inherits`, but uses a hash of prototype properties and\n  // class properties to be extended.\n  var extend = function(protoProps, staticProps) {\n    var parent = this;\n    var child;\n\n    // The constructor function for the new subclass is either defined by you\n    // (the \"constructor\" property in your `extend` definition), or defaulted\n    // by us to simply call the parent constructor.\n    if (protoProps && _.has(protoProps, 'constructor')) {\n      child = protoProps.constructor;\n    } else {\n      child = function(){ return parent.apply(this, arguments); };\n    }\n\n    // Add static properties to the constructor function, if supplied.\n    _.extend(child, parent, staticProps);\n\n    // Set the prototype chain to inherit from `parent`, without calling\n    // `parent`'s constructor function and add the prototype properties.\n    child.prototype = _.create(parent.prototype, protoProps);\n    child.prototype.constructor = child;\n\n    // Set a convenience property in case the parent's prototype is needed\n    // later.\n    child.__super__ = parent.prototype;\n\n    return child;\n  };\n\n  // Set up inheritance for the model, collection, router, view and history.\n  Model.extend = Collection.extend = Router.extend = View.extend = History.extend = extend;\n\n  // Throw an error when a URL is needed, and none is supplied.\n  var urlError = function() {\n    throw new Error('A \"url\" property or function must be specified');\n  };\n\n  // Wrap an optional error callback with a fallback error event.\n  var wrapError = function(model, options) {\n    var error = options.error;\n    options.error = function(resp) {\n      if (error) error.call(options.context, model, resp, options);\n      model.trigger('error', model, resp, options);\n    };\n  };\n\n  return Backbone;\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/backbone/backbone.js\n// module id = 3\n// module chunks = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 20","/** we augment the default behavior of collapsibles. For instance, when opening a collapsible, if the result of the open\n is that the title goes above the top of the screen, we scroll up to reveal the title **/\nimport { scrollTopDistance } from 'js/lib/helpers';\n\n\nconst MMCollapsible = Backbone.View.extend({\n    events: {\n        'shown.bs.collapse': 'maybeScrollToTitle'\n    },\n\n    initialize(opts) {\n        let defaults = {\n            scrollUpBuffer: 60, // the default amount of space to scroll up (past the start of the header) in the case that scroll up is required,\n            panelTitleSelector: '.panel-title' // the selector for the title of the collapsible\n        };\n\n        this.options = _.extend(defaults, opts || {});\n    },\n\n    // after showing a collapsible (specifically on mobile), if the panel header isn't visible, make sure to pull the viewport up\n    // to show the header\n    maybeScrollToTitle() {\n        let panelTop = this.$el.find(this.options.panelTitleSelector).offset().top;\n        if (scrollTopDistance() > panelTop) {\n            $('html, body').animate({\n                scrollTop: panelTop - this.options.scrollUpBuffer\n            }, 500);\n        }\n    }\n});\n\n\nlet collapsibleFactory = (el, opts={}) => new MMCollapsible(_.extend({ el: el }, opts));\n\nexport default collapsibleFactory;\n\n\n// WEBPACK FOOTER //\n// ./js/lib/views/collapsible.js","var g;\r\n\r\n// This works in non-strict mode\r\ng = (function() {\r\n\treturn this;\r\n})();\r\n\r\ntry {\r\n\t// This works if eval is allowed (see CSP)\r\n\tg = g || Function(\"return this\")() || (1,eval)(\"this\");\r\n} catch(e) {\r\n\t// This works if the window reference is available\r\n\tif(typeof window === \"object\")\r\n\t\tg = window;\r\n}\r\n\r\n// g can still be undefined, but nothing to do about it...\r\n// We return undefined, instead of nothing here, so it's\r\n// easier to handle this case. if(!global) { ...}\r\n\r\nmodule.exports = g;\r\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// (webpack)/buildin/global.js\n// module id = 4\n// module chunks = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20","\"use strict\";\n\n// Use the fastest means possible to execute a task in its own turn, with\n// priority over other events including IO, animation, reflow, and redraw\n// events in browsers.\n//\n// An exception thrown by a task will permanently interrupt the processing of\n// subsequent tasks. The higher level `asap` function ensures that if an\n// exception is thrown by a task, that the task queue will continue flushing as\n// soon as possible, but if you use `rawAsap` directly, you are responsible to\n// either ensure that no exceptions are thrown from your task, or to manually\n// call `rawAsap.requestFlush` if an exception is thrown.\nmodule.exports = rawAsap;\nfunction rawAsap(task) {\n    if (!queue.length) {\n        requestFlush();\n        flushing = true;\n    }\n    // Equivalent to push, but avoids a function call.\n    queue[queue.length] = task;\n}\n\nvar queue = [];\n// Once a flush has been requested, no further calls to `requestFlush` are\n// necessary until the next `flush` completes.\nvar flushing = false;\n// `requestFlush` is an implementation-specific method that attempts to kick\n// off a `flush` event as quickly as possible. `flush` will attempt to exhaust\n// the event queue before yielding to the browser's own event loop.\nvar requestFlush;\n// The position of the next task to execute in the task queue. This is\n// preserved between calls to `flush` so that it can be resumed if\n// a task throws an exception.\nvar index = 0;\n// If a task schedules additional tasks recursively, the task queue can grow\n// unbounded. To prevent memory exhaustion, the task queue will periodically\n// truncate already-completed tasks.\nvar capacity = 1024;\n\n// The flush function processes all tasks that have been scheduled with\n// `rawAsap` unless and until one of those tasks throws an exception.\n// If a task throws an exception, `flush` ensures that its state will remain\n// consistent and will resume where it left off when called again.\n// However, `flush` does not make any arrangements to be called again if an\n// exception is thrown.\nfunction flush() {\n    while (index < queue.length) {\n        var currentIndex = index;\n        // Advance the index before calling the task. This ensures that we will\n        // begin flushing on the next task the task throws an error.\n        index = index + 1;\n        queue[currentIndex].call();\n        // Prevent leaking memory for long chains of recursive calls to `asap`.\n        // If we call `asap` within tasks scheduled by `asap`, the queue will\n        // grow, but to avoid an O(n) walk for every task we execute, we don't\n        // shift tasks off the queue after they have been executed.\n        // Instead, we periodically shift 1024 tasks off the queue.\n        if (index > capacity) {\n            // Manually shift all values starting at the index back to the\n            // beginning of the queue.\n            for (var scan = 0, newLength = queue.length - index; scan < newLength; scan++) {\n                queue[scan] = queue[scan + index];\n            }\n            queue.length -= index;\n            index = 0;\n        }\n    }\n    queue.length = 0;\n    index = 0;\n    flushing = false;\n}\n\n// `requestFlush` is implemented using a strategy based on data collected from\n// every available SauceLabs Selenium web driver worker at time of writing.\n// https://docs.google.com/spreadsheets/d/1mG-5UYGup5qxGdEMWkhP6BWCz053NUb2E1QoUTU16uA/edit#gid=783724593\n\n// Safari 6 and 6.1 for desktop, iPad, and iPhone are the only browsers that\n// have WebKitMutationObserver but not un-prefixed MutationObserver.\n// Must use `global` or `self` instead of `window` to work in both frames and web\n// workers. `global` is a provision of Browserify, Mr, Mrs, or Mop.\n\n/* globals self */\nvar scope = typeof global !== \"undefined\" ? global : self;\nvar BrowserMutationObserver = scope.MutationObserver || scope.WebKitMutationObserver;\n\n// MutationObservers are desirable because they have high priority and work\n// reliably everywhere they are implemented.\n// They are implemented in all modern browsers.\n//\n// - Android 4-4.3\n// - Chrome 26-34\n// - Firefox 14-29\n// - Internet Explorer 11\n// - iPad Safari 6-7.1\n// - iPhone Safari 7-7.1\n// - Safari 6-7\nif (typeof BrowserMutationObserver === \"function\") {\n    requestFlush = makeRequestCallFromMutationObserver(flush);\n\n// MessageChannels are desirable because they give direct access to the HTML\n// task queue, are implemented in Internet Explorer 10, Safari 5.0-1, and Opera\n// 11-12, and in web workers in many engines.\n// Although message channels yield to any queued rendering and IO tasks, they\n// would be better than imposing the 4ms delay of timers.\n// However, they do not work reliably in Internet Explorer or Safari.\n\n// Internet Explorer 10 is the only browser that has setImmediate but does\n// not have MutationObservers.\n// Although setImmediate yields to the browser's renderer, it would be\n// preferrable to falling back to setTimeout since it does not have\n// the minimum 4ms penalty.\n// Unfortunately there appears to be a bug in Internet Explorer 10 Mobile (and\n// Desktop to a lesser extent) that renders both setImmediate and\n// MessageChannel useless for the purposes of ASAP.\n// https://github.com/kriskowal/q/issues/396\n\n// Timers are implemented universally.\n// We fall back to timers in workers in most engines, and in foreground\n// contexts in the following browsers.\n// However, note that even this simple case requires nuances to operate in a\n// broad spectrum of browsers.\n//\n// - Firefox 3-13\n// - Internet Explorer 6-9\n// - iPad Safari 4.3\n// - Lynx 2.8.7\n} else {\n    requestFlush = makeRequestCallFromTimer(flush);\n}\n\n// `requestFlush` requests that the high priority event queue be flushed as\n// soon as possible.\n// This is useful to prevent an error thrown in a task from stalling the event\n// queue if the exception handled by Node.js’s\n// `process.on(\"uncaughtException\")` or by a domain.\nrawAsap.requestFlush = requestFlush;\n\n// To request a high priority event, we induce a mutation observer by toggling\n// the text of a text node between \"1\" and \"-1\".\nfunction makeRequestCallFromMutationObserver(callback) {\n    var toggle = 1;\n    var observer = new BrowserMutationObserver(callback);\n    var node = document.createTextNode(\"\");\n    observer.observe(node, {characterData: true});\n    return function requestCall() {\n        toggle = -toggle;\n        node.data = toggle;\n    };\n}\n\n// The message channel technique was discovered by Malte Ubl and was the\n// original foundation for this library.\n// http://www.nonblocking.io/2011/06/windownexttick.html\n\n// Safari 6.0.5 (at least) intermittently fails to create message ports on a\n// page's first load. Thankfully, this version of Safari supports\n// MutationObservers, so we don't need to fall back in that case.\n\n// function makeRequestCallFromMessageChannel(callback) {\n//     var channel = new MessageChannel();\n//     channel.port1.onmessage = callback;\n//     return function requestCall() {\n//         channel.port2.postMessage(0);\n//     };\n// }\n\n// For reasons explained above, we are also unable to use `setImmediate`\n// under any circumstances.\n// Even if we were, there is another bug in Internet Explorer 10.\n// It is not sufficient to assign `setImmediate` to `requestFlush` because\n// `setImmediate` must be called *by name* and therefore must be wrapped in a\n// closure.\n// Never forget.\n\n// function makeRequestCallFromSetImmediate(callback) {\n//     return function requestCall() {\n//         setImmediate(callback);\n//     };\n// }\n\n// Safari 6.0 has a problem where timers will get lost while the user is\n// scrolling. This problem does not impact ASAP because Safari 6.0 supports\n// mutation observers, so that implementation is used instead.\n// However, if we ever elect to use timers in Safari, the prevalent work-around\n// is to add a scroll event listener that calls for a flush.\n\n// `setTimeout` does not call the passed callback if the delay is less than\n// approximately 7 in web workers in Firefox 8 through 18, and sometimes not\n// even then.\n\nfunction makeRequestCallFromTimer(callback) {\n    return function requestCall() {\n        // We dispatch a timeout with a specified delay of 0 for engines that\n        // can reliably accommodate that request. This will usually be snapped\n        // to a 4 milisecond delay, but once we're flushing, there's no delay\n        // between events.\n        var timeoutHandle = setTimeout(handleTimer, 0);\n        // However, since this timer gets frequently dropped in Firefox\n        // workers, we enlist an interval handle that will try to fire\n        // an event 20 times per second until it succeeds.\n        var intervalHandle = setInterval(handleTimer, 50);\n\n        function handleTimer() {\n            // Whichever timer succeeds will cancel both timers and\n            // execute the callback.\n            clearTimeout(timeoutHandle);\n            clearInterval(intervalHandle);\n            callback();\n        }\n    };\n}\n\n// This is for `asap.js` only.\n// Its name will be periodically randomized to break any code that depends on\n// its existence.\nrawAsap.makeRequestCallFromTimer = makeRequestCallFromTimer;\n\n// ASAP was originally a nextTick shim included in Q. This was factored out\n// into this ASAP package. It was later adapted to RSVP which made further\n// amendments. These decisions, particularly to marginalize MessageChannel and\n// to capture the MutationObserver implementation in a closure, were integrated\n// back into ASAP proper.\n// https://github.com/tildeio/rsvp.js/blob/cddf7232546a9cf858524b75cde6f9edf72620a7/lib/rsvp/asap.js\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/promise/~/asap/browser-raw.js\n// module id = 5\n// module chunks = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19","require('bootstrap/js/collapse');\nconst panelTpl = require('js/templates/slidedown.html');\n\nconst Slidedown = Backbone.Model.extend({\n    defaults: {\n        id: null,\n        title: null,\n        content: null\n    }\n});\n\nconst SlidedownPanel = Backbone.View.extend({\n    template: panelTpl,\n\n    initialize() {\n        this.render();\n    },\n\n    render() {\n        this.$el.html(this.template(this.model.attributes));\n        this.$el.collapse({\n            toggle: false\n        });\n    }\n});\n\n/**\n * construct a slidedown (bootstrap) element.\n * @param $el\n * @param model {Backbone.Model} instance to create a slidedown for\n * @param modelTransformer {Function} taking the backbone model as an argument, and returning an object containing the\n * data to set on a new {Slidedown} instance\n */\nexport function makeSlidedown($el, model, modelTransformer) {\n    let slidedown = new Slidedown(modelTransformer(model));\n\n    new SlidedownPanel({\n        el: $el,\n        model: slidedown\n    });\n}\n\nexport function makeSlidedowns($el, collection, modelTransformer) {\n    let $container = $('<div class=\"panel-group\" id=\"accordion\" role=\"tablist\" aria-multiselectable=\"true\"></div>');\n\n    $container.html(\n        collection\n            .reduce((acc, model) => {\n                let $panelEl = $('<div><div class=\"panel-group\" id=\"accordion\" role=\"tablist\" aria-multiselectable=\"true\"></div></div>');\n\n                makeSlidedown(\n                    $panelEl,\n                    model,\n                    modelTransformer\n                );\n\n                return $panelEl.html() + acc;\n            }, '')\n    );\n\n    $el.html($container);\n\n    return $el;\n}\n\n\n// WEBPACK FOOTER //\n// ./js/lib/views/slidedown.js","const Promise = require('promise');\n\n\n// http://stackoverflow.com/questions/901115/how-can-i-get-query-string-values-in-javascript\nexport function getParameterByName(name, url) {\n    if (!url) url = window.location.href;\n    name = name.replace(/[\\[\\]]/g, '\\\\$&');\n    let regex = new RegExp('[?&]' + name + '(=([^&#]*)|&|#|$)'),\n        results = regex.exec(url);\n\n    if (!results) return null;\n    if (!results[2]) return '';\n\n    return decodeURIComponent(results[2].replace(/\\+/g, ' '));\n}\n\n\n/**\n * get the current value of the hash in the URL - if it exists\n * @return @{String}\n */\nexport function getHashFromCurrentUrl() {\n    return window.location.hash ? window.location.hash.replace('#', '') : null;\n}\n\n\n/**\n * truncate the given string after `n` words\n * @param s\n * @param n\n * @param truncationChars @{String} the value to append to the truncated value (if truncation occurs)\n */\nexport function truncateWords(s, n, truncationChars='...') {\n    let words = s.split(' ');\n\n    if (words.length <= n) {\n        return s;\n    }\n\n    let truncated = words.slice(0, n).join(' ');\n    return truncated + truncationChars;\n}\n\n\n/**\n * truncate the given string after `n` characters\n * @param s\n * @param n\n * @param truncationChars\n */\nexport function truncateCharacters(s, n, truncationChars='...') {\n    if (s.length <= n) {\n        return s;\n    }\n\n    return s.substring(0, n) + truncationChars;\n}\n\n\nexport function toTitleCase(str) {\n    return str.replace(/\\w\\S*/g, function(txt){return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();});\n}\n\n\n/**\n * generate a random string of size n (wripped from https://stackoverflow.com/questions/1349404/generate-random-string-characters-in-javascript)\n * @param n\n * @returns {string}\n */\nexport function randomString(n=10) {\n    let text = '';\n    const possible = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';\n\n    for (let i = 0; i < n; i++)\n        text += possible.charAt(Math.floor(Math.random() * possible.length));\n\n    return text;\n}\n\n\n\n/**\n * browsers handle calculating the scroll distance from the top of the page differently. This method reconciles the different\n * ways browsers handle getting this value and returns the distance scrolled from the top:\n *\n * https://stackoverflow.com/questions/28633221/document-body-scrolltop-firefox-returns-0-only-js\n *\n * @returns {Number|number}\n */\nexport function scrollTopDistance() {\n    return window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0;\n}\n\n\n/**\n * toggle the ability to scroll in the page\n * @param flag {Boolean}\n */\nexport function toggleScroll(flag) {\n    $('html,body').css('overflow-y', flag ? 'auto' : 'hidden');\n}\n\n\n/**\n * listen for the window being scrolled to the given `limit` pixels down.\n * @param offset {Number} offset - in pixels - to reach\n * @return {Promise} resolving when the given offset is reached\n */\nexport function whenScrollReached(offset=100) {\n    return new Promise((resolve, reject) => {\n        let onScroll = _.throttle(() => {\n            if (scrollTopDistance() >= offset) {\n                window.removeEventListener('scroll', onScroll);\n                resolve();\n            }\n        }, 100);\n\n        window.addEventListener('scroll', onScroll);\n    });\n}\n\n\n\n// WEBPACK FOOTER //\n// ./js/lib/helpers.js","// removed by extract-text-webpack-plugin\nmodule.exports = {\"fa-cc-visa\":\"fa-cc-visa\",\"desktop-search-overlay\":\"desktop-search-overlay\",\"fa-sheqel\":\"fa-sheqel\",\"fa-rocket\":\"fa-rocket\",\"fa-battery-1\":\"fa-battery-1\",\"fa-scribd\":\"fa-scribd\",\"fa-sort-numeric-desc\":\"fa-sort-numeric-desc\",\"fa-arrow-circle-o-down\":\"fa-arrow-circle-o-down\",\"fa-hand-pointer-o\":\"fa-hand-pointer-o\",\"fa-meh-o\":\"fa-meh-o\",\"fa-blind\":\"fa-blind\",\"fa-globe\":\"fa-globe\",\"fa-yahoo\":\"fa-yahoo\",\"fa-map-o\":\"fa-map-o\",\"fa-feed\":\"fa-feed\",\"fa-moon-o\":\"fa-moon-o\",\"fa-hand-lizard-o\":\"fa-hand-lizard-o\",\"social-share-flat\":\"social-share-flat\",\"hs-input\":\"hs-input\",\"fa-sort-up\":\"fa-sort-up\",\"fa-cc-diners-club\":\"fa-cc-diners-club\",\"fa-anchor\":\"fa-anchor\",\"fa-bell-slash\":\"fa-bell-slash\",\"fa-birthday-cake\":\"fa-birthday-cake\",\"fa-sort-desc\":\"fa-sort-desc\",\"fa-mobile\":\"fa-mobile\",\"fa-optin-monster\":\"fa-optin-monster\",\"fa-columns\":\"fa-columns\",\"fa-facebook\":\"fa-facebook\",\"fa-fonticons\":\"fa-fonticons\",\"fa-github-alt\":\"fa-github-alt\",\"highlighted\":\"highlighted\",\"fa-angle-double-down\":\"fa-angle-double-down\",\"ctc-container\":\"ctc-container\",\"fa-paste\":\"fa-paste\",\"fa-git-square\":\"fa-git-square\",\"fa-calculator\":\"fa-calculator\",\"fa-registered\":\"fa-registered\",\"wide\":\"wide\",\"fa-dollar\":\"fa-dollar\",\"fa-hashtag\":\"fa-hashtag\",\"fa-play-circle\":\"fa-play-circle\",\"fa-chevron-down\":\"fa-chevron-down\",\"fa-sticky-note-o\":\"fa-sticky-note-o\",\"fa-mars\":\"fa-mars\",\"hero-header\":\"hero-header\",\"fa-window-minimize\":\"fa-window-minimize\",\"fa-amazon\":\"fa-amazon\",\"fa-square\":\"fa-square\",\"fa-code-fork\":\"fa-code-fork\",\"fa-navicon\":\"fa-navicon\",\"fa-qq\":\"fa-qq\",\"fa-map-signs\":\"fa-map-signs\",\"fa-play-circle-o\":\"fa-play-circle-o\",\"navbar-toggle\":\"navbar-toggle\",\"footer-contact\":\"footer-contact\",\"fa-weixin\":\"fa-weixin\",\"fa-caret-square-o-right\":\"fa-caret-square-o-right\",\"fa-superscript\":\"fa-superscript\",\"fa-recycle\":\"fa-recycle\",\"fa-question-circle\":\"fa-question-circle\",\"side-bar\":\"side-bar\",\"fa-file-movie-o\":\"fa-file-movie-o\",\"fa-ra\":\"fa-ra\",\"fa-hourglass-3\":\"fa-hourglass-3\",\"li\":\"li\",\"fa-gbp\":\"fa-gbp\",\"fa-inverse\":\"fa-inverse\",\"fa-credit-card-alt\":\"fa-credit-card-alt\",\"fa-edit\":\"fa-edit\",\"fa-hourglass-half\":\"fa-hourglass-half\",\"fa-paperclip\":\"fa-paperclip\",\"fa-download\":\"fa-download\",\"fa-flickr\":\"fa-flickr\",\"fa-thumbs-down\":\"fa-thumbs-down\",\"fa-git\":\"fa-git\",\"fa-hand-paper-o\":\"fa-hand-paper-o\",\"fa-plus-square-o\":\"fa-plus-square-o\",\"fa-bank\":\"fa-bank\",\"fa-hotel\":\"fa-hotel\",\"fa-sticky-note\":\"fa-sticky-note\",\"fa-sort-asc\":\"fa-sort-asc\",\"fa-share-alt\":\"fa-share-alt\",\"section\":\"section\",\"fa-euro\":\"fa-euro\",\"fa-thermometer-3\":\"fa-thermometer-3\",\"fa-li\":\"fa-li\",\"fa-pied-piper\":\"fa-pied-piper\",\"fa-close\":\"fa-close\",\"fa-gear\":\"fa-gear\",\"fa-adjust\":\"fa-adjust\",\"fa-stumbleupon\":\"fa-stumbleupon\",\"fa-wpforms\":\"fa-wpforms\",\"dropdown-mega\":\"dropdown-mega\",\"fa-paypal\":\"fa-paypal\",\"fa-toggle-left\":\"fa-toggle-left\",\"card-top-alert\":\"card-top-alert\",\"fa-id-badge\":\"fa-id-badge\",\"fa-hand-o-right\":\"fa-hand-o-right\",\"fa-exchange\":\"fa-exchange\",\"fa-binoculars\":\"fa-binoculars\",\"fa-gg\":\"fa-gg\",\"fa-plus-circle\":\"fa-plus-circle\",\"fa-toggle-right\":\"fa-toggle-right\",\"dropdown-florida-list\":\"dropdown-florida-list\",\"no-float\":\"no-float\",\"input-container\":\"input-container\",\"fa-facebook-square\":\"fa-facebook-square\",\"fa-indent\":\"fa-indent\",\"fa-calendar-minus-o\":\"fa-calendar-minus-o\",\"placeholder\":\"placeholder\",\"fa-heartbeat\":\"fa-heartbeat\",\"fa-windows\":\"fa-windows\",\"fa-vimeo-square\":\"fa-vimeo-square\",\"nav-email-col\":\"nav-email-col\",\"nav-ctc-container\":\"nav-ctc-container\",\"fa-viacoin\":\"fa-viacoin\",\"fa-drivers-license\":\"fa-drivers-license\",\"navbar\":\"navbar\",\"fa-long-arrow-left\":\"fa-long-arrow-left\",\"results-container\":\"results-container\",\"fa-money\":\"fa-money\",\"recent-firm-news-item\":\"recent-firm-news-item\",\"fa-sign-in\":\"fa-sign-in\",\"fa-arrow-circle-right\":\"fa-arrow-circle-right\",\"fa-puzzle-piece\":\"fa-puzzle-piece\",\"sr-only-focusable\":\"sr-only-focusable\",\"fa-codiepie\":\"fa-codiepie\",\"btn-black\":\"btn-black\",\"fa-openid\":\"fa-openid\",\"fa-shopping-bag\":\"fa-shopping-bag\",\"fa-info\":\"fa-info\",\"fa-check-square\":\"fa-check-square\",\"pointer\":\"pointer\",\"fa-cc-paypal\":\"fa-cc-paypal\",\"fa-circle\":\"fa-circle\",\"mm-recent-firm-news\":\"mm-recent-firm-news\",\"fa-eraser\":\"fa-eraser\",\"fa-chevron-up\":\"fa-chevron-up\",\"fa-copy\":\"fa-copy\",\"fa-chevron-circle-down\":\"fa-chevron-circle-down\",\"fa-bluetooth\":\"fa-bluetooth\",\"fa-share-square\":\"fa-share-square\",\"fa-repeat\":\"fa-repeat\",\"fa-desktop\":\"fa-desktop\",\"fa-hand-rock-o\":\"fa-hand-rock-o\",\"fa-th-large\":\"fa-th-large\",\"fa-arrow-circle-o-up\":\"fa-arrow-circle-o-up\",\"fa-google\":\"fa-google\",\"social-share-expanding\":\"social-share-expanding\",\"fa-bold\":\"fa-bold\",\"pullquote-right\":\"pullquote-right\",\"fa-video-camera\":\"fa-video-camera\",\"fa-file-audio-o\":\"fa-file-audio-o\",\"fa-bus\":\"fa-bus\",\"btn-ctc\":\"btn-ctc\",\"fa-stumbleupon-circle\":\"fa-stumbleupon-circle\",\"fa-yc\":\"fa-yc\",\"fa-heart\":\"fa-heart\",\"fa-frown-o\":\"fa-frown-o\",\"fa-mail-reply\":\"fa-mail-reply\",\"fa-vine\":\"fa-vine\",\"fa-sign-language\":\"fa-sign-language\",\"fa-tv\":\"fa-tv\",\"fa-user-times\":\"fa-user-times\",\"faq-card\":\"faq-card\",\"fa-database\":\"fa-database\",\"fa-codepen\":\"fa-codepen\",\"fa-simplybuilt\":\"fa-simplybuilt\",\"experiment-semaphore\":\"experiment-semaphore\",\"fa-window-maximize\":\"fa-window-maximize\",\"fa-map-marker\":\"fa-map-marker\",\"fa-sort-amount-desc\":\"fa-sort-amount-desc\",\"fa-file-picture-o\":\"fa-file-picture-o\",\"fa-usb\":\"fa-usb\",\"fa-terminal\":\"fa-terminal\",\"fa-bar-chart\":\"fa-bar-chart\",\"fa-product-hunt\":\"fa-product-hunt\",\"fa-image\":\"fa-image\",\"fa-stop-circle-o\":\"fa-stop-circle-o\",\"fa-venus-mars\":\"fa-venus-mars\",\"benefit\":\"benefit\",\"fa-commenting\":\"fa-commenting\",\"fa-trophy\":\"fa-trophy\",\"fa-rotate-270\":\"fa-rotate-270\",\"fa-soundcloud\":\"fa-soundcloud\",\"highlighteable\":\"highlighteable\",\"fa-gavel\":\"fa-gavel\",\"fa-random\":\"fa-random\",\"fa-stack-2x\":\"fa-stack-2x\",\"fa-ul\":\"fa-ul\",\"fa-asterisk\":\"fa-asterisk\",\"fa-arrows-h\":\"fa-arrows-h\",\"fa-jpy\":\"fa-jpy\",\"fa-y-combinator\":\"fa-y-combinator\",\"fa-mail-forward\":\"fa-mail-forward\",\"fa-legal\":\"fa-legal\",\"email\":\"email\",\"fa-volume-off\":\"fa-volume-off\",\"fa-external-link-square\":\"fa-external-link-square\",\"fa-opera\":\"fa-opera\",\"fa-superpowers\":\"fa-superpowers\",\"fa-maxcdn\":\"fa-maxcdn\",\"fa-apple\":\"fa-apple\",\"fa-foursquare\":\"fa-foursquare\",\"fa-scissors\":\"fa-scissors\",\"sub-title\":\"sub-title\",\"fa-cloud-download\":\"fa-cloud-download\",\"fa-twitch\":\"fa-twitch\",\"pullquote-left\":\"pullquote-left\",\"fa-snowflake-o\":\"fa-snowflake-o\",\"fa-tablet\":\"fa-tablet\",\"fa-star\":\"fa-star\",\"fa-leanpub\":\"fa-leanpub\",\"fa-play\":\"fa-play\",\"fa-creative-commons\":\"fa-creative-commons\",\"fa-wechat\":\"fa-wechat\",\"fa-stop\":\"fa-stop\",\"fa-tachometer\":\"fa-tachometer\",\"fa-ambulance\":\"fa-ambulance\",\"fa-weibo\":\"fa-weibo\",\"btn-pagination\":\"btn-pagination\",\"recent-firm-news-more-results\":\"recent-firm-news-more-results\",\"fa-wifi\":\"fa-wifi\",\"fa-mail-reply-all\":\"fa-mail-reply-all\",\"fa-space-shuttle\":\"fa-space-shuttle\",\"fa-soccer-ball-o\":\"fa-soccer-ball-o\",\"fa-user-o\":\"fa-user-o\",\"modal-body\":\"modal-body\",\"fa-trash\":\"fa-trash\",\"fa-paw\":\"fa-paw\",\"items-3\":\"items-3\",\"fa-ticket\":\"fa-ticket\",\"fa-times-circle\":\"fa-times-circle\",\"fa-grav\":\"fa-grav\",\"fa-angle-left\":\"fa-angle-left\",\"fa-btc\":\"fa-btc\",\"fa-medkit\":\"fa-medkit\",\"fa-user-circle\":\"fa-user-circle\",\"fa-unlock\":\"fa-unlock\",\"fa-linkedin\":\"fa-linkedin\",\"fa-area-chart\":\"fa-area-chart\",\"fa-arrow-circle-o-right\":\"fa-arrow-circle-o-right\",\"fa-address-book-o\":\"fa-address-book-o\",\"fa-thermometer-three-quarters\":\"fa-thermometer-three-quarters\",\"fa-american-sign-language-interpreting\":\"fa-american-sign-language-interpreting\",\"fa-fast-backward\":\"fa-fast-backward\",\"fa-github-square\":\"fa-github-square\",\"fa-times-rectangle-o\":\"fa-times-rectangle-o\",\"nav-call-col\":\"nav-call-col\",\"fa-subway\":\"fa-subway\",\"fa-newspaper-o\":\"fa-newspaper-o\",\"fa-google-plus-circle\":\"fa-google-plus-circle\",\"fa-bitbucket\":\"fa-bitbucket\",\"mm-search\":\"mm-search\",\"fa-reorder\":\"fa-reorder\",\"focused\":\"focused\",\"fa-thumbs-o-down\":\"fa-thumbs-o-down\",\"fa-street-view\":\"fa-street-view\",\"fa-calendar-times-o\":\"fa-calendar-times-o\",\"fa-keyboard-o\":\"fa-keyboard-o\",\"fa-magnet\":\"fa-magnet\",\"fa-ship\":\"fa-ship\",\"general-form\":\"general-form\",\"fa-automobile\":\"fa-automobile\",\"fa-wpbeginner\":\"fa-wpbeginner\",\"fa-battery-half\":\"fa-battery-half\",\"fa-pinterest\":\"fa-pinterest\",\"fa-th\":\"fa-th\",\"fa-share\":\"fa-share\",\"fa-sort-numeric-asc\":\"fa-sort-numeric-asc\",\"fa-percent\":\"fa-percent\",\"fa-mercury\":\"fa-mercury\",\"breadcrumb\":\"breadcrumb\",\"fa-thermometer\":\"fa-thermometer\",\"fa-mortar-board\":\"fa-mortar-board\",\"header-title\":\"header-title\",\"fa-key\":\"fa-key\",\"fa-s15\":\"fa-s15\",\"dropdown-locations\":\"dropdown-locations\",\"btn-red\":\"btn-red\",\"fa-cab\":\"fa-cab\",\"fa-slideshare\":\"fa-slideshare\",\"fa-angle-double-left\":\"fa-angle-double-left\",\"fa-ravelry\":\"fa-ravelry\",\"fb-comments\":\"fb-comments\",\"fa-lastfm\":\"fa-lastfm\",\"fa-rebel\":\"fa-rebel\",\"fa-chain-broken\":\"fa-chain-broken\",\"items-1\":\"items-1\",\"employment\":\"employment\",\"fa-strikethrough\":\"fa-strikethrough\",\"fa-sort-alpha-desc\":\"fa-sort-alpha-desc\",\"fa-phone-square\":\"fa-phone-square\",\"pull-right\":\"pull-right\",\"fa-envelope\":\"fa-envelope\",\"fa-th-list\":\"fa-th-list\",\"fa-at\":\"fa-at\",\"fa-remove\":\"fa-remove\",\"fa-life-bouy\":\"fa-life-bouy\",\"fa-battery-empty\":\"fa-battery-empty\",\"yt\":\"yt\",\"fa-arrow-circle-left\":\"fa-arrow-circle-left\",\"fa-arrow-circle-up\":\"fa-arrow-circle-up\",\"fa-pulse\":\"fa-pulse\",\"advertisement\":\"advertisement\",\"collapsed\":\"collapsed\",\"fa-expand\":\"fa-expand\",\"fa-mars-double\":\"fa-mars-double\",\"fa-comment-o\":\"fa-comment-o\",\"fa-adn\":\"fa-adn\",\"fa-vk\":\"fa-vk\",\"fa-ruble\":\"fa-ruble\",\"fa-laptop\":\"fa-laptop\",\"fa-xing-square\":\"fa-xing-square\",\"fa-expeditedssl\":\"fa-expeditedssl\",\"fa-first-order\":\"fa-first-order\",\"btn-twitter\":\"btn-twitter\",\"fa-google-plus\":\"fa-google-plus\",\"fa-caret-right\":\"fa-caret-right\",\"fa-code\":\"fa-code\",\"btn\":\"btn\",\"fa-building-o\":\"fa-building-o\",\"fa-check-circle-o\":\"fa-check-circle-o\",\"fa-circle-thin\":\"fa-circle-thin\",\"fa-angle-up\":\"fa-angle-up\",\"fa-text-height\":\"fa-text-height\",\"fa-gittip\":\"fa-gittip\",\"fa-angle-double-up\":\"fa-angle-double-up\",\"fa-usd\":\"fa-usd\",\"fa-file-archive-o\":\"fa-file-archive-o\",\"fa-gift\":\"fa-gift\",\"fa-thermometer-full\":\"fa-thermometer-full\",\"sr-only\":\"sr-only\",\"fa-steam\":\"fa-steam\",\"fa-3x\":\"fa-3x\",\"fa-battery-4\":\"fa-battery-4\",\"fa-address-card\":\"fa-address-card\",\"fa-fw\":\"fa-fw\",\"fa-motorcycle\":\"fa-motorcycle\",\"fa-times\":\"fa-times\",\"fa-list-ol\":\"fa-list-ol\",\"fa-black-tie\":\"fa-black-tie\",\"footer-form\":\"footer-form\",\"hs-error-msgs\":\"hs-error-msgs\",\"fa-address-card-o\":\"fa-address-card-o\",\"fa-map\":\"fa-map\",\"selected\":\"selected\",\"btn-ghost-black\":\"btn-ghost-black\",\"fa-file-sound-o\":\"fa-file-sound-o\",\"fa-meanpath\":\"fa-meanpath\",\"fa-info-circle\":\"fa-info-circle\",\"fa-dedent\":\"fa-dedent\",\"search-expand-lg\":\"search-expand-lg\",\"fa-toggle-off\":\"fa-toggle-off\",\"fa-certificate\":\"fa-certificate\",\"fa-font-awesome\":\"fa-font-awesome\",\"mm-table\":\"mm-table\",\"fa-camera\":\"fa-camera\",\"fa-sort-down\":\"fa-sort-down\",\"fa-thermometer-2\":\"fa-thermometer-2\",\"footer-logo\":\"footer-logo\",\"fa-user\":\"fa-user\",\"fa-group\":\"fa-group\",\"fa-power-off\":\"fa-power-off\",\"fa-android\":\"fa-android\",\"fa-futbol-o\":\"fa-futbol-o\",\"fa-circle-o\":\"fa-circle-o\",\"fa-pencil\":\"fa-pencil\",\"fa-sign-out\":\"fa-sign-out\",\"fa-sort-amount-asc\":\"fa-sort-amount-asc\",\"nav-search\":\"nav-search\",\"fa-spin\":\"fa-spin\",\"fa-users\":\"fa-users\",\"fa-align-center\":\"fa-align-center\",\"fa-connectdevelop\":\"fa-connectdevelop\",\"fa-qrcode\":\"fa-qrcode\",\"fa-tags\":\"fa-tags\",\"fa-minus-square-o\":\"fa-minus-square-o\",\"fa-star-half\":\"fa-star-half\",\"fa-eject\":\"fa-eject\",\"fa-stack-overflow\":\"fa-stack-overflow\",\"fa-bicycle\":\"fa-bicycle\",\"fa-cut\":\"fa-cut\",\"fa-rss\":\"fa-rss\",\"fa-joomla\":\"fa-joomla\",\"more\":\"more\",\"fa-server\":\"fa-server\",\"modal-header\":\"modal-header\",\"fa-4x\":\"fa-4x\",\"fa-chevron-circle-right\":\"fa-chevron-circle-right\",\"fa-clone\":\"fa-clone\",\"fa-align-left\":\"fa-align-left\",\"fa-mouse-pointer\":\"fa-mouse-pointer\",\"fa-hourglass-o\":\"fa-hourglass-o\",\"result-container\":\"result-container\",\"metadata\":\"metadata\",\"fa-linode\":\"fa-linode\",\"fa-bug\":\"fa-bug\",\"fa-thumb-tack\":\"fa-thumb-tack\",\"fa-bed\":\"fa-bed\",\"fa-link\":\"fa-link\",\"dropdown-menu\":\"dropdown-menu\",\"fa-reply-all\":\"fa-reply-all\",\"fa-subscript\":\"fa-subscript\",\"masthead\":\"masthead\",\"card-content-alert\":\"card-content-alert\",\"mobile\":\"mobile\",\"fa-align-justify\":\"fa-align-justify\",\"fa-ioxhost\":\"fa-ioxhost\",\"fa-credit-card\":\"fa-credit-card\",\"social-card\":\"social-card\",\"fa-youtube-square\":\"fa-youtube-square\",\"fa-battery-three-quarters\":\"fa-battery-three-quarters\",\"fa-bullhorn\":\"fa-bullhorn\",\"fa-tasks\":\"fa-tasks\",\"fa-filter\":\"fa-filter\",\"fa-pinterest-p\":\"fa-pinterest-p\",\"fa-bathtub\":\"fa-bathtub\",\"fa-2x\":\"fa-2x\",\"fa-share-square-o\":\"fa-share-square-o\",\"fa-flag-o\":\"fa-flag-o\",\"fa-thumbs-up\":\"fa-thumbs-up\",\"fa-underline\":\"fa-underline\",\"fa-star-half-full\":\"fa-star-half-full\",\"fa-delicious\":\"fa-delicious\",\"fa-gg-circle\":\"fa-gg-circle\",\"fa-vcard\":\"fa-vcard\",\"fa-hand-o-left\":\"fa-hand-o-left\",\"fa-i-cursor\":\"fa-i-cursor\",\"fa-arrow-left\":\"fa-arrow-left\",\"fa-won\":\"fa-won\",\"panel-body\":\"panel-body\",\"fa-odnoklassniki\":\"fa-odnoklassniki\",\"fa-caret-square-o-left\":\"fa-caret-square-o-left\",\"fa-search-plus\":\"fa-search-plus\",\"fa-pied-piper-alt\":\"fa-pied-piper-alt\",\"fa-chrome\":\"fa-chrome\",\"fa-youtube-play\":\"fa-youtube-play\",\"fa-bitcoin\":\"fa-bitcoin\",\"fa-crop\":\"fa-crop\",\"form-control\":\"form-control\",\"fa-object-ungroup\":\"fa-object-ungroup\",\"fa-neuter\":\"fa-neuter\",\"fa-dropbox\":\"fa-dropbox\",\"fa-assistive-listening-systems\":\"fa-assistive-listening-systems\",\"fa-linkedin-square\":\"fa-linkedin-square\",\"fa-ellipsis-v\":\"fa-ellipsis-v\",\"fa-caret-square-o-up\":\"fa-caret-square-o-up\",\"fa-glide\":\"fa-glide\",\"btn-close\":\"btn-close\",\"fa-eye\":\"fa-eye\",\"fa-list-ul\":\"fa-list-ul\",\"facebook-comment-wrapper\":\"facebook-comment-wrapper\",\"rt\":\"rt\",\"fa-cogs\":\"fa-cogs\",\"fa-bar-chart-o\":\"fa-bar-chart-o\",\"fa-question\":\"fa-question\",\"fa-pause-circle-o\":\"fa-pause-circle-o\",\"btn-social\":\"btn-social\",\"fa-volume-down\":\"fa-volume-down\",\"fa-map-pin\":\"fa-map-pin\",\"expander\":\"expander\",\"fa-file\":\"fa-file\",\"fa-check\":\"fa-check\",\"fa-reply\":\"fa-reply\",\"fa-hand-spock-o\":\"fa-hand-spock-o\",\"fa-unlock-alt\":\"fa-unlock-alt\",\"fa-drivers-license-o\":\"fa-drivers-license-o\",\"card-content\":\"card-content\",\"fa-compress\":\"fa-compress\",\"panel\":\"panel\",\"gp\":\"gp\",\"affix\":\"affix\",\"fa-inbox\":\"fa-inbox\",\"fa-cart-arrow-down\":\"fa-cart-arrow-down\",\"fa-reddit-alien\":\"fa-reddit-alien\",\"fa-behance\":\"fa-behance\",\"fa-calendar\":\"fa-calendar\",\"recent-firm-news-title\":\"recent-firm-news-title\",\"fa-google-plus-square\":\"fa-google-plus-square\",\"fa-wheelchair-alt\":\"fa-wheelchair-alt\",\"follow-row\":\"follow-row\",\"fa-folder-open\":\"fa-folder-open\",\"fa-yen\":\"fa-yen\",\"fa-spoon\":\"fa-spoon\",\"fa-ils\":\"fa-ils\",\"fa-trello\":\"fa-trello\",\"fa-envelope-open\":\"fa-envelope-open\",\"fa-cc-discover\":\"fa-cc-discover\",\"fa-mobile-phone\":\"fa-mobile-phone\",\"fa-comment\":\"fa-comment\",\"fa-eercast\":\"fa-eercast\",\"nav\":\"nav\",\"fa-cc-amex\":\"fa-cc-amex\",\"fa-archive\":\"fa-archive\",\"fa-sun-o\":\"fa-sun-o\",\"fa-thermometer-1\":\"fa-thermometer-1\",\"fa-arrows\":\"fa-arrows\",\"fa-quote-right\":\"fa-quote-right\",\"fa-universal-access\":\"fa-universal-access\",\"fa-train\":\"fa-train\",\"hidden-lg\":\"hidden-lg\",\"network\":\"network\",\"fa-pie-chart\":\"fa-pie-chart\",\"fa-buysellads\":\"fa-buysellads\",\"fa-taxi\":\"fa-taxi\",\"footer-subnav-links\":\"footer-subnav-links\",\"fa-sellsy\":\"fa-sellsy\",\"fa-glide-g\":\"fa-glide-g\",\"fa-retweet\":\"fa-retweet\",\"fa-text-width\":\"fa-text-width\",\"fa-rupee\":\"fa-rupee\",\"fa-ellipsis-h\":\"fa-ellipsis-h\",\"fa-folder-open-o\":\"fa-folder-open-o\",\"fa-photo\":\"fa-photo\",\"fa-object-group\":\"fa-object-group\",\"fa-unlink\":\"fa-unlink\",\"pin\":\"pin\",\"fa-slack\":\"fa-slack\",\"fa-twitter\":\"fa-twitter\",\"hs_yes_sign_me_up_for_the_newsletter_\":\"hs_yes_sign_me_up_for_the_newsletter_\",\"fa-caret-left\":\"fa-caret-left\",\"fa-exclamation\":\"fa-exclamation\",\"fa-file-powerpoint-o\":\"fa-file-powerpoint-o\",\"fa-eyedropper\":\"fa-eyedropper\",\"fa-contao\":\"fa-contao\",\"fa-search\":\"fa-search\",\"fa-exclamation-triangle\":\"fa-exclamation-triangle\",\"hero-unit\":\"hero-unit\",\"fa-twitter-square\":\"fa-twitter-square\",\"fa-plug\":\"fa-plug\",\"fa-dashboard\":\"fa-dashboard\",\"dropdown-toggle\":\"dropdown-toggle\",\"panel-title\":\"panel-title\",\"fa-file-word-o\":\"fa-file-word-o\",\"fa-eye-slash\":\"fa-eye-slash\",\"fa-xing\":\"fa-xing\",\"fa-thermometer-half\":\"fa-thermometer-half\",\"fa-handshake-o\":\"fa-handshake-o\",\"fa-chevron-circle-left\":\"fa-chevron-circle-left\",\"fa-glass\":\"fa-glass\",\"desktop\":\"desktop\",\"fa-eur\":\"fa-eur\",\"fa-braille\":\"fa-braille\",\"fa-floppy-o\":\"fa-floppy-o\",\"card-top\":\"card-top\",\"fa-skype\":\"fa-skype\",\"fa-volume-up\":\"fa-volume-up\",\"fa-cc-stripe\":\"fa-cc-stripe\",\"fa-hourglass-end\":\"fa-hourglass-end\",\"fa-microphone\":\"fa-microphone\",\"fa-5x\":\"fa-5x\",\"close\":\"close\",\"fa-font\":\"fa-font\",\"fa-meetup\":\"fa-meetup\",\"fa-arrows-alt\":\"fa-arrows-alt\",\"fa-pencil-square-o\":\"fa-pencil-square-o\",\"fa-hdd-o\":\"fa-hdd-o\",\"fa-home\":\"fa-home\",\"fa-road\":\"fa-road\",\"fa-crosshairs\":\"fa-crosshairs\",\"nav-logo\":\"nav-logo\",\"fa-building\":\"fa-building\",\"recent-firm-news-details\":\"recent-firm-news-details\",\"fa-level-up\":\"fa-level-up\",\"fa-stop-circle\":\"fa-stop-circle\",\"expandable\":\"expandable\",\"fa-id-card-o\":\"fa-id-card-o\",\"fa-thermometer-empty\":\"fa-thermometer-empty\",\"fa-chevron-right\":\"fa-chevron-right\",\"fa-file-excel-o\":\"fa-file-excel-o\",\"fa-plane\":\"fa-plane\",\"fa-venus-double\":\"fa-venus-double\",\"address\":\"address\",\"fa-check-circle\":\"fa-check-circle\",\"fa-envelope-o\":\"fa-envelope-o\",\"fa-toggle-up\":\"fa-toggle-up\",\"fa-snapchat-ghost\":\"fa-snapchat-ghost\",\"fa-try\":\"fa-try\",\"fa-file-photo-o\":\"fa-file-photo-o\",\"image-column\":\"image-column\",\"fa-long-arrow-down\":\"fa-long-arrow-down\",\"fa-plus\":\"fa-plus\",\"fa-battery-quarter\":\"fa-battery-quarter\",\"fa-hourglass-start\":\"fa-hourglass-start\",\"fa-line-chart\":\"fa-line-chart\",\"open\":\"open\",\"double-wide\":\"double-wide\",\"fa-history\":\"fa-history\",\"fa-folder\":\"fa-folder\",\"btn-dark\":\"btn-dark\",\"fa-microchip\":\"fa-microchip\",\"fa-bomb\":\"fa-bomb\",\"pointer-wrapper\":\"pointer-wrapper\",\"fa-tint\":\"fa-tint\",\"fa-low-vision\":\"fa-low-vision\",\"fa-snapchat-square\":\"fa-snapchat-square\",\"caret\":\"caret\",\"fa-bolt\":\"fa-bolt\",\"fa-undo\":\"fa-undo\",\"fa-arrow-up\":\"fa-arrow-up\",\"search-expand-md\":\"search-expand-md\",\"fa-pagelines\":\"fa-pagelines\",\"fa-heart-o\":\"fa-heart-o\",\"fa-send-o\":\"fa-send-o\",\"fa-television\":\"fa-television\",\"fa-support\":\"fa-support\",\"fa-opencart\":\"fa-opencart\",\"fa-diamond\":\"fa-diamond\",\"modal-title\":\"modal-title\",\"fa-battery\":\"fa-battery\",\"fa-500px\":\"fa-500px\",\"fa-film\":\"fa-film\",\"fa-book\":\"fa-book\",\"fa-window-close\":\"fa-window-close\",\"fa-comments\":\"fa-comments\",\"fa-themeisle\":\"fa-themeisle\",\"more-related-articles\":\"more-related-articles\",\"fa-suitcase\":\"fa-suitcase\",\"fa-clipboard\":\"fa-clipboard\",\"fa-check-square-o\":\"fa-check-square-o\",\"links-row\":\"links-row\",\"fa-tree\":\"fa-tree\",\"search-expand-sm\":\"search-expand-sm\",\"fa-medium\":\"fa-medium\",\"fa-location-arrow\":\"fa-location-arrow\",\"fa-user-plus\":\"fa-user-plus\",\"fa-stack\":\"fa-stack\",\"fa-krw\":\"fa-krw\",\"fa-hand-scissors-o\":\"fa-hand-scissors-o\",\"fa-houzz\":\"fa-houzz\",\"fa-volume-control-phone\":\"fa-volume-control-phone\",\"fa-clock-o\":\"fa-clock-o\",\"fa-fire\":\"fa-fire\",\"fa-file-text-o\":\"fa-file-text-o\",\"fa-arrow-circle-o-left\":\"fa-arrow-circle-o-left\",\"fa-hand-o-up\":\"fa-hand-o-up\",\"fa-lg\":\"fa-lg\",\"fa-life-buoy\":\"fa-life-buoy\",\"fa-align-right\":\"fa-align-right\",\"fa-arrows-v\":\"fa-arrows-v\",\"fa-viadeo\":\"fa-viadeo\",\"fa-vcard-o\":\"fa-vcard-o\",\"testimonials-items\":\"testimonials-items\",\"fa-hand-peace-o\":\"fa-hand-peace-o\",\"sidebar-form\":\"sidebar-form\",\"fa-safari\":\"fa-safari\",\"fa-reddit-square\":\"fa-reddit-square\",\"fa-vimeo\":\"fa-vimeo\",\"fa-files-o\":\"fa-files-o\",\"fa-file-text\":\"fa-file-text\",\"fa-copyright\":\"fa-copyright\",\"fa-id-card\":\"fa-id-card\",\"fa-chain\":\"fa-chain\",\"fa-dashcube\":\"fa-dashcube\",\"fa-facebook-official\":\"fa-facebook-official\",\"fa-pull-left\":\"fa-pull-left\",\"fa-pied-piper-pp\":\"fa-pied-piper-pp\",\"fa-audio-description\":\"fa-audio-description\",\"has-results\":\"has-results\",\"fa-cog\":\"fa-cog\",\"fa-venus\":\"fa-venus\",\"fa-odnoklassniki-square\":\"fa-odnoklassniki-square\",\"fa-angle-down\":\"fa-angle-down\",\"fa-minus-circle\":\"fa-minus-circle\",\"fa-drupal\":\"fa-drupal\",\"fa-dribbble\":\"fa-dribbble\",\"btn-red-centered\":\"btn-red-centered\",\"fa-file-video-o\":\"fa-file-video-o\",\"fa-industry\":\"fa-industry\",\"fa-user-md\":\"fa-user-md\",\"fa-pull-right\":\"fa-pull-right\",\"fa-folder-o\":\"fa-folder-o\",\"fa-fire-extinguisher\":\"fa-fire-extinguisher\",\"fa-shopping-basket\":\"fa-shopping-basket\",\"fa-yc-square\":\"fa-yc-square\",\"show\":\"show\",\"fa-life-saver\":\"fa-life-saver\",\"fa-square-o\":\"fa-square-o\",\"fa-etsy\":\"fa-etsy\",\"pull-left\":\"pull-left\",\"fa-resistance\":\"fa-resistance\",\"fa-bell-o\":\"fa-bell-o\",\"fa-skyatlas\":\"fa-skyatlas\",\"fa-battery-3\":\"fa-battery-3\",\"fa-quote-left\":\"fa-quote-left\",\"mm-header-container\":\"mm-header-container\",\"nav-desktop\":\"nav-desktop\",\"fa-toggle-down\":\"fa-toggle-down\",\"fa-shield\":\"fa-shield\",\"panel-group\":\"panel-group\",\"fa-step-forward\":\"fa-step-forward\",\"fa-commenting-o\":\"fa-commenting-o\",\"fa-camera-retro\":\"fa-camera-retro\",\"fa-paper-plane\":\"fa-paper-plane\",\"fa-briefcase\":\"fa-briefcase\",\"fa-digg\":\"fa-digg\",\"centered-button\":\"centered-button\",\"fa-thumbs-o-up\":\"fa-thumbs-o-up\",\"fa-behance-square\":\"fa-behance-square\",\"fa-italic\":\"fa-italic\",\"col-md-4\":\"col-md-4\",\"fa-sort-alpha-asc\":\"fa-sort-alpha-asc\",\"fa-step-backward\":\"fa-step-backward\",\"fb\":\"fb\",\"fa-flip-vertical\":\"fa-flip-vertical\",\"employment-locations\":\"employment-locations\",\"fa-stack-1x\":\"fa-stack-1x\",\"fa-sitemap\":\"fa-sitemap\",\"clicktocall\":\"clicktocall\",\"header-bar\":\"header-bar\",\"fa-border\":\"fa-border\",\"fa-file-image-o\":\"fa-file-image-o\",\"fa-asl-interpreting\":\"fa-asl-interpreting\",\"fa-pencil-square\":\"fa-pencil-square\",\"tw\":\"tw\",\"fa-linux\":\"fa-linux\",\"fa-wordpress\":\"fa-wordpress\",\"fa-comments-o\":\"fa-comments-o\",\"fa-toggle-on\":\"fa-toggle-on\",\"fa-cloud\":\"fa-cloud\",\"inputs-list\":\"inputs-list\",\"fa-user-secret\":\"fa-user-secret\",\"btn-fb\":\"btn-fb\",\"fa-deviantart\":\"fa-deviantart\",\"fa-signal\":\"fa-signal\",\"fa-rotate-right\":\"fa-rotate-right\",\"testimonials-header\":\"testimonials-header\",\"fa-star-o\":\"fa-star-o\",\"fa-angellist\":\"fa-angellist\",\"fa-tumblr-square\":\"fa-tumblr-square\",\"fa-cny\":\"fa-cny\",\"fa-battery-0\":\"fa-battery-0\",\"visible-lg\":\"visible-lg\",\"fa-list\":\"fa-list\",\"fa-lemon-o\":\"fa-lemon-o\",\"fa-fort-awesome\":\"fa-fort-awesome\",\"fa-chevron-circle-up\":\"fa-chevron-circle-up\",\"fa-fighter-jet\":\"fa-fighter-jet\",\"btn-yt\":\"btn-yt\",\"fa-cc-jcb\":\"fa-cc-jcb\",\"fa-deaf\":\"fa-deaf\",\"fa-bookmark-o\":\"fa-bookmark-o\",\"fa-arrow-circle-down\":\"fa-arrow-circle-down\",\"fa-warning\":\"fa-warning\",\"fa-empire\":\"fa-empire\",\"fa-turkish-lira\":\"fa-turkish-lira\",\"fa-long-arrow-up\":\"fa-long-arrow-up\",\"mm-search-input\":\"mm-search-input\",\"fa-steam-square\":\"fa-steam-square\",\"fa-chevron-left\":\"fa-chevron-left\",\"fa-facebook-f\":\"fa-facebook-f\",\"fa-transgender-alt\":\"fa-transgender-alt\",\"btn-ghost\":\"btn-ghost\",\"form-blurb\":\"form-blurb\",\"fa-tag\":\"fa-tag\",\"fa-bath\":\"fa-bath\",\"fa-cutlery\":\"fa-cutlery\",\"footer-subnav\":\"footer-subnav\",\"fa-shekel\":\"fa-shekel\",\"fa-flag\":\"fa-flag\",\"fa-fax\":\"fa-fax\",\"fa-envira\":\"fa-envira\",\"go-to-top-container\":\"go-to-top-container\",\"recent-firm-news-header\":\"recent-firm-news-header\",\"fa-shopping-cart\":\"fa-shopping-cart\",\"fa-file-o\":\"fa-file-o\",\"fa-thermometer-4\":\"fa-thermometer-4\",\"fa-angle-right\":\"fa-angle-right\",\"fa-mars-stroke-h\":\"fa-mars-stroke-h\",\"fa-user-circle-o\":\"fa-user-circle-o\",\"fa-arrow-down\":\"fa-arrow-down\",\"popup-contact-form\":\"popup-contact-form\",\"fa-life-ring\":\"fa-life-ring\",\"fa-ge\":\"fa-ge\",\"hs-button\":\"hs-button\",\"fa-battery-2\":\"fa-battery-2\",\"fa-address-book\":\"fa-address-book\",\"fa-caret-square-o-down\":\"fa-caret-square-o-down\",\"fa-google-wallet\":\"fa-google-wallet\",\"fa-hand-grab-o\":\"fa-hand-grab-o\",\"fa-barcode\":\"fa-barcode\",\"fa-thermometer-0\":\"fa-thermometer-0\",\"fa-header\":\"fa-header\",\"fa-beer\":\"fa-beer\",\"fa-inr\":\"fa-inr\",\"fa-hourglass-1\":\"fa-hourglass-1\",\"fa-minus-square\":\"fa-minus-square\",\"fa-reddit\":\"fa-reddit\",\"num\":\"num\",\"fa-renren\":\"fa-renren\",\"fa-backward\":\"fa-backward\",\"contact-card\":\"contact-card\",\"fa-calendar-check-o\":\"fa-calendar-check-o\",\"fa-gamepad\":\"fa-gamepad\",\"fa-calendar-plus-o\":\"fa-calendar-plus-o\",\"hs-richtext\":\"hs-richtext\",\"fa-caret-up\":\"fa-caret-up\",\"fa-file-code-o\":\"fa-file-code-o\",\"fa-star-half-empty\":\"fa-star-half-empty\",\"fa-youtube\":\"fa-youtube\",\"go-top\":\"go-top\",\"fa-bell\":\"fa-bell\",\"fa-telegram\":\"fa-telegram\",\"fa-viadeo-square\":\"fa-viadeo-square\",\"fa-external-link\":\"fa-external-link\",\"call-us\":\"call-us\",\"fa-cube\":\"fa-cube\",\"fa-forumbee\":\"fa-forumbee\",\"fa-snapchat\":\"fa-snapchat\",\"fa-graduation-cap\":\"fa-graduation-cap\",\"fa-arrow-right\":\"fa-arrow-right\",\"fa-flash\":\"fa-flash\",\"fa-smile-o\":\"fa-smile-o\",\"fa-headphones\":\"fa-headphones\",\"fa-instagram\":\"fa-instagram\",\"most-popular\":\"most-popular\",\"mm-sortable-table\":\"mm-sortable-table\",\"fa-yelp\":\"fa-yelp\",\"fa-y-combinator-square\":\"fa-y-combinator-square\",\"fa-hand-stop-o\":\"fa-hand-stop-o\",\"fa-edge\":\"fa-edge\",\"hs-form-field\":\"hs-form-field\",\"hs_submit\":\"hs_submit\",\"fa-cubes\":\"fa-cubes\",\"fa-pause\":\"fa-pause\",\"fa-ban\":\"fa-ban\",\"fa-rouble\":\"fa-rouble\",\"featured-link\":\"featured-link\",\"dropdown\":\"dropdown\",\"fa-tumblr\":\"fa-tumblr\",\"fa-unsorted\":\"fa-unsorted\",\"navbar-header\":\"navbar-header\",\"fa-rmb\":\"fa-rmb\",\"expanded\":\"expanded\",\"fa-window-close-o\":\"fa-window-close-o\",\"fa-circle-o-notch\":\"fa-circle-o-notch\",\"fa-coffee\":\"fa-coffee\",\"fa-hand-o-down\":\"fa-hand-o-down\",\"fa-paragraph\":\"fa-paragraph\",\"fa-gitlab\":\"fa-gitlab\",\"phone\":\"phone\",\"fa-mars-stroke-v\":\"fa-mars-stroke-v\",\"fa-stethoscope\":\"fa-stethoscope\",\"fa-quora\":\"fa-quora\",\"fa-institution\":\"fa-institution\",\"fa-stack-exchange\":\"fa-stack-exchange\",\"fa-shirtsinbulk\":\"fa-shirtsinbulk\",\"fa-thermometer-quarter\":\"fa-thermometer-quarter\",\"fa-cc\":\"fa-cc\",\"fa-h-square\":\"fa-h-square\",\"fa-leaf\":\"fa-leaf\",\"fa-compass\":\"fa-compass\",\"related-article-box\":\"related-article-box\",\"fa-window-restore\":\"fa-window-restore\",\"fa-github\":\"fa-github\",\"fa-times-rectangle\":\"fa-times-rectangle\",\"mm-news-articles-basic\":\"mm-news-articles-basic\",\"fa-print\":\"fa-print\",\"fa-wikipedia-w\":\"fa-wikipedia-w\",\"fa-css3\":\"fa-css3\",\"row-testimonials\":\"row-testimonials\",\"fa-intersex\":\"fa-intersex\",\"fa-bell-slash-o\":\"fa-bell-slash-o\",\"fa-firefox\":\"fa-firefox\",\"fa-hard-of-hearing\":\"fa-hard-of-hearing\",\"fa-wheelchair\":\"fa-wheelchair\",\"fa-picture-o\":\"fa-picture-o\",\"social\":\"social\",\"testimonials-see-more\":\"testimonials-see-more\",\"fa-bars\":\"fa-bars\",\"fa-get-pocket\":\"fa-get-pocket\",\"fa-pause-circle\":\"fa-pause-circle\",\"fa-exclamation-circle\":\"fa-exclamation-circle\",\"fa-question-circle-o\":\"fa-question-circle-o\",\"fa-modx\":\"fa-modx\",\"fa-hacker-news\":\"fa-hacker-news\",\"fa-trash-o\":\"fa-trash-o\",\"fa-forward\":\"fa-forward\",\"fa-fast-forward\":\"fa-fast-forward\",\"fa-google-plus-official\":\"fa-google-plus-official\",\"fa-rss-square\":\"fa-rss-square\",\"ca-logo\":\"ca-logo\",\"fa-child\":\"fa-child\",\"fa-spinner\":\"fa-spinner\",\"fa-rotate-left\":\"fa-rotate-left\",\"fa-balance-scale\":\"fa-balance-scale\",\"btn-play\":\"btn-play\",\"fa-music\":\"fa-music\",\"fa-rub\":\"fa-rub\",\"fa-internet-explorer\":\"fa-internet-explorer\",\"fa-sliders\":\"fa-sliders\",\"more-related-articles-container\":\"more-related-articles-container\",\"row\":\"row\",\"fa-times-circle-o\":\"fa-times-circle-o\",\"fa-car\":\"fa-car\",\"fa-paint-brush\":\"fa-paint-brush\",\"fa-tty\":\"fa-tty\",\"in\":\"in\",\"fa-bitbucket-square\":\"fa-bitbucket-square\",\"employment-benefits\":\"employment-benefits\",\"fa-rotate-90\":\"fa-rotate-90\",\"fa-envelope-square\":\"fa-envelope-square\",\"fa-lightbulb-o\":\"fa-lightbulb-o\",\"fa-file-zip-o\":\"fa-file-zip-o\",\"footer-form-wrapper\":\"footer-form-wrapper\",\"fa-tencent-weibo\":\"fa-tencent-weibo\",\"fa-dot-circle-o\":\"fa-dot-circle-o\",\"fa-truck\":\"fa-truck\",\"fa-male\":\"fa-male\",\"fa-microphone-slash\":\"fa-microphone-slash\",\"fa-umbrella\":\"fa-umbrella\",\"fa-hourglass-2\":\"fa-hourglass-2\",\"fa-genderless\":\"fa-genderless\",\"basic-see-more\":\"basic-see-more\",\"fa-lastfm-square\":\"fa-lastfm-square\",\"panel-heading\":\"panel-heading\",\"fa-phone\":\"fa-phone\",\"fa-whatsapp\":\"fa-whatsapp\",\"fa-signing\":\"fa-signing\",\"fa-university\":\"fa-university\",\"fa-battery-full\":\"fa-battery-full\",\"fa-magic\":\"fa-magic\",\"fa-html5\":\"fa-html5\",\"fa-trademark\":\"fa-trademark\",\"star-black\":\"star-black\",\"fa-sort\":\"fa-sort\",\"fa-envelope-open-o\":\"fa-envelope-open-o\",\"fa-gears\":\"fa-gears\",\"star-orange\":\"star-orange\",\"fa-bluetooth-b\":\"fa-bluetooth-b\",\"icon-bar\":\"icon-bar\",\"fa-file-pdf-o\":\"fa-file-pdf-o\",\"fa-list-alt\":\"fa-list-alt\",\"fa-yoast\":\"fa-yoast\",\"grouped\":\"grouped\",\"recent-firm-news-description\":\"recent-firm-news-description\",\"fa-language\":\"fa-language\",\"fa-long-arrow-right\":\"fa-long-arrow-right\",\"fa-send\":\"fa-send\",\"fa-refresh\":\"fa-refresh\",\"fa-search-minus\":\"fa-search-minus\",\"fa-hospital-o\":\"fa-hospital-o\",\"fa-jsfiddle\":\"fa-jsfiddle\",\"items-2\":\"items-2\",\"fa-spotify\":\"fa-spotify\",\"fa-shower\":\"fa-shower\",\"fa-flag-checkered\":\"fa-flag-checkered\",\"fa-podcast\":\"fa-podcast\",\"see-all\":\"see-all\",\"fa-imdb\":\"fa-imdb\",\"fa-bookmark\":\"fa-bookmark\",\"fa-level-down\":\"fa-level-down\",\"fa-wrench\":\"fa-wrench\",\"fa-mixcloud\":\"fa-mixcloud\",\"fa-outdent\":\"fa-outdent\",\"fa-share-alt-square\":\"fa-share-alt-square\",\"fa-lock\":\"fa-lock\",\"fa-gratipay\":\"fa-gratipay\",\"fa-table\":\"fa-table\",\"fa-flip-horizontal\":\"fa-flip-horizontal\",\"fa-plus-square\":\"fa-plus-square\",\"fa-transgender\":\"fa-transgender\",\"actions\":\"actions\",\"fa-bullseye\":\"fa-bullseye\",\"fa-star-half-o\":\"fa-star-half-o\",\"fa\":\"fa\",\"fa-female\":\"fa-female\",\"fa-angle-double-right\":\"fa-angle-double-right\",\"fa-free-code-camp\":\"fa-free-code-camp\",\"fa-cart-plus\":\"fa-cart-plus\",\"fa-rotate-180\":\"fa-rotate-180\",\"fa-calendar-o\":\"fa-calendar-o\",\"fa-flask\":\"fa-flask\",\"fa-bandcamp\":\"fa-bandcamp\",\"fa-caret-down\":\"fa-caret-down\",\"fa-hourglass\":\"fa-hourglass\",\"social-share-flat-wrapper\":\"social-share-flat-wrapper\",\"fa-pinterest-square\":\"fa-pinterest-square\",\"fa-paper-plane-o\":\"fa-paper-plane-o\",\"fa-fa\":\"fa-fa\",\"fa-mars-stroke\":\"fa-mars-stroke\",\"fa-save\":\"fa-save\",\"fa-upload\":\"fa-upload\",\"fa-cc-mastercard\":\"fa-cc-mastercard\",\"fa-wpexplorer\":\"fa-wpexplorer\",\"fa-cloud-upload\":\"fa-cloud-upload\",\"fa-minus\":\"fa-minus\",\"recent-firm-news-image\":\"recent-firm-news-image\",\"fa-tripadvisor\":\"fa-tripadvisor\",\"fa-deafness\":\"fa-deafness\",\"btn-close-expander\":\"btn-close-expander\"};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./sass/pages/employment.scss\n// module id = 66\n// module chunks = 14","'use strict';\n\nmodule.exports = require('./lib')\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/promise/index.js\n// module id = 7\n// module chunks = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19","'use strict';\n\nvar Promise = require('./core.js');\n\nmodule.exports = Promise;\nPromise.prototype.done = function (onFulfilled, onRejected) {\n  var self = arguments.length ? this.then.apply(this, arguments) : this;\n  self.then(null, function (err) {\n    setTimeout(function () {\n      throw err;\n    }, 0);\n  });\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/promise/lib/done.js\n// module id = 8\n// module chunks = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19","'use strict';\n\n//This file contains the ES6 extensions to the core Promises/A+ API\n\nvar Promise = require('./core.js');\n\nmodule.exports = Promise;\n\n/* Static Functions */\n\nvar TRUE = valuePromise(true);\nvar FALSE = valuePromise(false);\nvar NULL = valuePromise(null);\nvar UNDEFINED = valuePromise(undefined);\nvar ZERO = valuePromise(0);\nvar EMPTYSTRING = valuePromise('');\n\nfunction valuePromise(value) {\n  var p = new Promise(Promise._61);\n  p._65 = 1;\n  p._55 = value;\n  return p;\n}\nPromise.resolve = function (value) {\n  if (value instanceof Promise) return value;\n\n  if (value === null) return NULL;\n  if (value === undefined) return UNDEFINED;\n  if (value === true) return TRUE;\n  if (value === false) return FALSE;\n  if (value === 0) return ZERO;\n  if (value === '') return EMPTYSTRING;\n\n  if (typeof value === 'object' || typeof value === 'function') {\n    try {\n      var then = value.then;\n      if (typeof then === 'function') {\n        return new Promise(then.bind(value));\n      }\n    } catch (ex) {\n      return new Promise(function (resolve, reject) {\n        reject(ex);\n      });\n    }\n  }\n  return valuePromise(value);\n};\n\nPromise.all = function (arr) {\n  var args = Array.prototype.slice.call(arr);\n\n  return new Promise(function (resolve, reject) {\n    if (args.length === 0) return resolve([]);\n    var remaining = args.length;\n    function res(i, val) {\n      if (val && (typeof val === 'object' || typeof val === 'function')) {\n        if (val instanceof Promise && val.then === Promise.prototype.then) {\n          while (val._65 === 3) {\n            val = val._55;\n          }\n          if (val._65 === 1) return res(i, val._55);\n          if (val._65 === 2) reject(val._55);\n          val.then(function (val) {\n            res(i, val);\n          }, reject);\n          return;\n        } else {\n          var then = val.then;\n          if (typeof then === 'function') {\n            var p = new Promise(then.bind(val));\n            p.then(function (val) {\n              res(i, val);\n            }, reject);\n            return;\n          }\n        }\n      }\n      args[i] = val;\n      if (--remaining === 0) {\n        resolve(args);\n      }\n    }\n    for (var i = 0; i < args.length; i++) {\n      res(i, args[i]);\n    }\n  });\n};\n\nPromise.reject = function (value) {\n  return new Promise(function (resolve, reject) {\n    reject(value);\n  });\n};\n\nPromise.race = function (values) {\n  return new Promise(function (resolve, reject) {\n    values.forEach(function(value){\n      Promise.resolve(value).then(resolve, reject);\n    });\n  });\n};\n\n/* Prototype Methods */\n\nPromise.prototype['catch'] = function (onRejected) {\n  return this.then(null, onRejected);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/promise/lib/es6-extensions.js\n// module id = 9\n// module chunks = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19","require('sass/pages/employment.scss');\n\nimport { makeSlidedowns } from 'js/lib/views/slidedown';\nimport collapsibleFactory from 'js/lib/views/collapsible';\n\n\nconst Job = Backbone.Model.extend({\n    defaults: {\n        id: null,\n        title: null,\n        full_title: null,\n        location: {},\n        url: null,\n        department: null\n    }\n});\n\nconst Jobs = Backbone.Collection.extend({\n    model: Job,\n\n    parse(resp) {\n        return resp['jobs'];\n    },\n\n    url: '//proxypool.forthepeople.com/careers'\n});\n\nlet jobs = new Jobs();\n\njobs.fetch({\n    success(collection) {\n        let jobsTpl = _.template($('#city-jobs-template').html());\n        let groupedByCity = collection.groupBy(j => j.get('location').city);\n\n        makeSlidedowns(\n            $('.employment .employment-locations'),\n            _.keys(groupedByCity).sort().reverse(),\n            city => ({ id: groupedByCity[city][0].get('id'), title: city, content: jobsTpl({ jobs: groupedByCity[city] }) })\n        );\n\n        $('.employment .employment-locations .panel').each(function() { collapsibleFactory($(this)); });\n    }\n});\n\n\n// WEBPACK FOOTER //\n// ./js/pages/employment.js"],"sourceRoot":""}