/*
 *  /MathJax.js
 *
 *  Copyright (c) 2009-2018 The MathJax Consortium
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

if (document.getElementById && document.childNodes && document.createElement) {
  if (!(window.MathJax && MathJax.Hub)) {
    if (window.MathJax) {
      window.MathJax = { AuthorConfig: window.MathJax };
    } else {
      window.MathJax = {};
    }
    MathJax.isPacked = true;
    MathJax.version = "2.7.5";
    MathJax.fileversion = "2.7.5";
    MathJax.cdnVersion = "2.7.5";
    MathJax.cdnFileVersions = {};
    (function (d) {
      var b = window[d];
      if (!b) {
        b = window[d] = {};
      }
      var e = [];
      var c = function (f) {
        var g = f.constructor;
        if (!g) {
          g = function () {};
        }
        for (var h in f) {
          if (h !== "constructor" && f.hasOwnProperty(h)) {
            g[h] = f[h];
          }
        }
        return g;
      };
      var a = function () {
        return function () {
          return arguments.callee.Init.call(this, arguments);
        };
      };
      b.Object = c({
        constructor: a(),
        Subclass: function (f, h) {
          var g = a();
          g.SUPER = this;
          g.Init = this.Init;
          g.Subclass = this.Subclass;
          g.Augment = this.Augment;
          g.protoFunction = this.protoFunction;
          g.can = this.can;
          g.has = this.has;
          g.isa = this.isa;
          g.prototype = new this(e);
          g.prototype.constructor = g;
          g.Augment(f, h);
          return g;
        },
        Init: function (f) {
          var g = this;
          if (f.length === 1 && f[0] === e) {
            return g;
          }
          if (!(g instanceof f.callee)) {
            g = new f.callee(e);
          }
          return g.Init.apply(g, f) || g;
        },
        Augment: function (f, g) {
          var h;
          if (f != null) {
            for (h in f) {
              if (f.hasOwnProperty(h)) {
                this.protoFunction(h, f[h]);
              }
            }
            if (
              f.toString !== this.prototype.toString &&
              f.toString !== {}.toString
            ) {
              this.protoFunction("toString", f.toString);
            }
          }
          if (g != null) {
            for (h in g) {
              if (g.hasOwnProperty(h)) {
                this[h] = g[h];
              }
            }
          }
          return this;
        },
        protoFunction: function (g, f) {
          this.prototype[g] = f;
          if (typeof f === "function") {
            f.SUPER = this.SUPER.prototype;
          }
        },
        prototype: {
          Init: function () {},
          SUPER: function (f) {
            return f.callee.SUPER;
          },
          can: function (f) {
            return typeof this[f] === "function";
          },
          has: function (f) {
            return typeof this[f] !== "undefined";
          },
          isa: function (f) {
            return f instanceof Object && this instanceof f;
          },
        },
        can: function (f) {
          return this.prototype.can.call(this, f);
        },
        has: function (f) {
          return this.prototype.has.call(this, f);
        },
        isa: function (g) {
          var f = this;
          while (f) {
            if (f === g) {
              return true;
            } else {
              f = f.SUPER;
            }
          }
          return false;
        },
        SimpleSUPER: c({
          constructor: function (f) {
            return this.SimpleSUPER.define(f);
          },
          define: function (f) {
            var h = {};
            if (f != null) {
              for (var g in f) {
                if (f.hasOwnProperty(g)) {
                  h[g] = this.wrap(g, f[g]);
                }
              }
              if (
                f.toString !== this.prototype.toString &&
                f.toString !== {}.toString
              ) {
                h.toString = this.wrap("toString", f.toString);
              }
            }
            return h;
          },
          wrap: function (i, h) {
            if (
              typeof h !== "function" ||
              !h.toString().match(/\.\s*SUPER\s*\(/)
            ) {
              return h;
            }
            var g = function () {
              this.SUPER = g.SUPER[i];
              try {
                var f = h.apply(this, arguments);
              } catch (j) {
                delete this.SUPER;
                throw j;
              }
              delete this.SUPER;
              return f;
            };
            g.toString = function () {
              return h.toString.apply(h, arguments);
            };
            return g;
          },
        }),
      });
      b.Object.isArray =
        Array.isArray ||
        function (f) {
          return Object.prototype.toString.call(f) === "[object Array]";
        };
      b.Object.Array = Array;
    })("MathJax");
    (function (BASENAME) {
      var BASE = window[BASENAME];
      if (!BASE) {
        BASE = window[BASENAME] = {};
      }
      var isArray = BASE.Object.isArray;
      var CALLBACK = function (data) {
        var cb = function () {
          return arguments.callee.execute.apply(arguments.callee, arguments);
        };
        for (var id in CALLBACK.prototype) {
          if (CALLBACK.prototype.hasOwnProperty(id)) {
            if (typeof data[id] !== "undefined") {
              cb[id] = data[id];
            } else {
              cb[id] = CALLBACK.prototype[id];
            }
          }
        }
        cb.toString = CALLBACK.prototype.toString;
        return cb;
      };
      CALLBACK.prototype = {
        isCallback: true,
        hook: function () {},
        data: [],
        object: window,
        execute: function () {
          if (!this.called || this.autoReset) {
            this.called = !this.autoReset;
            return this.hook.apply(
              this.object,
              this.data.concat([].slice.call(arguments, 0))
            );
          }
        },
        reset: function () {
          delete this.called;
        },
        toString: function () {
          return this.hook.toString.apply(this.hook, arguments);
        },
      };
      var ISCALLBACK = function (f) {
        return typeof f === "function" && f.isCallback;
      };
      var EVAL = function (code) {
        return eval.call(window, code);
      };
      var TESTEVAL = function () {
        EVAL("var __TeSt_VaR__ = 1");
        if (window.__TeSt_VaR__) {
          try {
            delete window.__TeSt_VaR__;
          } catch (error) {
            window.__TeSt_VaR__ = null;
          }
        } else {
          if (window.execScript) {
            EVAL = function (code) {
              BASE.__code = code;
              code =
                "try {" +
                BASENAME +
                ".__result = eval(" +
                BASENAME +
                ".__code)} catch(err) {" +
                BASENAME +
                ".__result = err}";
              window.execScript(code);
              var result = BASE.__result;
              delete BASE.__result;
              delete BASE.__code;
              if (result instanceof Error) {
                throw result;
              }
              return result;
            };
          } else {
            EVAL = function (code) {
              BASE.__code = code;
              code =
                "try {" +
                BASENAME +
                ".__result = eval(" +
                BASENAME +
                ".__code)} catch(err) {" +
                BASENAME +
                ".__result = err}";
              var head = document.getElementsByTagName("head")[0];
              if (!head) {
                head = document.body;
              }
              var script = document.createElement("script");
              script.appendChild(document.createTextNode(code));
              head.appendChild(script);
              head.removeChild(script);
              var result = BASE.__result;
              delete BASE.__result;
              delete BASE.__code;
              if (result instanceof Error) {
                throw result;
              }
              return result;
            };
          }
        }
        TESTEVAL = null;
      };
      var USING = function (args, i) {
        if (arguments.length > 1) {
          if (
            arguments.length === 2 &&
            !(typeof arguments[0] === "function") &&
            arguments[0] instanceof Object &&
            typeof arguments[1] === "number"
          ) {
            args = [].slice.call(args, i);
          } else {
            args = [].slice.call(arguments, 0);
          }
        }
        if (
          isArray(args) &&
          args.length === 1 &&
          typeof args[0] === "function"
        ) {
          args = args[0];
        }
        if (typeof args === "function") {
          if (args.execute === CALLBACK.prototype.execute) {
            return args;
          }
          return CALLBACK({ hook: args });
        } else {
          if (isArray(args)) {
            if (
              typeof args[0] === "string" &&
              args[1] instanceof Object &&
              typeof args[1][args[0]] === "function"
            ) {
              return CALLBACK({
                hook: args[1][args[0]],
                object: args[1],
                data: args.slice(2),
              });
            } else {
              if (typeof args[0] === "function") {
                return CALLBACK({ hook: args[0], data: args.slice(1) });
              } else {
                if (typeof args[1] === "function") {
                  return CALLBACK({
                    hook: args[1],
                    object: args[0],
                    data: args.slice(2),
                  });
                }
              }
            }
          } else {
            if (typeof args === "string") {
              if (TESTEVAL) {
                TESTEVAL();
              }
              return CALLBACK({ hook: EVAL, data: [args] });
            } else {
              if (args instanceof Object) {
                return CALLBACK(args);
              } else {
                if (typeof args === "undefined") {
                  return CALLBACK({});
                }
              }
            }
          }
        }
        throw Error("Can't make callback from given data");
      };
      var DELAY = function (time, callback) {
        callback = USING(callback);
        callback.timeout = setTimeout(callback, time);
        return callback;
      };
      var WAITFOR = function (callback, signal) {
        callback = USING(callback);
        if (!callback.called) {
          WAITSIGNAL(callback, signal);
          signal.pending++;
        }
      };
      var WAITEXECUTE = function () {
        var signals = this.signal;
        delete this.signal;
        this.execute = this.oldExecute;
        delete this.oldExecute;
        var result = this.execute.apply(this, arguments);
        if (ISCALLBACK(result) && !result.called) {
          WAITSIGNAL(result, signals);
        } else {
          for (var i = 0, m = signals.length; i < m; i++) {
            signals[i].pending--;
            if (signals[i].pending <= 0) {
              signals[i].call();
            }
          }
        }
      };
      var WAITSIGNAL = function (callback, signals) {
        if (!isArray(signals)) {
          signals = [signals];
        }
        if (!callback.signal) {
          callback.oldExecute = callback.execute;
          callback.execute = WAITEXECUTE;
          callback.signal = signals;
        } else {
          if (signals.length === 1) {
            callback.signal.push(signals[0]);
          } else {
            callback.signal = callback.signal.concat(signals);
          }
        }
      };
      var AFTER = function (callback) {
        callback = USING(callback);
        callback.pending = 0;
        for (var i = 1, m = arguments.length; i < m; i++) {
          if (arguments[i]) {
            WAITFOR(arguments[i], callback);
          }
        }
        if (callback.pending === 0) {
          var result = callback();
          if (ISCALLBACK(result)) {
            callback = result;
          }
        }
        return callback;
      };
      var HOOKS = MathJax.Object.Subclass({
        Init: function (reset) {
          this.hooks = [];
          this.remove = [];
          this.reset = reset;
          this.running = false;
        },
        Add: function (hook, priority) {
          if (priority == null) {
            priority = 10;
          }
          if (!ISCALLBACK(hook)) {
            hook = USING(hook);
          }
          hook.priority = priority;
          var i = this.hooks.length;
          while (i > 0 && priority < this.hooks[i - 1].priority) {
            i--;
          }
          this.hooks.splice(i, 0, hook);
          return hook;
        },
        Remove: function (hook) {
          for (var i = 0, m = this.hooks.length; i < m; i++) {
            if (this.hooks[i] === hook) {
              if (this.running) {
                this.remove.push(i);
              } else {
                this.hooks.splice(i, 1);
              }
              return;
            }
          }
        },
        Execute: function () {
          var callbacks = [{}];
          this.running = true;
          for (var i = 0, m = this.hooks.length; i < m; i++) {
            if (this.reset) {
              this.hooks[i].reset();
            }
            var result = this.hooks[i].apply(window, arguments);
            if (ISCALLBACK(result) && !result.called) {
              callbacks.push(result);
            }
          }
          this.running = false;
          if (this.remove.length) {
            this.RemovePending();
          }
          if (callbacks.length === 1) {
            return null;
          }
          if (callbacks.length === 2) {
            return callbacks[1];
          }
          return AFTER.apply({}, callbacks);
        },
        RemovePending: function () {
          this.remove = this.remove.sort();
          for (var i = this.remove.length - 1; i >= 0; i--) {
            this.hooks.splice(i, 1);
          }
          this.remove = [];
        },
      });
      var EXECUTEHOOKS = function (hooks, data, reset) {
        if (!hooks) {
          return null;
        }
        if (!isArray(hooks)) {
          hooks = [hooks];
        }
        if (!isArray(data)) {
          data = data == null ? [] : [data];
        }
        var handler = HOOKS(reset);
        for (var i = 0, m = hooks.length; i < m; i++) {
          handler.Add(hooks[i]);
        }
        return handler.Execute.apply(handler, data);
      };
      var QUEUE = BASE.Object.Subclass({
        Init: function () {
          this.pending = this.running = 0;
          this.queue = [];
          this.Push.apply(this, arguments);
        },
        Push: function () {
          var callback;
          for (var i = 0, m = arguments.length; i < m; i++) {
            callback = USING(arguments[i]);
            if (callback === arguments[i] && !callback.called) {
              callback = USING(["wait", this, callback]);
            }
            this.queue.push(callback);
          }
          if (!this.running && !this.pending) {
            this.Process();
          }
          return callback;
        },
        Process: function (queue) {
          while (!this.running && !this.pending && this.queue.length) {
            var callback = this.queue[0];
            queue = this.queue.slice(1);
            this.queue = [];
            this.Suspend();
            var result = callback();
            this.Resume();
            if (queue.length) {
              this.queue = queue.concat(this.queue);
            }
            if (ISCALLBACK(result) && !result.called) {
              WAITFOR(result, this);
            }
          }
        },
        Suspend: function () {
          this.running++;
        },
        Resume: function () {
          if (this.running) {
            this.running--;
          }
        },
        call: function () {
          this.Process.apply(this, arguments);
        },
        wait: function (callback) {
          return callback;
        },
      });
      var SIGNAL = QUEUE.Subclass(
        {
          Init: function (name) {
            QUEUE.prototype.Init.call(this);
            this.name = name;
            this.posted = [];
            this.listeners = HOOKS(true);
            this.posting = false;
            this.callback = null;
          },
          Post: function (message, callback, forget) {
            callback = USING(callback);
            if (this.posting || this.pending) {
              this.Push(["Post", this, message, callback, forget]);
            } else {
              this.callback = callback;
              callback.reset();
              if (!forget) {
                this.posted.push(message);
              }
              this.Suspend();
              this.posting = true;
              var result = this.listeners.Execute(message);
              if (ISCALLBACK(result) && !result.called) {
                WAITFOR(result, this);
              }
              this.Resume();
              this.posting = false;
              if (!this.pending) {
                this.call();
              }
            }
            return callback;
          },
          Clear: function (callback) {
            callback = USING(callback);
            if (this.posting || this.pending) {
              callback = this.Push(["Clear", this, callback]);
            } else {
              this.posted = [];
              callback();
            }
            return callback;
          },
          call: function () {
            this.callback(this);
            this.Process();
          },
          Interest: function (callback, ignorePast, priority) {
            callback = USING(callback);
            this.listeners.Add(callback, priority);
            if (!ignorePast) {
              for (var i = 0, m = this.posted.length; i < m; i++) {
                callback.reset();
                var result = callback(this.posted[i]);
                if (ISCALLBACK(result) && i === this.posted.length - 1) {
                  WAITFOR(result, this);
                }
              }
            }
            return callback;
          },
          NoInterest: function (callback) {
            this.listeners.Remove(callback);
          },
          MessageHook: function (msg, callback, priority) {
            callback = USING(callback);
            if (!this.hooks) {
              this.hooks = {};
              this.Interest(["ExecuteHooks", this]);
            }
            if (!this.hooks[msg]) {
              this.hooks[msg] = HOOKS(true);
            }
            this.hooks[msg].Add(callback, priority);
            for (var i = 0, m = this.posted.length; i < m; i++) {
              if (this.posted[i] == msg) {
                callback.reset();
                callback(this.posted[i]);
              }
            }
            callback.msg = msg;
            return callback;
          },
          ExecuteHooks: function (msg) {
            var type = isArray(msg) ? msg[0] : msg;
            if (!this.hooks[type]) {
              return null;
            }
            return this.hooks[type].Execute(msg);
          },
          RemoveHook: function (hook) {
            this.hooks[hook.msg].Remove(hook);
          },
        },
        {
          signals: {},
          find: function (name) {
            if (!SIGNAL.signals[name]) {
              SIGNAL.signals[name] = new SIGNAL(name);
            }
            return SIGNAL.signals[name];
          },
        }
      );
      BASE.Callback = BASE.CallBack = USING;
      BASE.Callback.Delay = DELAY;
      BASE.Callback.After = AFTER;
      BASE.Callback.Queue = QUEUE;
      BASE.Callback.Signal = SIGNAL.find;
      BASE.Callback.Hooks = HOOKS;
      BASE.Callback.ExecuteHooks = EXECUTEHOOKS;
    })("MathJax");
    (function (e) {
      var a = window[e];
      if (!a) {
        a = window[e] = {};
      }
      var d =
        navigator.vendor === "Apple Computer, Inc." &&
        typeof navigator.vendorSub === "undefined";
      var g = 0;
      var h = function (i) {
        if (document.styleSheets && document.styleSheets.length > g) {
          g = document.styleSheets.length;
        }
        if (!i) {
          i = document.head || document.getElementsByTagName("head")[0];
          if (!i) {
            i = document.body;
          }
        }
        return i;
      };
      var f = [];
      var c = function () {
        for (var k = 0, j = f.length; k < j; k++) {
          a.Ajax.head.removeChild(f[k]);
        }
        f = [];
      };
      var b = {};
      b[e] = "";
      b.a11y = "[MathJax]/extensions/a11y";
      b.Contrib = "https://cdn.mathjax.org/mathjax/contrib";
      a.Ajax = {
        loaded: {},
        loading: {},
        loadHooks: {},
        timeout: 15 * 1000,
        styleDelay: 1,
        config: { root: "", path: b },
        params: {},
        STATUS: { OK: 1, ERROR: -1 },
        fileURL: function (j) {
          var i;
          while (
            (i = j.match(/^\[([-._a-z0-9]+)\]/i)) &&
            b.hasOwnProperty(i[1])
          ) {
            j = (b[i[1]] || this.config.root) + j.substr(i[1].length + 2);
          }
          return j;
        },
        fileName: function (j) {
          var i = this.config.root;
          if (j.substr(0, i.length) === i) {
            j = "[" + e + "]" + j.substr(i.length);
          }
          do {
            var k = false;
            for (var l in b) {
              if (b.hasOwnProperty(l) && b[l]) {
                if (j.substr(0, b[l].length) === b[l]) {
                  j = "[" + l + "]" + j.substr(b[l].length);
                  k = true;
                  break;
                }
              }
            }
          } while (k);
          return j;
        },
        fileRev: function (j) {
          var i = a.cdnFileVersions[j] || a.cdnVersion || "";
          if (i) {
            i = "?V=" + i;
          }
          return i;
        },
        urlRev: function (i) {
          return this.fileURL(i) + this.fileRev(i);
        },
        Require: function (k, n) {
          n = a.Callback(n);
          var l;
          if (k instanceof Object) {
            for (var j in k) {
              if (k.hasOwnProperty(j)) {
                l = j.toUpperCase();
                k = k[j];
              }
            }
          } else {
            l = k.split(/\./).pop().toUpperCase();
          }
          if (this.params.noContrib && k.substr(0, 9) === "[Contrib]") {
            n(this.STATUS.ERROR);
          } else {
            k = this.fileURL(k);
            if (this.loaded[k]) {
              n(this.loaded[k]);
            } else {
              var m = {};
              m[l] = k;
              this.Load(m, n);
            }
          }
          return n;
        },
        Load: function (k, m) {
          m = a.Callback(m);
          var l;
          if (k instanceof Object) {
            for (var j in k) {
              if (k.hasOwnProperty(j)) {
                l = j.toUpperCase();
                k = k[j];
              }
            }
          } else {
            l = k.split(/\./).pop().toUpperCase();
          }
          k = this.fileURL(k);
          if (this.loading[k]) {
            this.addHook(k, m);
          } else {
            this.head = h(this.head);
            if (this.loader[l]) {
              this.loader[l].call(this, k, m);
            } else {
              throw Error("Can't load files of type " + l);
            }
          }
          return m;
        },
        LoadHook: function (l, m, k) {
          m = a.Callback(m);
          if (l instanceof Object) {
            for (var j in l) {
              if (l.hasOwnProperty(j)) {
                l = l[j];
              }
            }
          }
          l = this.fileURL(l);
          if (this.loaded[l]) {
            m(this.loaded[l]);
          } else {
            this.addHook(l, m, k);
          }
          return m;
        },
        addHook: function (j, k, i) {
          if (!this.loadHooks[j]) {
            this.loadHooks[j] = MathJax.Callback.Hooks();
          }
          this.loadHooks[j].Add(k, i);
          k.file = j;
        },
        removeHook: function (i) {
          if (this.loadHooks[i.file]) {
            this.loadHooks[i.file].Remove(i);
            if (!this.loadHooks[i.file].hooks.length) {
              delete this.loadHooks[i.file];
            }
          }
        },
        Preloading: function () {
          for (var l = 0, j = arguments.length; l < j; l++) {
            var k = this.fileURL(arguments[l]);
            if (!this.loading[k]) {
              this.loading[k] = { preloaded: true };
            }
          }
        },
        loader: {
          JS: function (k, m) {
            var j = this.fileName(k);
            var i = document.createElement("script");
            var l = a.Callback(["loadTimeout", this, k]);
            this.loading[k] = {
              callback: m,
              timeout: setTimeout(l, this.timeout),
              status: this.STATUS.OK,
              script: i,
            };
            this.loading[k].message = a.Message.File(j);
            i.onerror = l;
            i.type = "text/javascript";
            i.src = k + this.fileRev(j);
            this.head.appendChild(i);
          },
          CSS: function (j, l) {
            var i = this.fileName(j);
            var k = document.createElement("link");
            k.rel = "stylesheet";
            k.type = "text/css";
            k.href = j + this.fileRev(i);
            this.loading[j] = {
              callback: l,
              message: a.Message.File(i),
              status: this.STATUS.OK,
            };
            this.head.appendChild(k);
            this.timer.create.call(this, [this.timer.file, j], k);
          },
        },
        timer: {
          create: function (j, i) {
            j = a.Callback(j);
            if (
              i.nodeName === "STYLE" &&
              i.styleSheet &&
              typeof i.styleSheet.cssText !== "undefined"
            ) {
              j(this.STATUS.OK);
            } else {
              if (window.chrome && i.nodeName === "LINK") {
                j(this.STATUS.OK);
              } else {
                if (d) {
                  this.timer.start(
                    this,
                    [this.timer.checkSafari2, g++, j],
                    this.styleDelay
                  );
                } else {
                  this.timer.start(
                    this,
                    [this.timer.checkLength, i, j],
                    this.styleDelay
                  );
                }
              }
            }
            return j;
          },
          start: function (j, i, k, l) {
            i = a.Callback(i);
            i.execute = this.execute;
            i.time = this.time;
            i.STATUS = j.STATUS;
            i.timeout = l || j.timeout;
            i.delay = i.total = k || 0;
            if (k) {
              setTimeout(i, k);
            } else {
              i();
            }
          },
          time: function (i) {
            this.total += this.delay;
            this.delay = Math.floor(this.delay * 1.05 + 5);
            if (this.total >= this.timeout) {
              i(this.STATUS.ERROR);
              return 1;
            }
            return 0;
          },
          file: function (j, i) {
            if (i < 0) {
              a.Ajax.loadTimeout(j);
            } else {
              a.Ajax.loadComplete(j);
            }
          },
          execute: function () {
            this.hook.call(this.object, this, this.data[0], this.data[1]);
          },
          checkSafari2: function (i, j, k) {
            if (i.time(k)) {
              return;
            }
            if (
              document.styleSheets.length > j &&
              document.styleSheets[j].cssRules &&
              document.styleSheets[j].cssRules.length
            ) {
              k(i.STATUS.OK);
            } else {
              setTimeout(i, i.delay);
            }
          },
          checkLength: function (i, l, n) {
            if (i.time(n)) {
              return;
            }
            var m = 0;
            var j = l.sheet || l.styleSheet;
            try {
              if ((j.cssRules || j.rules || []).length > 0) {
                m = 1;
              }
            } catch (k) {
              if (k.message.match(/protected variable|restricted URI/)) {
                m = 1;
              } else {
                if (k.message.match(/Security error/)) {
                  m = 1;
                }
              }
            }
            if (m) {
              setTimeout(a.Callback([n, i.STATUS.OK]), 0);
            } else {
              setTimeout(i, i.delay);
            }
          },
        },
        loadComplete: function (i) {
          i = this.fileURL(i);
          var j = this.loading[i];
          if (j && !j.preloaded) {
            a.Message.Clear(j.message);
            clearTimeout(j.timeout);
            if (j.script) {
              if (f.length === 0) {
                setTimeout(c, 0);
              }
              f.push(j.script);
            }
            this.loaded[i] = j.status;
            delete this.loading[i];
            this.addHook(i, j.callback);
          } else {
            if (j) {
              delete this.loading[i];
            }
            this.loaded[i] = this.STATUS.OK;
            j = { status: this.STATUS.OK };
          }
          if (!this.loadHooks[i]) {
            return null;
          }
          return this.loadHooks[i].Execute(j.status);
        },
        loadTimeout: function (i) {
          if (this.loading[i].timeout) {
            clearTimeout(this.loading[i].timeout);
          }
          this.loading[i].status = this.STATUS.ERROR;
          this.loadError(i);
          this.loadComplete(i);
        },
        loadError: function (i) {
          a.Message.Set(
            ["LoadFailed", "File failed to load: %1", i],
            null,
            2000
          );
          a.Hub.signal.Post(["file load error", i]);
        },
        Styles: function (k, l) {
          var i = this.StyleString(k);
          if (i === "") {
            l = a.Callback(l);
            l();
          } else {
            var j = document.createElement("style");
            j.type = "text/css";
            this.head = h(this.head);
            this.head.appendChild(j);
            if (j.styleSheet && typeof j.styleSheet.cssText !== "undefined") {
              j.styleSheet.cssText = i;
            } else {
              j.appendChild(document.createTextNode(i));
            }
            l = this.timer.create.call(this, l, j);
          }
          return l;
        },
        StyleString: function (n) {
          if (typeof n === "string") {
            return n;
          }
          var k = "",
            o,
            m;
          for (o in n) {
            if (n.hasOwnProperty(o)) {
              if (typeof n[o] === "string") {
                k += o + " {" + n[o] + "}\n";
              } else {
                if (a.Object.isArray(n[o])) {
                  for (var l = 0; l < n[o].length; l++) {
                    m = {};
                    m[o] = n[o][l];
                    k += this.StyleString(m);
                  }
                } else {
                  if (o.substr(0, 6) === "@media") {
                    k += o + " {" + this.StyleString(n[o]) + "}\n";
                  } else {
                    if (n[o] != null) {
                      m = [];
                      for (var j in n[o]) {
                        if (n[o].hasOwnProperty(j)) {
                          if (n[o][j] != null) {
                            m[m.length] = j + ": " + n[o][j];
                          }
                        }
                      }
                      k += o + " {" + m.join("; ") + "}\n";
                    }
                  }
                }
              }
            }
          }
          return k;
        },
      };
    })("MathJax");
    MathJax.HTML = {
      Element: function (d, f, e) {
        var g = document.createElement(d),
          h;
        if (f) {
          if (f.hasOwnProperty("style")) {
            var c = f.style;
            f.style = {};
            for (h in c) {
              if (c.hasOwnProperty(h)) {
                f.style[h.replace(/-([a-z])/g, this.ucMatch)] = c[h];
              }
            }
          }
          MathJax.Hub.Insert(g, f);
          for (h in f) {
            if (h === "role" || h.substr(0, 5) === "aria-") {
              g.setAttribute(h, f[h]);
            }
          }
        }
        if (e) {
          if (!MathJax.Object.isArray(e)) {
            e = [e];
          }
          for (var b = 0, a = e.length; b < a; b++) {
            if (MathJax.Object.isArray(e[b])) {
              g.appendChild(this.Element(e[b][0], e[b][1], e[b][2]));
            } else {
              if (d === "script") {
                this.setScript(g, e[b]);
              } else {
                g.appendChild(document.createTextNode(e[b]));
              }
            }
          }
        }
        return g;
      },
      ucMatch: function (a, b) {
        return b.toUpperCase();
      },
      addElement: function (b, a, d, c) {
        return b.appendChild(this.Element(a, d, c));
      },
      TextNode: function (a) {
        return document.createTextNode(a);
      },
      addText: function (a, b) {
        return a.appendChild(this.TextNode(b));
      },
      setScript: function (a, b) {
        if (this.setScriptBug) {
          a.text = b;
        } else {
          while (a.firstChild) {
            a.removeChild(a.firstChild);
          }
          this.addText(a, b);
        }
      },
      getScript: function (a) {
        var b = a.text === "" ? a.innerHTML : a.text;
        return b.replace(/^\s+/, "").replace(/\s+$/, "");
      },
      Cookie: {
        prefix: "mjx",
        expires: 365,
        Set: function (a, e) {
          var d = [];
          if (e) {
            for (var g in e) {
              if (e.hasOwnProperty(g)) {
                d.push(g + ":" + e[g].toString().replace(/&/g, "&&"));
              }
            }
          }
          var b = this.prefix + "." + a + "=" + escape(d.join("&;"));
          if (this.expires) {
            var f = new Date();
            f.setDate(f.getDate() + this.expires);
            b += "; expires=" + f.toGMTString();
          }
          try {
            document.cookie = b + "; path=/";
          } catch (c) {}
        },
        Get: function (a, d) {
          if (!d) {
            d = {};
          }
          var g = new RegExp(
            "(?:^|;\\s*)" + this.prefix + "\\." + a + "=([^;]*)(?:;|$)"
          );
          var f;
          try {
            f = g.exec(document.cookie);
          } catch (c) {}
          if (f && f[1] !== "") {
            var j = unescape(f[1]).split("&;");
            for (var e = 0, b = j.length; e < b; e++) {
              f = j[e].match(/([^:]+):(.*)/);
              var h = f[2].replace(/&&/g, "&");
              if (h === "true") {
                h = true;
              } else {
                if (h === "false") {
                  h = false;
                } else {
                  if (h.match(/^-?(\d+(\.\d+)?|\.\d+)$/)) {
                    h = parseFloat(h);
                  }
                }
              }
              d[f[1]] = h;
            }
          }
          return d;
        },
      },
    };
    MathJax.Localization = {
      locale: "en",
      directory: "[MathJax]/localization",
      strings: {
        ar: { menuTitle: "\u0627\u0644\u0639\u0631\u0628\u064A\u0629" },
        ast: { menuTitle: "asturianu" },
        bg: {
          menuTitle: "\u0431\u044A\u043B\u0433\u0430\u0440\u0441\u043A\u0438",
        },
        bcc: { menuTitle: "\u0628\u0644\u0648\u0686\u06CC" },
        br: { menuTitle: "brezhoneg" },
        ca: { menuTitle: "catal\u00E0" },
        cdo: { menuTitle: "M\u00ECng-d\u0115\u0324ng-ng\u1E73\u0304" },
        cs: { menuTitle: "\u010De\u0161tina" },
        da: { menuTitle: "dansk" },
        de: { menuTitle: "Deutsch" },
        diq: { menuTitle: "Zazaki" },
        en: { menuTitle: "English", isLoaded: true },
        eo: { menuTitle: "Esperanto" },
        es: { menuTitle: "espa\u00F1ol" },
        fa: { menuTitle: "\u0641\u0627\u0631\u0633\u06CC" },
        fi: { menuTitle: "suomi" },
        fr: { menuTitle: "fran\u00E7ais" },
        gl: { menuTitle: "galego" },
        he: { menuTitle: "\u05E2\u05D1\u05E8\u05D9\u05EA" },
        ia: { menuTitle: "interlingua" },
        it: { menuTitle: "italiano" },
        ja: { menuTitle: "\u65E5\u672C\u8A9E" },
        kn: { menuTitle: "\u0C95\u0CA8\u0CCD\u0CA8\u0CA1" },
        ko: { menuTitle: "\uD55C\uAD6D\uC5B4" },
        lb: { menuTitle: "L\u00EBtzebuergesch" },
        lki: { menuTitle: "\u0644\u06D5\u06A9\u06CC" },
        lt: { menuTitle: "lietuvi\u0173" },
        mk: {
          menuTitle:
            "\u043C\u0430\u043A\u0435\u0434\u043E\u043D\u0441\u043A\u0438",
        },
        nl: { menuTitle: "Nederlands" },
        oc: { menuTitle: "occitan" },
        pl: { menuTitle: "polski" },
        pt: { menuTitle: "portugu\u00EAs" },
        "pt-br": { menuTitle: "portugu\u00EAs do Brasil" },
        ru: { menuTitle: "\u0440\u0443\u0441\u0441\u043A\u0438\u0439" },
        sco: { menuTitle: "Scots" },
        scn: { menuTitle: "sicilianu" },
        sk: { menuTitle: "sloven\u010Dina" },
        sl: { menuTitle: "sloven\u0161\u010Dina" },
        sv: { menuTitle: "svenska" },
        th: { menuTitle: "\u0E44\u0E17\u0E22" },
        tr: { menuTitle: "T\u00FCrk\u00E7e" },
        uk: {
          menuTitle:
            "\u0443\u043A\u0440\u0430\u0457\u043D\u0441\u044C\u043A\u0430",
        },
        vi: { menuTitle: "Ti\u1EBFng Vi\u1EC7t" },
        "zh-hans": { menuTitle: "\u4E2D\u6587\uFF08\u7B80\u4F53\uFF09" },
        "zh-hant": { menuTitle: "\u6C49\u8BED" },
      },
      pattern:
        /%(\d+|\{\d+\}|\{[a-z]+:\%\d+(?:\|(?:%\{\d+\}|%.|[^\}])*)+\}|.)/g,
      SPLIT:
        "axb".split(/(x)/).length === 3
          ? function (a, b) {
              return a.split(b);
            }
          : function (c, e) {
              var a = [],
                b,
                d = 0;
              e.lastIndex = 0;
              while ((b = e.exec(c))) {
                a.push(c.substr(d, b.index - d));
                a.push.apply(a, b.slice(1));
                d = b.index + b[0].length;
              }
              a.push(c.substr(d));
              return a;
            },
      _: function (b, a) {
        if (MathJax.Object.isArray(a)) {
          return this.processSnippet(b, a);
        }
        return this.processString(
          this.lookupPhrase(b, a),
          [].slice.call(arguments, 2)
        );
      },
      processString: function (l, p, g) {
        var j,
          e,
          o = MathJax.Object.isArray;
        for (j = 0, e = p.length; j < e; j++) {
          if (g && o(p[j])) {
            p[j] = this.processSnippet(g, p[j]);
          }
        }
        var f = this.SPLIT(l, this.pattern);
        for (j = 1, e = f.length; j < e; j += 2) {
          var q = f[j].charAt(0);
          if (q >= "0" && q <= "9") {
            f[j] = p[f[j] - 1];
            if (typeof f[j] === "number") {
              f[j] = this.number(f[j]);
            }
          } else {
            if (q === "{") {
              q = f[j].substr(1);
              if (q >= "0" && q <= "9") {
                f[j] = p[f[j].substr(1, f[j].length - 2) - 1];
                if (typeof f[j] === "number") {
                  f[j] = this.number(f[j]);
                }
              } else {
                var k = f[j].match(/^\{([a-z]+):%(\d+)\|(.*)\}$/);
                if (k) {
                  if (k[1] === "plural") {
                    var d = p[k[2] - 1];
                    if (typeof d === "undefined") {
                      f[j] = "???";
                    } else {
                      d = this.plural(d) - 1;
                      var h = k[3]
                        .replace(/(^|[^%])(%%)*%\|/g, "$1$2%\uEFEF")
                        .split(/\|/);
                      if (d >= 0 && d < h.length) {
                        f[j] = this.processString(
                          h[d].replace(/\uEFEF/g, "|"),
                          p,
                          g
                        );
                      } else {
                        f[j] = "???";
                      }
                    }
                  } else {
                    f[j] = "%" + f[j];
                  }
                }
              }
            }
          }
          if (f[j] == null) {
            f[j] = "???";
          }
        }
        if (!g) {
          return f.join("");
        }
        var a = [],
          b = "";
        for (j = 0; j < e; j++) {
          b += f[j];
          j++;
          if (j < e) {
            if (o(f[j])) {
              a.push(b);
              a = a.concat(f[j]);
              b = "";
            } else {
              b += f[j];
            }
          }
        }
        if (b !== "") {
          a.push(b);
        }
        return a;
      },
      processSnippet: function (g, e) {
        var c = [];
        for (var d = 0, b = e.length; d < b; d++) {
          if (MathJax.Object.isArray(e[d])) {
            var f = e[d];
            if (typeof f[1] === "string") {
              var h = f[0];
              if (!MathJax.Object.isArray(h)) {
                h = [g, h];
              }
              var a = this.lookupPhrase(h, f[1]);
              c = c.concat(this.processMarkdown(a, f.slice(2), g));
            } else {
              if (MathJax.Object.isArray(f[1])) {
                c = c.concat(this.processSnippet.apply(this, f));
              } else {
                if (f.length >= 3) {
                  c.push([f[0], f[1], this.processSnippet(g, f[2])]);
                } else {
                  c.push(e[d]);
                }
              }
            }
          } else {
            c.push(e[d]);
          }
        }
        return c;
      },
      markdownPattern:
        /(%.)|(\*{1,3})((?:%.|.)+?)\2|(`+)((?:%.|.)+?)\4|\[((?:%.|.)+?)\]\(([^\s\)]+)\)/,
      processMarkdown: function (b, h, d) {
        var j = [],
          e;
        var c = b.split(this.markdownPattern);
        var g = c[0];
        for (var f = 1, a = c.length; f < a; f += 8) {
          if (c[f + 1]) {
            e = this.processString(c[f + 2], h, d);
            if (!MathJax.Object.isArray(e)) {
              e = [e];
            }
            e = [["b", "i", "i"][c[f + 1].length - 1], {}, e];
            if (c[f + 1].length === 3) {
              e = ["b", {}, e];
            }
          } else {
            if (c[f + 3]) {
              e = this.processString(
                c[f + 4].replace(/^\s/, "").replace(/\s$/, ""),
                h,
                d
              );
              if (!MathJax.Object.isArray(e)) {
                e = [e];
              }
              e = ["code", {}, e];
            } else {
              if (c[f + 5]) {
                e = this.processString(c[f + 5], h, d);
                if (!MathJax.Object.isArray(e)) {
                  e = [e];
                }
                e = [
                  "a",
                  { href: this.processString(c[f + 6], h), target: "_blank" },
                  e,
                ];
              } else {
                g += c[f];
                e = null;
              }
            }
          }
          if (e) {
            j = this.concatString(j, g, h, d);
            j.push(e);
            g = "";
          }
          if (c[f + 7] !== "") {
            g += c[f + 7];
          }
        }
        j = this.concatString(j, g, h, d);
        return j;
      },
      concatString: function (a, c, b, d) {
        if (c != "") {
          c = this.processString(c, b, d);
          if (!MathJax.Object.isArray(c)) {
            c = [c];
          }
          a = a.concat(c);
        }
        return a;
      },
      lookupPhrase: function (f, a, d) {
        if (!d) {
          d = "_";
        }
        if (MathJax.Object.isArray(f)) {
          d = f[0] || "_";
          f = f[1] || "";
        }
        var c = this.loadDomain(d);
        if (c) {
          MathJax.Hub.RestartAfter(c);
        }
        var b = this.strings[this.locale];
        if (b) {
          if (b.domains && d in b.domains) {
            var e = b.domains[d];
            if (e.strings && f in e.strings) {
              a = e.strings[f];
            }
          }
        }
        return a;
      },
      loadFile: function (b, d, e) {
        e = MathJax.Callback(e);
        b = d.file || b;
        if (!b.match(/\.js$/)) {
          b += ".js";
        }
        if (!b.match(/^([a-z]+:|\[MathJax\])/)) {
          var a =
            this.strings[this.locale].directory ||
            this.directory + "/" + this.locale ||
            "[MathJax]/localization/" + this.locale;
          b = a + "/" + b;
        }
        var c = MathJax.Ajax.Require(b, function () {
          d.isLoaded = true;
          return e();
        });
        return c.called ? null : c;
      },
      loadDomain: function (c, e) {
        var b,
          a = this.strings[this.locale];
        if (a) {
          if (!a.isLoaded) {
            b = this.loadFile(this.locale, a);
            if (b) {
              return MathJax.Callback.Queue(b, ["loadDomain", this, c]).Push(
                e || {}
              );
            }
          }
          if (a.domains && c in a.domains) {
            var d = a.domains[c];
            if (!d.isLoaded) {
              b = this.loadFile(c, d);
              if (b) {
                return MathJax.Callback.Queue(b).Push(e);
              }
            }
          }
        }
        return MathJax.Callback(e)();
      },
      Try: function (a) {
        a = MathJax.Callback(a);
        a.autoReset = true;
        try {
          a();
        } catch (b) {
          if (!b.restart) {
            throw b;
          }
          MathJax.Callback.After(["Try", this, a], b.restart);
        }
      },
      resetLocale: function (a) {
        if (!a) {
          return;
        }
        a = a.toLowerCase();
        while (!this.strings[a]) {
          var c = a.lastIndexOf("-");
          if (c === -1) {
            return;
          }
          a = a.substring(0, c);
        }
        var b = this.strings[a].remap;
        this.locale = b ? b : a;
        MathJax.Callback.Signal("Hub").Post(["Locale Reset", this.locale]);
      },
      setLocale: function (a) {
        this.resetLocale(a);
        if (MathJax.Menu) {
          this.loadDomain("MathMenu");
        }
      },
      addTranslation: function (b, e, c) {
        var d = this.strings[b],
          a = false;
        if (!d) {
          d = this.strings[b] = {};
          a = true;
        }
        if (!d.domains) {
          d.domains = {};
        }
        if (e) {
          if (!d.domains[e]) {
            d.domains[e] = {};
          }
          d = d.domains[e];
        }
        MathJax.Hub.Insert(d, c);
        if (a && MathJax.Menu.menu) {
          MathJax.Menu.CreateLocaleMenu();
        }
      },
      setCSS: function (b) {
        var a = this.strings[this.locale];
        if (a) {
          if (a.fontFamily) {
            b.style.fontFamily = a.fontFamily;
          }
          if (a.fontDirection) {
            b.style.direction = a.fontDirection;
            if (a.fontDirection === "rtl") {
              b.style.textAlign = "right";
            }
          }
        }
        return b;
      },
      fontFamily: function () {
        var a = this.strings[this.locale];
        return a ? a.fontFamily : null;
      },
      fontDirection: function () {
        var a = this.strings[this.locale];
        return a ? a.fontDirection : null;
      },
      plural: function (b) {
        var a = this.strings[this.locale];
        if (a && a.plural) {
          return a.plural(b);
        }
        if (b == 1) {
          return 1;
        }
        return 2;
      },
      number: function (b) {
        var a = this.strings[this.locale];
        if (a && a.number) {
          return a.number(b);
        }
        return b;
      },
    };
    MathJax.Message = {
      ready: false,
      log: [{}],
      current: null,
      textNodeBug:
        (navigator.vendor === "Apple Computer, Inc." &&
          typeof navigator.vendorSub === "undefined") ||
        (window.hasOwnProperty && window.hasOwnProperty("konqueror")),
      styles: {
        "#MathJax_Message": {
          position: "fixed",
          left: "1px",
          bottom: "2px",
          "background-color": "#E6E6E6",
          border: "1px solid #959595",
          margin: "0px",
          padding: "2px 8px",
          "z-index": "102",
          color: "black",
          "font-size": "80%",
          width: "auto",
          "white-space": "nowrap",
        },
        "#MathJax_MSIE_Frame": {
          position: "absolute",
          top: 0,
          left: 0,
          width: "0px",
          "z-index": 101,
          border: "0px",
          margin: "0px",
          padding: "0px",
        },
      },
      browsers: {
        MSIE: function (a) {
          MathJax.Message.msieFixedPositionBug =
            (document.documentMode || 0) < 7;
          if (MathJax.Message.msieFixedPositionBug) {
            MathJax.Hub.config.styles["#MathJax_Message"].position = "absolute";
          }
          MathJax.Message.quirks = document.compatMode === "BackCompat";
        },
        Chrome: function (a) {
          MathJax.Hub.config.styles["#MathJax_Message"].bottom = "1.5em";
          MathJax.Hub.config.styles["#MathJax_Message"].left = "1em";
        },
      },
      Init: function (a) {
        if (a) {
          this.ready = true;
        }
        if (!document.body || !this.ready) {
          return false;
        }
        if (this.div && this.div.parentNode == null) {
          this.div = document.getElementById("MathJax_Message");
          this.text = this.div ? this.div.firstChild : null;
        }
        if (!this.div) {
          var b = document.body;
          if (this.msieFixedPositionBug && window.attachEvent) {
            b = this.frame = this.addDiv(document.body);
            b.removeAttribute("id");
            b.style.position = "absolute";
            b.style.border = b.style.margin = b.style.padding = "0px";
            b.style.zIndex = "101";
            b.style.height = "0px";
            b = this.addDiv(b);
            b.id = "MathJax_MSIE_Frame";
            window.attachEvent("onscroll", this.MoveFrame);
            window.attachEvent("onresize", this.MoveFrame);
            this.MoveFrame();
          }
          this.div = this.addDiv(b);
          this.div.style.display = "none";
        }
        if (!this.text) {
          this.text = this.div.appendChild(document.createTextNode(""));
        }
        return true;
      },
      addDiv: function (a) {
        var b = document.createElement("div");
        b.id = "MathJax_Message";
        if (a.firstChild) {
          a.insertBefore(b, a.firstChild);
        } else {
          a.appendChild(b);
        }
        return b;
      },
      MoveFrame: function () {
        var a = MathJax.Message.quirks
          ? document.body
          : document.documentElement;
        var b = MathJax.Message.frame;
        b.style.left = a.scrollLeft + "px";
        b.style.top = a.scrollTop + "px";
        b.style.width = a.clientWidth + "px";
        b = b.firstChild;
        b.style.height = a.clientHeight + "px";
      },
      localize: function (a) {
        return MathJax.Localization._(a, a);
      },
      filterText: function (a, c, b) {
        if (MathJax.Hub.config.messageStyle === "simple") {
          if (b === "LoadFile") {
            if (!this.loading) {
              this.loading = this.localize("Loading") + " ";
            }
            a = this.loading;
            this.loading += ".";
          } else {
            if (b === "ProcessMath") {
              if (!this.processing) {
                this.processing = this.localize("Processing") + " ";
              }
              a = this.processing;
              this.processing += ".";
            } else {
              if (b === "TypesetMath") {
                if (!this.typesetting) {
                  this.typesetting = this.localize("Typesetting") + " ";
                }
                a = this.typesetting;
                this.typesetting += ".";
              }
            }
          }
        }
        return a;
      },
      clearCounts: function () {
        delete this.loading;
        delete this.processing;
        delete this.typesetting;
      },
      Set: function (c, e, b) {
        if (e == null) {
          e = this.log.length;
          this.log[e] = {};
        }
        var d = "";
        if (MathJax.Object.isArray(c)) {
          d = c[0];
          if (MathJax.Object.isArray(d)) {
            d = d[1];
          }
          try {
            c = MathJax.Localization._.apply(MathJax.Localization, c);
          } catch (a) {
            if (!a.restart) {
              throw a;
            }
            if (!a.restart.called) {
              if (this.log[e].restarted == null) {
                this.log[e].restarted = 0;
              }
              this.log[e].restarted++;
              delete this.log[e].cleared;
              MathJax.Callback.After(["Set", this, c, e, b], a.restart);
              return e;
            }
          }
        }
        if (this.timer) {
          clearTimeout(this.timer);
          delete this.timer;
        }
        this.log[e].text = c;
        this.log[e].filteredText = c = this.filterText(c, e, d);
        if (typeof this.log[e].next === "undefined") {
          this.log[e].next = this.current;
          if (this.current != null) {
            this.log[this.current].prev = e;
          }
          this.current = e;
        }
        if (this.current === e && MathJax.Hub.config.messageStyle !== "none") {
          if (this.Init()) {
            if (this.textNodeBug) {
              this.div.innerHTML = c;
            } else {
              this.text.nodeValue = c;
            }
            this.div.style.display = "";
            if (this.status) {
              window.status = "";
              delete this.status;
            }
          } else {
            window.status = c;
            this.status = true;
          }
        }
        if (this.log[e].restarted) {
          if (this.log[e].cleared) {
            b = 0;
          }
          if (--this.log[e].restarted === 0) {
            delete this.log[e].cleared;
          }
        }
        if (b) {
          setTimeout(MathJax.Callback(["Clear", this, e]), b);
        } else {
          if (b == 0) {
            this.Clear(e, 0);
          }
        }
        return e;
      },
      Clear: function (b, a) {
        if (this.log[b].prev != null) {
          this.log[this.log[b].prev].next = this.log[b].next;
        }
        if (this.log[b].next != null) {
          this.log[this.log[b].next].prev = this.log[b].prev;
        }
        if (this.current === b) {
          this.current = this.log[b].next;
          if (this.text) {
            if (this.div.parentNode == null) {
              this.Init();
            }
            if (this.current == null) {
              if (this.timer) {
                clearTimeout(this.timer);
                delete this.timer;
              }
              if (a == null) {
                a = 600;
              }
              if (a === 0) {
                this.Remove();
              } else {
                this.timer = setTimeout(MathJax.Callback(["Remove", this]), a);
              }
            } else {
              if (MathJax.Hub.config.messageStyle !== "none") {
                if (this.textNodeBug) {
                  this.div.innerHTML = this.log[this.current].filteredText;
                } else {
                  this.text.nodeValue = this.log[this.current].filteredText;
                }
              }
            }
            if (this.status) {
              window.status = "";
              delete this.status;
            }
          } else {
            if (this.status) {
              window.status =
                this.current == null ? "" : this.log[this.current].text;
            }
          }
        }
        delete this.log[b].next;
        delete this.log[b].prev;
        delete this.log[b].filteredText;
        if (this.log[b].restarted) {
          this.log[b].cleared = true;
        }
      },
      Remove: function () {
        this.text.nodeValue = "";
        this.div.style.display = "none";
      },
      File: function (a) {
        return this.Set(["LoadFile", "Loading %1", a], null, null);
      },
      Log: function () {
        var b = [];
        for (var c = 1, a = this.log.length; c < a; c++) {
          b[c] = this.log[c].text;
        }
        return b.join("\n");
      },
    };
    MathJax.Hub = {
      config: {
        root: "",
        config: [],
        styleSheets: [],
        styles: { ".MathJax_Preview": { color: "#888" } },
        jax: [],
        extensions: [],
        preJax: null,
        postJax: null,
        displayAlign: "center",
        displayIndent: "0",
        preRemoveClass: "MathJax_Preview",
        showProcessingMessages: true,
        messageStyle: "normal",
        delayStartupUntil: "none",
        skipStartupTypeset: false,
        elements: [],
        positionToHash: true,
        showMathMenu: true,
        showMathMenuMSIE: true,
        menuSettings: {
          zoom: "None",
          CTRL: false,
          ALT: false,
          CMD: false,
          Shift: false,
          discoverable: false,
          zscale: "200%",
          renderer: null,
          font: "Auto",
          context: "MathJax",
          locale: null,
          mpContext: false,
          mpMouse: false,
          texHints: true,
          FastPreview: null,
          assistiveMML: null,
          inTabOrder: true,
          semantics: false,
        },
        errorSettings: {
          message: ["[", ["MathProcessingError", "Math Processing Error"], "]"],
          style: { color: "#CC0000", "font-style": "italic" },
        },
        ignoreMMLattributes: {},
      },
      preProcessors: MathJax.Callback.Hooks(true),
      inputJax: {},
      outputJax: { order: {} },
      processSectionDelay: 50,
      processUpdateTime: 250,
      processUpdateDelay: 10,
      signal: MathJax.Callback.Signal("Hub"),
      Config: function (a) {
        this.Insert(this.config, a);
        if (this.config.Augment) {
          this.Augment(this.config.Augment);
        }
      },
      CombineConfig: function (c, f) {
        var b = this.config,
          g,
          e;
        c = c.split(/\./);
        for (var d = 0, a = c.length; d < a; d++) {
          g = c[d];
          if (!b[g]) {
            b[g] = {};
          }
          e = b;
          b = b[g];
        }
        e[g] = b = this.Insert(f, b);
        return b;
      },
      Register: {
        PreProcessor: function () {
          return MathJax.Hub.preProcessors.Add.apply(
            MathJax.Hub.preProcessors,
            arguments
          );
        },
        MessageHook: function () {
          return MathJax.Hub.signal.MessageHook.apply(
            MathJax.Hub.signal,
            arguments
          );
        },
        StartupHook: function () {
          return MathJax.Hub.Startup.signal.MessageHook.apply(
            MathJax.Hub.Startup.signal,
            arguments
          );
        },
        LoadHook: function () {
          return MathJax.Ajax.LoadHook.apply(MathJax.Ajax, arguments);
        },
      },
      UnRegister: {
        PreProcessor: function (a) {
          MathJax.Hub.preProcessors.Remove(a);
        },
        MessageHook: function (a) {
          MathJax.Hub.signal.RemoveHook(a);
        },
        StartupHook: function (a) {
          MathJax.Hub.Startup.signal.RemoveHook(a);
        },
        LoadHook: function (a) {
          MathJax.Ajax.removeHook(a);
        },
      },
      getAllJax: function (e) {
        var c = [],
          b = this.elementScripts(e);
        for (var d = 0, a = b.length; d < a; d++) {
          if (b[d].MathJax && b[d].MathJax.elementJax) {
            c.push(b[d].MathJax.elementJax);
          }
        }
        return c;
      },
      getJaxByType: function (f, e) {
        var c = [],
          b = this.elementScripts(e);
        for (var d = 0, a = b.length; d < a; d++) {
          if (
            b[d].MathJax &&
            b[d].MathJax.elementJax &&
            b[d].MathJax.elementJax.mimeType === f
          ) {
            c.push(b[d].MathJax.elementJax);
          }
        }
        return c;
      },
      getJaxByInputType: function (f, e) {
        var c = [],
          b = this.elementScripts(e);
        for (var d = 0, a = b.length; d < a; d++) {
          if (
            b[d].MathJax &&
            b[d].MathJax.elementJax &&
            b[d].type &&
            b[d].type.replace(/ *;(.|\s)*/, "") === f
          ) {
            c.push(b[d].MathJax.elementJax);
          }
        }
        return c;
      },
      getJaxFor: function (a) {
        if (typeof a === "string") {
          a = document.getElementById(a);
        }
        if (a && a.MathJax) {
          return a.MathJax.elementJax;
        }
        if (this.isMathJaxNode(a)) {
          if (!a.isMathJax) {
            a = a.firstChild;
          }
          while (a && !a.jaxID) {
            a = a.parentNode;
          }
          if (a) {
            return MathJax.OutputJax[a.jaxID].getJaxFromMath(a);
          }
        }
        return null;
      },
      isJax: function (a) {
        if (typeof a === "string") {
          a = document.getElementById(a);
        }
        if (this.isMathJaxNode(a)) {
          return 1;
        }
        if (a && (a.tagName || "").toLowerCase() === "script") {
          if (a.MathJax) {
            return a.MathJax.state === MathJax.ElementJax.STATE.PROCESSED
              ? 1
              : -1;
          }
          if (a.type && this.inputJax[a.type.replace(/ *;(.|\s)*/, "")]) {
            return -1;
          }
        }
        return 0;
      },
      isMathJaxNode: function (a) {
        return !!a && (a.isMathJax || (a.className || "") === "MathJax_MathML");
      },
      setRenderer: function (d, c) {
        if (!d) {
          return;
        }
        var e = MathJax.OutputJax[d];
        if (!e) {
          MathJax.OutputJax[d] = MathJax.OutputJax({
            id: "unknown",
            version: "1.0.0",
            isUnknown: true,
          });
          this.config.menuSettings.renderer = "";
          var b = "[MathJax]/jax/output/" + d + "/config.js";
          return MathJax.Ajax.Require(b, ["setRenderer", this, d, c]);
        } else {
          this.config.menuSettings.renderer = d;
          if (c == null) {
            c = "jax/mml";
          }
          if (e.isUnknown) {
            e.Register(c);
          }
          var a = this.outputJax;
          if (a[c] && a[c].length) {
            if (d !== a[c][0].id) {
              a[c].unshift(e);
              return this.signal.Post(["Renderer Selected", d]);
            }
          }
          return null;
        }
      },
      Queue: function () {
        return this.queue.Push.apply(this.queue, arguments);
      },
      Typeset: function (c, d) {
        if (!MathJax.isReady) {
          return null;
        }
        var b = this.elementCallback(c, d);
        if (b.count) {
          var a = MathJax.Callback.Queue(
            ["PreProcess", this, b.elements],
            ["Process", this, b.elements]
          );
        }
        return a.Push(b.callback);
      },
      PreProcess: function (e, g) {
        var c = this.elementCallback(e, g);
        var b = MathJax.Callback.Queue();
        if (c.count) {
          var f = c.count === 1 ? [c.elements] : c.elements;
          b.Push(["Post", this.signal, ["Begin PreProcess", c.elements]]);
          for (var d = 0, a = f.length; d < a; d++) {
            if (f[d]) {
              b.Push(["Execute", this.preProcessors, f[d]]);
            }
          }
          b.Push(["Post", this.signal, ["End PreProcess", c.elements]]);
        }
        return b.Push(c.callback);
      },
      Process: function (a, b) {
        return this.takeAction("Process", a, b);
      },
      Update: function (a, b) {
        return this.takeAction("Update", a, b);
      },
      Reprocess: function (a, b) {
        return this.takeAction("Reprocess", a, b);
      },
      Rerender: function (a, b) {
        return this.takeAction("Rerender", a, b);
      },
      takeAction: function (g, d, h) {
        var c = this.elementCallback(d, h);
        var f = c.elements;
        var a = MathJax.Callback.Queue(["Clear", this.signal]);
        var e = {
          scripts: [],
          start: new Date().getTime(),
          i: 0,
          j: 0,
          jax: {},
          jaxIDs: [],
        };
        if (c.count) {
          var b = ["Delay", MathJax.Callback, this.processSectionDelay];
          if (!b[2]) {
            b = {};
          }
          a.Push(
            ["clearCounts", MathJax.Message],
            ["Post", this.signal, ["Begin " + g, f]],
            ["Post", this.signal, ["Begin Math", f, g]],
            ["prepareScripts", this, g, f, e],
            ["Post", this.signal, ["Begin Math Input", f, g]],
            ["processInput", this, e],
            ["Post", this.signal, ["End Math Input", f, g]],
            b,
            ["prepareOutput", this, e, "preProcess"],
            b,
            ["Post", this.signal, ["Begin Math Output", f, g]],
            ["processOutput", this, e],
            ["Post", this.signal, ["End Math Output", f, g]],
            b,
            ["prepareOutput", this, e, "postProcess"],
            b,
            ["Post", this.signal, ["End Math", f, g]],
            ["Post", this.signal, ["End " + g, f]],
            ["clearCounts", MathJax.Message]
          );
        }
        return a.Push(c.callback);
      },
      scriptAction: {
        Process: function (a) {},
        Update: function (b) {
          var a = b.MathJax.elementJax;
          if (a && a.needsUpdate()) {
            a.Remove(true);
            b.MathJax.state = a.STATE.UPDATE;
          } else {
            b.MathJax.state = a.STATE.PROCESSED;
          }
        },
        Reprocess: function (b) {
          var a = b.MathJax.elementJax;
          if (a) {
            a.Remove(true);
            b.MathJax.state = a.STATE.UPDATE;
          }
        },
        Rerender: function (b) {
          var a = b.MathJax.elementJax;
          if (a) {
            a.Remove(true);
            b.MathJax.state = a.STATE.OUTPUT;
          }
        },
      },
      prepareScripts: function (h, e, g) {
        if (arguments.callee.disabled) {
          return;
        }
        var b = this.elementScripts(e);
        var f = MathJax.ElementJax.STATE;
        for (var d = 0, a = b.length; d < a; d++) {
          var c = b[d];
          if (c.type && this.inputJax[c.type.replace(/ *;(.|\n)*/, "")]) {
            if (c.MathJax) {
              if (c.MathJax.elementJax && c.MathJax.elementJax.hover) {
                MathJax.Extension.MathEvents.Hover.ClearHover(
                  c.MathJax.elementJax
                );
              }
              if (c.MathJax.state !== f.PENDING) {
                this.scriptAction[h](c);
              }
            }
            if (!c.MathJax) {
              c.MathJax = { state: f.PENDING };
            }
            if (c.MathJax.error) {
              delete c.MathJax.error;
            }
            if (c.MathJax.state !== f.PROCESSED) {
              g.scripts.push(c);
            }
          }
        }
      },
      checkScriptSiblings: function (a) {
        if (a.MathJax.checked) {
          return;
        }
        var b = this.config,
          f = a.previousSibling;
        if (f && f.nodeName === "#text") {
          var d,
            e,
            c = a.nextSibling;
          if (c && c.nodeName !== "#text") {
            c = null;
          }
          if (b.preJax) {
            if (typeof b.preJax === "string") {
              b.preJax = new RegExp(b.preJax + "$");
            }
            d = f.nodeValue.match(b.preJax);
          }
          if (b.postJax && c) {
            if (typeof b.postJax === "string") {
              b.postJax = new RegExp("^" + b.postJax);
            }
            e = c.nodeValue.match(b.postJax);
          }
          if (d && (!b.postJax || e)) {
            f.nodeValue = f.nodeValue.replace(
              b.preJax,
              d.length > 1 ? d[1] : ""
            );
            f = null;
          }
          if (e && (!b.preJax || d)) {
            c.nodeValue = c.nodeValue.replace(
              b.postJax,
              e.length > 1 ? e[1] : ""
            );
          }
          if (f && !f.nodeValue.match(/\S/)) {
            f = f.previousSibling;
          }
        }
        if (b.preRemoveClass && f && f.className === b.preRemoveClass) {
          a.MathJax.preview = f;
        }
        a.MathJax.checked = 1;
      },
      processInput: function (a) {
        var b,
          i = MathJax.ElementJax.STATE;
        var h,
          e,
          d = a.scripts.length;
        try {
          while (a.i < d) {
            h = a.scripts[a.i];
            if (!h) {
              a.i++;
              continue;
            }
            e = h.previousSibling;
            if (e && e.className === "MathJax_Error") {
              e.parentNode.removeChild(e);
            }
            if (
              !h.parentNode ||
              !h.MathJax ||
              h.MathJax.state === i.PROCESSED
            ) {
              a.i++;
              continue;
            }
            if (!h.MathJax.elementJax || h.MathJax.state === i.UPDATE) {
              this.checkScriptSiblings(h);
              var g = h.type.replace(/ *;(.|\s)*/, "");
              var j = this.inputJax[g];
              b = j.Process(h, a);
              if (typeof b === "function") {
                if (b.called) {
                  continue;
                }
                this.RestartAfter(b);
              }
              b = b.Attach(h, j.id);
              this.saveScript(b, a, h, i);
              this.postInputHooks.Execute(b, j.id, h);
            } else {
              if (h.MathJax.state === i.OUTPUT) {
                this.saveScript(h.MathJax.elementJax, a, h, i);
              }
            }
            a.i++;
            var c = new Date().getTime();
            if (
              c - a.start > this.processUpdateTime &&
              a.i < a.scripts.length
            ) {
              a.start = c;
              this.RestartAfter(MathJax.Callback.Delay(1));
            }
          }
        } catch (f) {
          return this.processError(f, a, "Input");
        }
        if (a.scripts.length && this.config.showProcessingMessages) {
          MathJax.Message.Set(["ProcessMath", "Processing math: %1%%", 100], 0);
        }
        a.start = new Date().getTime();
        a.i = a.j = 0;
        return null;
      },
      postInputHooks: MathJax.Callback.Hooks(true),
      saveScript: function (a, d, b, c) {
        if (!this.outputJax[a.mimeType]) {
          b.MathJax.state = c.UPDATE;
          throw Error("No output jax registered for " + a.mimeType);
        }
        a.outputJax = this.outputJax[a.mimeType][0].id;
        if (!d.jax[a.outputJax]) {
          if (d.jaxIDs.length === 0) {
            d.jax[a.outputJax] = d.scripts;
          } else {
            if (d.jaxIDs.length === 1) {
              d.jax[d.jaxIDs[0]] = d.scripts.slice(0, d.i);
            }
            d.jax[a.outputJax] = [];
          }
          d.jaxIDs.push(a.outputJax);
        }
        if (d.jaxIDs.length > 1) {
          d.jax[a.outputJax].push(b);
        }
        b.MathJax.state = c.OUTPUT;
      },
      prepareOutput: function (c, f) {
        while (c.j < c.jaxIDs.length) {
          var e = c.jaxIDs[c.j],
            d = MathJax.OutputJax[e];
          if (d[f]) {
            try {
              var a = d[f](c);
              if (typeof a === "function") {
                if (a.called) {
                  continue;
                }
                this.RestartAfter(a);
              }
            } catch (b) {
              if (!b.restart) {
                MathJax.Message.Set(
                  ["PrepError", "Error preparing %1 output (%2)", e, f],
                  null,
                  600
                );
                MathJax.Hub.lastPrepError = b;
                c.j++;
              }
              return MathJax.Callback.After(
                ["prepareOutput", this, c, f],
                b.restart
              );
            }
          }
          c.j++;
        }
        return null;
      },
      processOutput: function (h) {
        var b,
          g = MathJax.ElementJax.STATE,
          d,
          a = h.scripts.length;
        try {
          while (h.i < a) {
            d = h.scripts[h.i];
            if (!d || !d.parentNode || !d.MathJax || d.MathJax.error) {
              h.i++;
              continue;
            }
            var c = d.MathJax.elementJax;
            if (!c) {
              h.i++;
              continue;
            }
            b = MathJax.OutputJax[c.outputJax].Process(d, h);
            if (b !== false) {
              d.MathJax.state = g.PROCESSED;
              if (d.MathJax.preview) {
                d.MathJax.preview.innerHTML = "";
                d.MathJax.preview.style.display = "none";
              }
              this.signal.Post(["New Math", c.inputID]);
            }
            h.i++;
            var e = new Date().getTime();
            if (
              e - h.start > this.processUpdateTime &&
              h.i < h.scripts.length
            ) {
              h.start = e;
              this.RestartAfter(
                MathJax.Callback.Delay(this.processUpdateDelay)
              );
            }
          }
        } catch (f) {
          return this.processError(f, h, "Output");
        }
        if (h.scripts.length && this.config.showProcessingMessages) {
          MathJax.Message.Set(
            ["TypesetMath", "Typesetting math: %1%%", 100],
            0
          );
          MathJax.Message.Clear(0);
        }
        h.i = h.j = 0;
        return null;
      },
      processMessage: function (d, b) {
        var a = Math.floor((d.i / d.scripts.length) * 100);
        var c =
          b === "Output"
            ? ["TypesetMath", "Typesetting math: %1%%"]
            : ["ProcessMath", "Processing math: %1%%"];
        if (this.config.showProcessingMessages) {
          MathJax.Message.Set(c.concat(a), 0);
        }
      },
      processError: function (b, c, a) {
        if (!b.restart) {
          if (!this.config.errorSettings.message) {
            throw b;
          }
          this.formatError(c.scripts[c.i], b);
          c.i++;
        }
        this.processMessage(c, a);
        return MathJax.Callback.After(["process" + a, this, c], b.restart);
      },
      formatError: function (b, f) {
        var h = function (l, k, j, i) {
          return MathJax.Localization._(l, k, j, i);
        };
        var e = h("ErrorMessage", "Error: %1", f.message) + "\n";
        if (f.sourceURL || f.fileName) {
          e += "\n" + h("ErrorFile", "file: %1", f.sourceURL || f.fileName);
        }
        if (f.line || f.lineNumber) {
          e += "\n" + h("ErrorLine", "line: %1", f.line || f.lineNumber);
        }
        e +=
          "\n\n" +
          h(
            "ErrorTips",
            "Debugging tips: use %1, inspect %2 in the browser console",
            "'unpacked/MathJax.js'",
            "'MathJax.Hub.lastError'"
          );
        b.MathJax.error = MathJax.OutputJax.Error.Jax(e, b);
        if (b.MathJax.elementJax) {
          b.MathJax.error.inputID = b.MathJax.elementJax.inputID;
        }
        var g = this.config.errorSettings;
        var a = h(g.messageId, g.message);
        var c = MathJax.HTML.Element(
          "span",
          {
            className: "MathJax_Error",
            jaxID: "Error",
            isMathJax: true,
            id: b.MathJax.error.inputID + "-Frame",
          },
          [["span", null, a]]
        );
        MathJax.Ajax.Require("[MathJax]/extensions/MathEvents.js", function () {
          var j = MathJax.Extension.MathEvents.Event,
            i = MathJax.Hub;
          c.oncontextmenu = j.Menu;
          c.onmousedown = j.Mousedown;
          c.onkeydown = j.Keydown;
          c.tabIndex = i.getTabOrder(i.getJaxFor(b));
        });
        var d = document.getElementById(c.id);
        if (d) {
          d.parentNode.removeChild(d);
        }
        if (b.parentNode) {
          b.parentNode.insertBefore(c, b);
        }
        if (b.MathJax.preview) {
          b.MathJax.preview.innerHTML = "";
          b.MathJax.preview.style.display = "none";
        }
        this.lastError = f;
        this.signal.Post(["Math Processing Error", b, f]);
      },
      RestartAfter: function (a) {
        throw this.Insert(Error("restart"), { restart: MathJax.Callback(a) });
      },
      elementCallback: function (c, f) {
        if (
          f == null &&
          (MathJax.Object.isArray(c) || typeof c === "function")
        ) {
          try {
            MathJax.Callback(c);
            f = c;
            c = null;
          } catch (d) {}
        }
        if (c == null) {
          c = this.config.elements || [];
        }
        if (this.isHTMLCollection(c)) {
          c = this.HTMLCollection2Array(c);
        }
        if (!MathJax.Object.isArray(c)) {
          c = [c];
        }
        c = [].concat(c);
        for (var b = 0, a = c.length; b < a; b++) {
          if (typeof c[b] === "string") {
            c[b] = document.getElementById(c[b]);
          }
        }
        if (!document.body) {
          document.body = document.getElementsByTagName("body")[0];
        }
        if (c.length == 0) {
          c.push(document.body);
        }
        if (!f) {
          f = {};
        }
        return {
          count: c.length,
          elements: c.length === 1 ? c[0] : c,
          callback: f,
        };
      },
      elementScripts: function (e) {
        var b = [];
        if (MathJax.Object.isArray(e) || this.isHTMLCollection(e)) {
          for (var d = 0, a = e.length; d < a; d++) {
            var f = 0;
            for (var c = 0; c < d && !f; c++) {
              f = e[c].contains(e[d]);
            }
            if (!f) {
              b.push.apply(b, this.elementScripts(e[d]));
            }
          }
          return b;
        }
        if (typeof e === "string") {
          e = document.getElementById(e);
        }
        if (!document.body) {
          document.body = document.getElementsByTagName("body")[0];
        }
        if (e == null) {
          e = document.body;
        }
        if (e.tagName != null && e.tagName.toLowerCase() === "script") {
          return [e];
        }
        b = e.getElementsByTagName("script");
        if (this.msieHTMLCollectionBug) {
          b = this.HTMLCollection2Array(b);
        }
        return b;
      },
      isHTMLCollection: function (a) {
        return (
          "HTMLCollection" in window &&
          typeof a === "object" &&
          a instanceof HTMLCollection
        );
      },
      HTMLCollection2Array: function (c) {
        if (!this.msieHTMLCollectionBug) {
          return [].slice.call(c);
        }
        var b = [];
        for (var d = 0, a = c.length; d < a; d++) {
          b[d] = c[d];
        }
        return b;
      },
      Insert: function (c, a) {
        for (var b in a) {
          if (a.hasOwnProperty(b)) {
            if (
              typeof a[b] === "object" &&
              !MathJax.Object.isArray(a[b]) &&
              (typeof c[b] === "object" || typeof c[b] === "function")
            ) {
              this.Insert(c[b], a[b]);
            } else {
              c[b] = a[b];
            }
          }
        }
        return c;
      },
      getTabOrder: function (a) {
        return this.config.menuSettings.inTabOrder ? 0 : -1;
      },
      SplitList:
        "trim" in String.prototype
          ? function (a) {
              return a.trim().split(/\s+/);
            }
          : function (a) {
              return a.replace(/^\s+/, "").replace(/\s+$/, "").split(/\s+/);
            },
    };
    MathJax.Hub.Insert(MathJax.Hub.config.styles, MathJax.Message.styles);
    MathJax.Hub.Insert(MathJax.Hub.config.styles, {
      ".MathJax_Error": MathJax.Hub.config.errorSettings.style,
    });
    MathJax.Extension = {};
    MathJax.Hub.Configured = MathJax.Callback({});
    MathJax.Hub.Startup = {
      script: "",
      queue: MathJax.Callback.Queue(),
      signal: MathJax.Callback.Signal("Startup"),
      params: {},
      Config: function () {
        this.queue.Push(["Post", this.signal, "Begin Config"]);
        if (MathJax.AuthorConfig && MathJax.AuthorConfig.root) {
          MathJax.Ajax.config.root = MathJax.AuthorConfig.root;
        }
        if (this.params.locale) {
          MathJax.Localization.resetLocale(this.params.locale);
          MathJax.Hub.config.menuSettings.locale = this.params.locale;
        }
        if (this.params.config) {
          var c = this.params.config.split(/,/);
          for (var b = 0, a = c.length; b < a; b++) {
            if (!c[b].match(/\.js$/)) {
              c[b] += ".js";
            }
            this.queue.Push([
              "Require",
              MathJax.Ajax,
              this.URL("config", c[b]),
            ]);
          }
        }
        this.queue.Push(["Config", MathJax.Hub, MathJax.AuthorConfig]);
        if (this.script.match(/\S/)) {
          this.queue.Push(this.script + ";\n1;");
        }
        this.queue.Push(
          ["ConfigDelay", this],
          ["ConfigBlocks", this],
          [
            function (d) {
              return d.loadArray(
                MathJax.Hub.config.config,
                "config",
                null,
                true
              );
            },
            this,
          ],
          ["Post", this.signal, "End Config"]
        );
      },
      ConfigDelay: function () {
        var a =
          this.params.delayStartupUntil || MathJax.Hub.config.delayStartupUntil;
        if (a === "onload") {
          return this.onload;
        }
        if (a === "configured") {
          return MathJax.Hub.Configured;
        }
        return a;
      },
      ConfigBlocks: function () {
        var c = document.getElementsByTagName("script");
        var b = MathJax.Callback.Queue();
        for (var d = 0, a = c.length; d < a; d++) {
          var e = String(c[d].type).replace(/ /g, "");
          if (
            e.match(/^text\/x-mathjax-config(;.*)?$/) &&
            !e.match(/;executed=true/)
          ) {
            c[d].type += ";executed=true";
            b.Push(c[d].innerHTML + ";\n1;");
          }
        }
        return b.Push(function () {
          MathJax.Ajax.config.root = MathJax.Hub.config.root;
        });
      },
      Cookie: function () {
        return this.queue.Push(
          ["Post", this.signal, "Begin Cookie"],
          ["Get", MathJax.HTML.Cookie, "menu", MathJax.Hub.config.menuSettings],
          [
            function (e) {
              var d = e.menuSettings;
              if (d.locale) {
                MathJax.Localization.resetLocale(d.locale);
              }
              var g = e.menuSettings.renderer,
                b = e.jax;
              if (g) {
                var c = "output/" + g;
                b.sort();
                for (var f = 0, a = b.length; f < a; f++) {
                  if (b[f].substr(0, 7) === "output/") {
                    break;
                  }
                }
                if (f == a - 1) {
                  b.pop();
                } else {
                  while (f < a) {
                    if (b[f] === c) {
                      b.splice(f, 1);
                      break;
                    }
                    f++;
                  }
                }
                b.unshift(c);
              }
              if (d.CHTMLpreview != null) {
                if (d.FastPreview == null) {
                  d.FastPreview = d.CHTMLpreview;
                }
                delete d.CHTMLpreview;
              }
              if (d.FastPreview && !MathJax.Extension["fast-preview"]) {
                MathJax.Hub.config.extensions.push("fast-preview.js");
              }
              if (
                e.menuSettings.assistiveMML &&
                !MathJax.Extension.AssistiveMML
              ) {
                MathJax.Hub.config.extensions.push("AssistiveMML.js");
              }
            },
            MathJax.Hub.config,
          ],
          ["Post", this.signal, "End Cookie"]
        );
      },
      Styles: function () {
        return this.queue.Push(
          ["Post", this.signal, "Begin Styles"],
          ["loadArray", this, MathJax.Hub.config.styleSheets, "config"],
          ["Styles", MathJax.Ajax, MathJax.Hub.config.styles],
          ["Post", this.signal, "End Styles"]
        );
      },
      Jax: function () {
        var f = MathJax.Hub.config,
          c = MathJax.Hub.outputJax;
        for (var g = 0, b = f.jax.length, d = 0; g < b; g++) {
          var e = f.jax[g].substr(7);
          if (f.jax[g].substr(0, 7) === "output/" && c.order[e] == null) {
            c.order[e] = d;
            d++;
          }
        }
        var a = MathJax.Callback.Queue();
        return a.Push(
          ["Post", this.signal, "Begin Jax"],
          ["loadArray", this, f.jax, "jax", "config.js"],
          ["Post", this.signal, "End Jax"]
        );
      },
      Extensions: function () {
        var a = MathJax.Callback.Queue();
        return a.Push(
          ["Post", this.signal, "Begin Extensions"],
          ["loadArray", this, MathJax.Hub.config.extensions, "extensions"],
          ["Post", this.signal, "End Extensions"]
        );
      },
      Message: function () {
        MathJax.Message.Init(true);
      },
      Menu: function () {
        var b = MathJax.Hub.config.menuSettings,
          a = MathJax.Hub.outputJax,
          d;
        for (var c in a) {
          if (a.hasOwnProperty(c)) {
            if (a[c].length) {
              d = a[c];
              break;
            }
          }
        }
        if (d && d.length) {
          if (b.renderer && b.renderer !== d[0].id) {
            d.unshift(MathJax.OutputJax[b.renderer]);
          }
          b.renderer = d[0].id;
        }
      },
      Hash: function () {
        if (
          MathJax.Hub.config.positionToHash &&
          document.location.hash &&
          document.body &&
          document.body.scrollIntoView
        ) {
          var d = decodeURIComponent(document.location.hash.substr(1));
          var f = document.getElementById(d);
          if (!f) {
            var c = document.getElementsByTagName("a");
            for (var e = 0, b = c.length; e < b; e++) {
              if (c[e].name === d) {
                f = c[e];
                break;
              }
            }
          }
          if (f) {
            while (!f.scrollIntoView) {
              f = f.parentNode;
            }
            f = this.HashCheck(f);
            if (f && f.scrollIntoView) {
              setTimeout(function () {
                f.scrollIntoView(true);
              }, 1);
            }
          }
        }
      },
      HashCheck: function (b) {
        var a = MathJax.Hub.getJaxFor(b);
        if (a && MathJax.OutputJax[a.outputJax].hashCheck) {
          b = MathJax.OutputJax[a.outputJax].hashCheck(b);
        }
        return b;
      },
      MenuZoom: function () {
        if (MathJax.Hub.config.showMathMenu) {
          if (!MathJax.Extension.MathMenu) {
            setTimeout(function () {
              MathJax.Callback.Queue(
                [
                  "Require",
                  MathJax.Ajax,
                  "[MathJax]/extensions/MathMenu.js",
                  {},
                ],
                ["loadDomain", MathJax.Localization, "MathMenu"]
              );
            }, 1000);
          } else {
            setTimeout(
              MathJax.Callback([
                "loadDomain",
                MathJax.Localization,
                "MathMenu",
              ]),
              1000
            );
          }
          if (!MathJax.Extension.MathZoom) {
            setTimeout(
              MathJax.Callback([
                "Require",
                MathJax.Ajax,
                "[MathJax]/extensions/MathZoom.js",
                {},
              ]),
              2000
            );
          }
        }
      },
      onLoad: function () {
        var a = (this.onload = MathJax.Callback(function () {
          MathJax.Hub.Startup.signal.Post("onLoad");
        }));
        if (document.body && document.readyState) {
          if (MathJax.Hub.Browser.isMSIE) {
            if (document.readyState === "complete") {
              return [a];
            }
          } else {
            if (document.readyState !== "loading") {
              return [a];
            }
          }
        }
        if (window.addEventListener) {
          window.addEventListener("load", a, false);
          if (!this.params.noDOMContentEvent) {
            window.addEventListener("DOMContentLoaded", a, false);
          }
        } else {
          if (window.attachEvent) {
            window.attachEvent("onload", a);
          } else {
            window.onload = a;
          }
        }
        return a;
      },
      Typeset: function (a, b) {
        if (MathJax.Hub.config.skipStartupTypeset) {
          return function () {};
        }
        return this.queue.Push(
          ["Post", this.signal, "Begin Typeset"],
          ["Typeset", MathJax.Hub, a, b],
          ["Post", this.signal, "End Typeset"]
        );
      },
      URL: function (b, a) {
        if (!a.match(/^([a-z]+:\/\/|\[|\/)/)) {
          a = "[MathJax]/" + b + "/" + a;
        }
        return a;
      },
      loadArray: function (b, f, c, a) {
        if (b) {
          if (!MathJax.Object.isArray(b)) {
            b = [b];
          }
          if (b.length) {
            var h = MathJax.Callback.Queue(),
              j = {},
              e;
            for (var g = 0, d = b.length; g < d; g++) {
              e = this.URL(f, b[g]);
              if (c) {
                e += "/" + c;
              }
              if (a) {
                h.Push(["Require", MathJax.Ajax, e, j]);
              } else {
                h.Push(MathJax.Ajax.Require(e, j));
              }
            }
            return h.Push({});
          }
        }
        return null;
      },
    };
    (function (d) {
      var b = window[d],
        e = "[" + d + "]";
      var c = b.Hub,
        a = b.Ajax,
        f = b.Callback;
      var g = MathJax.Object.Subclass(
        {
          JAXFILE: "jax.js",
          require: null,
          config: {},
          Init: function (i, h) {
            if (arguments.length === 0) {
              return this;
            }
            return this.constructor.Subclass(i, h)();
          },
          Augment: function (k, j) {
            var i = this.constructor,
              h = {};
            if (k != null) {
              for (var l in k) {
                if (k.hasOwnProperty(l)) {
                  if (typeof k[l] === "function") {
                    i.protoFunction(l, k[l]);
                  } else {
                    h[l] = k[l];
                  }
                }
              }
              if (
                k.toString !== i.prototype.toString &&
                k.toString !== {}.toString
              ) {
                i.protoFunction("toString", k.toString);
              }
            }
            c.Insert(i.prototype, h);
            i.Augment(null, j);
            return this;
          },
          Translate: function (h, i) {
            throw Error(
              this.directory +
                "/" +
                this.JAXFILE +
                " failed to define the Translate() method"
            );
          },
          Register: function (h) {},
          Config: function () {
            this.config = c.CombineConfig(this.id, this.config);
            if (this.config.Augment) {
              this.Augment(this.config.Augment);
            }
          },
          Startup: function () {},
          loadComplete: function (i) {
            if (i === "config.js") {
              return a.loadComplete(this.directory + "/" + i);
            } else {
              var h = f.Queue();
              h.Push(
                c.Register.StartupHook("End Config", {}),
                ["Post", c.Startup.signal, this.id + " Jax Config"],
                ["Config", this],
                ["Post", c.Startup.signal, this.id + " Jax Require"],
                [
                  function (j) {
                    return MathJax.Hub.Startup.loadArray(
                      j.require,
                      this.directory
                    );
                  },
                  this,
                ],
                [
                  function (j, k) {
                    return MathJax.Hub.Startup.loadArray(
                      j.extensions,
                      "extensions/" + k
                    );
                  },
                  this.config || {},
                  this.id,
                ],
                ["Post", c.Startup.signal, this.id + " Jax Startup"],
                ["Startup", this],
                ["Post", c.Startup.signal, this.id + " Jax Ready"]
              );
              if (this.copyTranslate) {
                h.Push([
                  function (j) {
                    j.preProcess = j.preTranslate;
                    j.Process = j.Translate;
                    j.postProcess = j.postTranslate;
                  },
                  this.constructor.prototype,
                ]);
              }
              return h.Push(["loadComplete", a, this.directory + "/" + i]);
            }
          },
        },
        {
          id: "Jax",
          version: "2.7.5",
          directory: e + "/jax",
          extensionDir: e + "/extensions",
        }
      );
      b.InputJax = g.Subclass(
        {
          elementJax: "mml",
          sourceMenuTitle: ["Original", "Original Form"],
          copyTranslate: true,
          Process: function (l, q) {
            var j = f.Queue(),
              o;
            var k = this.elementJax;
            if (!b.Object.isArray(k)) {
              k = [k];
            }
            for (var n = 0, h = k.length; n < h; n++) {
              o = b.ElementJax.directory + "/" + k[n] + "/" + this.JAXFILE;
              if (!this.require) {
                this.require = [];
              } else {
                if (!b.Object.isArray(this.require)) {
                  this.require = [this.require];
                }
              }
              this.require.push(o);
              j.Push(a.Require(o));
            }
            o = this.directory + "/" + this.JAXFILE;
            var p = j.Push(a.Require(o));
            if (!p.called) {
              this.constructor.prototype.Process = function () {
                if (!p.called) {
                  return p;
                }
                throw Error(o + " failed to load properly");
              };
            }
            k = c.outputJax["jax/" + k[0]];
            if (k) {
              j.Push(a.Require(k[0].directory + "/" + this.JAXFILE));
            }
            return j.Push({});
          },
          needsUpdate: function (h) {
            var i = h.SourceElement();
            return h.originalText !== b.HTML.getScript(i);
          },
          Register: function (h) {
            if (!c.inputJax) {
              c.inputJax = {};
            }
            c.inputJax[h] = this;
          },
        },
        {
          id: "InputJax",
          version: "2.7.5",
          directory: g.directory + "/input",
          extensionDir: g.extensionDir,
        }
      );
      b.OutputJax = g.Subclass(
        {
          copyTranslate: true,
          preProcess: function (j) {
            var i,
              h = this.directory + "/" + this.JAXFILE;
            this.constructor.prototype.preProcess = function (k) {
              if (!i.called) {
                return i;
              }
              throw Error(h + " failed to load properly");
            };
            i = a.Require(h);
            return i;
          },
          Process: function (h) {
            throw Error(this.id + " output jax failed to load properly");
          },
          Register: function (i) {
            var h = c.outputJax;
            if (!h[i]) {
              h[i] = [];
            }
            if (
              h[i].length &&
              (this.id === c.config.menuSettings.renderer ||
                (h.order[this.id] || 0) < (h.order[h[i][0].id] || 0))
            ) {
              h[i].unshift(this);
            } else {
              h[i].push(this);
            }
            if (!this.require) {
              this.require = [];
            } else {
              if (!b.Object.isArray(this.require)) {
                this.require = [this.require];
              }
            }
            this.require.push(
              b.ElementJax.directory +
                "/" +
                i.split(/\//)[1] +
                "/" +
                this.JAXFILE
            );
          },
          Remove: function (h) {},
        },
        {
          id: "OutputJax",
          version: "2.7.5",
          directory: g.directory + "/output",
          extensionDir: g.extensionDir,
          fontDir: e + (b.isPacked ? "" : "/..") + "/fonts",
          imageDir: e + (b.isPacked ? "" : "/..") + "/images",
        }
      );
      b.ElementJax = g.Subclass(
        {
          Init: function (i, h) {
            return this.constructor.Subclass(i, h);
          },
          inputJax: null,
          outputJax: null,
          inputID: null,
          originalText: "",
          mimeType: "",
          sourceMenuTitle: ["MathMLcode", "MathML Code"],
          Text: function (i, j) {
            var h = this.SourceElement();
            b.HTML.setScript(h, i);
            h.MathJax.state = this.STATE.UPDATE;
            return c.Update(h, j);
          },
          Reprocess: function (i) {
            var h = this.SourceElement();
            h.MathJax.state = this.STATE.UPDATE;
            return c.Reprocess(h, i);
          },
          Update: function (h) {
            return this.Rerender(h);
          },
          Rerender: function (i) {
            var h = this.SourceElement();
            h.MathJax.state = this.STATE.OUTPUT;
            return c.Process(h, i);
          },
          Remove: function (h) {
            if (this.hover) {
              this.hover.clear(this);
            }
            b.OutputJax[this.outputJax].Remove(this);
            if (!h) {
              c.signal.Post(["Remove Math", this.inputID]);
              this.Detach();
            }
          },
          needsUpdate: function () {
            return b.InputJax[this.inputJax].needsUpdate(this);
          },
          SourceElement: function () {
            return document.getElementById(this.inputID);
          },
          Attach: function (i, j) {
            var h = i.MathJax.elementJax;
            if (i.MathJax.state === this.STATE.UPDATE) {
              h.Clone(this);
            } else {
              h = i.MathJax.elementJax = this;
              if (i.id) {
                this.inputID = i.id;
              } else {
                i.id = this.inputID = b.ElementJax.GetID();
                this.newID = 1;
              }
            }
            h.originalText = b.HTML.getScript(i);
            h.inputJax = j;
            if (h.root) {
              h.root.inputID = h.inputID;
            }
            return h;
          },
          Detach: function () {
            var h = this.SourceElement();
            if (!h) {
              return;
            }
            try {
              delete h.MathJax;
            } catch (i) {
              h.MathJax = null;
            }
            if (this.newID) {
              h.id = "";
            }
          },
          Clone: function (h) {
            var i;
            for (i in this) {
              if (!this.hasOwnProperty(i)) {
                continue;
              }
              if (typeof h[i] === "undefined" && i !== "newID") {
                delete this[i];
              }
            }
            for (i in h) {
              if (!h.hasOwnProperty(i)) {
                continue;
              }
              if (
                typeof this[i] === "undefined" ||
                (this[i] !== h[i] && i !== "inputID")
              ) {
                this[i] = h[i];
              }
            }
          },
        },
        {
          id: "ElementJax",
          version: "2.7.5",
          directory: g.directory + "/element",
          extensionDir: g.extensionDir,
          ID: 0,
          STATE: { PENDING: 1, PROCESSED: 2, UPDATE: 3, OUTPUT: 4 },
          GetID: function () {
            this.ID++;
            return "MathJax-Element-" + this.ID;
          },
          Subclass: function () {
            var h = g.Subclass.apply(this, arguments);
            h.loadComplete = this.prototype.loadComplete;
            return h;
          },
        }
      );
      b.ElementJax.prototype.STATE = b.ElementJax.STATE;
      b.OutputJax.Error = {
        id: "Error",
        version: "2.7.5",
        config: {},
        errors: 0,
        ContextMenu: function () {
          return b.Extension.MathEvents.Event.ContextMenu.apply(
            b.Extension.MathEvents.Event,
            arguments
          );
        },
        Mousedown: function () {
          return b.Extension.MathEvents.Event.AltContextMenu.apply(
            b.Extension.MathEvents.Event,
            arguments
          );
        },
        getJaxFromMath: function (h) {
          return (h.nextSibling.MathJax || {}).error;
        },
        Jax: function (j, i) {
          var h = MathJax.Hub.inputJax[i.type.replace(/ *;(.|\s)*/, "")];
          this.errors++;
          return {
            inputJax: (h || { id: "Error" }).id,
            outputJax: "Error",
            inputID: "MathJax-Error-" + this.errors,
            sourceMenuTitle: ["ErrorMessage", "Error Message"],
            sourceMenuFormat: "Error",
            originalText: MathJax.HTML.getScript(i),
            errorText: j,
          };
        },
      };
      b.InputJax.Error = {
        id: "Error",
        version: "2.7.5",
        config: {},
        sourceMenuTitle: ["Original", "Original Form"],
      };
    })("MathJax");
    (function (o) {
      var h = window[o];
      if (!h) {
        h = window[o] = {};
      }
      var d = h.Hub;
      var s = d.Startup;
      var w = d.config;
      var g = document.head || document.getElementsByTagName("head")[0];
      if (!g) {
        g = document.childNodes[0];
      }
      var b = (document.documentElement || document).getElementsByTagName(
        "script"
      );
      if (b.length === 0 && g.namespaceURI) {
        b = document.getElementsByTagNameNS(g.namespaceURI, "script");
      }
      var f = new RegExp("(^|/)" + o + "\\.js(\\?.*)?$");
      for (var q = b.length - 1; q >= 0; q--) {
        if ((b[q].src || "").match(f)) {
          s.script = b[q].innerHTML;
          if (RegExp.$2) {
            var t = RegExp.$2.substr(1).split(/\&/);
            for (var p = 0, l = t.length; p < l; p++) {
              var n = t[p].match(/(.*)=(.*)/);
              if (n) {
                s.params[unescape(n[1])] = unescape(n[2]);
              } else {
                s.params[t[p]] = true;
              }
            }
          }
          w.root = b[q].src.replace(/(^|\/)[^\/]*(\?.*)?$/, "");
          h.Ajax.config.root = w.root;
          h.Ajax.params = s.params;
          break;
        }
      }
      var k = navigator.userAgent;
      var a = {
        isMac: navigator.platform.substr(0, 3) === "Mac",
        isPC: navigator.platform.substr(0, 3) === "Win",
        isMSIE: "ActiveXObject" in window && "clipboardData" in window,
        isEdge:
          "MSGestureEvent" in window &&
          "chrome" in window &&
          window.chrome.loadTimes == null,
        isFirefox: !!k.match(/Gecko\//) && !k.match(/like Gecko/),
        isSafari:
          !!k.match(/ (Apple)?WebKit\//) &&
          !k.match(/ like iPhone /) &&
          (!window.chrome || window.chrome.app == null),
        isChrome: "chrome" in window && window.chrome.loadTimes != null,
        isOpera: "opera" in window && window.opera.version != null,
        isKonqueror: "konqueror" in window && navigator.vendor == "KDE",
        versionAtLeast: function (y) {
          var x = this.version.split(".");
          y = new String(y).split(".");
          for (var z = 0, j = y.length; z < j; z++) {
            if (x[z] != y[z]) {
              return parseInt(x[z] || "0") >= parseInt(y[z]);
            }
          }
          return true;
        },
        Select: function (j) {
          var i = j[d.Browser];
          if (i) {
            return i(d.Browser);
          }
          return null;
        },
      };
      var e = k
        .replace(/^Mozilla\/(\d+\.)+\d+ /, "")
        .replace(/[a-z][-a-z0-9._: ]+\/\d+[^ ]*-[^ ]*\.([a-z][a-z])?\d+ /i, "")
        .replace(/Gentoo |Ubuntu\/(\d+\.)*\d+ (\([^)]*\) )?/, "");
      d.Browser = d.Insert(
        d.Insert(new String("Unknown"), { version: "0.0" }),
        a
      );
      for (var v in a) {
        if (a.hasOwnProperty(v)) {
          if (a[v] && v.substr(0, 2) === "is") {
            v = v.slice(2);
            if (v === "Mac" || v === "PC") {
              continue;
            }
            d.Browser = d.Insert(new String(v), a);
            var r = new RegExp(
              ".*(Version/| Trident/.*; rv:)((?:\\d+\\.)+\\d+)|.*(" +
                v +
                ")" +
                (v == "MSIE" ? " " : "/") +
                "((?:\\d+\\.)*\\d+)|(?:^|\\(| )([a-z][-a-z0-9._: ]+|(?:Apple)?WebKit)/((?:\\d+\\.)+\\d+)"
            );
            var u = r.exec(e) || ["", "", "", "unknown", "0.0"];
            d.Browser.name = u[1] != "" ? v : u[3] || u[5];
            d.Browser.version = u[2] || u[4] || u[6];
            break;
          }
        }
      }
      try {
        d.Browser.Select({
          Safari: function (j) {
            var i = parseInt(String(j.version).split(".")[0]);
            if (i > 85) {
              j.webkit = j.version;
            }
            if (i >= 538) {
              j.version = "8.0";
            } else {
              if (i >= 537) {
                j.version = "7.0";
              } else {
                if (i >= 536) {
                  j.version = "6.0";
                } else {
                  if (i >= 534) {
                    j.version = "5.1";
                  } else {
                    if (i >= 533) {
                      j.version = "5.0";
                    } else {
                      if (i >= 526) {
                        j.version = "4.0";
                      } else {
                        if (i >= 525) {
                          j.version = "3.1";
                        } else {
                          if (i > 500) {
                            j.version = "3.0";
                          } else {
                            if (i > 400) {
                              j.version = "2.0";
                            } else {
                              if (i > 85) {
                                j.version = "1.0";
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
            j.webkit = navigator.appVersion.match(/WebKit\/(\d+)\./)[1];
            j.isMobile = navigator.appVersion.match(/Mobile/i) != null;
            j.noContextMenu = j.isMobile;
          },
          Firefox: function (j) {
            if (
              (j.version === "0.0" || k.match(/Firefox/) == null) &&
              navigator.product === "Gecko"
            ) {
              var m = k.match(/[\/ ]rv:(\d+\.\d.*?)[\) ]/);
              if (m) {
                j.version = m[1];
              } else {
                var i = (
                  navigator.buildID ||
                  navigator.productSub ||
                  "0"
                ).substr(0, 8);
                if (i >= "20111220") {
                  j.version = "9.0";
                } else {
                  if (i >= "20111120") {
                    j.version = "8.0";
                  } else {
                    if (i >= "20110927") {
                      j.version = "7.0";
                    } else {
                      if (i >= "20110816") {
                        j.version = "6.0";
                      } else {
                        if (i >= "20110621") {
                          j.version = "5.0";
                        } else {
                          if (i >= "20110320") {
                            j.version = "4.0";
                          } else {
                            if (i >= "20100121") {
                              j.version = "3.6";
                            } else {
                              if (i >= "20090630") {
                                j.version = "3.5";
                              } else {
                                if (i >= "20080617") {
                                  j.version = "3.0";
                                } else {
                                  if (i >= "20061024") {
                                    j.version = "2.0";
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
            j.isMobile =
              navigator.appVersion.match(/Android/i) != null ||
              k.match(/ Fennec\//) != null ||
              k.match(/Mobile/) != null;
          },
          Chrome: function (i) {
            i.noContextMenu = i.isMobile =
              !!navigator.userAgent.match(/ Mobile[ \/]/);
          },
          Opera: function (i) {
            i.version = opera.version();
          },
          Edge: function (i) {
            i.isMobile = !!navigator.userAgent.match(/ Phone/);
          },
          MSIE: function (j) {
            j.isMobile = !!navigator.userAgent.match(/ Phone/);
            j.isIE9 = !!(
              document.documentMode &&
              (window.performance || window.msPerformance)
            );
            MathJax.HTML.setScriptBug = !j.isIE9 || document.documentMode < 9;
            MathJax.Hub.msieHTMLCollectionBug = document.documentMode < 9;
            if (document.documentMode < 10 && !s.params.NoMathPlayer) {
              try {
                new ActiveXObject("MathPlayer.Factory.1");
                j.hasMathPlayer = true;
              } catch (m) {}
              try {
                if (j.hasMathPlayer) {
                  var i = document.createElement("object");
                  i.id = "mathplayer";
                  i.classid = "clsid:32F66A20-7614-11D4-BD11-00104BD3F987";
                  g.appendChild(i);
                  document.namespaces.add(
                    "m",
                    "http://www.w3.org/1998/Math/MathML"
                  );
                  j.mpNamespace = true;
                  if (
                    document.readyState &&
                    (document.readyState === "loading" ||
                      document.readyState === "interactive")
                  ) {
                    document.write(
                      '<?import namespace="m" implementation="#MathPlayer">'
                    );
                    j.mpImported = true;
                  }
                } else {
                  document.namespaces.add(
                    "mjx_IE_fix",
                    "http://www.w3.org/1999/xlink"
                  );
                }
              } catch (m) {}
            }
          },
        });
      } catch (c) {
        console.error(c.message);
      }
      d.Browser.Select(MathJax.Message.browsers);
      if (h.AuthorConfig && typeof h.AuthorConfig.AuthorInit === "function") {
        h.AuthorConfig.AuthorInit();
      }
      d.queue = h.Callback.Queue();
      d.queue.Push(
        ["Post", s.signal, "Begin"],
        ["Config", s],
        ["Cookie", s],
        ["Styles", s],
        ["Message", s],
        function () {
          var i = h.Callback.Queue(s.Jax(), s.Extensions());
          return i.Push({});
        },
        ["Menu", s],
        s.onLoad(),
        function () {
          MathJax.isReady = true;
        },
        ["Typeset", s],
        ["Hash", s],
        ["MenuZoom", s],
        ["Post", s.signal, "End"]
      );
    })("MathJax");
  }
}