{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///indico/web/client/js/jquery/compat/mathjax.js","webpack:///node_modules/mathjax/unpacked/MathJax.js","webpack:///indico/web/client/js/jquery/utils/pagedown_mathjax.js"],"names":["webpackJsonpCallback","data","moduleId","chunkId","chunkIds","moreModules","executeModules","i","resolves","length","Object","prototype","hasOwnProperty","call","installedChunks","push","modules","parentJsonpFunction","shift","deferredModules","apply","checkDeferredModules","result","deferredModule","fulfilled","j","depId","splice","__webpack_require__","s","installedModules","143","exports","module","l","e","Promise","resolve","m","c","d","name","getter","o","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","p","jsonpArray","window","oldJsonpFunction","slice","MathJax","isPacked","OutputJax","fontDir","imageDir","BASE","ROOT","HUB","AJAX","CALLBACK","JAX","document","getElementById","childNodes","createElement","Hub","AuthorConfig","version","fileversion","cdnVersion","cdnFileVersions","BASENAME","PROTO","OBJECT","def","obj","constructor","id","arguments","callee","Init","this","Subclass","classdef","SUPER","Augment","protoFunction","can","has","isa","args","toString","fn","method","SimpleSUPER","define","src","dst","wrap","f","match","err","isArray","Array","cb","execute","isCallback","hook","called","autoReset","concat","reset","ISCALLBACK","EVAL","code","eval","TESTEVAL","__TeSt_VaR__","error","execScript","__code","__result","Error","head","getElementsByTagName","body","script","appendChild","createTextNode","removeChild","USING","WAITFOR","callback","signal","WAITSIGNAL","pending","WAITEXECUTE","signals","oldExecute","AFTER","HOOKS","hooks","remove","running","Add","priority","Remove","Execute","callbacks","RemovePending","sort","QUEUE","queue","Push","Process","Suspend","Resume","wait","SIGNAL","posted","listeners","posting","Post","message","forget","Clear","Interest","ignorePast","NoInterest","MessageHook","msg","ExecuteHooks","type","RemoveHook","find","Callback","CallBack","Delay","time","timeout","setTimeout","After","Queue","Signal","Hooks","handler","isSafari2","navigator","vendor","vendorSub","sheets","HEAD","styleSheets","SCRIPTS","REMOVESCRIPTS","Ajax","PATH","loaded","loading","loadHooks","styleDelay","config","root","path","params","STATUS","OK","ERROR","fileURL","file","substr","fileName","url","recheck","fileRev","V","urlRev","Require","toUpperCase","split","pop","noContrib","FILE","Load","addHook","loader","LoadHook","removeHook","Preloading","preloaded","JS","status","Message","File","onerror","CSS","link","rel","href","timer","node","nodeName","styleSheet","chrome","start","checkSafari2","checkLength","check","delay","total","Math","floor","loadTimeout","loadComplete","cssRules","isStyle","sheet","rules","clearTimeout","loadError","Set","Styles","styles","styleString","StyleString","style","cssText","string","join","HTML","Element","contents","replace","ucMatch","Insert","setAttribute","setScript","addElement","span","TextNode","text","addText","setScriptBug","firstChild","getScript","innerHTML","Cookie","prefix","expires","keys","cookie","escape","Date","setDate","getDate","toGMTString","Get","pattern","RegExp","exec","unescape","parseFloat","Localization","locale","directory","strings","menuTitle","isLoaded","SPLIT","regex","last","lastIndex","index","_","phrase","processSnippet","processString","lookupPhrase","domain","parts","charAt","number","plural","plurals","snippet","part","processMarkdown","markdownPattern","target","concatString","load","loadDomain","RestartAfter","localeData","domains","domainData","loadFile","Try","restart","resetLocale","toLowerCase","dashPos","lastIndexOf","substring","remap","setLocale","Menu","addTranslation","definition","isNew","menu","CreateLocaleMenu","setCSS","div","fontFamily","fontDirection","direction","textAlign","ready","log","current","textNodeBug","position","left","bottom","border","margin","padding","color","width","top","browsers","MSIE","browser","msieFixedPositionBug","documentMode","quirks","compatMode","Chrome","parentNode","frame","attachEvent","addDiv","removeAttribute","zIndex","height","MoveFrame","display","parent","insertBefore","documentElement","scrollLeft","scrollTop","clientWidth","clientHeight","localize","filterText","messageStyle","processing","typesetting","clearCounts","clearDelay","restarted","cleared","filteredText","next","prev","nodeValue","Log","jax","extensions","preJax","postJax","displayAlign","displayIndent","preRemoveClass","showProcessingMessages","delayStartupUntil","skipStartupTypeset","elements","positionToHash","showMathMenu","showMathMenuMSIE","menuSettings","zoom","CTRL","ALT","CMD","Shift","discoverable","zscale","renderer","font","context","mpContext","mpMouse","texHints","FastPreview","assistiveMML","inTabOrder","semantics","errorSettings","ignoreMMLattributes","preProcessors","inputJax","outputJax","order","processSectionDelay","processUpdateTime","processUpdateDelay","Config","CombineConfig","Register","PreProcessor","StartupHook","Startup","UnRegister","getAllJax","element","scripts","elementScripts","elementJax","getJaxByType","mimeType","getJaxByInputType","getJaxFor","isMathJaxNode","isMathJax","jaxID","getJaxFromMath","isJax","tagName","state","ElementJax","STATE","PROCESSED","className","setRenderer","isUnknown","unshift","Typeset","isReady","ec","elementCallback","count","PreProcess","takeAction","Update","Reprocess","Rerender","action","getTime","jaxIDs","scriptAction","needsUpdate","UPDATE","OUTPUT","prepareScripts","disabled","hover","Extension","MathEvents","Hover","ClearHover","PENDING","checkScriptSiblings","checked","pre","previousSibling","post","nextSibling","preview","processInput","saveScript","input","Attach","postInputHooks","now","processError","prepareOutput","lastPrepError","processOutput","inputID","processMessage","formatError","LOCALIZE","arg1","arg2","sourceURL","line","lineNumber","Jax","errorText","messageId","EVENT","Event","oncontextmenu","onmousedown","Mousedown","onkeydown","Keydown","tabIndex","getTabOrder","lastError","isHTMLCollection","HTMLCollection2Array","alreadyDone","contains","msieHTMLCollectionBug","HTMLCollection","nodes","NODES","SplitList","String","list","trim","Configured","files","URL","THIS","loadArray","ConfigDelay","onload","ConfigBlocks","SETTINGS","CHTMLpreview","AssistiveMML","k","Extensions","registered","Hash","location","hash","scrollIntoView","decodeURIComponent","a","HashCheck","hashCheck","MenuZoom","MathMenu","MathZoom","onLoad","readyState","Browser","isMSIE","addEventListener","noDOMContentEvent","dir","synchronous","JAXFILE","require","cdef","cObject","ndef","Translate","mimetype","copyTranslate","preProcess","preTranslate","postProcess","postTranslate","extensionDir","InputJax","sourceMenuTitle","SourceElement","originalText","Text","keep","clear","Detach","Clone","GetID","newID","ID","errors","ContextMenu","AltContextMenu","math","sourceMenuFormat","STARTUP","CONFIG","namespaceURI","getElementsByTagNameNS","namePattern","$2","KV","AGENT","userAgent","BROWSERS","isMac","platform","isPC","isEdge","loadTimes","isFirefox","isSafari","app","isChrome","isOpera","opera","isKonqueror","versionAtLeast","v","bv","parseInt","Select","choices","xAGENT","MATCH","Safari","webkit","appVersion","isMobile","noContextMenu","Firefox","product","rv","date","buildID","productSub","Opera","Edge","isIE9","performance","msPerformance","NoMathPlayer","ActiveXObject","hasMathPlayer","mathplayer","classid","namespaces","add","mpNamespace","write","mpImported","console","AuthorInit","$","Indico","Urls","Base","DELIMITERS","PageDownMathJax","blocks","end","braces","$preview","ready_listeners","EqnChunk","EqnChunkFactor","forEach","listener","processMath","block","removeMath","replaceMath","restartMJ","cancelTypeset","typeset","elem","undefined","createPreview","editorObject","converterObject","getConverter","updateMJ","new_height","outerHeight","$wrapper","closest","is_empty","is","toggleClass","css","chain","mathJax","createEditor","$container","fieldId","converter","Markdown","getSanitizingConverter","rbg","whole","inner","editor","Editor","helpButton","imagedialog","run","pd","each","pagedown","_pagedown","options","pd_context","last_change","$save_button","siblings","_set_saving","prop","addClass","removeClass","$T","save","val","extend","on","my_time","wait_time"],"mappings":"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","file":"js/mathjax.25308fd9.bundle.js","sourcesContent":[" \t// install a JSONP callback for chunk loading\n \tfunction webpackJsonpCallback(data) {\n \t\tvar chunkIds = data[0];\n \t\tvar moreModules = data[1];\n \t\tvar executeModules = data[2];\n\n \t\t// add \"moreModules\" to the modules object,\n \t\t// then flag all \"chunkIds\" as loaded and fire callback\n \t\tvar moduleId, chunkId, i = 0, resolves = [];\n \t\tfor(;i < chunkIds.length; i++) {\n \t\t\tchunkId = chunkIds[i];\n \t\t\tif(Object.prototype.hasOwnProperty.call(installedChunks, chunkId) && installedChunks[chunkId]) {\n \t\t\t\tresolves.push(installedChunks[chunkId][0]);\n \t\t\t}\n \t\t\tinstalledChunks[chunkId] = 0;\n \t\t}\n \t\tfor(moduleId in moreModules) {\n \t\t\tif(Object.prototype.hasOwnProperty.call(moreModules, moduleId)) {\n \t\t\t\tmodules[moduleId] = moreModules[moduleId];\n \t\t\t}\n \t\t}\n \t\tif(parentJsonpFunction) parentJsonpFunction(data);\n\n \t\twhile(resolves.length) {\n \t\t\tresolves.shift()();\n \t\t}\n\n \t\t// add entry modules from loaded chunk to deferred list\n \t\tdeferredModules.push.apply(deferredModules, executeModules || []);\n\n \t\t// run deferred modules when all chunks ready\n \t\treturn checkDeferredModules();\n \t};\n \tfunction checkDeferredModules() {\n \t\tvar result;\n \t\tfor(var i = 0; i < deferredModules.length; i++) {\n \t\t\tvar deferredModule = deferredModules[i];\n \t\t\tvar fulfilled = true;\n \t\t\tfor(var j = 1; j < deferredModule.length; j++) {\n \t\t\t\tvar depId = deferredModule[j];\n \t\t\t\tif(installedChunks[depId] !== 0) fulfilled = false;\n \t\t\t}\n \t\t\tif(fulfilled) {\n \t\t\t\tdeferredModules.splice(i--, 1);\n \t\t\t\tresult = __webpack_require__(__webpack_require__.s = deferredModule[0]);\n \t\t\t}\n \t\t}\n\n \t\treturn result;\n \t}\n\n \t// The module cache\n \tvar installedModules = {};\n\n \t// object to store loaded and loading chunks\n \t// undefined = chunk not loaded, null = chunk preloaded/prefetched\n \t// Promise = chunk loading, 0 = chunk loaded\n \tvar installedChunks = {\n \t\t143: 0\n \t};\n\n \tvar deferredModules = [];\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 \t// The chunk loading function for additional chunks\n \t// Since all referenced chunks are already included\n \t// in this file, this function is empty here.\n \t__webpack_require__.e = function requireEnsure() {\n \t\treturn Promise.resolve();\n \t};\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// 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, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\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 = \"/dist/\";\n\n \tvar jsonpArray = window[\"coreJsonp\"] = window[\"coreJsonp\"] || [];\n \tvar oldJsonpFunction = jsonpArray.push.bind(jsonpArray);\n \tjsonpArray.push = webpackJsonpCallback;\n \tjsonpArray = jsonpArray.slice();\n \tfor(var i = 0; i < jsonpArray.length; i++) webpackJsonpCallback(jsonpArray[i]);\n \tvar parentJsonpFunction = oldJsonpFunction;\n\n\n \t// add entry module to deferred list\n \tdeferredModules.push([1874,0]);\n \t// run deferred modules when ready\n \treturn checkDeferredModules();\n","// This file is part of Indico.\n// Copyright (C) 2002 - 2021 CERN\n//\n// Indico is free software; you can redistribute it and/or\n// modify it under the terms of the MIT License; see the\n// LICENSE file for more details.\n\nimport 'mathjax';\nimport '../utils/pagedown_mathjax';\n\n// pretend this is not an \"unpacked\" setup\nMathJax.isPacked = true;\n// the default values for these paths use isPacked before we can set it\nMathJax.OutputJax.fontDir = '[MathJax]/fonts';\nMathJax.OutputJax.imageDir = '[MathJax]/images';\n","/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */\n/* vim: set ts=2 et sw=2 tw=80: */\n\n/*************************************************************\n *\n *  MathJax.js\n *\n *  The main support code for the MathJax Hub, including the\n *  Ajax, Callback, Messaging, and Object-Oriented Programming\n *  libraries, as well as the base Jax classes, and startup\n *  processing code.\n *\n *  ---------------------------------------------------------------------\n *\n *  Copyright (c) 2009-2020 The MathJax Consortium\n *\n *  Licensed under the Apache License, Version 2.0 (the \"License\");\n *  you may not use this file except in compliance with the License.\n *  You may obtain a copy of the License at\n *\n *      http://www.apache.org/licenses/LICENSE-2.0\n *\n *  Unless required by applicable law or agreed to in writing, software\n *  distributed under the License is distributed on an \"AS IS\" BASIS,\n *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *  See the License for the specific language governing permissions and\n *  limitations under the License.\n */\n\n\n//\n//  Check if browser can support MathJax (no one fails this nowadays)\n//\nif (document.getElementById && document.childNodes && document.createElement) {\n//\n//  Skip if MathJax is already loaded\n//\nif (!(window.MathJax && MathJax.Hub)) {\n\n//\n//  Get author configuration from MathJax variable, if any\n//\nif (window.MathJax) {window.MathJax = {AuthorConfig: window.MathJax}}\n               else {window.MathJax = {}}\n\n// MathJax.isPacked = true; // This line is uncommented by the packer.\n\nMathJax.version = \"2.7.9\";\nMathJax.fileversion = \"2.7.9\";\nMathJax.cdnVersion = \"2.7.9\";  // specifies a revision to break caching\nMathJax.cdnFileVersions = {};  // can be used to specify revisions for individual files\n\n/**********************************************************/\n\n(function (BASENAME) {\n  var BASE = window[BASENAME];\n  if (!BASE) {BASE = window[BASENAME] = {}}\n\n  var PROTO = [];  // a static object used to indicate when a prototype is being created\n  var OBJECT = function (def) {\n    var obj = def.constructor; if (!obj) {obj = function () {}}\n    for (var id in def) {if (id !== 'constructor' && def.hasOwnProperty(id)) {obj[id] = def[id]}}\n    return obj;\n  };\n  var CONSTRUCTOR = function () {\n    return function () {return arguments.callee.Init.call(this,arguments)};\n  };\n\n  BASE.Object = OBJECT({\n    constructor: CONSTRUCTOR(),\n\n    Subclass: function (def,classdef) {\n      var obj = CONSTRUCTOR();\n      obj.SUPER = this; obj.Init = this.Init;\n      obj.Subclass = this.Subclass; obj.Augment = this.Augment;\n      obj.protoFunction = this.protoFunction;\n      obj.can = this.can; obj.has = this.has; obj.isa = this.isa;\n      obj.prototype = new this(PROTO);\n      obj.prototype.constructor = obj;  // the real constructor\n      obj.Augment(def,classdef);\n      return obj;\n    },\n\n    Init: function (args) {\n      var obj = this;\n      if (args.length === 1 && args[0] === PROTO) {return obj}\n      if (!(obj instanceof args.callee)) {obj = new args.callee(PROTO)}\n      return obj.Init.apply(obj,args) || obj;\n    },\n\n    Augment: function (def,classdef) {\n      var id;\n      if (def != null) {\n        for (id in def) {if (def.hasOwnProperty(id)) {this.protoFunction(id,def[id])}}\n        // MSIE doesn't list toString even if it is not native so handle it separately\n        if (def.toString !== this.prototype.toString && def.toString !== {}.toString)\n          {this.protoFunction('toString',def.toString)}\n      }\n      if (classdef != null) {\n        for (id in classdef) {if (classdef.hasOwnProperty(id)) {this[id] = classdef[id]}}\n      }\n      return this;\n    },\n\n    protoFunction: function (id,def) {\n      this.prototype[id] = def;\n      if (typeof def === \"function\") {def.SUPER = this.SUPER.prototype}\n    },\n\n    prototype: {\n      Init: function () {},\n      SUPER: function (fn) {return fn.callee.SUPER},\n      can: function (method) {return typeof(this[method]) === \"function\"},\n      has: function (property) {return typeof(this[property]) !== \"undefined\"},\n      isa: function (obj) {return (obj instanceof Object) && (this instanceof obj)}\n    },\n\n    can: function (method)   {return this.prototype.can.call(this,method)},\n    has: function (property) {return this.prototype.has.call(this,property)},\n    isa: function (obj) {\n      var constructor = this;\n      while (constructor) {\n        if (constructor === obj) {return true} else {constructor = constructor.SUPER}\n      }\n      return false;\n    },\n\n\n    SimpleSUPER: OBJECT({\n      constructor: function (def) {return this.SimpleSUPER.define(def)},\n\n      define: function (src) {\n\tvar dst = {};\n\tif (src != null) {\n          for (var id in src) {if (src.hasOwnProperty(id)) {dst[id] = this.wrap(id,src[id])}}\n\t  // MSIE doesn't list toString even if it is not native so handle it separately\n          if (src.toString !== this.prototype.toString && src.toString !== {}.toString)\n            {dst.toString = this.wrap('toString',src.toString)}\n\t}\n\treturn dst;\n      },\n\n      wrap: function (id,f) {\n        if (typeof(f) !== 'function' || !f.toString().match(/\\.\\s*SUPER\\s*\\(/)) {return f}\n        var fn = function () {\n          this.SUPER = fn.SUPER[id];\n          try {var result = f.apply(this,arguments)} catch (err) {delete this.SUPER; throw err}\n          delete this.SUPER;\n          return result;\n        }\n        fn.toString = function () {return f.toString.apply(f,arguments)}\n        return fn;\n      }\n\n    })\n  });\n\n  BASE.Object.isArray = Array.isArray || function (obj) {\n    return Object.prototype.toString.call(obj) === \"[object Array]\";\n  };\n\n  BASE.Object.Array = Array;\n\n})(\"MathJax\");\n\n/**********************************************************/\n\n/*\n *  Create a callback function from various forms of data:\n *\n *     MathJax.Callback(fn)    -- callback to a function\n *\n *     MathJax.Callback([fn])  -- callback to function\n *     MathJax.Callback([fn,data...])\n *                             -- callback to function with given data as arguments\n *     MathJax.Callback([object,fn])\n *                             -- call fn with object as \"this\"\n *     MathJax.Callback([object,fn,data...])\n *                             -- call fn with object as \"this\" and data as arguments\n *     MathJax.Callback([\"method\",object])\n *                             -- call method of object wth object as \"this\"\n *     MathJax.Callback([\"method\",object,data...])\n *                             -- as above, but with data as arguments to method\n *\n *     MathJax.Callback({hook: fn, data: [...], object: this})\n *                             -- give function, data, and object to act as \"this\" explicitly\n *\n *     MathJax.Callback(\"code\")  -- callback that compiles and executes a string\n *\n *     MathJax.Callback([...],i)\n *                             -- use slice of array starting at i and interpret\n *                                result as above.  (Used for passing \"arguments\" array\n *                                and trimming initial arguments, if any.)\n */\n\n/*\n *    MathJax.Callback.After([...],cb1,cb2,...)\n *                             -- make a callback that isn't called until all the other\n *                                ones are called first.  I.e., wait for a union of\n *                                callbacks to occur before making the given callback.\n */\n\n/*\n *  MathJax.Callback.Queue([callback,...])\n *                             -- make a synchronized queue of commands that process\n *                                sequentially, waiting for those that return uncalled\n *                                callbacks.\n */\n\n/*\n *  MathJax.Callback.Signal(name)\n *                             -- finds or creates a names signal, to which listeners\n *                                can be attached and are signaled by messages posted\n *                                to the signal.  Responses can be asynchronous.\n */\n\n(function (BASENAME) {\n  var BASE = window[BASENAME];\n  if (!BASE) {BASE = window[BASENAME] = {}}\n  var isArray = BASE.Object.isArray;\n  //\n  //  Create a callback from an associative array\n  //\n  var CALLBACK = function (data) {\n    var cb = function () {return arguments.callee.execute.apply(arguments.callee,arguments)};\n    for (var id in CALLBACK.prototype) {\n      if (CALLBACK.prototype.hasOwnProperty(id)) {\n        if (typeof(data[id]) !== 'undefined') {cb[id] = data[id]}\n                                         else {cb[id] = CALLBACK.prototype[id]}\n      }\n    }\n    cb.toString = CALLBACK.prototype.toString;\n    return cb;\n  };\n  CALLBACK.prototype = {\n    isCallback: true,\n    hook: function () {},\n    data: [],\n    object: window,\n    execute: function () {\n      if (!this.called || this.autoReset) {\n        this.called = !this.autoReset;\n        return this.hook.apply(this.object,this.data.concat([].slice.call(arguments,0)));\n      }\n    },\n    reset: function () {delete this.called},\n    toString: function () {return this.hook.toString.apply(this.hook,arguments)}\n  };\n  var ISCALLBACK = function (f) {\n    return (typeof(f) === \"function\" && f.isCallback);\n  }\n\n  //\n  //  Evaluate a string in global context\n  //\n  var EVAL = function (code) {return eval.call(window,code)}\n  var TESTEVAL = function () {\n    EVAL(\"var __TeSt_VaR__ = 1\"); // check if it works in global context\n    if (window.__TeSt_VaR__) {\n      try { delete window.__TeSt_VaR__; } // NOTE IE9 throws when in IE7 mode\n      catch (error) { window.__TeSt_VaR__ = null; }\n    } else {\n      if (window.execScript) {\n        // IE\n        EVAL = function (code) {\n          BASE.__code = code;\n          code = \"try {\"+BASENAME+\".__result = eval(\"+BASENAME+\".__code)} catch(err) {\"+BASENAME+\".__result = err}\";\n          window.execScript(code);\n          var result = BASE.__result; delete BASE.__result; delete BASE.__code;\n          if (result instanceof Error) {throw result}\n          return result;\n        }\n      } else {\n        // Safari2\n        EVAL = function (code) {\n          BASE.__code = code;\n          code = \"try {\"+BASENAME+\".__result = eval(\"+BASENAME+\".__code)} catch(err) {\"+BASENAME+\".__result = err}\";\n          var head = (document.getElementsByTagName(\"head\"))[0]; if (!head) {head = document.body}\n          var script = document.createElement(\"script\");\n          script.appendChild(document.createTextNode(code));\n          head.appendChild(script); head.removeChild(script);\n          var result = BASE.__result; delete BASE.__result; delete BASE.__code;\n          if (result instanceof Error) {throw result}\n          return result;\n        }\n      }\n    }\n    TESTEVAL = null;\n  };\n\n  //\n  //  Create a callback from various types of data\n  //\n  var USING = function (args,i) {\n    if (arguments.length > 1) {\n      if (arguments.length === 2 && !(typeof arguments[0] === 'function') &&\n          arguments[0] instanceof Object && typeof arguments[1] === 'number')\n            {args = [].slice.call(args,i)}\n      else {args = [].slice.call(arguments,0)}\n    }\n    if (isArray(args) && args.length === 1 && typeof(args[0]) === 'function') {args = args[0]}\n    if (typeof args === 'function') {\n      if (args.execute === CALLBACK.prototype.execute) {return args}\n      return CALLBACK({hook: args});\n    } else if (isArray(args)) {\n      if (typeof(args[0]) === 'string' && args[1] instanceof Object &&\n                 typeof args[1][args[0]] === 'function') {\n        return CALLBACK({hook: args[1][args[0]], object: args[1], data: args.slice(2)});\n      } else if (typeof args[0] === 'function') {\n        return CALLBACK({hook: args[0], data: args.slice(1)});\n      } else if (typeof args[1] === 'function') {\n        return CALLBACK({hook: args[1], object: args[0], data: args.slice(2)});\n      }\n    } else if (typeof(args) === 'string') {\n      if (TESTEVAL) TESTEVAL();\n      return CALLBACK({hook: EVAL, data: [args]});\n    } else if (args instanceof Object) {\n      return CALLBACK(args);\n    } else if (typeof(args) === 'undefined') {\n      return CALLBACK({});\n    }\n    throw Error(\"Can't make callback from given data\");\n  };\n\n  //\n  //  Wait for a given time to elapse and then perform the callback\n  //\n  var DELAY = function (time,callback) {\n    callback = USING(callback);\n    callback.timeout = setTimeout(callback,time);\n    return callback;\n  };\n\n  //\n  //  Callback used by AFTER, QUEUE, and SIGNAL to check if calls have completed\n  //\n  var WAITFOR = function (callback,signal) {\n    callback = USING(callback);\n    if (!callback.called) {WAITSIGNAL(callback,signal); signal.pending++}\n  };\n  var WAITEXECUTE = function () {\n    var signals = this.signal; delete this.signal;\n    this.execute = this.oldExecute; delete this.oldExecute;\n    var result = this.execute.apply(this,arguments);\n    if (ISCALLBACK(result) && !result.called) {WAITSIGNAL(result,signals)} else {\n      for (var i = 0, m = signals.length; i < m; i++) {\n        signals[i].pending--;\n        if (signals[i].pending <= 0) {signals[i].call()}\n      }\n    }\n  };\n  var WAITSIGNAL = function (callback,signals) {\n    if (!isArray(signals)) {signals = [signals]}\n    if (!callback.signal) {\n      callback.oldExecute = callback.execute;\n      callback.execute = WAITEXECUTE;\n      callback.signal = signals;\n    } else if (signals.length === 1) {callback.signal.push(signals[0])}\n      else {callback.signal = callback.signal.concat(signals)}\n  };\n\n  //\n  //  Create a callback that is called when a collection of other callbacks have\n  //  all been executed.  If the callback gets called immediately (i.e., the\n  //  others are all already called), check if it returns another callback\n  //  and return that instead.\n  //\n  var AFTER = function (callback) {\n    callback = USING(callback);\n    callback.pending = 0;\n    for (var i = 1, m = arguments.length; i < m; i++)\n      {if (arguments[i]) {WAITFOR(arguments[i],callback)}}\n    if (callback.pending === 0) {\n      var result = callback();\n      if (ISCALLBACK(result)) {callback = result}\n    }\n    return callback;\n  };\n\n  //\n  //  An array of prioritized hooks that are executed sequentially\n  //  with a given set of data.\n  //\n  var HOOKS = MathJax.Object.Subclass({\n    //\n    //  Initialize the array and the auto-reset status\n    //\n    Init: function (reset) {\n      this.hooks = [];\n      this.remove = []; // used when hooks are removed during execution of list\n      this.reset = reset;\n      this.running = false;\n    },\n    //\n    //  Add a callback to the list, in priority order (default priority is 10)\n    //\n    Add: function (hook,priority) {\n      if (priority == null) {priority = 10}\n      if (!ISCALLBACK(hook)) {hook = USING(hook)}\n      hook.priority = priority;\n      var i = this.hooks.length;\n      while (i > 0 && priority < this.hooks[i-1].priority) {i--}\n      this.hooks.splice(i,0,hook);\n      return hook;\n    },\n    Remove: function (hook) {\n      for (var i = 0, m = this.hooks.length; i < m; i++) {\n        if (this.hooks[i] === hook) {\n          if (this.running) {this.remove.push(i)}\n            else {this.hooks.splice(i,1)}\n          return;\n        }\n      }\n    },\n    //\n    //  Execute the list of callbacks, resetting them if requested.\n    //  If any return callbacks, return a callback that will be\n    //  executed when they all have completed.\n    //  Remove any hooks that requested being removed during processing.\n    //\n    Execute: function () {\n      var callbacks = [{}];\n      this.running = true;\n      for (var i = 0, m = this.hooks.length; i < m; i++) {\n        if (this.reset) {this.hooks[i].reset()}\n        var result = this.hooks[i].apply(window,arguments);\n        if (ISCALLBACK(result) && !result.called) {callbacks.push(result)}\n      }\n      this.running = false;\n      if (this.remove.length) {this.RemovePending()}\n      if (callbacks.length === 1) {return null}\n      if (callbacks.length === 2) {return callbacks[1]}\n      return AFTER.apply({},callbacks);\n    },\n    //\n    //  Remove hooks that asked to be removed during execution of list\n    //\n    RemovePending: function () {\n      this.remove = this.remove.sort();\n      for (var i = this.remove.length-1; i >= 0; i--) {this.hooks.splice(i,1)}\n      this.remove = [];\n    }\n\n  });\n\n  //\n  //  Run an array of callbacks passing them the given data.\n  //  (Legacy function, since this has been replaced by the HOOKS object).\n  //\n  var EXECUTEHOOKS = function (hooks,data,reset) {\n    if (!hooks) {return null}\n    if (!isArray(hooks)) {hooks = [hooks]}\n    if (!isArray(data))  {data = (data == null ? [] : [data])}\n    var handler = HOOKS(reset);\n    for (var i = 0, m = hooks.length; i < m; i++) {handler.Add(hooks[i])}\n    return handler.Execute.apply(handler,data);\n  };\n\n  //\n  //  Command queue that performs commands in order, waiting when\n  //  necessary for commands to complete asynchronousely\n  //\n  var QUEUE = BASE.Object.Subclass({\n    //\n    //  Create the queue and push any commands that are specified\n    //\n    Init: function () {\n      this.pending = this.running = 0;\n      this.queue = [];\n      this.Push.apply(this,arguments);\n    },\n    //\n    //  Add commands to the queue and run them. Adding a callback object\n    //  (rather than a callback specification) queues a wait for that callback.\n    //  Return the final callback for synchronization purposes.\n    //\n    Push: function () {\n      var callback;\n      for (var i = 0, m = arguments.length; i < m; i++) {\n        callback = USING(arguments[i]);\n        if (callback === arguments[i] && !callback.called)\n          {callback = USING([\"wait\",this,callback])}\n        this.queue.push(callback);\n      }\n      if (!this.running && !this.pending) {this.Process()}\n      return callback;\n    },\n    //\n    //  Process the command queue if we aren't waiting on another command\n    //\n    Process: function (queue) {\n      while (!this.running && !this.pending && this.queue.length) {\n        var callback = this.queue[0];\n        queue = this.queue.slice(1); this.queue = [];\n        this.Suspend(); var result = callback(); this.Resume();\n        if (queue.length) {this.queue = queue.concat(this.queue)}\n        if (ISCALLBACK(result) && !result.called) {WAITFOR(result,this)}\n      }\n    },\n    //\n    //  Suspend/Resume command processing on this queue\n    //\n    Suspend: function () {this.running++},\n    Resume: function () {if (this.running) {this.running--}},\n    //\n    //  Used by WAITFOR to restart the queue when an action completes\n    //\n    call: function () {this.Process.apply(this,arguments)},\n    wait: function (callback) {return callback}\n  });\n\n  //\n  //  Create a named signal that listeners can attach to, to be signaled by\n  //  postings made to the signal.  Posts are queued if they occur while one\n  //  is already in process.\n  //\n  var SIGNAL = QUEUE.Subclass({\n    Init: function (name) {\n      QUEUE.prototype.Init.call(this);\n      this.name = name;\n      this.posted = [];              // the messages posted so far\n      this.listeners = HOOKS(true);  // those with interest in this signal\n      this.posting = false;\n      this.callback = null;\n    },\n    //\n    // Post a message to the signal listeners, with callback for when complete\n    //\n    Post: function (message,callback,forget) {\n      callback = USING(callback);\n      if (this.posting || this.pending) {\n        this.Push([\"Post\",this,message,callback,forget]);\n      } else {\n        this.callback = callback; callback.reset();\n        if (!forget) {this.posted.push(message)}\n        this.Suspend(); this.posting = true;\n        var result = this.listeners.Execute(message);\n        if (ISCALLBACK(result) && !result.called) {WAITFOR(result,this)}\n        this.Resume(); this.posting = false;\n        if (!this.pending) {this.call()}\n      }\n      return callback;\n    },\n    //\n    //  Clear the post history (so new listeners won't get old messages)\n    //\n    Clear: function (callback) {\n      callback = USING(callback);\n      if (this.posting || this.pending) {\n        callback = this.Push([\"Clear\",this,callback]);\n      } else {\n        this.posted = [];\n        callback();\n      }\n      return callback;\n    },\n    //\n    //  Call the callback (all replies are in) and process the command queue\n    //\n    call: function () {this.callback(this); this.Process()},\n\n    //\n    //  A listener calls this to register interest in the signal (so it will be called\n    //  when posts occur).  If ignorePast is true, it will not be sent the post history.\n    //\n    Interest: function (callback,ignorePast,priority) {\n      callback = USING(callback);\n      this.listeners.Add(callback,priority);\n      if (!ignorePast) {\n        for (var i = 0, m = this.posted.length; i < m; i++) {\n          callback.reset();\n          var result = callback(this.posted[i]);\n          if (ISCALLBACK(result) && i === this.posted.length-1) {WAITFOR(result,this)}\n        }\n      }\n      return callback;\n    },\n    //\n    //  A listener calls this to remove itself from a signal\n    //\n    NoInterest: function (callback) {\n      this.listeners.Remove(callback);\n    },\n\n    //\n    //  Hook a callback to a particular message on this signal\n    //\n    MessageHook: function (msg,callback,priority) {\n      callback = USING(callback);\n      if (!this.hooks) {this.hooks = {}; this.Interest([\"ExecuteHooks\",this])}\n      if (!this.hooks[msg]) {this.hooks[msg] = HOOKS(true)}\n      this.hooks[msg].Add(callback,priority);\n      for (var i = 0, m = this.posted.length; i < m; i++)\n        {if (this.posted[i] == msg) {callback.reset(); callback(this.posted[i])}}\n      callback.msg = msg; // keep track so we can remove it\n      return callback;\n    },\n    //\n    //  Execute the message hooks for the given message\n    //\n    ExecuteHooks: function (msg) {\n      var type = (isArray(msg) ? msg[0] : msg);\n      if (!this.hooks[type]) {return null}\n      return this.hooks[type].Execute(msg);\n    },\n    //\n    //  Remove a hook safely\n    //\n    RemoveHook: function (hook) {\n      this.hooks[hook.msg].Remove(hook);\n    }\n\n  },{\n    signals: {},  // the named signals\n    find: function (name) {\n      if (!SIGNAL.signals[name]) {SIGNAL.signals[name] = new SIGNAL(name)}\n      return SIGNAL.signals[name];\n    }\n  });\n\n  //\n  //  The main entry-points\n  //\n  BASE.Callback = BASE.CallBack = USING;\n  BASE.Callback.Delay = DELAY;\n  BASE.Callback.After = AFTER;\n  BASE.Callback.Queue = QUEUE;\n  BASE.Callback.Signal = SIGNAL.find;\n  BASE.Callback.Hooks = HOOKS;\n  BASE.Callback.ExecuteHooks = EXECUTEHOOKS;\n})(\"MathJax\");\n\n\n/**********************************************************/\n\n(function (BASENAME) {\n  var BASE = window[BASENAME];\n  if (!BASE) {BASE = window[BASENAME] = {}}\n\n  var isSafari2 = (navigator.vendor === \"Apple Computer, Inc.\" &&\n                   typeof navigator.vendorSub === \"undefined\");\n  var sheets = 0; // used by Safari2\n\n  //\n  //  Update sheets count and look up the head object\n  //\n  var HEAD = function (head) {\n    if (document.styleSheets && document.styleSheets.length > sheets)\n      {sheets = document.styleSheets.length}\n    if (!head) {\n      head = document.head || ((document.getElementsByTagName(\"head\"))[0]);\n      if (!head) {head = document.body}\n    }\n    return head;\n  };\n\n  //\n  //  Remove scripts that are completed so they don't clutter up the HEAD.\n  //  This runs via setTimeout since IE7 can't remove the script while it is running.\n  //\n  var SCRIPTS = [];  // stores scripts to be removed after a delay\n  var REMOVESCRIPTS = function () {\n    for (var i = 0, m = SCRIPTS.length; i < m; i++) {BASE.Ajax.head.removeChild(SCRIPTS[i])}\n    SCRIPTS = [];\n  };\n\n  var PATH = {};\n  PATH[BASENAME] = \"\";                                        // empty path gets the root URL\n  PATH.a11y = '[MathJax]/extensions/a11y';                    // a11y extensions\n\n  BASE.Ajax = {\n    loaded: {},         // files already loaded\n    loading: {},        // files currently in process of loading\n    loadHooks: {},      // hooks to call when files are loaded\n    timeout: 15*1000,   // timeout for loading of files (15 seconds)\n    styleDelay: 1,      // delay to use before styles are available\n    config: {\n      root: \"\",         // URL of root directory to load from\n      path: PATH        // paths to named URL's (e.g., [MathJax]/...)\n    },\n    params:  {},        // filled in from MathJax.js?...\n\n    STATUS: {\n      OK: 1,         // file is loading or did load OK\n      ERROR: -1      // file timed out during load\n    },\n\n    //\n    //  Return a complete URL to a file (replacing any root names)\n    //\n    fileURL: function (file) {\n      var match;\n      while ((match = file.match(/^\\[([-._a-z0-9]+)\\]/i)) && PATH.hasOwnProperty(match[1])) {\n        file = (PATH[match[1]]||this.config.root) + file.substr(match[1].length+2);\n      }\n      return file;\n    },\n    //\n    //  Replace root names if URL includes one\n    //\n    fileName: function (url) {\n      var root = this.config.root;\n      if (url.substr(0,root.length) === root) {url = \"[\"+BASENAME+\"]\"+url.substr(root.length)}\n      do {\n        var recheck = false;\n        for (var id in PATH) {if (PATH.hasOwnProperty(id) && PATH[id]) {\n          if (url.substr(0,PATH[id].length) === PATH[id]) {\n            url = \"[\"+id+\"]\"+url.substr(PATH[id].length);\n            recheck = true;\n            break;\n          }\n        }}\n      } while (recheck);\n      return url;\n    },\n    //\n    //  Cache-breaking revision number for file\n    //\n    fileRev: function (file) {\n      var V = BASE.cdnFileVersions[file] || BASE.cdnVersion || '';\n      if (V) {V = \"?V=\"+V}\n      return V;\n    },\n    urlRev: function (file) {return this.fileURL(file)+this.fileRev(file)},\n\n    //\n    //  Load a file if it hasn't been already.\n    //  Make sure the file URL is \"safe\"?\n    //\n    Require: function (file,callback) {\n      callback = BASE.Callback(callback); var type;\n      if (file instanceof Object) {\n        for (var i in file)\n          {if (file.hasOwnProperty(i)) {type = i.toUpperCase(); file = file[i]}}\n      } else {type = file.split(/\\./).pop().toUpperCase()}\n      if (this.params.noContrib && file.substr(0,9) === \"[Contrib]\") {\n        callback(this.STATUS.ERROR);\n      } else {\n        file = this.fileURL(file);\n        // FIXME: check that URL is OK\n        if (this.loaded[file]) {\n          callback(this.loaded[file]);\n        } else {\n          var FILE = {}; FILE[type] = file;\n          this.Load(FILE,callback);\n        }\n      }\n      return callback;\n    },\n\n    //\n    //  Load a file regardless of where it is and whether it has\n    //  already been loaded.\n    //\n    Load: function (file,callback) {\n      callback = BASE.Callback(callback); var type;\n      if (file instanceof Object) {\n        for (var i in file)\n          {if (file.hasOwnProperty(i)) {type = i.toUpperCase(); file = file[i]}}\n      } else {type = file.split(/\\./).pop().toUpperCase()}\n      file = this.fileURL(file);\n      if (this.loading[file]) {\n        this.addHook(file,callback);\n      } else {\n        this.head = HEAD(this.head);\n        if (this.loader[type]) {this.loader[type].call(this,file,callback)}\n          else {throw Error(\"Can't load files of type \"+type)}\n      }\n      return callback;\n    },\n\n    //\n    //  Register a load hook for a particular file (it will be called when\n    //  loadComplete() is called for that file)\n    //\n    LoadHook: function (file,callback,priority) {\n      callback = BASE.Callback(callback);\n      if (file instanceof Object)\n        {for (var i in file) {if (file.hasOwnProperty(i)) {file = file[i]}}}\n      file = this.fileURL(file);\n      if (this.loaded[file]) {callback(this.loaded[file])}\n        else {this.addHook(file,callback,priority)}\n      return callback;\n    },\n    addHook: function (file,callback,priority) {\n      if (!this.loadHooks[file]) {this.loadHooks[file] = MathJax.Callback.Hooks()}\n      this.loadHooks[file].Add(callback,priority);\n      callback.file = file;\n    },\n    removeHook: function (hook) {\n      if (this.loadHooks[hook.file]) {\n        this.loadHooks[hook.file].Remove(hook);\n        if (!this.loadHooks[hook.file].hooks.length) {delete this.loadHooks[hook.file]}\n      }\n    },\n\n    //\n    //  Used when files are combined in a preloading configuration file\n    //\n    Preloading: function () {\n      for (var i = 0, m = arguments.length; i < m; i++) {\n        var file = this.fileURL(arguments[i]);\n        if (!this.loading[file]) {this.loading[file] = {preloaded: true}}\n      }\n    },\n\n    //\n    //  Code used to load the various types of files\n    //  (JS for JavaScript, CSS for style sheets)\n    //\n    loader: {\n      //\n      //  Create a SCRIPT tag to load the file\n      //\n      JS: function (file,callback) {\n        var name = this.fileName(file);\n        var script = document.createElement(\"script\");\n        var timeout = BASE.Callback([\"loadTimeout\",this,file]);\n        this.loading[file] = {\n          callback: callback,\n          timeout: setTimeout(timeout,this.timeout),\n          status: this.STATUS.OK,\n          script: script\n        };\n        //\n        // Add this to the structure above after it is created to prevent recursion\n        //  when loading the initial localization file (before loading message is available)\n        //\n        this.loading[file].message = BASE.Message.File(name);\n        script.onerror = timeout;  // doesn't work in IE and no apparent substitute\n        script.type = \"text/javascript\";\n        script.src = file+this.fileRev(name);\n        this.head.appendChild(script);\n      },\n      //\n      //  Create a LINK tag to load the style sheet\n      //\n      CSS: function (file,callback) {\n        var name = this.fileName(file);\n        var link = document.createElement(\"link\");\n        link.rel = \"stylesheet\"; link.type = \"text/css\";\n        link.href = file+this.fileRev(name);\n        this.loading[file] = {\n          callback: callback,\n          message: BASE.Message.File(name),\n          status: this.STATUS.OK\n        };\n        this.head.appendChild(link);\n        this.timer.create.call(this,[this.timer.file,file],link);\n      }\n    },\n\n    //\n    //  Timing code for checking when style sheets are available.\n    //\n    timer: {\n      //\n      //  Create the timing callback and start the timing loop.\n      //  We use a delay because some browsers need it to allow the styles\n      //  to be processed.\n      //\n      create: function (callback,node) {\n        callback = BASE.Callback(callback);\n        if (node.nodeName === \"STYLE\" && node.styleSheet &&\n            typeof(node.styleSheet.cssText) !== 'undefined') {\n          callback(this.STATUS.OK); // MSIE processes style immediately, but doesn't set its styleSheet!\n        } else if (window.chrome && node.nodeName === \"LINK\") {\n          callback(this.STATUS.OK); // Chrome doesn't give access to cssRules for stylesheet in\n                                    //   a link node, so we can't detect when it is loaded.\n        } else if (isSafari2) {\n          this.timer.start(this,[this.timer.checkSafari2,sheets++,callback],this.styleDelay);\n        } else {\n          this.timer.start(this,[this.timer.checkLength,node,callback],this.styleDelay);\n        }\n        return callback;\n      },\n      //\n      //  Start the timer for the given callback checker\n      //\n      start: function (AJAX,check,delay,timeout) {\n        check = BASE.Callback(check);\n        check.execute = this.execute; check.time = this.time;\n        check.STATUS = AJAX.STATUS; check.timeout = timeout || AJAX.timeout;\n        check.delay = check.total = delay || 0;\n        if (delay) {setTimeout(check,delay)} else {check()}\n      },\n      //\n      //  Increment the time total, increase the delay\n      //  and test if we are past the timeout time.\n      //\n      time: function (callback) {\n        this.total += this.delay;\n        this.delay = Math.floor(this.delay * 1.05 + 5);\n        if (this.total >= this.timeout) {callback(this.STATUS.ERROR); return 1}\n        return 0;\n      },\n      //\n      //  For JS file loads, call the proper routine according to status\n      //\n      file: function (file,status) {\n        if (status < 0) {BASE.Ajax.loadTimeout(file)} else {BASE.Ajax.loadComplete(file)}\n      },\n      //\n      //  Call the hook with the required data\n      //\n      execute: function () {this.hook.call(this.object,this,this.data[0],this.data[1])},\n      //\n      //  Safari2 doesn't set the link's stylesheet, so we need to look in the\n      //  document.styleSheets array for the new sheet when it is created\n      //\n      checkSafari2: function (check,length,callback) {\n        if (check.time(callback)) return;\n        if (document.styleSheets.length > length &&\n            document.styleSheets[length].cssRules &&\n            document.styleSheets[length].cssRules.length)\n          {callback(check.STATUS.OK)} else {setTimeout(check,check.delay)}\n      },\n      //\n      //  Look for the stylesheets rules and check when they are defined\n      //  and no longer of length zero.  (This assumes there actually ARE\n      //  some rules in the stylesheet.)\n      //\n      checkLength: function (check,node,callback) {\n        if (check.time(callback)) return;\n        var isStyle = 0; var sheet = (node.sheet || node.styleSheet);\n        try {if ((sheet.cssRules||sheet.rules||[]).length > 0) {isStyle = 1}} catch(err) {\n          if (err.message.match(/protected variable|restricted URI/)) {isStyle = 1}\n          else if (err.message.match(/Security error/)) {\n            // Firefox3 gives \"Security error\" for missing files, so\n            //   can't distinguish that from OK files on remote servers.\n            //   or OK files in different directory from local files.\n            isStyle = 1; // just say it is OK (can't really tell)\n          }\n        }\n        if (isStyle) {\n          // Opera 9.6 requires this setTimeout\n          setTimeout(BASE.Callback([callback,check.STATUS.OK]),0);\n        } else {\n          setTimeout(check,check.delay);\n        }\n      }\n    },\n\n    //\n    //  JavaScript code must call this when they are completely initialized\n    //  (this allows them to perform asynchronous actions before indicating\n    //  that they are complete).\n    //\n    loadComplete: function (file) {\n      file = this.fileURL(file);\n      var loading = this.loading[file];\n      if (loading && !loading.preloaded) {\n        BASE.Message.Clear(loading.message);\n        clearTimeout(loading.timeout);\n\tif (loading.script) {\n\t  if (SCRIPTS.length === 0) {setTimeout(REMOVESCRIPTS,0)}\n\t  SCRIPTS.push(loading.script);\n\t}\n        this.loaded[file] = loading.status; delete this.loading[file];\n        this.addHook(file,loading.callback);\n      } else {\n        if (loading) {delete this.loading[file]}\n        this.loaded[file] = this.STATUS.OK;\n        loading = {status: this.STATUS.OK}\n      }\n      if (!this.loadHooks[file]) {return null}\n      return this.loadHooks[file].Execute(loading.status);\n    },\n\n    //\n    //  If a file fails to load within the timeout period (or the onerror handler\n    //  is called), this routine runs to signal the error condition.\n    //\n    loadTimeout: function (file) {\n      if (this.loading[file].timeout) {clearTimeout(this.loading[file].timeout)}\n      this.loading[file].status = this.STATUS.ERROR;\n      this.loadError(file);\n      this.loadComplete(file);\n    },\n\n    //\n    //  The default error hook for file load failures\n    //\n    loadError: function (file) {\n      BASE.Message.Set([\"LoadFailed\",\"File failed to load: %1\",file],null,2000);\n      BASE.Hub.signal.Post([\"file load error\",file]);\n    },\n\n    //\n    //  Defines a style sheet from a hash of style declarations (key:value pairs\n    //  where the key is the style selector and the value is a hash of CSS attributes\n    //  and values).\n    //\n    Styles: function (styles,callback) {\n      var styleString = this.StyleString(styles);\n      if (styleString === \"\") {\n        callback = BASE.Callback(callback);\n        callback();\n      } else {\n        var style = document.createElement(\"style\"); style.type = \"text/css\";\n        this.head = HEAD(this.head);\n        this.head.appendChild(style);\n        if (style.styleSheet && typeof(style.styleSheet.cssText) !== 'undefined') {\n          style.styleSheet.cssText = styleString;\n        } else {\n          style.appendChild(document.createTextNode(styleString));\n        }\n        callback = this.timer.create.call(this,callback,style);\n      }\n      return callback;\n    },\n\n    //\n    //  Create a stylesheet string from a style declaration object\n    //\n    StyleString: function (styles) {\n      if (typeof(styles) === 'string') {return styles}\n      var string = \"\", id, style;\n      for (id in styles) {if (styles.hasOwnProperty(id)) {\n        if (typeof styles[id] === 'string') {\n          string += id + \" {\"+styles[id]+\"}\\n\";\n        } else if (BASE.Object.isArray(styles[id])) {\n          for (var i = 0; i < styles[id].length; i++) {\n            style = {}; style[id] = styles[id][i];\n            string += this.StyleString(style);\n          }\n        } else if (id.substr(0,6) === '@media') {\n          string += id + \" {\"+this.StyleString(styles[id])+\"}\\n\";\n        } else if (styles[id] != null) {\n          style = [];\n          for (var name in styles[id]) {if (styles[id].hasOwnProperty(name)) {\n            if (styles[id][name] != null)\n              {style[style.length] = name + ': ' + styles[id][name]}\n          }}\n          string += id +\" {\"+style.join('; ')+\"}\\n\";\n        }\n      }}\n      return string;\n    }\n  };\n\n})(\"MathJax\");\n\n/**********************************************************/\n\nMathJax.HTML = {\n  //\n  //  Create an HTML element with given attributes and content.\n  //  The def parameter is an (optional) object containing key:value pairs\n  //  of the attributes and their values, and contents is an (optional)\n  //  array of strings to be inserted as text, or arrays of the form\n  //  [type,def,contents] that describes an HTML element to be inserted\n  //  into the current element.  Thus the contents can describe a complete\n  //  HTML snippet of arbitrary complexity.  E.g.:\n  //\n  //    MathJax.HTML.Element(\"span\",{id:\"mySpan\",style{\"font-style\":\"italic\"}},[\n  //        \"(See the \",[\"a\",{href:\"http://www.mathjax.org\"},[\"MathJax home page\"]],\n  //        \" for more details.)\"]);\n  //\n  Element: function (type,def,contents) {\n    var obj = document.createElement(type), id;\n    if (def) {\n      if (def.hasOwnProperty(\"style\")) {\n        var style = def.style; def.style = {};\n        for (id in style) {if (style.hasOwnProperty(id))\n          {def.style[id.replace(/-([a-z])/g,this.ucMatch)] = style[id]}}\n      }\n      MathJax.Hub.Insert(obj,def);\n      for (id in def) {\n        if (id === \"role\" || id.substr(0,5) === \"aria-\") obj.setAttribute(id,def[id]);\n      }\n    }\n    if (contents) {\n      if (!MathJax.Object.isArray(contents)) {contents = [contents]}\n      for (var i = 0, m = contents.length; i < m; i++) {\n        if (MathJax.Object.isArray(contents[i])) {\n          obj.appendChild(this.Element(contents[i][0],contents[i][1],contents[i][2]));\n        } else if (type === \"script\") { // IE throws an error if script is added as a text node\n          this.setScript(obj, contents[i]);\n        } else {\n          obj.appendChild(document.createTextNode(contents[i]));\n        }\n      }\n    }\n    return obj;\n  },\n  ucMatch: function (match,c) {return c.toUpperCase()},\n  addElement: function (span,type,def,contents) {return span.appendChild(this.Element(type,def,contents))},\n  TextNode: function (text) {return document.createTextNode(text)},\n  addText: function (span,text) {return span.appendChild(this.TextNode(text))},\n\n  //\n  //  Set and get the text of a script\n  //\n  setScript: function (script,text) {\n    if (this.setScriptBug) {script.text = text} else {\n      while (script.firstChild) {script.removeChild(script.firstChild)}\n      this.addText(script,text);\n    }\n  },\n  getScript: function (script) {\n    var text = (script.text === \"\" ? script.innerHTML : script.text);\n    return text.replace(/^\\s+/,\"\").replace(/\\s+$/,\"\");\n  },\n\n  //\n  //  Manage cookies\n  //\n  Cookie: {\n    prefix: \"mjx\",\n    expires: 365,\n\n    //\n    //  Save an object as a named cookie\n    //\n    Set: function (name,def) {\n      var keys = [];\n      if (def) {\n        for (var id in def) {if (def.hasOwnProperty(id)) {\n          keys.push(id+\":\"+def[id].toString().replace(/&/g,\"&&\"));\n        }}\n      }\n      var cookie = this.prefix+\".\"+name+\"=\"+escape(keys.join('&;'));\n      if (this.expires) {\n        var time = new Date(); time.setDate(time.getDate() + this.expires);\n        cookie += '; expires='+time.toGMTString();\n      }\n      try {document.cookie = cookie+\"; path=/\"} catch (err) {} // ignore errors saving cookies\n    },\n\n    //\n    //  Get the contents of a named cookie and incorporate\n    //  it into the given object (or return a fresh one)\n    //\n    Get: function (name,obj) {\n      if (!obj) {obj = {}}\n      var pattern = new RegExp(\"(?:^|;\\\\s*)\"+this.prefix+\"\\\\.\"+name+\"=([^;]*)(?:;|$)\");\n      var match;\n      try {match = pattern.exec(document.cookie)} catch (err) {}; // ignore errors reading cookies\n      if (match && match[1] !== \"\") {\n        var keys = unescape(match[1]).split('&;');\n        for (var i = 0, m = keys.length; i < m; i++) {\n          match = keys[i].match(/([^:]+):(.*)/);\n          var value = match[2].replace(/&&/g,'&');\n          if (value === \"true\") {value = true} else if (value === \"false\") {value = false}\n            else if (value.match(/^-?(\\d+(\\.\\d+)?|\\.\\d+)$/)) {value = parseFloat(value)}\n          obj[match[1]] = value;\n        }\n      }\n      return obj;\n    }\n  }\n\n};\n\n\n/**********************************************************/\n\nMathJax.Localization = {\n\n  locale: \"en\",\n  directory: \"[MathJax]/localization\",\n  strings: {\n    // Currently, this list is not modified by the MathJax-i18n script. You can\n    // run the following command in MathJax/unpacked/localization to update it:\n    //\n    // find . -name \"*.js\" | xargs grep menuTitle\\: | grep -v qqq | sed 's/^\\.\\/\\(.*\\)\\/.*\\.js\\:  /    \"\\1\"\\: \\{/' | sed 's/,$/\\},/' | sed 's/\"English\"/\"English\", isLoaded: true/' > tmp ; sort tmp > tmp2 ; sed '$ s/,$//' tmp2 ; rm tmp*\n    //\n    // This only takes languages with localization data so you must also add\n    // the languages that use a remap but are not translated at all.\n    //\n    \"ar\": {menuTitle: \"\\u0627\\u0644\\u0639\\u0631\\u0628\\u064A\\u0629\"},\n    \"ast\": {menuTitle: \"asturianu\"},\n    \"bg\": {menuTitle: \"\\u0431\\u044A\\u043B\\u0433\\u0430\\u0440\\u0441\\u043A\\u0438\"},\n    \"bcc\": {menuTitle: \"\\u0628\\u0644\\u0648\\u0686\\u06CC\"},\n    \"br\": {menuTitle: \"brezhoneg\"},\n    \"ca\": {menuTitle: \"catal\\u00E0\"},\n    \"cdo\": {menuTitle: \"M\\u00ECng-d\\u0115\\u0324ng-ng\\u1E73\\u0304\"},\n    \"cs\": {menuTitle: \"\\u010De\\u0161tina\"},\n    \"da\": {menuTitle: \"dansk\"},\n    \"de\": {menuTitle: \"Deutsch\"},\n    \"diq\": {menuTitle: \"Zazaki\"},\n    \"en\": {menuTitle: \"English\", isLoaded: true},\n    \"eo\": {menuTitle: \"Esperanto\"},\n    \"es\": {menuTitle: \"espa\\u00F1ol\"},\n    \"fa\": {menuTitle: \"\\u0641\\u0627\\u0631\\u0633\\u06CC\"},\n    \"fi\": {menuTitle: \"suomi\"},\n    \"fr\": {menuTitle: \"fran\\u00E7ais\"},\n    \"gl\": {menuTitle: \"galego\"},\n    \"he\": {menuTitle: \"\\u05E2\\u05D1\\u05E8\\u05D9\\u05EA\"},\n    \"ia\": {menuTitle: \"interlingua\"},\n    \"it\": {menuTitle: \"italiano\"},\n    \"ja\": {menuTitle: \"\\u65E5\\u672C\\u8A9E\"},\n    \"kn\": {menuTitle: \"\\u0C95\\u0CA8\\u0CCD\\u0CA8\\u0CA1\"},\n    \"ko\": {menuTitle: \"\\uD55C\\uAD6D\\uC5B4\"},\n    \"lb\": {menuTitle: \"L\\u00EBtzebuergesch\"},\n    \"lki\": {menuTitle: \"\\u0644\\u06D5\\u06A9\\u06CC\"},\n    \"lt\": {menuTitle: \"lietuvi\\u0173\"},\n    \"mk\": {menuTitle: \"\\u043C\\u0430\\u043A\\u0435\\u0434\\u043E\\u043D\\u0441\\u043A\\u0438\"},\n    \"nl\": {menuTitle: \"Nederlands\"},\n    \"oc\": {menuTitle: \"occitan\"},\n    \"pl\": {menuTitle: \"polski\"},\n    \"pt\": {menuTitle: \"portugu\\u00EAs\"},\n    \"pt-br\": {menuTitle: \"portugu\\u00EAs do Brasil\"},\n    \"ru\": {menuTitle: \"\\u0440\\u0443\\u0441\\u0441\\u043A\\u0438\\u0439\"},\n    \"sco\": {menuTitle: \"Scots\"},\n    \"scn\": {menuTitle: \"sicilianu\"},\n    \"sk\": {menuTitle: \"sloven\\u010Dina\"},\n    \"sl\": {menuTitle: \"sloven\\u0161\\u010Dina\"},\n    \"sv\": {menuTitle: \"svenska\"},\n    \"th\": {menuTitle: \"\\u0E44\\u0E17\\u0E22\"},\n    \"tr\": {menuTitle: \"T\\u00FCrk\\u00E7e\"},\n    \"uk\": {menuTitle: \"\\u0443\\u043A\\u0440\\u0430\\u0457\\u043D\\u0441\\u044C\\u043A\\u0430\"},\n    \"vi\": {menuTitle: \"Ti\\u1EBFng Vi\\u1EC7t\"},\n    \"zh-hans\": {menuTitle: \"\\u4E2D\\u6587\\uFF08\\u7B80\\u4F53\\uFF09\"},\n    \"zh-hant\": {menuTitle: \"\\u6C49\\u8BED\"}\n  },\n\n  //\n  //  The pattern for substitution escapes:\n  //      %n or %{n} or %{plural:%n|option1|option1|...} or %c\n  //\n  pattern: /%(\\d+|\\{\\d+\\}|\\{[a-z]+:\\%\\d+(?:\\|(?:%\\{\\d+\\}|%.|[^\\}])*)+\\}|.)/g,\n\n  SPLIT: (\"axb\".split(/(x)/).length === 3 ?\n    function (string,regex) {return string.split(regex)} :\n    //\n    //  IE8 and below don't do split() correctly when the pattern includes\n    //    parentheses (the split should include the matched exrepssions).\n    //    So implement it by hand here.\n    //\n    function (string,regex) {\n      var result = [], match, last = 0;\n      regex.lastIndex = 0;\n      while ((match = regex.exec(string))) {\n        result.push(string.substr(last,match.index-last));\n        result.push.apply(result,match.slice(1));\n        last = match.index + match[0].length;\n      }\n      result.push(string.substr(last));\n      return result;\n    }),\n\n  _: function (id,phrase) {\n    if (MathJax.Object.isArray(phrase)) {return this.processSnippet(id,phrase)}\n    return this.processString(this.lookupPhrase(id,phrase),[].slice.call(arguments,2));\n  },\n\n  processString: function (string,args,domain) {\n    //\n    //  Process arguments for substitution\n    //    If the argument is a snippet (and we are processing snippets) do so,\n    //    Otherwise, if it is a number, convert it for the lacale\n    //\n    var i, m, isArray = MathJax.Object.isArray;\n    for (i = 0, m = args.length; i < m; i++) {\n      if (domain && isArray(args[i])) {args[i] = this.processSnippet(domain,args[i])}\n    }\n    //\n    //  Split string at escapes and process them individually\n    //\n    var parts = this.SPLIT(string,this.pattern);\n    for (i = 1, m = parts.length; i < m; i += 2) {\n      var c = parts[i].charAt(0);  // first char will be { or \\d or a char to be kept literally\n      if (c >= \"0\" && c <= \"9\") {    // %n\n        parts[i] = args[parts[i]-1];\n        if (typeof parts[i] === \"number\") parts[i] = this.number(parts[i]);\n      } else if (c === \"{\") {        // %{n} or %{plural:%n|...}\n        c = parts[i].substr(1);\n        if (c >= \"0\" && c <= \"9\") {  // %{n}\n          parts[i] = args[parts[i].substr(1,parts[i].length-2)-1];\n          if (typeof parts[i] === \"number\") parts[i] = this.number(parts[i]);\n        } else {                     // %{plural:%n|...}\n          var match = parts[i].match(/^\\{([a-z]+):%(\\d+)\\|(.*)\\}$/);\n          if (match) {\n            if (match[1] === \"plural\") {\n              var n = args[match[2]-1];\n              if (typeof n === \"undefined\") {\n                parts[i] = \"???\";        // argument doesn't exist\n              } else {\n                n = this.plural(n) - 1;  // index of the form to use\n                var plurals = match[3].replace(/(^|[^%])(%%)*%\\|/g,\"$1$2%\\uEFEF\").split(/\\|/); // the parts (replacing %| with a special character)\n                if (n >= 0 && n < plurals.length) {\n                  parts[i] = this.processString(plurals[n].replace(/\\uEFEF/g,\"|\"),args,domain);\n                } else {\n                  parts[i] = \"???\";      // no string for this index\n                }\n              }\n            } else {parts[i] = \"%\"+parts[i]}  // not \"plural\", put back the % and leave unchanged\n          }\n        }\n      }\n      if (parts[i] == null) {parts[i] = \"???\"}\n    }\n    //\n    //  If we are not forming a snippet, return the completed string\n    //\n    if (!domain) {return parts.join(\"\")}\n    //\n    //  We need to return an HTML snippet, so buld it from the\n    //  broken up string with inserted parts (that could be snippets)\n    //\n    var snippet = [], part = \"\";\n    for (i = 0; i < m; i++) {\n      part += parts[i]; i++;  // add the string and move on to substitution result\n      if (i < m) {\n        if (isArray(parts[i]))  {                // substitution was a snippet\n          snippet.push(part);                        // add the accumulated string\n          snippet = snippet.concat(parts[i]);        // concatenate the substution snippet\n          part = \"\";                                 // start accumulating a new string\n        } else {                                 // substitution was a string\n          part += parts[i];                          // add to accumulating string\n        }\n      }\n    }\n    if (part !== \"\") {snippet.push(part)} // add final string\n    return snippet;\n  },\n\n  processSnippet: function (domain,snippet) {\n    var result = [];   // the new snippet\n    //\n    //  Look through the original snippet for\n    //   strings or snippets to translate\n    //\n    for (var i = 0, m = snippet.length; i < m; i++) {\n      if (MathJax.Object.isArray(snippet[i])) {\n        //\n        //  This could be a sub-snippet:\n        //    [\"tag\"] or [\"tag\",{properties}] or [\"tag\",{properties},snippet]\n        //  Or it could be something to translate:\n        //    [id,string,args] or [domain,snippet]\n        var data = snippet[i];\n        if (typeof data[1] === \"string\") {        // [id,string,args]\n          var id = data[0]; if (!MathJax.Object.isArray(id)) {id = [domain,id]}\n          var phrase = this.lookupPhrase(id,data[1]);\n          result = result.concat(this.processMarkdown(phrase,data.slice(2),domain));\n        } else if (MathJax.Object.isArray(data[1])) {    // [domain,snippet]\n          result = result.concat(this.processSnippet.apply(this,data));\n        } else if (data.length >= 3) {            // [\"tag\",{properties},snippet]\n          result.push([data[0],data[1],this.processSnippet(domain,data[2])]);\n        } else {                                  // [\"tag\"] or [\"tag\",{properties}]\n          result.push(snippet[i]);\n        }\n      } else {                                    // a string\n        result.push(snippet[i]);\n      }\n    }\n    return result;\n  },\n\n  markdownPattern: /(%.)|(\\*{1,3})((?:%.|.)+?)\\2|(`+)((?:%.|.)+?)\\4|\\[((?:%.|.)+?)\\]\\(([^\\s\\)]+)\\)/,\n  //   %c or *bold*, **italics**, ***bold-italics***, or `code`, or [link](url)\n\n  processMarkdown: function (phrase,args,domain) {\n    var result = [], data;\n    //\n    //  Split the string by the Markdown pattern\n    //    (the text blocks are separated by\n    //      c,stars,star-text,backtics,code-text,link-text,URL).\n    //  Start with the first text string from the split.\n    //\n    var parts = phrase.split(this.markdownPattern);\n    var string = parts[0];\n    //\n    //  Loop through the matches and process them\n    //\n    for (var i = 1, m = parts.length; i < m; i += 8) {\n      if (parts[i+1]) {        // stars (for bold/italic)\n        //\n        //  Select the tag to use by number of stars (three stars requires two tags)\n        //\n        data = this.processString(parts[i+2],args,domain);\n        if (!MathJax.Object.isArray(data)) {data = [data]}\n        data = [[\"b\",\"i\",\"i\"][parts[i+1].length-1],{},data]; // number of stars determines type\n        if (parts[i+1].length === 3) {data = [\"b\",{},data]}  // bold-italic\n      } else if (parts[i+3]) { //  backtics (for code)\n        //\n        //  Remove one leading or trailing space, and process substitutions\n        //  Make a <code> tag\n        //\n        data = this.processString(parts[i+4].replace(/^\\s/,\"\").replace(/\\s$/,\"\"),args,domain);\n        if (!MathJax.Object.isArray(data)) {data = [data]}\n        data = [\"code\",{},data];\n      } else if (parts[i+5]) { //  hyperlink\n        //\n        //  Process the link text, and make an <a> tag with the URL\n        //\n        data = this.processString(parts[i+5],args,domain);\n        if (!MathJax.Object.isArray(data)) {data = [data]}\n        data = [\"a\",{href:this.processString(parts[i+6],args),target:\"_blank\"},data];\n      } else {\n        //\n        //  Escaped character (%c) gets added into the string.\n        //\n        string += parts[i]; data = null;\n      }\n      //\n      //  If there is a tag to insert,\n      //     Add any pending string, then push the tag\n      //\n      if (data) {\n        result = this.concatString(result,string,args,domain);\n        result.push(data); string = \"\";\n      }\n      //\n      //  Process the string that follows matches pattern\n      //\n      if (parts[i+7] !== \"\") {string += parts[i+7]}\n    };\n    //\n    //  Add any pending string and return the resulting snippet\n    //\n    result = this.concatString(result,string,args,domain);\n    return result;\n  },\n  concatString: function (result,string,args,domain) {\n    if (string != \"\") {\n      //\n      //  Process the substutions.\n      //  If the result is not a snippet, turn it into one.\n      //  Then concatenate the snippet to the current one\n      //\n      string = this.processString(string,args,domain);\n      if (!MathJax.Object.isArray(string)) {string = [string]}\n      result = result.concat(string);\n    }\n    return result;\n  },\n\n  lookupPhrase: function (id,phrase,domain) {\n    //\n    //  Get the domain and messageID\n    //\n    if (!domain) {domain = \"_\"}\n    if (MathJax.Object.isArray(id)) {domain = (id[0] || \"_\"); id = (id[1] || \"\")}\n    //\n    //  Check if the data is available and if not,\n    //    load it and throw a restart error so the calling\n    //    code can wait for the load and try again.\n    //\n    var load = this.loadDomain(domain);\n    if (load) {MathJax.Hub.RestartAfter(load)}\n    //\n    //  Look up the message in the localization data\n    //    (if not found, the original English is used)\n    //\n    var localeData = this.strings[this.locale];\n    if (localeData) {\n      if (localeData.domains && domain in localeData.domains) {\n        var domainData = localeData.domains[domain];\n        if (domainData.strings && id in domainData.strings)\n          {phrase = domainData.strings[id]}\n      }\n    }\n    //\n    //  return the translated phrase\n    //\n    return phrase;\n  },\n\n  //\n  //  Load a langauge data file from the proper\n  //  directory and file.\n  //\n  loadFile: function (file,data,callback) {\n    callback = MathJax.Callback(callback);\n    file = (data.file || file);  // the data's file name or the default name\n    if (!file.match(/\\.js$/)) {file += \".js\"} // add .js if needed\n    //\n    //  Add the directory if the file doesn't\n    //  contain a full URL already.\n    //\n    if (!file.match(/^([a-z]+:|\\[MathJax\\])/)) {\n      var dir = (this.strings[this.locale].directory  ||\n                 this.directory + \"/\" + this.locale ||\n                 \"[MathJax]/localization/\" + this.locale);\n      file = dir + \"/\" + file;\n    }\n    //\n    //  Load the file and mark the data as loaded (even if it\n    //  failed to load, so we don't continue to try to load it\n    //  over and over).\n    //\n    var load = MathJax.Ajax.Require(file,function () {data.isLoaded = true; return callback()});\n    //\n    //  Return the callback if needed, otherwise null.\n    //\n    return (load.called ? null : load);\n  },\n\n  //\n  //  Check to see if the localization data are loaded\n  //  for the given domain; if not, load the data file,\n  //  and return a callback for the loading operation.\n  //  Otherwise return null (data are loaded).\n  //\n  loadDomain: function (domain,callback) {\n    var load, localeData = this.strings[this.locale];\n    if (localeData) {\n      if (!localeData.isLoaded) {\n        load = this.loadFile(this.locale,localeData);\n        if (load) {\n          return MathJax.Callback.Queue(\n            load,[\"loadDomain\",this,domain] // call again to load domain\n          ).Push(callback||{});\n        }\n      }\n      if (localeData.domains && domain in localeData.domains) {\n        var domainData = localeData.domains[domain];\n        if (!domainData.isLoaded) {\n          load = this.loadFile(domain,domainData);\n          if (load) {return MathJax.Callback.Queue(load).Push(callback)}\n        }\n      }\n    }\n    // localization data are loaded, so just do the callback\n    return MathJax.Callback(callback)();\n  },\n\n  //\n  //  Perform a function, properly handling\n  //  restarts due to localization file loads.\n  //\n  //  Note that this may return before the function\n  //  has been called successfully, so you should\n  //  consider fn as running asynchronously.  (Callbacks\n  //  can be used to synchronize it with other actions.)\n  //\n  Try: function (fn) {\n    fn = MathJax.Callback(fn); fn.autoReset = true;\n    try {fn()} catch (err) {\n      if (!err.restart) {throw err}\n      MathJax.Callback.After([\"Try\",this,fn],err.restart);\n    }\n  },\n\n  //\n  //  Reset the current language\n  //\n  resetLocale: function(locale) {\n    // Selection algorithm:\n    // 1) Downcase locale name (e.g. \"en-US\" => \"en-us\")\n    // 2) Try a parent language (e.g. \"en-us\" => \"en\")\n    // 3) Try the fallback specified in the data (e.g. \"pt\" => \"pt-br\")\n    // 4) Otherwise don't change the locale.\n    if (!locale) return;\n    locale = locale.toLowerCase();\n    while (!this.strings[locale]) {\n      var dashPos = locale.lastIndexOf(\"-\");\n      if (dashPos === -1) return;\n      locale = locale.substring(0, dashPos);\n    }\n    var remap = this.strings[locale].remap;\n    this.locale = remap ? remap : locale;\n    MathJax.Callback.Signal(\"Hub\").Post([\"Locale Reset\", this.locale]);\n  },\n\n  //\n  //  Set the current language\n  //\n  setLocale: function(locale) {\n    this.resetLocale(locale);\n    if (MathJax.Menu) {this.loadDomain(\"MathMenu\")}\n  },\n\n  //\n  //  Add or update a language or domain\n  //\n  addTranslation: function (locale,domain,definition) {\n    var data = this.strings[locale], isNew = false;\n    if (!data) {data = this.strings[locale] = {}; isNew = true}\n    if (!data.domains) {data.domains = {}}\n    if (domain) {\n      if (!data.domains[domain]) {data.domains[domain] = {}}\n      data = data.domains[domain];\n    }\n    MathJax.Hub.Insert(data,definition);\n    if (isNew && MathJax.Menu.menu) {MathJax.Menu.CreateLocaleMenu()}\n  },\n\n  //\n  //  Set CSS for an element based on font requirements\n  //\n  setCSS: function (div) {\n    var locale = this.strings[this.locale];\n    if (locale) {\n      if (locale.fontFamily) {div.style.fontFamily = locale.fontFamily}\n      if (locale.fontDirection) {\n        div.style.direction = locale.fontDirection;\n        if (locale.fontDirection === \"rtl\") {div.style.textAlign = \"right\"}\n      }\n    }\n    return div;\n  },\n\n  //\n  //  Get the language's font family or direction\n  //\n  fontFamily: function () {\n    var locale = this.strings[this.locale];\n    return (locale ? locale.fontFamily : null);\n  },\n  fontDirection: function () {\n    var locale = this.strings[this.locale];\n    return (locale ? locale.fontDirection : null);\n  },\n\n  //\n  //  Get the language's plural index for a number\n  //\n  plural: function (n) {\n    var locale = this.strings[this.locale];\n    if (locale && locale.plural) {return locale.plural(n)}\n    // default\n    if (n == 1) {return 1} // one\n    return 2; // other\n  },\n\n  //\n  //  Convert a number to language-specific form\n  //\n  number: function(n) {\n    var locale = this.strings[this.locale];\n    if (locale && locale.number) {return locale.number(n)}\n    // default\n    return n;\n  }\n};\n\n\n/**********************************************************/\n\nMathJax.Message = {\n  ready: false,  // used to tell when the styles are available\n  log: [{}], current: null,\n  textNodeBug: (navigator.vendor === \"Apple Computer, Inc.\" &&\n                typeof navigator.vendorSub === \"undefined\") ||\n               (window.hasOwnProperty && window.hasOwnProperty(\"konqueror\")), // Konqueror displays some gibberish with text.nodeValue = \"...\"\n\n  styles: {\n    \"#MathJax_Message\": {\n      position: \"fixed\", left: \"1px\", bottom: \"2px\",\n      'background-color': \"#E6E6E6\",  border: \"1px solid #959595\",\n      margin: \"0px\", padding: \"2px 8px\",\n      'z-index': \"102\", color: \"black\", 'font-size': \"80%\",\n      width: \"auto\", 'white-space': \"nowrap\"\n    },\n\n    \"#MathJax_MSIE_Frame\": {\n      position: \"absolute\",\n      top:0, left: 0, width: \"0px\", 'z-index': 101,\n      border: \"0px\", margin: \"0px\", padding: \"0px\"\n    }\n  },\n\n  browsers: {\n    MSIE: function (browser) {\n      MathJax.Message.msieFixedPositionBug = ((document.documentMode||0) < 7);\n      if (MathJax.Message.msieFixedPositionBug)\n        {MathJax.Hub.config.styles[\"#MathJax_Message\"].position = \"absolute\"}\n      MathJax.Message.quirks = (document.compatMode === \"BackCompat\");\n    },\n    Chrome: function (browser) {\n      MathJax.Hub.config.styles[\"#MathJax_Message\"].bottom = \"1.5em\";\n      MathJax.Hub.config.styles[\"#MathJax_Message\"].left = \"1em\";\n    }\n  },\n\n  Init: function (styles) {\n    if (styles) {this.ready = true}\n    if (!document.body || !this.ready) {return false}\n    //\n    //  ASCIIMathML replaces the entire page with a copy of itself (@#!#%@!!)\n    //  so check that this.div is still part of the page, otherwise look up\n    //  the copy and use that.\n    //\n    if (this.div && this.div.parentNode == null) {\n      this.div = document.getElementById(\"MathJax_Message\");\n      this.text = (this.div ? this.div.firstChild : null);\n    }\n    if (!this.div) {\n      var frame = document.body;\n      if (this.msieFixedPositionBug && window.attachEvent) {\n        frame = this.frame = this.addDiv(document.body); frame.removeAttribute(\"id\");\n        frame.style.position = \"absolute\";\n        frame.style.border = frame.style.margin = frame.style.padding = \"0px\";\n        frame.style.zIndex = \"101\"; frame.style.height = \"0px\";\n        frame = this.addDiv(frame);\n        frame.id = \"MathJax_MSIE_Frame\";\n        window.attachEvent(\"onscroll\",this.MoveFrame);\n        window.attachEvent(\"onresize\",this.MoveFrame);\n        this.MoveFrame();\n      }\n      this.div = this.addDiv(frame); this.div.style.display = \"none\";\n    }\n    if (!this.text) {\n      this.text = this.div.appendChild(document.createTextNode(\"\"));\n    }\n    return true;\n  },\n\n  addDiv: function (parent) {\n    var div = document.createElement(\"div\");\n    div.id = \"MathJax_Message\";\n    if (parent.firstChild) {parent.insertBefore(div,parent.firstChild)}\n      else {parent.appendChild(div)}\n    return div;\n  },\n\n  MoveFrame: function () {\n    var body = (MathJax.Message.quirks ? document.body : document.documentElement);\n    var frame = MathJax.Message.frame;\n    frame.style.left = body.scrollLeft + 'px';\n    frame.style.top = body.scrollTop + 'px';\n    frame.style.width = body.clientWidth + 'px';\n    frame = frame.firstChild;\n    frame.style.height = body.clientHeight + 'px';\n  },\n\n  localize: function (message) {\n    return MathJax.Localization._(message,message);\n  },\n\n  filterText: function (text,n,id) {\n    if (MathJax.Hub.config.messageStyle === \"simple\") {\n      if (id === \"LoadFile\") {\n        if (!this.loading) {this.loading = this.localize(\"Loading\") + \" \"}\n        text = this.loading; this.loading += \".\";\n      } else if (id === \"ProcessMath\") {\n        if (!this.processing) {this.processing = this.localize(\"Processing\") + \" \"}\n        text = this.processing; this.processing += \".\";\n      } else if (id === \"TypesetMath\") {\n        if (!this.typesetting) {this.typesetting = this.localize(\"Typesetting\") + \" \"}\n        text = this.typesetting; this.typesetting += \".\";\n      }\n    }\n    return text;\n  },\n\n  clearCounts: function () {\n    delete this.loading;\n    delete this.processing;\n    delete this.typesetting;\n  },\n\n  Set: function (text,n,clearDelay) {\n    if (n == null) {n = this.log.length; this.log[n] = {}}\n    //\n    //  Translate message if it is [id,message,arguments]\n    //\n    var id = \"\";\n    if (MathJax.Object.isArray(text)) {\n      id = text[0]; if (MathJax.Object.isArray(id)) {id = id[1]}\n      //\n      // Localization._() will throw a restart error if a localization file\n      //   needs to be loaded, so trap that and redo the Set() call\n      //   after it is loaded.\n      //\n      try {\n        text = MathJax.Localization._.apply(MathJax.Localization,text);\n      } catch (err) {\n        if (!err.restart) {throw err}\n        if (!err.restart.called) {\n          //\n          //  Mark it so we can tell if the Clear() comes before the message is displayed\n          //\n          if (this.log[n].restarted == null) {this.log[n].restarted = 0}\n          this.log[n].restarted++; delete this.log[n].cleared;\n          MathJax.Callback.After([\"Set\",this,text,n,clearDelay],err.restart);\n          return n;\n        }\n      }\n    }\n    //\n    // Clear the timout timer.\n    //\n    if (this.timer) {clearTimeout(this.timer); delete this.timer}\n    //\n    //  Save the message and filtered message.\n    //\n    this.log[n].text = text; this.log[n].filteredText = text = this.filterText(text,n,id);\n    //\n    //  Hook the message into the message list so we can tell\n    //   what message to put up when this one is removed.\n    //\n    if (typeof(this.log[n].next) === \"undefined\") {\n      this.log[n].next = this.current;\n      if (this.current != null) {this.log[this.current].prev = n}\n      this.current = n;\n    }\n    //\n    //  Show the message if it is the currently active one.\n    //\n    if (this.current === n && MathJax.Hub.config.messageStyle !== \"none\") {\n      if (this.Init()) {\n        if (this.textNodeBug) {this.div.innerHTML = text} else {this.text.nodeValue = text}\n        this.div.style.display = \"\";\n        if (this.status) {window.status = \"\"; delete this.status}\n      } else {\n        window.status = text;\n        this.status = true;\n      }\n    }\n    //\n    //  Check if the message was resetarted to load a localization file\n    //    and if it has been cleared in the meanwhile.\n    //\n    if (this.log[n].restarted) {\n      if (this.log[n].cleared) {clearDelay = 0}\n      if (--this.log[n].restarted === 0) {delete this.log[n].cleared}\n    }\n    //\n    //  Check if we need to clear the message automatically.\n    //\n    if (clearDelay) {setTimeout(MathJax.Callback([\"Clear\",this,n]),clearDelay)}\n      else if (clearDelay == 0) {this.Clear(n,0)}\n    //\n    //  Return the message number.\n    //\n    return n;\n  },\n\n  Clear: function (n,delay) {\n    //\n    //  Detatch the message from the active list.\n    //\n    if (this.log[n].prev != null) {this.log[this.log[n].prev].next = this.log[n].next}\n    if (this.log[n].next != null) {this.log[this.log[n].next].prev = this.log[n].prev}\n    //\n    //  If it is the current message, get the next one to show.\n    //\n    if (this.current === n) {\n      this.current = this.log[n].next;\n      if (this.text) {\n        if (this.div.parentNode == null) {this.Init()} // see ASCIIMathML comments above\n        if (this.current == null) {\n          //\n          //  If there are no more messages, remove the message box.\n          //\n          if (this.timer) {clearTimeout(this.timer); delete this.timer}\n          if (delay == null) {delay = 600}\n          if (delay === 0) {this.Remove()}\n\t    else {this.timer = setTimeout(MathJax.Callback([\"Remove\",this]),delay)}\n        } else if (MathJax.Hub.config.messageStyle !== \"none\") {\n          //\n          //  If there is an old message, put it in place\n          //\n          if (this.textNodeBug) {this.div.innerHTML = this.log[this.current].filteredText}\n                           else {this.text.nodeValue = this.log[this.current].filteredText}\n        }\n        if (this.status) {window.status = \"\"; delete this.status}\n      } else if (this.status) {\n        window.status = (this.current == null ? \"\" : this.log[this.current].text);\n      }\n    }\n    //\n    //  Clean up the log data no longer needed\n    //\n    delete this.log[n].next; delete this.log[n].prev;\n    delete this.log[n].filteredText;\n    //\n    //  If this is a restarted localization message, mark that it has been cleared\n    //    while waiting for the file to load.\n    //\n    if (this.log[n].restarted) {this.log[n].cleared = true}\n  },\n\n  Remove: function () {\n    // FIXME:  do a fade out or something else interesting?\n    this.text.nodeValue = \"\";\n    this.div.style.display = \"none\";\n  },\n\n  File: function (file) {\n    return this.Set([\"LoadFile\",\"Loading %1\",file],null,null);\n  },\n\n  Log: function () {\n    var strings = [];\n    for (var i = 1, m = this.log.length; i < m; i++) {strings[i] = this.log[i].text}\n    return strings.join(\"\\n\");\n  }\n\n};\n\n/**********************************************************/\n\nMathJax.Hub = {\n  config: {\n    root: \"\",\n    config: [],      // list of configuration files to load\n    styleSheets: [], // list of CSS files to load\n    styles: {        // styles to generate in-line\n      \".MathJax_Preview\": {\n        color: \"#888\",\n        display: \"contents\" // for RTL languages in Chrome (see issue #2190)\n      }\n    },\n    jax: [],         // list of input and output jax to load\n    extensions: [],  // list of extensions to load\n    preJax: null,    // pattern to remove from before math script tag\n    postJax: null,   // pattern to remove from after math script tag\n    displayAlign: 'center',       // how to align displayed equations (left, center, right)\n    displayIndent: '0',           // indentation for displayed equations (when not centered)\n    preRemoveClass: 'MathJax_Preview', // class of objects to remove preceding math script\n    showProcessingMessages: true, // display \"Processing math: nn%\" messages or not\n    messageStyle: \"normal\",       // set to \"none\" or \"simple\" (for \"Loading...\" and \"Processing...\")\n    delayStartupUntil: \"none\",    // set to \"onload\" to delay setup until the onload handler runs\n                                  // set to \"configured\" to delay startup until MathJax.Hub.Configured() is called\n                                  // set to a Callback to wait for before continuing with the startup\n    skipStartupTypeset: false,    // set to true to skip PreProcess and Process during startup\n    elements: [],             // array of elements to process when none is given explicitly\n    positionToHash: true,    // after initial typeset pass, position to #hash location?\n\n    showMathMenu: true,      // attach math context menu to typeset math?\n    showMathMenuMSIE: true,  // separtely determine if MSIE should have math menu\n                             //  (since the code for that is a bit delicate)\n\n    menuSettings: {\n      zoom: \"None\",        //  when to do MathZoom\n      CTRL: false,         //    require CTRL for MathZoom?\n      ALT: false,          //    require Alt or Option?\n      CMD: false,          //    require CMD?\n      Shift: false,        //    require Shift?\n      discoverable: false, //  make math menu discoverable on hover?\n      zscale: \"200%\",      //  the scaling factor for MathZoom\n      renderer: null,      //  set when Jax are loaded\n      font: \"Auto\",        //  what font HTML-CSS should use\n      context: \"MathJax\",  //  or \"Browser\" for pass-through to browser menu\n      locale: null,        //  the language to use for messages\n      mpContext: false,    //  true means pass menu events to MathPlayer in IE\n      mpMouse: false,      //  true means pass mouse events to MathPlayer in IE\n      texHints: true,      //  include class names for TeXAtom elements\n      FastPreview: null,   //  use PreviewHTML output as preview?\n      assistiveMML: null,  //  include hidden MathML for screen readers?\n      inTabOrder: true,    //  set to false if math elements should be included in the tabindex\n      semantics: false     //  add semantics tag with original form in MathML output\n    },\n\n    errorSettings: {\n       // localized HTML snippet structure for message to use\n      message: [\"[\",[\"MathProcessingError\",\"Math Processing Error\"],\"]\"],\n      style: {color: \"#CC0000\", \"font-style\":\"italic\"}  // style for message\n    },\n\n    ignoreMMLattributes: {}  // attributes not to copy to HTML-CSS or SVG output\n                             //   from MathML input (in addition to the ones in MML.nocopyAttributes).\n                             //   An id set to true will be ignored, one set to false will\n                             //   be allowed (even if other criteria normally would prevent\n                             //   it from being copied); use false carefully!\n  },\n\n  preProcessors: MathJax.Callback.Hooks(true), // list of callbacks for preprocessing (initialized by extensions)\n  inputJax: {},          // mime-type mapped to input jax (by registration)\n  outputJax: {order:{}}, // mime-type mapped to output jax list (by registration)\n\n  processSectionDelay: 50, // pause between input and output phases of processing\n  processUpdateTime: 250, // time between screen updates when processing math (milliseconds)\n  processUpdateDelay: 10, // pause between screen updates to allow other processing (milliseconds)\n\n  signal: MathJax.Callback.Signal(\"Hub\"), // Signal used for Hub events\n\n  Config: function (def) {\n    this.Insert(this.config,def);\n    if (this.config.Augment) {this.Augment(this.config.Augment)}\n  },\n  CombineConfig: function (name,def) {\n    var config = this.config, id, parent; name = name.split(/\\./);\n    for (var i = 0, m = name.length; i < m; i++) {\n      id = name[i]; if (!config[id]) {config[id] = {}}\n      parent = config; config = config[id];\n    }\n    parent[id] = config = this.Insert(def,config);\n    return config;\n  },\n\n  Register: {\n    PreProcessor: function () {return MathJax.Hub.preProcessors.Add.apply(MathJax.Hub.preProcessors,arguments)},\n    MessageHook: function () {return MathJax.Hub.signal.MessageHook.apply(MathJax.Hub.signal,arguments)},\n    StartupHook: function () {return MathJax.Hub.Startup.signal.MessageHook.apply(MathJax.Hub.Startup.signal,arguments)},\n    LoadHook: function () {return MathJax.Ajax.LoadHook.apply(MathJax.Ajax,arguments)}\n  },\n  UnRegister: {\n    PreProcessor: function (hook) {MathJax.Hub.preProcessors.Remove(hook)},\n    MessageHook: function (hook) {MathJax.Hub.signal.RemoveHook(hook)},\n    StartupHook: function (hook) {MathJax.Hub.Startup.signal.RemoveHook(hook)},\n    LoadHook: function (hook) {MathJax.Ajax.removeHook(hook)}\n  },\n\n  getAllJax: function (element) {\n    var jax = [], scripts = this.elementScripts(element);\n    for (var i = 0, m = scripts.length; i < m; i++) {\n      if (scripts[i].MathJax && scripts[i].MathJax.elementJax)\n        {jax.push(scripts[i].MathJax.elementJax)}\n    }\n    return jax;\n  },\n\n  getJaxByType: function (type,element) {\n    var jax = [], scripts = this.elementScripts(element);\n    for (var i = 0, m = scripts.length; i < m; i++) {\n      if (scripts[i].MathJax && scripts[i].MathJax.elementJax &&\n          scripts[i].MathJax.elementJax.mimeType === type)\n            {jax.push(scripts[i].MathJax.elementJax)}\n    }\n    return jax;\n  },\n\n  getJaxByInputType: function (type,element) {\n    var jax = [], scripts = this.elementScripts(element);\n    for (var i = 0, m = scripts.length; i < m; i++) {\n      if (scripts[i].MathJax && scripts[i].MathJax.elementJax &&\n          scripts[i].type && scripts[i].type.replace(/ *;(.|\\s)*/,\"\") === type)\n        {jax.push(scripts[i].MathJax.elementJax)}\n    }\n    return jax;\n  },\n\n  getJaxFor: function (element) {\n    if (typeof(element) === 'string') {element = document.getElementById(element)}\n    if (element && element.MathJax) {return element.MathJax.elementJax}\n    if (this.isMathJaxNode(element)) {\n      if (!element.isMathJax) {element = element.firstChild}  // for NativeMML output\n      while (element && !element.jaxID) {element = element.parentNode}\n      if (element) {return MathJax.OutputJax[element.jaxID].getJaxFromMath(element)}\n    }\n    return null;\n  },\n\n  isJax: function (element) {\n    if (typeof(element) === 'string') {element = document.getElementById(element)}\n    if (this.isMathJaxNode(element)) {return 1}\n    if (element && (element.tagName||\"\").toLowerCase() === 'script') {\n      if (element.MathJax)\n        {return (element.MathJax.state === MathJax.ElementJax.STATE.PROCESSED ? 1 : -1)}\n      if (element.type && this.inputJax[element.type.replace(/ *;(.|\\s)*/,\"\")]) {return -1}\n    }\n    return 0;\n  },\n  isMathJaxNode: function (element) {\n    return !!element && (element.isMathJax || (element.className||\"\") === \"MathJax_MathML\");\n  },\n\n  setRenderer: function (renderer,type) {\n    if (!renderer) return;\n    var JAX = MathJax.OutputJax[renderer];\n    if (!JAX) {\n      MathJax.OutputJax[renderer] = MathJax.OutputJax({id: \"unknown\", version:\"1.0.0\", isUnknown: true});\n      this.config.menuSettings.renderer = \"\";\n      var file = \"[MathJax]/jax/output/\"+renderer+\"/config.js\";\n      return MathJax.Ajax.Require(file,[\"setRenderer\",this,renderer,type]);\n    } else {\n      this.config.menuSettings.renderer = renderer;\n      if (type == null) {type = \"jax/mml\"}\n      if (JAX.isUnknown) JAX.Register(type);\n      var jax = this.outputJax;\n      if (jax[type] && jax[type].length) {\n        if (renderer !== jax[type][0].id) {\n          jax[type].unshift(JAX);\n          return this.signal.Post([\"Renderer Selected\",renderer]);\n        }\n      }\n      return null;\n    }\n  },\n\n  Queue: function () {\n    return this.queue.Push.apply(this.queue,arguments);\n  },\n\n  Typeset: function (element,callback) {\n    if (!MathJax.isReady) return null;\n    var ec = this.elementCallback(element,callback);\n    if (ec.count) {\n      var queue = MathJax.Callback.Queue(\n        [\"PreProcess\",this,ec.elements],\n        [\"Process\",this,ec.elements]\n      );\n    }\n    return queue.Push(ec.callback);\n  },\n\n  PreProcess: function (element,callback) {\n    var ec = this.elementCallback(element,callback);\n    var queue = MathJax.Callback.Queue();\n    if (ec.count) {\n      var elements = (ec.count === 1 ? [ec.elements] : ec.elements);\n      queue.Push([\"Post\",this.signal,[\"Begin PreProcess\",ec.elements]]);\n      for (var i = 0, m = elements.length; i < m; i++) {\n        if (elements[i]) {queue.Push([\"Execute\",this.preProcessors,elements[i]])}\n      }\n      queue.Push([\"Post\",this.signal,[\"End PreProcess\",ec.elements]]);\n    }\n    return queue.Push(ec.callback);\n  },\n\n  Process:   function (element,callback) {return this.takeAction(\"Process\",element,callback)},\n  Update:    function (element,callback) {return this.takeAction(\"Update\",element,callback)},\n  Reprocess: function (element,callback) {return this.takeAction(\"Reprocess\",element,callback)},\n  Rerender:  function (element,callback) {return this.takeAction(\"Rerender\",element,callback)},\n\n  takeAction: function (action,element,callback) {\n    var ec = this.elementCallback(element,callback);\n    var elements = ec.elements;\n    var queue = MathJax.Callback.Queue([\"Clear\",this.signal]);\n    var state = {\n      scripts: [],                  // filled in by prepareScripts\n      start: new Date().getTime(),  // timer for processing messages\n      i: 0, j: 0,                   // current script, current jax\n      jax: {},                      // scripts grouped by output jax\n      jaxIDs: []                    // id's of jax used\n    };\n    if (ec.count) {\n      var delay = [\"Delay\",MathJax.Callback,this.processSectionDelay];\n      if (!delay[2]) {delay = {}}\n      queue.Push(\n        [\"clearCounts\",MathJax.Message],\n        [\"Post\",this.signal,[\"Begin \"+action,elements]],\n        [\"Post\",this.signal,[\"Begin Math\",elements,action]],\n        [\"prepareScripts\",this,action,elements,state],\n        [\"Post\",this.signal,[\"Begin Math Input\",elements,action]],\n        [\"processInput\",this,state],\n        [\"Post\",this.signal,[\"End Math Input\",elements,action]],\n        delay,\n        [\"prepareOutput\",this,state,\"preProcess\"],\n        delay,\n        [\"Post\",this.signal,[\"Begin Math Output\",elements,action]],\n        [\"processOutput\",this,state],\n        [\"Post\",this.signal,[\"End Math Output\",elements,action]],\n        delay,\n        [\"prepareOutput\",this,state,\"postProcess\"],\n        delay,\n        [\"Post\",this.signal,[\"End Math\",elements,action]],\n        [\"Post\",this.signal,[\"End \"+action,elements]],\n        [\"clearCounts\",MathJax.Message]\n      );\n    }\n    return queue.Push(ec.callback);\n  },\n\n  scriptAction: {\n    Process: function (script) {},\n    Update: function (script) {\n      var jax = script.MathJax.elementJax;\n      if (jax && jax.needsUpdate()) {jax.Remove(true); script.MathJax.state = jax.STATE.UPDATE}\n        else {script.MathJax.state = jax.STATE.PROCESSED}\n    },\n    Reprocess: function (script) {\n      var jax = script.MathJax.elementJax;\n      if (jax) {jax.Remove(true); script.MathJax.state = jax.STATE.UPDATE}\n    },\n    Rerender: function (script) {\n      var jax = script.MathJax.elementJax;\n      if (jax) {jax.Remove(true); script.MathJax.state = jax.STATE.OUTPUT}\n    }\n  },\n\n  prepareScripts: function (action,element,state) {\n    if (arguments.callee.disabled) return;\n    var scripts = this.elementScripts(element);\n    var STATE = MathJax.ElementJax.STATE;\n    for (var i = 0, m = scripts.length; i < m; i++) {\n      var script = scripts[i];\n      if (script.type && this.inputJax[script.type.replace(/ *;(.|\\n)*/,\"\")]) {\n        if (script.MathJax) {\n          if (script.MathJax.elementJax && script.MathJax.elementJax.hover) {\n            MathJax.Extension.MathEvents.Hover.ClearHover(script.MathJax.elementJax);\n          }\n          if (script.MathJax.state !== STATE.PENDING) {this.scriptAction[action](script)}\n        }\n        if (!script.MathJax) {script.MathJax = {state: STATE.PENDING}}\n        if (script.MathJax.error) delete script.MathJax.error;\n        if (script.MathJax.state !== STATE.PROCESSED) {state.scripts.push(script)}\n      }\n    }\n  },\n\n  checkScriptSiblings: function (script) {\n    if (script.MathJax.checked) return;\n    var config = this.config, pre = script.previousSibling;\n    if (pre && pre.nodeName === \"#text\") {\n      var preJax,postJax, post = script.nextSibling;\n      if (post && post.nodeName !== \"#text\") {post = null}\n      if (config.preJax) {\n        if (typeof(config.preJax) === \"string\") {config.preJax = new RegExp(config.preJax+\"$\")}\n        preJax = pre.nodeValue.match(config.preJax);\n      }\n      if (config.postJax && post) {\n        if (typeof(config.postJax) === \"string\") {config.postJax = new RegExp(\"^\"+config.postJax)}\n        postJax = post.nodeValue.match(config.postJax);\n      }\n      if (preJax && (!config.postJax || postJax)) {\n        pre.nodeValue  = pre.nodeValue.replace\n          (config.preJax,(preJax.length > 1? preJax[1] : \"\"));\n        pre = null;\n      }\n      if (postJax && (!config.preJax || preJax)) {\n        post.nodeValue = post.nodeValue.replace\n          (config.postJax,(postJax.length > 1? postJax[1] : \"\"));\n      }\n      if (pre && !pre.nodeValue.match(/\\S/)) {pre = pre.previousSibling}\n    }\n    if (config.preRemoveClass && pre && pre.className === config.preRemoveClass)\n      {script.MathJax.preview = pre}\n    script.MathJax.checked = 1;\n  },\n\n  processInput: function (state) {\n    var jax, STATE = MathJax.ElementJax.STATE;\n    var script, prev, m = state.scripts.length;\n    try {\n      //\n      //  Loop through the scripts\n      //\n      while (state.i < m) {\n        script = state.scripts[state.i]; if (!script) {state.i++; continue}\n        //\n        //  Remove previous error marker, if any\n        //\n        prev = script.previousSibling;\n        if (prev && prev.className === \"MathJax_Error\") {prev.parentNode.removeChild(prev)}\n        //\n        //  Check if already processed or needs processing\n        //\n        if (!script.parentNode || !script.MathJax || script.MathJax.state === STATE.PROCESSED) {state.i++; continue};\n        if (!script.MathJax.elementJax || script.MathJax.state === STATE.UPDATE) {\n          this.checkScriptSiblings(script);                 // remove preJax/postJax etc.\n          var type = script.type.replace(/ *;(.|\\s)*/,\"\");  // the input jax type\n          var input = this.inputJax[type];                  // the input jax itself\n          jax = input.Process(script,state);                // run the input jax\n          if (typeof jax === 'function') {                  // if a callback was returned\n            if (jax.called) continue;                       //   go back and call Process() again\n            this.RestartAfter(jax);                         //   wait for the callback\n          }\n          jax = jax.Attach(script,input.id);                // register the jax on the script\n          this.saveScript(jax,state,script,STATE);          // add script to state\n          this.postInputHooks.Execute(jax,input.id,script); // run global jax filters\n        } else if (script.MathJax.state === STATE.OUTPUT) {\n          this.saveScript(script.MathJax.elementJax,state,script,STATE); // add script to state\n        }\n        //\n        //  Go on to the next script, and check if we need to update the processing message\n        //\n        state.i++; var now = new Date().getTime();\n        if (now - state.start > this.processUpdateTime && state.i < state.scripts.length)\n          {state.start = now; this.RestartAfter(MathJax.Callback.Delay(1))}\n      }\n    } catch (err) {return this.processError(err,state,\"Input\")}\n    //\n    //  Put up final message, reset the state and return\n    //\n    if (state.scripts.length && this.config.showProcessingMessages)\n      {MathJax.Message.Set([\"ProcessMath\",\"Processing math: %1%%\",100],0)}\n    state.start = new Date().getTime(); state.i = state.j = 0;\n    return null;\n  },\n  postInputHooks: MathJax.Callback.Hooks(true),  // hooks to run after element jax is created\n  saveScript: function (jax,state,script,STATE) {\n    //\n    //  Check that output jax exists\n    //\n    if (!this.outputJax[jax.mimeType]) {\n      script.MathJax.state = STATE.UPDATE;\n      throw Error(\"No output jax registered for \"+jax.mimeType);\n    }\n    //\n    //  Record the output jax\n    //  and put this script in the queue for that jax\n    //\n    jax.outputJax = this.outputJax[jax.mimeType][0].id;\n    if (!state.jax[jax.outputJax]) {\n      if (state.jaxIDs.length === 0) {\n        // use original array until we know there are more (rather than two copies)\n        state.jax[jax.outputJax] = state.scripts;\n      } else {\n        if (state.jaxIDs.length === 1) // get the script so far for the existing jax\n          {state.jax[state.jaxIDs[0]] = state.scripts.slice(0,state.i)}\n        state.jax[jax.outputJax] = []; // start a new array for the new jax\n      }\n      state.jaxIDs.push(jax.outputJax); // save the ID of the jax\n    }\n    if (state.jaxIDs.length > 1) {state.jax[jax.outputJax].push(script)}\n    //\n    //  Mark script as needing output\n    //\n    script.MathJax.state = STATE.OUTPUT;\n  },\n\n  //\n  //  Pre- and post-process scripts by jax\n  //    (to get scaling factors, hide/show output, and so on)\n  //  Since this can cause the jax to load, we need to trap restarts\n  //\n  prepareOutput: function (state,method) {\n    while (state.j < state.jaxIDs.length) {\n      var id = state.jaxIDs[state.j], JAX = MathJax.OutputJax[id];\n      if (JAX[method]) {\n        try {\n          var result = JAX[method](state);\n          if (typeof result === 'function') {\n            if (result.called) continue;  // go back and try again\n            this.RestartAfter(result);\n          }\n        } catch (err) {\n          if (!err.restart) {\n            MathJax.Message.Set([\"PrepError\",\"Error preparing %1 output (%2)\",id,method],null,600);\n            MathJax.Hub.lastPrepError = err;\n            state.j++;\n          }\n          return MathJax.Callback.After([\"prepareOutput\",this,state,method],err.restart);\n        }\n      }\n      state.j++;\n    }\n    return null;\n  },\n\n  processOutput: function (state) {\n    var result, STATE = MathJax.ElementJax.STATE, script, m = state.scripts.length;\n    try {\n      //\n      //  Loop through the scripts\n      //\n      while (state.i < m) {\n        //\n        //  Check that there is an element jax\n        //\n        script = state.scripts[state.i];\n        if (!script || !script.parentNode || !script.MathJax || script.MathJax.error) {state.i++; continue}\n        var jax = script.MathJax.elementJax; if (!jax) {state.i++; continue}\n        //\n        //  Call the output Jax's Process method (which will be its Translate()\n        //  method once loaded).  Mark it as complete and remove the preview unless\n        //  the Process() call returns an explicit false value (in which case, it will\n        //  handle this later during the postProcess phase, as HTML-CSS does).\n        //\n        result = MathJax.OutputJax[jax.outputJax].Process(script,state);\n        if (result !== false) {\n          script.MathJax.state = STATE.PROCESSED;\n          if (script.MathJax.preview) {\n            script.MathJax.preview.innerHTML = \"\";\n            script.MathJax.preview.style.display = \"none\";\n          }\n          //\n          //  Signal that new math is available\n          //\n          this.signal.Post([\"New Math\",jax.inputID]); // FIXME: wait for this?  (i.e., restart if returns uncalled callback)\n        }\n        //\n        //  Go on to next math expression\n        //\n        state.i++;\n        //\n        //  Update the processing message, if needed\n        //\n        var now = new Date().getTime();\n        if (now - state.start > this.processUpdateTime && state.i < state.scripts.length)\n          {state.start = now; this.RestartAfter(MathJax.Callback.Delay(this.processUpdateDelay))}\n      }\n    } catch (err) {return this.processError(err,state,\"Output\")}\n    //\n    //  Put up the typesetting-complete message\n    //\n    if (state.scripts.length && this.config.showProcessingMessages) {\n      MathJax.Message.Set([\"TypesetMath\",\"Typesetting math: %1%%\",100],0);\n      MathJax.Message.Clear(0);\n    }\n    state.i = state.j = 0;\n    return null;\n  },\n\n  processMessage: function (state,type) {\n    var m = Math.floor(state.i/(state.scripts.length)*100);\n    var message = (type === \"Output\" ? [\"TypesetMath\",\"Typesetting math: %1%%\"] :\n                                       [\"ProcessMath\",\"Processing math: %1%%\"]);\n    if (this.config.showProcessingMessages) {MathJax.Message.Set(message.concat(m),0)}\n  },\n\n  processError: function (err,state,type) {\n    if (!err.restart) {\n      if (!this.config.errorSettings.message) {throw err}\n      this.formatError(state.scripts[state.i],err); state.i++;\n    }\n    this.processMessage(state,type);\n    return MathJax.Callback.After([\"process\"+type,this,state],err.restart);\n  },\n\n  formatError: function (script,err) {\n    var LOCALIZE = function (id,text,arg1,arg2) {return MathJax.Localization._(id,text,arg1,arg2)};\n    //\n    //  Get the error message, URL, and line, and save it for\n    //    reporting in the Show Math As Error menu\n    //\n    var message = LOCALIZE(\"ErrorMessage\",\"Error: %1\",err.message)+\"\\n\";\n    if (err.sourceURL||err.fileName) message += \"\\n\"+LOCALIZE(\"ErrorFile\",\"file: %1\",err.sourceURL||err.fileName);\n    if (err.line||err.lineNumber) message += \"\\n\"+LOCALIZE(\"ErrorLine\",\"line: %1\",err.line||err.lineNumber);\n    message += \"\\n\\n\"+LOCALIZE(\"ErrorTips\",\"Debugging tips: use %1, inspect %2 in the browser console\",\"'unpacked/MathJax.js'\",\"'MathJax.Hub.lastError'\");\n    script.MathJax.error = MathJax.OutputJax.Error.Jax(message,script);\n    if (script.MathJax.elementJax)\n      script.MathJax.error.inputID = script.MathJax.elementJax.inputID;\n    //\n    //  Create the [Math Processing Error] span\n    //\n    var errorSettings = this.config.errorSettings;\n    var errorText = LOCALIZE(errorSettings.messageId,errorSettings.message);\n    var error = MathJax.HTML.Element(\"span\", {\n      className:\"MathJax_Error\", jaxID:\"Error\", isMathJax:true,\n      id: script.MathJax.error.inputID+\"-Frame\"\n    },[[\"span\",null,errorText]]);\n    //\n    //  Attach the menu events\n    //\n    MathJax.Ajax.Require(\"[MathJax]/extensions/MathEvents.js\",function () {\n      var EVENT = MathJax.Extension.MathEvents.Event,\n          HUB = MathJax.Hub;\n      error.oncontextmenu = EVENT.Menu;\n      error.onmousedown = EVENT.Mousedown;\n      error.onkeydown = EVENT.Keydown;\n      error.tabIndex = HUB.getTabOrder(HUB.getJaxFor(script));\n    });\n    //\n    //  Insert the error into the page and remove any preview\n    //\n    var node = document.getElementById(error.id);\n    if (node) node.parentNode.removeChild(node);\n    if (script.parentNode) script.parentNode.insertBefore(error,script);\n    if (script.MathJax.preview) {\n      script.MathJax.preview.innerHTML = \"\";\n      script.MathJax.preview.style.display = \"none\";\n    }\n    //\n    //  Save the error for debugging purposes\n    //  Report the error as a signal\n    //\n    this.lastError = err;\n    this.signal.Post([\"Math Processing Error\",script,err]);\n  },\n\n  RestartAfter: function (callback) {\n    throw this.Insert(Error(\"restart\"),{restart: MathJax.Callback(callback)});\n  },\n\n  elementCallback: function (element,callback) {\n    if (callback == null && (MathJax.Object.isArray(element) || typeof element === 'function'))\n      {try {MathJax.Callback(element); callback = element; element = null} catch(e) {}}\n    if (element == null) {element = this.config.elements || []}\n    if (this.isHTMLCollection(element)) {element = this.HTMLCollection2Array(element)}\n    if (!MathJax.Object.isArray(element)) {element = [element]}\n    element = [].concat(element); // make a copy so the original isn't changed\n    for (var i = 0, m = element.length; i < m; i++)\n      {if (typeof(element[i]) === 'string') {element[i] = document.getElementById(element[i])}}\n    if (!document.body) {document.body = document.getElementsByTagName(\"body\")[0]}\n    if (element.length == 0) {element.push(document.body)}\n    if (!callback) {callback = {}}\n    return {\n      count: element.length,\n      elements: (element.length === 1 ? element[0] : element),\n      callback: callback\n    };\n  },\n\n  elementScripts: function (element) {\n    var scripts = [];\n    if (MathJax.Object.isArray(element) || this.isHTMLCollection(element)) {\n      for (var i = 0, m = element.length; i < m; i++) {\n        var alreadyDone = 0;\n        for (var j = 0; j < i && !alreadyDone; j++)\n          {alreadyDone = element[j].contains(element[i])}\n        if (!alreadyDone) scripts.push.apply(scripts,this.elementScripts(element[i]));\n      }\n      return scripts;\n    }\n    if (typeof(element) === 'string') {element = document.getElementById(element)}\n    if (!document.body) {document.body = document.getElementsByTagName(\"body\")[0]}\n    if (element == null) {element = document.body}\n    if (element.tagName != null && element.tagName.toLowerCase() === \"script\") {return [element]}\n    scripts = element.getElementsByTagName(\"script\");\n    if (this.msieHTMLCollectionBug) {scripts = this.HTMLCollection2Array(scripts)}\n    return scripts;\n  },\n\n  //\n  //  IE8 fails to check \"obj instanceof HTMLCollection\" for some values of obj.\n  //\n  isHTMLCollection: function (obj) {\n    return (\"HTMLCollection\" in window && typeof(obj) === \"object\" && obj instanceof HTMLCollection);\n  },\n  //\n  //  IE8 doesn't deal with HTMLCollection as an array, so convert to array\n  //\n  HTMLCollection2Array: function (nodes) {\n    if (!this.msieHTMLCollectionBug) {return [].slice.call(nodes)}\n    var NODES = [];\n    for (var i = 0, m = nodes.length; i < m; i++) {NODES[i] = nodes[i]}\n    return NODES;\n  },\n\n  Insert: function (dst,src) {\n    for (var id in src) {if (src.hasOwnProperty(id)) {\n      // allow for concatenation of arrays?\n      if (typeof src[id] === 'object' && !(MathJax.Object.isArray(src[id])) &&\n         (typeof dst[id] === 'object' || typeof dst[id] === 'function')) {\n        this.Insert(dst[id],src[id]);\n      } else {\n        dst[id] = src[id];\n      }\n    }}\n    return dst;\n  },\n\n  getTabOrder: function(script) {\n    return this.config.menuSettings.inTabOrder ? 0 : -1;\n  },\n\n  // Old browsers (e.g. Internet Explorer <= 8) do not support trim().\n  SplitList: (\"trim\" in String.prototype ?\n              function (list) {return list.trim().split(/\\s+/)} :\n              function (list) {return list.replace(/^\\s+/,'').\n                                           replace(/\\s+$/,'').split(/\\s+/)})\n};\nMathJax.Hub.Insert(MathJax.Hub.config.styles,MathJax.Message.styles);\nMathJax.Hub.Insert(MathJax.Hub.config.styles,{\".MathJax_Error\":MathJax.Hub.config.errorSettings.style});\n\n//\n//  Storage area for extensions and preprocessors\n//\nMathJax.Extension = {};\n\n//\n//  Hub Startup code\n//\nMathJax.Hub.Configured = MathJax.Callback({}); // called when configuration is complete\nMathJax.Hub.Startup = {\n  script: \"\", // the startup script from the SCRIPT call that loads MathJax.js\n  queue:   MathJax.Callback.Queue(),           // Queue used for startup actions\n  signal:  MathJax.Callback.Signal(\"Startup\"), // Signal used for startup events\n  params:  {},\n\n  //\n  //  Load the configuration files\n  //\n  Config: function () {\n    this.queue.Push([\"Post\",this.signal,\"Begin Config\"]);\n    //\n    //  Make sure root is set before loading any files\n    //\n    if (MathJax.AuthorConfig && MathJax.AuthorConfig.root)\n      MathJax.Ajax.config.root = MathJax.AuthorConfig.root;\n    //\n    //  If a locale is given as a parameter,\n    //    set the locale and the default menu value for the locale\n    //\n    if (this.params.locale) {\n      MathJax.Localization.resetLocale(this.params.locale);\n      MathJax.Hub.config.menuSettings.locale = this.params.locale;\n    }\n    //\n    //  Run the config files, if any are given in the parameter list\n    //\n    if (this.params.config) {\n      var files = this.params.config.split(/,/);\n      for (var i = 0, m = files.length; i < m; i++) {\n        if (!files[i].match(/\\.js$/)) {files[i] += \".js\"}\n        this.queue.Push([\"Require\",MathJax.Ajax,this.URL(\"config\",files[i])]);\n      }\n    }\n    //\n    //  Perform author configuration from in-line MathJax = {...}\n    //\n    this.queue.Push([\"Config\",MathJax.Hub,MathJax.AuthorConfig]);\n    //\n    //  Run the deprecated configuration script, if any (ignoring return value)\n    //  Wait for the startup delay signal\n    //  Run the mathjax-config blocks\n    //  Load the files in the configuration's config array\n    //\n    if (this.script.match(/\\S/)) {this.queue.Push(this.script+\";\\n1;\")}\n    this.queue.Push(\n      [\"ConfigDelay\",this],\n      [\"ConfigBlocks\",this],\n      [function (THIS) {return THIS.loadArray(MathJax.Hub.config.config,\"config\",null,true)},this],\n      [\"Post\",this.signal,\"End Config\"]\n    );\n  },\n  //\n  //  Return the delay callback\n  //\n  ConfigDelay: function () {\n    var delay = this.params.delayStartupUntil || MathJax.Hub.config.delayStartupUntil;\n    if (delay === \"onload\") {return this.onload}\n    if (delay === \"configured\") {return MathJax.Hub.Configured}\n    return delay;\n  },\n  //\n  //  Run the scripts of type=text/x-mathjax-config\n  //\n  ConfigBlocks: function () {\n    var scripts = document.getElementsByTagName(\"script\");\n    var queue = MathJax.Callback.Queue();\n    for (var i = 0, m = scripts.length; i < m; i++) {\n      var type = String(scripts[i].type).replace(/ /g,\"\");\n      if (type.match(/^text\\/x-mathjax-config(;.*)?$/) && !type.match(/;executed=true/)) {\n        scripts[i].type += \";executed=true\";\n        queue.Push(scripts[i].innerHTML+\";\\n1;\");\n      }\n    }\n    return queue.Push(function () {MathJax.Ajax.config.root = MathJax.Hub.config.root});\n  },\n\n  //\n  //  Read cookie and set up menu defaults\n  //  (set the locale according to the cookie)\n  //  (adjust the jax to accommodate renderer preferences)\n  //\n  Cookie: function () {\n    return this.queue.Push(\n      [\"Post\",this.signal,\"Begin Cookie\"],\n      [\"Get\",MathJax.HTML.Cookie,\"menu\",MathJax.Hub.config.menuSettings],\n      [function (config) {\n        var SETTINGS = config.menuSettings;\n        if (SETTINGS.locale) MathJax.Localization.resetLocale(SETTINGS.locale);\n        var renderer = config.menuSettings.renderer, jax = config.jax;\n        if (renderer) {\n          var name = \"output/\"+renderer; jax.sort();\n          for (var i = 0, m = jax.length; i < m; i++) {\n            if (jax[i].substr(0,7) === \"output/\") break;\n          }\n          if (i == m-1) {jax.pop()} else {\n            while (i < m) {if (jax[i] === name) {jax.splice(i,1); break}; i++}\n          }\n          jax.unshift(name);\n        }\n        if (SETTINGS.CHTMLpreview != null) {\n          if (SETTINGS.FastPreview == null) SETTINGS.FastPreview = SETTINGS.CHTMLpreview;\n          delete SETTINGS.CHTMLpreview;\n        }\n        if (SETTINGS.FastPreview && !MathJax.Extension[\"fast-preview\"])\n          MathJax.Hub.config.extensions.push(\"fast-preview.js\");\n        if (config.menuSettings.assistiveMML && !MathJax.Extension.AssistiveMML)\n          MathJax.Hub.config.extensions.push(\"AssistiveMML.js\");\n      },MathJax.Hub.config],\n      [\"Post\",this.signal,\"End Cookie\"]\n    );\n  },\n  //\n  //  Setup stylesheets and extra styles\n  //\n  Styles: function () {\n    return this.queue.Push(\n      [\"Post\",this.signal,\"Begin Styles\"],\n      [\"loadArray\",this,MathJax.Hub.config.styleSheets,\"config\"],\n      [\"Styles\",MathJax.Ajax,MathJax.Hub.config.styles],\n      [\"Post\",this.signal,\"End Styles\"]\n    );\n  },\n  //\n  //  Load the input and output jax\n  //\n  Jax: function () {\n    var config = MathJax.Hub.config, jax = MathJax.Hub.outputJax;\n    //  Save the order of the output jax since they are loading asynchronously\n    for (var i = 0, m = config.jax.length, k = 0; i < m; i++) {\n      var name = config.jax[i].substr(7);\n      if (config.jax[i].substr(0,7) === \"output/\" && jax.order[name] == null)\n        {jax.order[name] = k; k++}\n    }\n    var queue = MathJax.Callback.Queue();\n    return queue.Push(\n      [\"Post\",this.signal,\"Begin Jax\"],\n      [\"loadArray\",this,config.jax,\"jax\",\"config.js\"],\n      [\"Post\",this.signal,\"End Jax\"]\n    );\n  },\n  //\n  //  Load the extensions\n  //\n  Extensions: function () {\n    var queue = MathJax.Callback.Queue();\n    return queue.Push(\n      [\"Post\",this.signal,\"Begin Extensions\"],\n      [\"loadArray\",this,MathJax.Hub.config.extensions,\"extensions\"],\n      [\"Post\",this.signal,\"End Extensions\"]\n    );\n  },\n\n  //\n  //  Initialize the Message system\n  //\n  Message: function () {\n    MathJax.Message.Init(true);\n  },\n\n  //\n  //  Set the math menu renderer, if it isn't already\n  //  (this must come after the jax are loaded)\n  //\n  Menu: function () {\n    var menu = MathJax.Hub.config.menuSettings, jax = MathJax.Hub.outputJax, registered;\n    for (var id in jax) {if (jax.hasOwnProperty(id)) {\n      if (jax[id].length) {registered = jax[id]; break}\n    }}\n    if (registered && registered.length) {\n      if (menu.renderer && menu.renderer !== registered[0].id)\n        {registered.unshift(MathJax.OutputJax[menu.renderer])}\n      menu.renderer = registered[0].id;\n    }\n  },\n\n  //\n  //  Set the location to the designated hash position\n  //\n  Hash: function () {\n    if (MathJax.Hub.config.positionToHash && document.location.hash &&\n        document.body && document.body.scrollIntoView) {\n      var name = decodeURIComponent(document.location.hash.substr(1));\n      var target = document.getElementById(name);\n      if (!target) {\n        var a = document.getElementsByTagName(\"a\");\n        for (var i = 0, m = a.length; i < m; i++)\n          {if (a[i].name === name) {target = a[i]; break}}\n      }\n      if (target) {\n        while (!target.scrollIntoView) {target = target.parentNode}\n        target = this.HashCheck(target);\n        if (target && target.scrollIntoView)\n          {setTimeout(function () {target.scrollIntoView(true)},1)}\n      }\n    }\n  },\n  HashCheck: function (target) {\n    var jax = MathJax.Hub.getJaxFor(target);\n    if (jax && MathJax.OutputJax[jax.outputJax].hashCheck)\n      {target = MathJax.OutputJax[jax.outputJax].hashCheck(target)}\n    return target;\n  },\n\n  //\n  //  Load the Menu and Zoom code, if it hasn't already been loaded.\n  //  This is called after the initial typeset, so should no longer be\n  //  competing with other page loads, but will make these available\n  //  if needed later on.\n  //\n  MenuZoom: function () {\n    if (MathJax.Hub.config.showMathMenu) {\n      if (!MathJax.Extension.MathMenu) {\n        setTimeout(\n          function () {\n            MathJax.Callback.Queue(\n              [\"Require\",MathJax.Ajax,\"[MathJax]/extensions/MathMenu.js\",{}],\n              [\"loadDomain\",MathJax.Localization,\"MathMenu\"]\n            )\n          },1000\n        );\n      } else {\n        setTimeout(\n          MathJax.Callback([\"loadDomain\",MathJax.Localization,\"MathMenu\"]),\n          1000\n        );\n      }\n      if (!MathJax.Extension.MathZoom) {\n        setTimeout(\n          MathJax.Callback([\"Require\",MathJax.Ajax,\"[MathJax]/extensions/MathZoom.js\",{}]),\n          2000\n        );\n      }\n    }\n  },\n\n  //\n  //  Setup the onload callback\n  //\n  onLoad: function () {\n    var onload = this.onload =\n      MathJax.Callback(function () {MathJax.Hub.Startup.signal.Post(\"onLoad\")});\n    if (document.body && document.readyState)\n      if (MathJax.Hub.Browser.isMSIE) {\n        // IE can change from loading to interactive before\n        //  full page is ready, so go with complete (even though\n        //  that means we may have to wait longer).\n        if (document.readyState === \"complete\") {return [onload]}\n      } else if (document.readyState !== \"loading\") {return [onload]}\n    if (window.addEventListener) {\n      window.addEventListener(\"load\",onload,false);\n      if (!this.params.noDOMContentEvent)\n        {window.addEventListener(\"DOMContentLoaded\",onload,false)}\n    }\n    else if (window.attachEvent) {window.attachEvent(\"onload\",onload)}\n    else {window.onload = onload}\n    return onload;\n  },\n\n  //\n  //  Perform the initial typesetting (or skip if configuration says to)\n  //\n  Typeset: function (element,callback) {\n    if (MathJax.Hub.config.skipStartupTypeset) {return function () {}}\n    return this.queue.Push(\n      [\"Post\",this.signal,\"Begin Typeset\"],\n      [\"Typeset\",MathJax.Hub,element,callback],\n      [\"Post\",this.signal,\"End Typeset\"]\n    );\n  },\n\n  //\n  //  Create a URL in the MathJax hierarchy\n  //\n  URL: function (dir,name) {\n    if (!name.match(/^([a-z]+:\\/\\/|\\[|\\/)/)) {name = \"[MathJax]/\"+dir+\"/\"+name}\n    return name;\n  },\n\n  //\n  //  Load an array of files, waiting for all of them\n  //  to be loaded before going on\n  //\n  loadArray: function (files,dir,name,synchronous) {\n    if (files) {\n      if (!MathJax.Object.isArray(files)) {files = [files]}\n      if (files.length) {\n        var queue = MathJax.Callback.Queue(), callback = {}, file;\n        for (var i = 0, m = files.length; i < m; i++) {\n          file = this.URL(dir,files[i]);\n          if (name) {file += \"/\" + name}\n          if (synchronous) {queue.Push([\"Require\",MathJax.Ajax,file,callback])}\n                      else {queue.Push(MathJax.Ajax.Require(file,callback))}\n        }\n        return queue.Push({}); // wait for everything to finish\n      }\n    }\n    return null;\n  }\n\n};\n\n\n/**********************************************************/\n\n(function (BASENAME) {\n  var BASE = window[BASENAME], ROOT = \"[\"+BASENAME+\"]\";\n  var HUB = BASE.Hub, AJAX = BASE.Ajax, CALLBACK = BASE.Callback;\n\n  var JAX = MathJax.Object.Subclass({\n    JAXFILE: \"jax.js\",\n    require: null, // array of files to load before jax.js is complete\n    config: {},\n    //\n    //  Make a subclass and return an instance of it.\n    //  (FIXME: should we replace config with a copy of the constructor's\n    //   config?  Otherwise all subclasses share the same config structure.)\n    //\n    Init: function (def,cdef) {\n      if (arguments.length === 0) {return this}\n      return (this.constructor.Subclass(def,cdef))();\n    },\n    //\n    //  Augment by merging with class definition (not replacing)\n    //\n    Augment: function (def,cdef) {\n      var cObject = this.constructor, ndef = {};\n      if (def != null) {\n        for (var id in def) {if (def.hasOwnProperty(id)) {\n          if (typeof def[id] === \"function\")\n            {cObject.protoFunction(id,def[id])} else {ndef[id] = def[id]}\n        }}\n        // MSIE doesn't list toString even if it is not native so handle it separately\n        if (def.toString !== cObject.prototype.toString && def.toString !== {}.toString)\n          {cObject.protoFunction('toString',def.toString)}\n      }\n      HUB.Insert(cObject.prototype,ndef);\n      cObject.Augment(null,cdef);\n      return this;\n    },\n    Translate: function (script,state) {\n      throw Error(this.directory+\"/\"+this.JAXFILE+\" failed to define the Translate() method\");\n    },\n    Register: function (mimetype) {},\n    Config: function () {\n      this.config = HUB.CombineConfig(this.id,this.config);\n      if (this.config.Augment) {this.Augment(this.config.Augment)}\n    },\n    Startup: function () {},\n    loadComplete: function (file) {\n      if (file === \"config.js\") {\n        return AJAX.loadComplete(this.directory+\"/\"+file);\n      } else {\n        var queue = CALLBACK.Queue();\n        queue.Push(\n          HUB.Register.StartupHook(\"End Config\",{}), // wait until config complete\n          [\"Post\",HUB.Startup.signal,this.id+\" Jax Config\"],\n          [\"Config\",this],\n          [\"Post\",HUB.Startup.signal,this.id+\" Jax Require\"],\n          // Config may set the required and extensions array,\n          //  so use functions to delay making the reference until needed\n          [function (THIS) {return MathJax.Hub.Startup.loadArray(THIS.require,this.directory)},this],\n          [function (config,id) {return MathJax.Hub.Startup.loadArray(config.extensions,\"extensions/\"+id)},this.config||{},this.id],\n          [\"Post\",HUB.Startup.signal,this.id+\" Jax Startup\"],\n          [\"Startup\",this],\n          [\"Post\",HUB.Startup.signal,this.id+\" Jax Ready\"]\n        );\n        if (this.copyTranslate) {\n          queue.Push(\n            [function (THIS) {\n              THIS.preProcess  = THIS.preTranslate;\n              THIS.Process     = THIS.Translate;\n              THIS.postProcess = THIS.postTranslate;\n            },this.constructor.prototype]\n          );\n        }\n        return queue.Push([\"loadComplete\",AJAX,this.directory+\"/\"+file]);\n      }\n    }\n  },{\n    id: \"Jax\",\n    version: \"2.7.9\",\n    directory: ROOT+\"/jax\",\n    extensionDir: ROOT+\"/extensions\"\n  });\n\n  /***********************************/\n\n  BASE.InputJax = JAX.Subclass({\n    elementJax: \"mml\",  // the element jax to load for this input jax\n    sourceMenuTitle: /*_(MathMenu)*/ [\"Original\",\"Original Form\"],\n    copyTranslate: true,\n    Process: function (script,state) {\n      var queue = CALLBACK.Queue(), file;\n      // Load any needed element jax\n      var jax = this.elementJax; if (!BASE.Object.isArray(jax)) {jax = [jax]}\n      for (var i = 0, m = jax.length; i < m; i++) {\n        file = BASE.ElementJax.directory+\"/\"+jax[i]+\"/\"+this.JAXFILE;\n        if (!this.require) {this.require = []}\n          else if (!BASE.Object.isArray(this.require)) {this.require = [this.require]};\n        this.require.push(file);  // so Startup will wait for it to be loaded\n        queue.Push(AJAX.Require(file));\n      }\n      // Load the input jax\n      file = this.directory+\"/\"+this.JAXFILE;\n      var load = queue.Push(AJAX.Require(file));\n      if (!load.called) {\n        this.constructor.prototype.Process = function () {\n          if (!load.called) {return load}\n          throw Error(file+\" failed to load properly\");\n        }\n      }\n      // Load the associated output jax\n      jax = HUB.outputJax[\"jax/\"+jax[0]];\n      if (jax) {queue.Push(AJAX.Require(jax[0].directory+\"/\"+this.JAXFILE))}\n      return queue.Push({});\n    },\n    needsUpdate: function (jax) {\n      var script = jax.SourceElement();\n      return (jax.originalText !== BASE.HTML.getScript(script));\n    },\n    Register: function (mimetype) {\n      if (!HUB.inputJax) {HUB.inputJax = {}}\n      HUB.inputJax[mimetype] = this;\n    }\n  },{\n    id: \"InputJax\",\n    version: \"2.7.9\",\n    directory: JAX.directory+\"/input\",\n    extensionDir: JAX.extensionDir\n  });\n\n  /***********************************/\n\n  BASE.OutputJax = JAX.Subclass({\n    copyTranslate: true,\n    preProcess: function (state) {\n      var load, file = this.directory+\"/\"+this.JAXFILE;\n      this.constructor.prototype.preProcess = function (state) {\n\tif (!load.called) {return load}\n        throw Error(file+\" failed to load properly\");\n      }\n      load = AJAX.Require(file);\n      return load;\n    },\n    Process: function (state) {throw Error(this.id + \" output jax failed to load properly\")},\n    Register: function (mimetype) {\n      var jax = HUB.outputJax;\n      if (!jax[mimetype]) {jax[mimetype] = []}\n      //  If the output jax is earlier in the original configuration list, put it first here\n      if (jax[mimetype].length && (this.id === HUB.config.menuSettings.renderer ||\n            (jax.order[this.id]||0) < (jax.order[jax[mimetype][0].id]||0)))\n        {jax[mimetype].unshift(this)} else {jax[mimetype].push(this)}\n      //  Make sure the element jax is loaded before Startup is called\n      if (!this.require) {this.require = []}\n        else if (!BASE.Object.isArray(this.require)) {this.require = [this.require]};\n      this.require.push(BASE.ElementJax.directory+\"/\"+(mimetype.split(/\\//)[1])+\"/\"+this.JAXFILE);\n    },\n    Remove: function (jax) {}\n  },{\n    id: \"OutputJax\",\n    version: \"2.7.9\",\n    directory: JAX.directory+\"/output\",\n    extensionDir: JAX.extensionDir,\n    fontDir: ROOT+(BASE.isPacked?\"\":\"/..\")+\"/fonts\",\n    imageDir: ROOT+(BASE.isPacked?\"\":\"/..\")+\"/images\"\n  });\n\n  /***********************************/\n\n  BASE.ElementJax = JAX.Subclass({\n    // make a subclass, not an instance\n    Init: function (def,cdef) {return this.constructor.Subclass(def,cdef)},\n\n    inputJax: null,\n    outputJax: null,\n    inputID: null,\n    originalText: \"\",\n    mimeType: \"\",\n    sourceMenuTitle: /*_(MathMenu)*/ [\"MathMLcode\",\"MathML Code\"],\n\n    Text: function (text,callback) {\n      var script = this.SourceElement();\n      BASE.HTML.setScript(script,text);\n      script.MathJax.state = this.STATE.UPDATE;\n      return HUB.Update(script,callback);\n    },\n    Reprocess: function (callback) {\n      var script = this.SourceElement();\n      script.MathJax.state = this.STATE.UPDATE;\n      return HUB.Reprocess(script,callback);\n    },\n    Update: function (callback) {return this.Rerender(callback)},\n    Rerender: function (callback) {\n      var script = this.SourceElement();\n      script.MathJax.state = this.STATE.OUTPUT;\n      return HUB.Process(script,callback);\n    },\n    Remove: function (keep) {\n      if (this.hover) {this.hover.clear(this)}\n      BASE.OutputJax[this.outputJax].Remove(this);\n      if (!keep) {\n        HUB.signal.Post([\"Remove Math\",this.inputID]); // wait for this to finish?\n        this.Detach();\n      }\n    },\n    needsUpdate: function () {\n      return BASE.InputJax[this.inputJax].needsUpdate(this);\n    },\n\n    SourceElement: function () {return document.getElementById(this.inputID)},\n\n    Attach: function (script,inputJax) {\n      var jax = script.MathJax.elementJax;\n      if (script.MathJax.state === this.STATE.UPDATE) {\n        jax.Clone(this);\n      } else {\n        jax = script.MathJax.elementJax = this;\n        if (script.id) {this.inputID = script.id}\n          else {script.id = this.inputID = BASE.ElementJax.GetID(); this.newID = 1}\n      }\n      jax.originalText = BASE.HTML.getScript(script);\n      jax.inputJax = inputJax;\n      if (jax.root) {jax.root.inputID = jax.inputID}\n      return jax;\n    },\n    Detach: function () {\n      var script = this.SourceElement(); if (!script) return;\n      try {delete script.MathJax} catch(err) {script.MathJax = null}\n      if (this.newID) {script.id = \"\"}\n    },\n    Clone: function (jax) {\n      var id;\n      for (id in this) {\n        if (!this.hasOwnProperty(id)) continue;\n        if (typeof(jax[id]) === 'undefined' && id !== 'newID') {delete this[id]}\n      }\n      for (id in jax) {\n        if (!jax.hasOwnProperty(id)) continue;\n        if (typeof(this[id]) === 'undefined' || (this[id] !== jax[id] && id !== 'inputID'))\n          {this[id] = jax[id]}\n      }\n    }\n  },{\n    id: \"ElementJax\",\n    version: \"2.7.9\",\n    directory: JAX.directory+\"/element\",\n    extensionDir: JAX.extensionDir,\n    ID: 0,  // jax counter (for IDs)\n    STATE: {\n      PENDING: 1,      // script is identified as math but not yet processed\n      PROCESSED: 2,    // script has been processed\n      UPDATE: 3,       // elementJax should be updated\n      OUTPUT: 4        // output should be updated (input is OK)\n    },\n\n    GetID: function () {this.ID++; return \"MathJax-Element-\"+this.ID},\n    Subclass: function () {\n      var obj = JAX.Subclass.apply(this,arguments);\n      obj.loadComplete = this.prototype.loadComplete;\n      return obj;\n    }\n  });\n  BASE.ElementJax.prototype.STATE = BASE.ElementJax.STATE;\n\n  //\n  //  Some \"Fake\" jax used to allow menu access for \"Math Processing Error\" messages\n  //\n  BASE.OutputJax.Error = {\n    id: \"Error\", version: \"2.7.9\", config: {}, errors: 0,\n    ContextMenu: function () {return BASE.Extension.MathEvents.Event.ContextMenu.apply(BASE.Extension.MathEvents.Event,arguments)},\n    Mousedown:   function () {return BASE.Extension.MathEvents.Event.AltContextMenu.apply(BASE.Extension.MathEvents.Event,arguments)},\n    getJaxFromMath: function (math) {return (math.nextSibling.MathJax||{}).error},\n    Jax: function (text,script) {\n      var jax = MathJax.Hub.inputJax[script.type.replace(/ *;(.|\\s)*/,\"\")];\n      this.errors++;\n      return {\n        inputJax: (jax||{id:\"Error\"}).id,  // Use Error InputJax as fallback\n        outputJax: \"Error\",\n        inputID: \"MathJax-Error-\"+this.errors,\n        sourceMenuTitle: /*_(MathMenu)*/ [\"ErrorMessage\",\"Error Message\"],\n        sourceMenuFormat: \"Error\",\n        originalText: MathJax.HTML.getScript(script),\n        errorText: text\n      }\n    }\n  };\n  BASE.InputJax.Error = {\n    id: \"Error\", version: \"2.7.9\", config: {},\n    sourceMenuTitle: /*_(MathMenu)*/ [\"Original\",\"Original Form\"]\n  };\n\n})(\"MathJax\");\n\n/**********************************************************/\n\n(function (BASENAME) {\n  var BASE = window[BASENAME];\n  if (!BASE) {BASE = window[BASENAME] = {}}\n\n  var HUB = BASE.Hub; var STARTUP = HUB.Startup; var CONFIG = HUB.config;\n  var HEAD = document.head || (document.getElementsByTagName(\"head\")[0]);\n  if (!HEAD) {HEAD = document.childNodes[0]};\n  var scripts = (document.documentElement || document).getElementsByTagName(\"script\");\n  if (scripts.length === 0 && HEAD.namespaceURI)\n    scripts = document.getElementsByTagNameNS(HEAD.namespaceURI,\"script\");\n  var namePattern = new RegExp(\"(^|/)\"+BASENAME+\"\\\\.js(\\\\?.*)?$\");\n  for (var i = scripts.length-1; i >= 0; i--) {\n    if ((scripts[i].src||\"\").match(namePattern)) {\n      STARTUP.script = scripts[i].innerHTML;\n      if (RegExp.$2) {\n        var params = RegExp.$2.substr(1).split(/\\&/);\n        for (var j = 0, m = params.length; j < m; j++) {\n          var KV = params[j].match(/(.*)=(.*)/);\n          if (KV) {STARTUP.params[unescape(KV[1])] = unescape(KV[2])}\n             else {STARTUP.params[params[j]] = true}\n        }\n      }\n      CONFIG.root = scripts[i].src.replace(/(^|\\/)[^\\/]*(\\?.*)?$/,'');\n      BASE.Ajax.config.root = CONFIG.root;\n      BASE.Ajax.params = STARTUP.params;\n      break;\n    }\n  }\n\n  var AGENT = navigator.userAgent;\n  var BROWSERS = {\n    isMac:       (navigator.platform.substr(0,3) === \"Mac\"),\n    isPC:        (navigator.platform.substr(0,3) === \"Win\"),\n    isMSIE:      (\"ActiveXObject\" in window && \"clipboardData\" in window),\n    isEdge:      (\"MSGestureEvent\" in window && \"chrome\" in window &&\n                     window.chrome.loadTimes == null),\n    isFirefox:   (!!AGENT.match(/Gecko\\//) && !AGENT.match(/like Gecko/)),\n    isSafari:    (!!AGENT.match(/ (Apple)?WebKit\\//) && !AGENT.match(/ like iPhone /) &&\n                     (!window.chrome || window.chrome.app == null)),\n    isChrome:    (\"chrome\" in window && window.chrome.loadTimes != null),\n    isOpera:     (\"opera\" in window && window.opera.version != null),\n    isKonqueror: (\"konqueror\" in window && navigator.vendor == \"KDE\"),\n    versionAtLeast: function (v) {\n      var bv = (this.version).split('.'); v = (new String(v)).split('.');\n      for (var i = 0, m = v.length; i < m; i++)\n        {if (bv[i] != v[i]) {return parseInt(bv[i]||\"0\") >= parseInt(v[i])}}\n      return true;\n    },\n    Select: function (choices) {\n      var browser = choices[HUB.Browser];\n      if (browser) {return browser(HUB.Browser)}\n      return null;\n    }\n  };\n\n  var xAGENT = AGENT\n    .replace(/^Mozilla\\/(\\d+\\.)+\\d+ /,\"\")                                   // remove initial Mozilla, which is never right\n    .replace(/[a-z][-a-z0-9._: ]+\\/\\d+[^ ]*-[^ ]*\\.([a-z][a-z])?\\d+ /i,\"\")  // remove linux version\n    .replace(/Gentoo |Ubuntu\\/(\\d+\\.)*\\d+ (\\([^)]*\\) )?/,\"\");               // special case for these\n\n  HUB.Browser = HUB.Insert(HUB.Insert(new String(\"Unknown\"),{version: \"0.0\"}),BROWSERS);\n  for (var browser in BROWSERS) {if (BROWSERS.hasOwnProperty(browser)) {\n    if (BROWSERS[browser] && browser.substr(0,2) === \"is\") {\n      browser = browser.slice(2);\n      if (browser === \"Mac\" || browser === \"PC\") continue;\n      HUB.Browser = HUB.Insert(new String(browser),BROWSERS);\n      var VERSION = new RegExp(\n        \".*(Version/| Trident/.*; rv:)((?:\\\\d+\\\\.)+\\\\d+)|\" +                      // for Safari, Opera10, and IE11+\n        \".*(\"+browser+\")\"+(browser == \"MSIE\" ? \" \" : \"/\")+\"((?:\\\\d+\\\\.)*\\\\d+)|\"+  // for one of the main browsers\n        \"(?:^|\\\\(| )([a-z][-a-z0-9._: ]+|(?:Apple)?WebKit)/((?:\\\\d+\\\\.)+\\\\d+)\");  // for unrecognized browser\n      var MATCH = VERSION.exec(xAGENT) || [\"\",\"\",\"\",\"unknown\",\"0.0\"];\n      HUB.Browser.name = (MATCH[1] != \"\" ? browser : (MATCH[3] || MATCH[5]));\n      HUB.Browser.version = MATCH[2] || MATCH[4] || MATCH[6];\n      break;\n    }\n  }};\n\n  //\n  //  Initial browser-specific info (e.g., touch up version or name, check for MathPlayer, etc.)\n  //  Wrap in try/catch just in case of error (see issue #1155).\n  //\n  try {HUB.Browser.Select({\n    Safari: function (browser) {\n      var v = parseInt((String(browser.version).split(\".\"))[0]);\n      if (v > 85) {browser.webkit = browser.version}\n      if      (v >= 538) {browser.version = \"8.0\"}\n      else if (v >= 537) {browser.version = \"7.0\"}\n      else if (v >= 536) {browser.version = \"6.0\"}\n      else if (v >= 534) {browser.version = \"5.1\"}\n      else if (v >= 533) {browser.version = \"5.0\"}\n      else if (v >= 526) {browser.version = \"4.0\"}\n      else if (v >= 525) {browser.version = \"3.1\"}\n      else if (v >  500) {browser.version = \"3.0\"}\n      else if (v >  400) {browser.version = \"2.0\"}\n      else if (v >   85) {browser.version = \"1.0\"}\n      browser.webkit = (navigator.appVersion.match(/WebKit\\/(\\d+)\\./))[1];\n      browser.isMobile = (navigator.appVersion.match(/Mobile/i) != null);\n      browser.noContextMenu = browser.isMobile;\n    },\n    Firefox: function (browser) {\n      if ((browser.version === \"0.0\" || AGENT.match(/Firefox/) == null) &&\n           navigator.product === \"Gecko\") {\n        var rv = AGENT.match(/[\\/ ]rv:(\\d+\\.\\d.*?)[\\) ]/);\n        if (rv) {browser.version = rv[1]}\n        else {\n          var date = (navigator.buildID||navigator.productSub||\"0\").substr(0,8);\n          if      (date >= \"20111220\") {browser.version = \"9.0\"}\n          else if (date >= \"20111120\") {browser.version = \"8.0\"}\n          else if (date >= \"20110927\") {browser.version = \"7.0\"}\n          else if (date >= \"20110816\") {browser.version = \"6.0\"}\n          else if (date >= \"20110621\") {browser.version = \"5.0\"}\n          else if (date >= \"20110320\") {browser.version = \"4.0\"}\n          else if (date >= \"20100121\") {browser.version = \"3.6\"}\n          else if (date >= \"20090630\") {browser.version = \"3.5\"}\n          else if (date >= \"20080617\") {browser.version = \"3.0\"}\n          else if (date >= \"20061024\") {browser.version = \"2.0\"}\n        }\n      }\n      browser.isMobile = (navigator.appVersion.match(/Android/i) != null ||\n                          AGENT.match(/ Fennec\\//) != null ||\n                          AGENT.match(/Mobile/) != null);\n    },\n    Chrome: function (browser) {\n      browser.noContextMenu = browser.isMobile = !!navigator.userAgent.match(/ Mobile[ \\/]/);\n    },\n    Opera: function (browser) {browser.version = opera.version()},\n    Edge: function (browser) {\n      browser.isMobile = !!navigator.userAgent.match(/ Phone/);\n    },\n    MSIE: function (browser) {\n      browser.isMobile = !!navigator.userAgent.match(/ Phone/);\n      browser.isIE9 = !!(document.documentMode && (window.performance || window.msPerformance));\n      MathJax.HTML.setScriptBug = !browser.isIE9 || document.documentMode < 9;\n      MathJax.Hub.msieHTMLCollectionBug = (document.documentMode < 9);\n      //\n      //  MathPlayer doesn't function properly in IE10, and not at all in IE11,\n      //  so don't even try to load it.\n      //\n      if (document.documentMode < 10 && !STARTUP.params.NoMathPlayer) {\n        try {\n          new ActiveXObject(\"MathPlayer.Factory.1\");\n          browser.hasMathPlayer = true;\n        } catch (err) {}\n        try {\n          if (browser.hasMathPlayer) {\n            var mathplayer = document.createElement(\"object\");\n            mathplayer.id = \"mathplayer\"; mathplayer.classid = \"clsid:32F66A20-7614-11D4-BD11-00104BD3F987\";\n            HEAD.appendChild(mathplayer);\n            document.namespaces.add(\"m\",\"http://www.w3.org/1998/Math/MathML\");\n            browser.mpNamespace = true;\n            if (document.readyState && (document.readyState === \"loading\" ||\n                                        document.readyState === \"interactive\")) {\n              document.write('<?import namespace=\"m\" implementation=\"#MathPlayer\">');\n              browser.mpImported = true;\n            }\n          } else {\n            //  Adding any namespace avoids a crash in IE9 in IE9-standards mode\n            //  (any reference to document.namespaces before document.readyState is\n            //   \"complete\" causes an \"unspecified error\" to be thrown)\n            document.namespaces.add(\"mjx_IE_fix\",\"http://www.w3.org/1999/xlink\");\n          }\n        } catch (err) {}\n      }\n    }\n  });} catch (err) {\n    console.error(err.message);\n  }\n  HUB.Browser.Select(MathJax.Message.browsers);\n\n  if (BASE.AuthorConfig && typeof BASE.AuthorConfig.AuthorInit === \"function\") {BASE.AuthorConfig.AuthorInit()}\n  HUB.queue = BASE.Callback.Queue();\n  HUB.queue.Push(\n    [\"Post\",STARTUP.signal,\"Begin\"],\n    [\"Config\",STARTUP],\n    [\"Cookie\",STARTUP],\n    [\"Styles\",STARTUP],\n    [\"Message\",STARTUP],\n    function () {\n      // Do Jax and Extensions in parallel, but wait for them all to complete\n      var queue = BASE.Callback.Queue(\n        STARTUP.Jax(),\n        STARTUP.Extensions()\n      );\n      return queue.Push({});\n    },\n    [\"Menu\",STARTUP],\n    STARTUP.onLoad(),\n    function () {MathJax.isReady = true}, // indicates that MathJax is ready to process math\n    [\"Typeset\",STARTUP],\n    [\"Hash\",STARTUP],\n    [\"MenuZoom\",STARTUP],\n    [\"Post\",STARTUP.signal,\"End\"]\n  );\n\n})(\"MathJax\");\n\n}}\n","// This file is part of Indico.\n// Copyright (C) 2002 - 2021 CERN\n//\n// Indico is free software; you can redistribute it and/or\n// modify it under the terms of the MIT License; see the\n// LICENSE file for more details.\n\n/* eslint-disable camelcase, one-var, no-lonely-if */\n/* global Markdown:false, MathJax:false, PageDownMathJax:false */\n\n// General MathJax configuration\n(function() {\n  MathJax.Ajax.config.root =\n    ($('html').data('static-site') ? 'static/' : Indico.Urls.Base) + '/dist/js/mathjax';\n})();\n\n(function() {\n  var DELIMITERS = [['$', '$'], ['$$', '$$']];\n\n  window.PageDownMathJax = function() {\n    var ready = false; // true after initial typeset is complete\n    var pending = false; // true when MathJax has been requested\n    var $preview = null; // the preview container\n    var ready_listeners = []; // the inline math delimiter\n\n    var blocks, start, end, last, braces; // used in searching for math\n    var math; // stores math until markdone is done\n    var HUB = MathJax.Hub;\n\n    //\n    // Runs after initial typeset\n    //\n    HUB.Queue(function() {\n      ready = true;\n      HUB.processUpdateTime = 50; // reduce update time so that we can cancel easier\n      HUB.Config({\n        'HTML-CSS': {\n          EqnChunk: 10,\n          EqnChunkFactor: 1,\n        }, // reduce chunk for more frequent updates\n        'SVG': {\n          EqnChunk: 10,\n          EqnChunkFactor: 1,\n        },\n      });\n\n      ready_listeners.forEach(listener => {\n        listener();\n      });\n    });\n\n    //\n    // The pattern for math delimiters and special symbols\n    // needed for searching for math in the page.\n    //\n    var SPLIT = /(\\$\\$?|\\\\(?:begin|end)\\{[a-z]*\\*?\\}|\\\\[\\\\{}$]|[{}]|(?:\\n\\s*)+|@@\\d+@@)/i;\n\n    /*\n     *  The math is in blocks i through j, so\n     * collect it into one block and clear the others.\n     * Replace &, <, and > by named entities.\n     * For IE, put <br> at the ends of comments since IE removes \\n.\n     * Clear the current math positions and store the index of the\n     * math, then push the math string onto the storage array.\n     */\n    function processMath(i, j) {\n      var block = blocks\n        .slice(i, j + 1)\n        .join('')\n        .replace(/&/g, '&') // use HTML entity for &\n        .replace(/</g, '<') // use HTML entity for <\n        .replace(/>/g, '>'); // use HTML entity for >\n      if (HUB.Browser.isMSIE) {\n        block = block.replace(/(%[^\\n]*)\\n/g, '$1<br/>\\n');\n      }\n      while (j > i) {\n        blocks[j] = '';\n        j--;\n      }\n      blocks[i] = '@@' + math.length + '@@';\n      math.push(block);\n      start = end = last = null;\n    }\n\n    //\n    // Break up the text into its component parts and search\n    // through them for math delimiters, braces, linebreaks, etc.\n    // Math delimiters must match and braces must balance.\n    // Don't allow math to pass through a double linebreak\n    // (which will be a paragraph).\n    //\n    function removeMath(text) {\n      start = end = last = null; // for tracking math delimiters\n      math = []; // stores math strings for latter\n\n      blocks = text.replace(/\\r\\n?/g, '\\n').split(SPLIT);\n      for (var i = 1, m = blocks.length; i < m; i += 2) {\n        var block = blocks[i];\n        if (block.charAt(0) === '@') {\n          //\n          // Things that look like our math markers will get\n          // stored and then retrieved along with the math.\n          //\n          blocks[i] = '@@' + math.length + '@@';\n          math.push(block);\n        } else if (start) {\n          //\n          // If we are in math, look for the end delimiter,\n          // but don't go past double line breaks, and\n          // and balance braces within the math.\n          //\n          if (block === end) {\n            if (braces) {\n              last = i;\n            } else {\n              processMath(start, i);\n            }\n          } else if (block.match(/\\n.*\\n/)) {\n            if (last) {\n              i = last;\n              processMath(start, i);\n            }\n            start = end = last = null;\n            braces = 0;\n          } else if (block === '{') {\n            braces++;\n          } else if (block === '}' && braces) {\n            braces--;\n          }\n        } else {\n          //\n          // Look for math start delimiters and when\n          // found, set up the end delimiter.\n          //\n          if (block === DELIMITERS[0][0] || block === DELIMITERS[1][0]) {\n            start = i;\n            end = block;\n            braces = 0;\n          } else if (block.substr(1, 5) === 'begin') {\n            start = i;\n            end = '\\\\end' + block.substr(6);\n            braces = 0;\n          }\n        }\n      }\n      if (last) {\n        processMath(start, last);\n      }\n      return blocks.join('');\n    }\n\n    //\n    // Put back the math strings that were saved,\n    // and clear the math array (no need to keep it around).\n    //\n    function replaceMath(text) {\n      text = text.replace(/@@(\\d+)@@/g, function(match, n) {\n        return math[n];\n      });\n      math = null;\n      return text;\n    }\n\n    //\n    // This is run to restart MathJax after it has finished\n    // the previous run (that may have been canceled)\n    //\n    function restartMJ(cb) {\n      pending = false;\n      HUB.cancelTypeset = false; // won't need to do this in the future\n\n      if ($preview) {\n        typeset($preview.get(0));\n      }\n\n      if (cb) {\n        HUB.Queue(cb);\n      }\n    }\n\n    //\n    // When the preview changes, cancel MathJax and restart,\n    // if we haven't done that already.\n    //\n    function updateMJ(elem, cb) {\n      var mathjaxEnabled = $(elem).data('no-mathjax') === undefined;\n      if (!mathjaxEnabled) {\n        cb();\n      } else if (!pending && ready) {\n        pending = true;\n        HUB.cancelTypeset = false;\n        HUB.Queue(restartMJ, cb);\n      }\n    }\n\n    function typeset(elem) {\n      if ($(elem).data('no-mathjax') === undefined) {\n        HUB.Queue(['Typeset', HUB, elem]);\n      }\n    }\n\n    function createPreview(elem, editorObject) {\n      var converterObject = editorObject.getConverter();\n      converterObject.hooks.chain('preConversion', removeMath);\n      converterObject.hooks.chain('postConversion', replaceMath);\n\n      function preview() {\n        updateMJ(elem, function() {\n          var new_height = $preview.outerHeight(),\n            $wrapper = $preview.closest('.md-preview-wrapper'),\n            is_empty = $preview.is(':empty');\n\n          $wrapper.toggleClass('empty', is_empty);\n          if (is_empty) {\n            $wrapper.css('height', '');\n          } else {\n            $wrapper.css('height', new_height);\n          }\n\n          $preview.scrollTop(new_height);\n        });\n      }\n\n      editorObject.hooks.chain('onPreviewRefresh', preview);\n      typeset($preview.get(0));\n      addListener(preview);\n    }\n\n    function createEditor(elem) {\n      var $container = $(elem).closest('[data-field-id]');\n      $preview = $container.find('.wmd-preview');\n\n      var fieldId = $container.data('fieldId'),\n        converter = Markdown.getSanitizingConverter();\n\n      converter.hooks.chain('preBlockGamut', function block_handler(text, rbg) {\n        return text.replace(/^ {0,3}\"\"\" *\\n((?:.*?\\n)+?) {0,3}\"\"\" *$/gm, function(whole, inner) {\n          return '<blockquote>' + rbg(inner) + '</blockquote>\\n';\n        });\n      });\n\n      var editor = new Markdown.Editor(converter, '-f_' + fieldId, {\n        helpButton: {\n          handler: function() {\n            return false;\n          },\n        },\n        strings: {\n          imagedialog:\n            '<p><b>Insert Image</b></p><p>http://example.com/images/diagram.jpg \"optional title\"',\n        },\n      });\n\n      createPreview(elem, editor);\n      editor.run();\n    }\n\n    function mathJax(elem) {\n      typeset(elem);\n    }\n\n    function addListener(listener) {\n      ready_listeners.push(listener);\n    }\n\n    return {\n      mathJax: mathJax,\n      createEditor: createEditor,\n    };\n  };\n\n  var pd = PageDownMathJax();\n\n  window.mathJax = pd.mathJax.bind(pd);\n\n  $.fn.mathJax = function() {\n    $(this).each(function() {\n      pd.mathJax(this);\n    });\n    return this;\n  };\n\n  $.fn.pagedown = function(arg1, arg2) {\n    function _pagedown(elem) {\n      var options = {},\n        pd_context = elem.data('pagedown'),\n        last_change = null,\n        $save_button = elem.siblings('.wmd-button-bar').find('.save-button');\n\n      function _set_saving() {\n        $save_button\n          .prop('disabled', true)\n          .addClass('saved')\n          .removeClass('saving waiting-save')\n          .text($T('Saving...'));\n        // the 'save' function will trigger a callback that sets\n        // the final state\n        options.save(elem.val(), function() {\n          $save_button\n            .text($T('Saved'))\n            .addClass('saved')\n            .removeClass('saving waiting-save');\n        });\n      }\n\n      function _save_cycle(my_time) {\n        return function() {\n          // if there's been a change meanwhile, don't do anything\n          if (last_change <= my_time) {\n            // otherwise, start saving\n            _set_saving();\n          }\n        };\n      }\n\n      if (pd_context) {\n        if (arg1 === 'auto-save' && $save_button.length) {\n          /*\n           * This is the 'auto-save' feature\n           * options:\n           *   - 'wait_time' - time to wait after a change, before saving\n           *   - save - function to be called on save (passed current data and callback)\n           *\n           * This feature also requires a '.save-button' button element to exist\n           * inside '.wmd-button-bar'\n           */\n\n          _.extend(options, arg2 || {});\n          elem.on('input', function() {\n            $save_button\n              .addClass('waiting-save')\n              .removeClass('saving saved')\n              .text($T('Save'))\n              .prop('disabled', false);\n\n            // let handlers (_save_cyle) know that they're out-of-date\n            // by updating last_change with the current time\n            last_change = new Date().getTime();\n            setTimeout(_save_cycle(last_change), options.wait_time || 2000);\n          });\n\n          $save_button.on('click', function() {\n            // let's kill handlers that may have been triggered\n            // by setting last_change to now\n            last_change = new Date().getTime();\n            _set_saving();\n          });\n        }\n      } else {\n        pd_context = PageDownMathJax();\n        elem.data('pagedown', pd_context);\n        pd_context.createEditor(elem.get(0));\n      }\n    }\n\n    $(this).each(function(i, elem) {\n      _pagedown($(elem));\n    });\n  };\n})();\n"],"sourceRoot":""}