(function (root) {
  var exports = undefined,
      module = undefined,
      require = undefined;
  var define = undefined;
  var self = root,
      window = root,
      global = root,
      globalThis = root;
  (function () {
    /** @license zlib.js 2012 - imaya [ https://github.com/imaya/zlib.js ] The MIT License */
    (function () {
      'use strict';

      function m(d) {
        throw d;
      }

      var w = void 0,
          z = !0,
          aa = this;

      function A(d, a) {
        var c = d.split("."),
            e = aa;
        !(c[0] in e) && e.execScript && e.execScript("var " + c[0]);

        for (var b; c.length && (b = c.shift());) !c.length && a !== w ? e[b] = a : e = e[b] ? e[b] : e[b] = {};
      }

      ;
      var G = "undefined" !== typeof Uint8Array && "undefined" !== typeof Uint16Array && "undefined" !== typeof Uint32Array && "undefined" !== typeof DataView;

      function I(d, a) {
        this.index = "number" === typeof a ? a : 0;
        this.i = 0;
        this.buffer = d instanceof (G ? Uint8Array : Array) ? d : new (G ? Uint8Array : Array)(32768);
        2 * this.buffer.length <= this.index && m(Error("invalid index"));
        this.buffer.length <= this.index && this.f();
      }

      I.prototype.f = function () {
        var d = this.buffer,
            a,
            c = d.length,
            e = new (G ? Uint8Array : Array)(c << 1);
        if (G) e.set(d);else for (a = 0; a < c; ++a) e[a] = d[a];
        return this.buffer = e;
      };

      I.prototype.d = function (d, a, c) {
        var e = this.buffer,
            b = this.index,
            f = this.i,
            g = e[b],
            h;
        c && 1 < a && (d = 8 < a ? (Q[d & 255] << 24 | Q[d >>> 8 & 255] << 16 | Q[d >>> 16 & 255] << 8 | Q[d >>> 24 & 255]) >> 32 - a : Q[d] >> 8 - a);
        if (8 > a + f) g = g << a | d, f += a;else for (h = 0; h < a; ++h) g = g << 1 | d >> a - h - 1 & 1, 8 === ++f && (f = 0, e[b++] = Q[g], g = 0, b === e.length && (e = this.f()));
        e[b] = g;
        this.buffer = e;
        this.i = f;
        this.index = b;
      };

      I.prototype.finish = function () {
        var d = this.buffer,
            a = this.index,
            c;
        0 < this.i && (d[a] <<= 8 - this.i, d[a] = Q[d[a]], a++);
        G ? c = d.subarray(0, a) : (d.length = a, c = d);
        return c;
      };

      var ba = new (G ? Uint8Array : Array)(256),
          ca;

      for (ca = 0; 256 > ca; ++ca) {
        for (var R = ca, ha = R, ia = 7, R = R >>> 1; R; R >>>= 1) ha <<= 1, ha |= R & 1, --ia;

        ba[ca] = (ha << ia & 255) >>> 0;
      }

      var Q = ba;

      function ja(d) {
        this.buffer = new (G ? Uint16Array : Array)(2 * d);
        this.length = 0;
      }

      ja.prototype.getParent = function (d) {
        return 2 * ((d - 2) / 4 | 0);
      };

      ja.prototype.push = function (d, a) {
        var c,
            e,
            b = this.buffer,
            f;
        c = this.length;
        b[this.length++] = a;

        for (b[this.length++] = d; 0 < c;) if (e = this.getParent(c), b[c] > b[e]) f = b[c], b[c] = b[e], b[e] = f, f = b[c + 1], b[c + 1] = b[e + 1], b[e + 1] = f, c = e;else break;

        return this.length;
      };

      ja.prototype.pop = function () {
        var d,
            a,
            c = this.buffer,
            e,
            b,
            f;
        a = c[0];
        d = c[1];
        this.length -= 2;
        c[0] = c[this.length];
        c[1] = c[this.length + 1];

        for (f = 0;;) {
          b = 2 * f + 2;
          if (b >= this.length) break;
          b + 2 < this.length && c[b + 2] > c[b] && (b += 2);
          if (c[b] > c[f]) e = c[f], c[f] = c[b], c[b] = e, e = c[f + 1], c[f + 1] = c[b + 1], c[b + 1] = e;else break;
          f = b;
        }

        return {
          index: d,
          value: a,
          length: this.length
        };
      };

      function S(d) {
        var a = d.length,
            c = 0,
            e = Number.POSITIVE_INFINITY,
            b,
            f,
            g,
            h,
            k,
            p,
            q,
            r,
            n,
            l;

        for (r = 0; r < a; ++r) d[r] > c && (c = d[r]), d[r] < e && (e = d[r]);

        b = 1 << c;
        f = new (G ? Uint32Array : Array)(b);
        g = 1;
        h = 0;

        for (k = 2; g <= c;) {
          for (r = 0; r < a; ++r) if (d[r] === g) {
            p = 0;
            q = h;

            for (n = 0; n < g; ++n) p = p << 1 | q & 1, q >>= 1;

            l = g << 16 | r;

            for (n = p; n < b; n += k) f[n] = l;

            ++h;
          }

          ++g;
          h <<= 1;
          k <<= 1;
        }

        return [f, c, e];
      }

      ;

      function ka(d, a) {
        this.h = na;
        this.w = 0;
        this.input = G && d instanceof Array ? new Uint8Array(d) : d;
        this.b = 0;
        a && (a.lazy && (this.w = a.lazy), "number" === typeof a.compressionType && (this.h = a.compressionType), a.outputBuffer && (this.a = G && a.outputBuffer instanceof Array ? new Uint8Array(a.outputBuffer) : a.outputBuffer), "number" === typeof a.outputIndex && (this.b = a.outputIndex));
        this.a || (this.a = new (G ? Uint8Array : Array)(32768));
      }

      var na = 2,
          oa = {
        NONE: 0,
        r: 1,
        k: na,
        N: 3
      },
          pa = [],
          T;

      for (T = 0; 288 > T; T++) switch (z) {
        case 143 >= T:
          pa.push([T + 48, 8]);
          break;

        case 255 >= T:
          pa.push([T - 144 + 400, 9]);
          break;

        case 279 >= T:
          pa.push([T - 256 + 0, 7]);
          break;

        case 287 >= T:
          pa.push([T - 280 + 192, 8]);
          break;

        default:
          m("invalid literal: " + T);
      }

      ka.prototype.j = function () {
        var d,
            a,
            c,
            e,
            b = this.input;

        switch (this.h) {
          case 0:
            c = 0;

            for (e = b.length; c < e;) {
              a = G ? b.subarray(c, c + 65535) : b.slice(c, c + 65535);
              c += a.length;
              var f = a,
                  g = c === e,
                  h = w,
                  k = w,
                  p = w,
                  q = w,
                  r = w,
                  n = this.a,
                  l = this.b;

              if (G) {
                for (n = new Uint8Array(this.a.buffer); n.length <= l + f.length + 5;) n = new Uint8Array(n.length << 1);

                n.set(this.a);
              }

              h = g ? 1 : 0;
              n[l++] = h | 0;
              k = f.length;
              p = ~k + 65536 & 65535;
              n[l++] = k & 255;
              n[l++] = k >>> 8 & 255;
              n[l++] = p & 255;
              n[l++] = p >>> 8 & 255;
              if (G) n.set(f, l), l += f.length, n = n.subarray(0, l);else {
                q = 0;

                for (r = f.length; q < r; ++q) n[l++] = f[q];

                n.length = l;
              }
              this.b = l;
              this.a = n;
            }

            break;

          case 1:
            var s = new I(G ? new Uint8Array(this.a.buffer) : this.a, this.b);
            s.d(1, 1, z);
            s.d(1, 2, z);
            var t = qa(this, b),
                x,
                E,
                B;
            x = 0;

            for (E = t.length; x < E; x++) if (B = t[x], I.prototype.d.apply(s, pa[B]), 256 < B) s.d(t[++x], t[++x], z), s.d(t[++x], 5), s.d(t[++x], t[++x], z);else if (256 === B) break;

            this.a = s.finish();
            this.b = this.a.length;
            break;

          case na:
            var C = new I(G ? new Uint8Array(this.a.buffer) : this.a, this.b),
                L,
                v,
                M,
                Y,
                Z,
                gb = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15],
                da,
                Fa,
                ea,
                Ga,
                la,
                sa = Array(19),
                Ha,
                $,
                ma,
                D,
                Ia;
            L = na;
            C.d(1, 1, z);
            C.d(L, 2, z);
            v = qa(this, b);
            da = ra(this.L, 15);
            Fa = ta(da);
            ea = ra(this.K, 7);
            Ga = ta(ea);

            for (M = 286; 257 < M && 0 === da[M - 1]; M--);

            for (Y = 30; 1 < Y && 0 === ea[Y - 1]; Y--);

            var Ja = M,
                Ka = Y,
                K = new (G ? Uint32Array : Array)(Ja + Ka),
                u,
                N,
                y,
                fa,
                J = new (G ? Uint32Array : Array)(316),
                H,
                F,
                O = new (G ? Uint8Array : Array)(19);

            for (u = N = 0; u < Ja; u++) K[N++] = da[u];

            for (u = 0; u < Ka; u++) K[N++] = ea[u];

            if (!G) {
              u = 0;

              for (fa = O.length; u < fa; ++u) O[u] = 0;
            }

            u = H = 0;

            for (fa = K.length; u < fa; u += N) {
              for (N = 1; u + N < fa && K[u + N] === K[u]; ++N);

              y = N;
              if (0 === K[u]) {
                if (3 > y) for (; 0 < y--;) J[H++] = 0, O[0]++;else for (; 0 < y;) F = 138 > y ? y : 138, F > y - 3 && F < y && (F = y - 3), 10 >= F ? (J[H++] = 17, J[H++] = F - 3, O[17]++) : (J[H++] = 18, J[H++] = F - 11, O[18]++), y -= F;
              } else if (J[H++] = K[u], O[K[u]]++, y--, 3 > y) for (; 0 < y--;) J[H++] = K[u], O[K[u]]++;else for (; 0 < y;) F = 6 > y ? y : 6, F > y - 3 && F < y && (F = y - 3), J[H++] = 16, J[H++] = F - 3, O[16]++, y -= F;
            }

            d = G ? J.subarray(0, H) : J.slice(0, H);
            la = ra(O, 7);

            for (D = 0; 19 > D; D++) sa[D] = la[gb[D]];

            for (Z = 19; 4 < Z && 0 === sa[Z - 1]; Z--);

            Ha = ta(la);
            C.d(M - 257, 5, z);
            C.d(Y - 1, 5, z);
            C.d(Z - 4, 4, z);

            for (D = 0; D < Z; D++) C.d(sa[D], 3, z);

            D = 0;

            for (Ia = d.length; D < Ia; D++) if ($ = d[D], C.d(Ha[$], la[$], z), 16 <= $) {
              D++;

              switch ($) {
                case 16:
                  ma = 2;
                  break;

                case 17:
                  ma = 3;
                  break;

                case 18:
                  ma = 7;
                  break;

                default:
                  m("invalid code: " + $);
              }

              C.d(d[D], ma, z);
            }

            var La = [Fa, da],
                Ma = [Ga, ea],
                P,
                Na,
                ga,
                va,
                Oa,
                Pa,
                Qa,
                Ra;
            Oa = La[0];
            Pa = La[1];
            Qa = Ma[0];
            Ra = Ma[1];
            P = 0;

            for (Na = v.length; P < Na; ++P) if (ga = v[P], C.d(Oa[ga], Pa[ga], z), 256 < ga) C.d(v[++P], v[++P], z), va = v[++P], C.d(Qa[va], Ra[va], z), C.d(v[++P], v[++P], z);else if (256 === ga) break;

            this.a = C.finish();
            this.b = this.a.length;
            break;

          default:
            m("invalid compression type");
        }

        return this.a;
      };

      function ua(d, a) {
        this.length = d;
        this.G = a;
      }

      var wa = function () {
        function d(b) {
          switch (z) {
            case 3 === b:
              return [257, b - 3, 0];

            case 4 === b:
              return [258, b - 4, 0];

            case 5 === b:
              return [259, b - 5, 0];

            case 6 === b:
              return [260, b - 6, 0];

            case 7 === b:
              return [261, b - 7, 0];

            case 8 === b:
              return [262, b - 8, 0];

            case 9 === b:
              return [263, b - 9, 0];

            case 10 === b:
              return [264, b - 10, 0];

            case 12 >= b:
              return [265, b - 11, 1];

            case 14 >= b:
              return [266, b - 13, 1];

            case 16 >= b:
              return [267, b - 15, 1];

            case 18 >= b:
              return [268, b - 17, 1];

            case 22 >= b:
              return [269, b - 19, 2];

            case 26 >= b:
              return [270, b - 23, 2];

            case 30 >= b:
              return [271, b - 27, 2];

            case 34 >= b:
              return [272, b - 31, 2];

            case 42 >= b:
              return [273, b - 35, 3];

            case 50 >= b:
              return [274, b - 43, 3];

            case 58 >= b:
              return [275, b - 51, 3];

            case 66 >= b:
              return [276, b - 59, 3];

            case 82 >= b:
              return [277, b - 67, 4];

            case 98 >= b:
              return [278, b - 83, 4];

            case 114 >= b:
              return [279, b - 99, 4];

            case 130 >= b:
              return [280, b - 115, 4];

            case 162 >= b:
              return [281, b - 131, 5];

            case 194 >= b:
              return [282, b - 163, 5];

            case 226 >= b:
              return [283, b - 195, 5];

            case 257 >= b:
              return [284, b - 227, 5];

            case 258 === b:
              return [285, b - 258, 0];

            default:
              m("invalid length: " + b);
          }
        }

        var a = [],
            c,
            e;

        for (c = 3; 258 >= c; c++) e = d(c), a[c] = e[2] << 24 | e[1] << 16 | e[0];

        return a;
      }(),
          xa = G ? new Uint32Array(wa) : wa;

      function qa(d, a) {
        function c(b, c) {
          var a = b.G,
              d = [],
              e = 0,
              f;
          f = xa[b.length];
          d[e++] = f & 65535;
          d[e++] = f >> 16 & 255;
          d[e++] = f >> 24;
          var g;

          switch (z) {
            case 1 === a:
              g = [0, a - 1, 0];
              break;

            case 2 === a:
              g = [1, a - 2, 0];
              break;

            case 3 === a:
              g = [2, a - 3, 0];
              break;

            case 4 === a:
              g = [3, a - 4, 0];
              break;

            case 6 >= a:
              g = [4, a - 5, 1];
              break;

            case 8 >= a:
              g = [5, a - 7, 1];
              break;

            case 12 >= a:
              g = [6, a - 9, 2];
              break;

            case 16 >= a:
              g = [7, a - 13, 2];
              break;

            case 24 >= a:
              g = [8, a - 17, 3];
              break;

            case 32 >= a:
              g = [9, a - 25, 3];
              break;

            case 48 >= a:
              g = [10, a - 33, 4];
              break;

            case 64 >= a:
              g = [11, a - 49, 4];
              break;

            case 96 >= a:
              g = [12, a - 65, 5];
              break;

            case 128 >= a:
              g = [13, a - 97, 5];
              break;

            case 192 >= a:
              g = [14, a - 129, 6];
              break;

            case 256 >= a:
              g = [15, a - 193, 6];
              break;

            case 384 >= a:
              g = [16, a - 257, 7];
              break;

            case 512 >= a:
              g = [17, a - 385, 7];
              break;

            case 768 >= a:
              g = [18, a - 513, 8];
              break;

            case 1024 >= a:
              g = [19, a - 769, 8];
              break;

            case 1536 >= a:
              g = [20, a - 1025, 9];
              break;

            case 2048 >= a:
              g = [21, a - 1537, 9];
              break;

            case 3072 >= a:
              g = [22, a - 2049, 10];
              break;

            case 4096 >= a:
              g = [23, a - 3073, 10];
              break;

            case 6144 >= a:
              g = [24, a - 4097, 11];
              break;

            case 8192 >= a:
              g = [25, a - 6145, 11];
              break;

            case 12288 >= a:
              g = [26, a - 8193, 12];
              break;

            case 16384 >= a:
              g = [27, a - 12289, 12];
              break;

            case 24576 >= a:
              g = [28, a - 16385, 13];
              break;

            case 32768 >= a:
              g = [29, a - 24577, 13];
              break;

            default:
              m("invalid distance");
          }

          f = g;
          d[e++] = f[0];
          d[e++] = f[1];
          d[e++] = f[2];
          var h, k;
          h = 0;

          for (k = d.length; h < k; ++h) n[l++] = d[h];

          t[d[0]]++;
          x[d[3]]++;
          s = b.length + c - 1;
          r = null;
        }

        var e,
            b,
            f,
            g,
            h,
            k = {},
            p,
            q,
            r,
            n = G ? new Uint16Array(2 * a.length) : [],
            l = 0,
            s = 0,
            t = new (G ? Uint32Array : Array)(286),
            x = new (G ? Uint32Array : Array)(30),
            E = d.w,
            B;

        if (!G) {
          for (f = 0; 285 >= f;) t[f++] = 0;

          for (f = 0; 29 >= f;) x[f++] = 0;
        }

        t[256] = 1;
        e = 0;

        for (b = a.length; e < b; ++e) {
          f = h = 0;

          for (g = 3; f < g && e + f !== b; ++f) h = h << 8 | a[e + f];

          k[h] === w && (k[h] = []);
          p = k[h];

          if (!(0 < s--)) {
            for (; 0 < p.length && 32768 < e - p[0];) p.shift();

            if (e + 3 >= b) {
              r && c(r, -1);
              f = 0;

              for (g = b - e; f < g; ++f) B = a[e + f], n[l++] = B, ++t[B];

              break;
            }

            0 < p.length ? (q = ya(a, e, p), r ? r.length < q.length ? (B = a[e - 1], n[l++] = B, ++t[B], c(q, 0)) : c(r, -1) : q.length < E ? r = q : c(q, 0)) : r ? c(r, -1) : (B = a[e], n[l++] = B, ++t[B]);
          }

          p.push(e);
        }

        n[l++] = 256;
        t[256]++;
        d.L = t;
        d.K = x;
        return G ? n.subarray(0, l) : n;
      }

      function ya(d, a, c) {
        var e,
            b,
            f = 0,
            g,
            h,
            k,
            p,
            q = d.length;
        h = 0;
        p = c.length;

        a: for (; h < p; h++) {
          e = c[p - h - 1];
          g = 3;

          if (3 < f) {
            for (k = f; 3 < k; k--) if (d[e + k - 1] !== d[a + k - 1]) continue a;

            g = f;
          }

          for (; 258 > g && a + g < q && d[e + g] === d[a + g];) ++g;

          g > f && (b = e, f = g);
          if (258 === g) break;
        }

        return new ua(f, a - b);
      }

      function ra(d, a) {
        var c = d.length,
            e = new ja(572),
            b = new (G ? Uint8Array : Array)(c),
            f,
            g,
            h,
            k,
            p;
        if (!G) for (k = 0; k < c; k++) b[k] = 0;

        for (k = 0; k < c; ++k) 0 < d[k] && e.push(k, d[k]);

        f = Array(e.length / 2);
        g = new (G ? Uint32Array : Array)(e.length / 2);
        if (1 === f.length) return b[e.pop().index] = 1, b;
        k = 0;

        for (p = e.length / 2; k < p; ++k) f[k] = e.pop(), g[k] = f[k].value;

        h = za(g, g.length, a);
        k = 0;

        for (p = f.length; k < p; ++k) b[f[k].index] = h[k];

        return b;
      }

      function za(d, a, c) {
        function e(b) {
          var c = k[b][p[b]];
          c === a ? (e(b + 1), e(b + 1)) : --g[c];
          ++p[b];
        }

        var b = new (G ? Uint16Array : Array)(c),
            f = new (G ? Uint8Array : Array)(c),
            g = new (G ? Uint8Array : Array)(a),
            h = Array(c),
            k = Array(c),
            p = Array(c),
            q = (1 << c) - a,
            r = 1 << c - 1,
            n,
            l,
            s,
            t,
            x;
        b[c - 1] = a;

        for (l = 0; l < c; ++l) q < r ? f[l] = 0 : (f[l] = 1, q -= r), q <<= 1, b[c - 2 - l] = (b[c - 1 - l] / 2 | 0) + a;

        b[0] = f[0];
        h[0] = Array(b[0]);
        k[0] = Array(b[0]);

        for (l = 1; l < c; ++l) b[l] > 2 * b[l - 1] + f[l] && (b[l] = 2 * b[l - 1] + f[l]), h[l] = Array(b[l]), k[l] = Array(b[l]);

        for (n = 0; n < a; ++n) g[n] = c;

        for (s = 0; s < b[c - 1]; ++s) h[c - 1][s] = d[s], k[c - 1][s] = s;

        for (n = 0; n < c; ++n) p[n] = 0;

        1 === f[c - 1] && (--g[0], ++p[c - 1]);

        for (l = c - 2; 0 <= l; --l) {
          t = n = 0;
          x = p[l + 1];

          for (s = 0; s < b[l]; s++) t = h[l + 1][x] + h[l + 1][x + 1], t > d[n] ? (h[l][s] = t, k[l][s] = a, x += 2) : (h[l][s] = d[n], k[l][s] = n, ++n);

          p[l] = 0;
          1 === f[l] && e(l);
        }

        return g;
      }

      function ta(d) {
        var a = new (G ? Uint16Array : Array)(d.length),
            c = [],
            e = [],
            b = 0,
            f,
            g,
            h,
            k;
        f = 0;

        for (g = d.length; f < g; f++) c[d[f]] = (c[d[f]] | 0) + 1;

        f = 1;

        for (g = 16; f <= g; f++) e[f] = b, b += c[f] | 0, b <<= 1;

        f = 0;

        for (g = d.length; f < g; f++) {
          b = e[d[f]];
          e[d[f]] += 1;
          h = a[f] = 0;

          for (k = d[f]; h < k; h++) a[f] = a[f] << 1 | b & 1, b >>>= 1;
        }

        return a;
      }

      ;

      function U(d, a) {
        this.l = [];
        this.m = 32768;
        this.e = this.g = this.c = this.q = 0;
        this.input = G ? new Uint8Array(d) : d;
        this.s = !1;
        this.n = Aa;
        this.B = !1;
        if (a || !(a = {})) a.index && (this.c = a.index), a.bufferSize && (this.m = a.bufferSize), a.bufferType && (this.n = a.bufferType), a.resize && (this.B = a.resize);

        switch (this.n) {
          case Ba:
            this.b = 32768;
            this.a = new (G ? Uint8Array : Array)(32768 + this.m + 258);
            break;

          case Aa:
            this.b = 0;
            this.a = new (G ? Uint8Array : Array)(this.m);
            this.f = this.J;
            this.t = this.H;
            this.o = this.I;
            break;

          default:
            m(Error("invalid inflate mode"));
        }
      }

      var Ba = 0,
          Aa = 1,
          Ca = {
        D: Ba,
        C: Aa
      };

      U.prototype.p = function () {
        for (; !this.s;) {
          var d = V(this, 3);
          d & 1 && (this.s = z);
          d >>>= 1;

          switch (d) {
            case 0:
              var a = this.input,
                  c = this.c,
                  e = this.a,
                  b = this.b,
                  f = a.length,
                  g = w,
                  h = w,
                  k = e.length,
                  p = w;
              this.e = this.g = 0;
              c + 1 >= f && m(Error("invalid uncompressed block header: LEN"));
              g = a[c++] | a[c++] << 8;
              c + 1 >= f && m(Error("invalid uncompressed block header: NLEN"));
              h = a[c++] | a[c++] << 8;
              g === ~h && m(Error("invalid uncompressed block header: length verify"));
              c + g > a.length && m(Error("input buffer is broken"));

              switch (this.n) {
                case Ba:
                  for (; b + g > e.length;) {
                    p = k - b;
                    g -= p;
                    if (G) e.set(a.subarray(c, c + p), b), b += p, c += p;else for (; p--;) e[b++] = a[c++];
                    this.b = b;
                    e = this.f();
                    b = this.b;
                  }

                  break;

                case Aa:
                  for (; b + g > e.length;) e = this.f({
                    v: 2
                  });

                  break;

                default:
                  m(Error("invalid inflate mode"));
              }

              if (G) e.set(a.subarray(c, c + g), b), b += g, c += g;else for (; g--;) e[b++] = a[c++];
              this.c = c;
              this.b = b;
              this.a = e;
              break;

            case 1:
              this.o(Da, Ea);
              break;

            case 2:
              for (var q = V(this, 5) + 257, r = V(this, 5) + 1, n = V(this, 4) + 4, l = new (G ? Uint8Array : Array)(Sa.length), s = w, t = w, x = w, E = w, B = w, C = w, L = w, v = w, M = w, v = 0; v < n; ++v) l[Sa[v]] = V(this, 3);

              if (!G) {
                v = n;

                for (n = l.length; v < n; ++v) l[Sa[v]] = 0;
              }

              s = S(l);
              E = new (G ? Uint8Array : Array)(q + r);
              v = 0;

              for (M = q + r; v < M;) switch (B = Ta(this, s), B) {
                case 16:
                  for (L = 3 + V(this, 2); L--;) E[v++] = C;

                  break;

                case 17:
                  for (L = 3 + V(this, 3); L--;) E[v++] = 0;

                  C = 0;
                  break;

                case 18:
                  for (L = 11 + V(this, 7); L--;) E[v++] = 0;

                  C = 0;
                  break;

                default:
                  C = E[v++] = B;
              }

              t = G ? S(E.subarray(0, q)) : S(E.slice(0, q));
              x = G ? S(E.subarray(q)) : S(E.slice(q));
              this.o(t, x);
              break;

            default:
              m(Error("unknown BTYPE: " + d));
          }
        }

        return this.t();
      };

      var Ua = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15],
          Sa = G ? new Uint16Array(Ua) : Ua,
          Va = [3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 258, 258],
          Wa = G ? new Uint16Array(Va) : Va,
          Xa = [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 0, 0],
          Ya = G ? new Uint8Array(Xa) : Xa,
          Za = [1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577],
          $a = G ? new Uint16Array(Za) : Za,
          ab = [0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13],
          bb = G ? new Uint8Array(ab) : ab,
          cb = new (G ? Uint8Array : Array)(288),
          W,
          db;
      W = 0;

      for (db = cb.length; W < db; ++W) cb[W] = 143 >= W ? 8 : 255 >= W ? 9 : 279 >= W ? 7 : 8;

      var Da = S(cb),
          eb = new (G ? Uint8Array : Array)(30),
          fb,
          hb;
      fb = 0;

      for (hb = eb.length; fb < hb; ++fb) eb[fb] = 5;

      var Ea = S(eb);

      function V(d, a) {
        for (var c = d.g, e = d.e, b = d.input, f = d.c, g = b.length, h; e < a;) f >= g && m(Error("input buffer is broken")), c |= b[f++] << e, e += 8;

        h = c & (1 << a) - 1;
        d.g = c >>> a;
        d.e = e - a;
        d.c = f;
        return h;
      }

      function Ta(d, a) {
        for (var c = d.g, e = d.e, b = d.input, f = d.c, g = b.length, h = a[0], k = a[1], p, q; e < k && !(f >= g);) c |= b[f++] << e, e += 8;

        p = h[c & (1 << k) - 1];
        q = p >>> 16;
        q > e && m(Error("invalid code length: " + q));
        d.g = c >> q;
        d.e = e - q;
        d.c = f;
        return p & 65535;
      }

      U.prototype.o = function (d, a) {
        var c = this.a,
            e = this.b;
        this.u = d;

        for (var b = c.length - 258, f, g, h, k; 256 !== (f = Ta(this, d));) if (256 > f) e >= b && (this.b = e, c = this.f(), e = this.b), c[e++] = f;else {
          g = f - 257;
          k = Wa[g];
          0 < Ya[g] && (k += V(this, Ya[g]));
          f = Ta(this, a);
          h = $a[f];
          0 < bb[f] && (h += V(this, bb[f]));
          e >= b && (this.b = e, c = this.f(), e = this.b);

          for (; k--;) c[e] = c[e++ - h];
        }

        for (; 8 <= this.e;) this.e -= 8, this.c--;

        this.b = e;
      };

      U.prototype.I = function (d, a) {
        var c = this.a,
            e = this.b;
        this.u = d;

        for (var b = c.length, f, g, h, k; 256 !== (f = Ta(this, d));) if (256 > f) e >= b && (c = this.f(), b = c.length), c[e++] = f;else {
          g = f - 257;
          k = Wa[g];
          0 < Ya[g] && (k += V(this, Ya[g]));
          f = Ta(this, a);
          h = $a[f];
          0 < bb[f] && (h += V(this, bb[f]));
          e + k > b && (c = this.f(), b = c.length);

          for (; k--;) c[e] = c[e++ - h];
        }

        for (; 8 <= this.e;) this.e -= 8, this.c--;

        this.b = e;
      };

      U.prototype.f = function () {
        var d = new (G ? Uint8Array : Array)(this.b - 32768),
            a = this.b - 32768,
            c,
            e,
            b = this.a;
        if (G) d.set(b.subarray(32768, d.length));else {
          c = 0;

          for (e = d.length; c < e; ++c) d[c] = b[c + 32768];
        }
        this.l.push(d);
        this.q += d.length;
        if (G) b.set(b.subarray(a, a + 32768));else for (c = 0; 32768 > c; ++c) b[c] = b[a + c];
        this.b = 32768;
        return b;
      };

      U.prototype.J = function (d) {
        var a,
            c = this.input.length / this.c + 1 | 0,
            e,
            b,
            f,
            g = this.input,
            h = this.a;
        d && ("number" === typeof d.v && (c = d.v), "number" === typeof d.F && (c += d.F));
        2 > c ? (e = (g.length - this.c) / this.u[2], f = 258 * (e / 2) | 0, b = f < h.length ? h.length + f : h.length << 1) : b = h.length * c;
        G ? (a = new Uint8Array(b), a.set(h)) : a = h;
        return this.a = a;
      };

      U.prototype.t = function () {
        var d = 0,
            a = this.a,
            c = this.l,
            e,
            b = new (G ? Uint8Array : Array)(this.q + (this.b - 32768)),
            f,
            g,
            h,
            k;
        if (0 === c.length) return G ? this.a.subarray(32768, this.b) : this.a.slice(32768, this.b);
        f = 0;

        for (g = c.length; f < g; ++f) {
          e = c[f];
          h = 0;

          for (k = e.length; h < k; ++h) b[d++] = e[h];
        }

        f = 32768;

        for (g = this.b; f < g; ++f) b[d++] = a[f];

        this.l = [];
        return this.buffer = b;
      };

      U.prototype.H = function () {
        var d,
            a = this.b;
        G ? this.B ? (d = new Uint8Array(a), d.set(this.a.subarray(0, a))) : d = this.a.subarray(0, a) : (this.a.length > a && (this.a.length = a), d = this.a);
        return this.buffer = d;
      };

      function ib(d) {
        if ("string" === typeof d) {
          var a = d.split(""),
              c,
              e;
          c = 0;

          for (e = a.length; c < e; c++) a[c] = (a[c].charCodeAt(0) & 255) >>> 0;

          d = a;
        }

        for (var b = 1, f = 0, g = d.length, h, k = 0; 0 < g;) {
          h = 1024 < g ? 1024 : g;
          g -= h;

          do b += d[k++], f += b; while (--h);

          b %= 65521;
          f %= 65521;
        }

        return (f << 16 | b) >>> 0;
      }

      ;

      function jb(d, a) {
        var c, e;
        this.input = d;
        this.c = 0;
        if (a || !(a = {})) a.index && (this.c = a.index), a.verify && (this.M = a.verify);
        c = d[this.c++];
        e = d[this.c++];

        switch (c & 15) {
          case kb:
            this.method = kb;
            break;

          default:
            m(Error("unsupported compression method"));
        }

        0 !== ((c << 8) + e) % 31 && m(Error("invalid fcheck flag:" + ((c << 8) + e) % 31));
        e & 32 && m(Error("fdict flag is not supported"));
        this.A = new U(d, {
          index: this.c,
          bufferSize: a.bufferSize,
          bufferType: a.bufferType,
          resize: a.resize
        });
      }

      jb.prototype.p = function () {
        var d = this.input,
            a,
            c;
        a = this.A.p();
        this.c = this.A.c;
        this.M && (c = (d[this.c++] << 24 | d[this.c++] << 16 | d[this.c++] << 8 | d[this.c++]) >>> 0, c !== ib(a) && m(Error("invalid adler-32 checksum")));
        return a;
      };

      var kb = 8;

      function lb(d, a) {
        this.input = d;
        this.a = new (G ? Uint8Array : Array)(32768);
        this.h = X.k;
        var c = {},
            e;
        if ((a || !(a = {})) && "number" === typeof a.compressionType) this.h = a.compressionType;

        for (e in a) c[e] = a[e];

        c.outputBuffer = this.a;
        this.z = new ka(this.input, c);
      }

      var X = oa;

      lb.prototype.j = function () {
        var d,
            a,
            c,
            e,
            b,
            f,
            g,
            h = 0;
        g = this.a;
        d = kb;

        switch (d) {
          case kb:
            a = Math.LOG2E * Math.log(32768) - 8;
            break;

          default:
            m(Error("invalid compression method"));
        }

        c = a << 4 | d;
        g[h++] = c;

        switch (d) {
          case kb:
            switch (this.h) {
              case X.NONE:
                b = 0;
                break;

              case X.r:
                b = 1;
                break;

              case X.k:
                b = 2;
                break;

              default:
                m(Error("unsupported compression type"));
            }

            break;

          default:
            m(Error("invalid compression method"));
        }

        e = b << 6 | 0;
        g[h++] = e | 31 - (256 * c + e) % 31;
        f = ib(this.input);
        this.z.b = h;
        g = this.z.j();
        h = g.length;
        G && (g = new Uint8Array(g.buffer), g.length <= h + 4 && (this.a = new Uint8Array(g.length + 4), this.a.set(g), g = this.a), g = g.subarray(0, h + 4));
        g[h++] = f >> 24 & 255;
        g[h++] = f >> 16 & 255;
        g[h++] = f >> 8 & 255;
        g[h++] = f & 255;
        return g;
      };

      function mb(d, a) {
        var c, e, b, f;
        if (Object.keys) c = Object.keys(a);else for (e in c = [], b = 0, a) c[b++] = e;
        b = 0;

        for (f = c.length; b < f; ++b) e = c[b], A(d + "." + e, a[e]);
      }

      ;
      A("Zlib.Inflate", jb);
      A("Zlib.Inflate.prototype.decompress", jb.prototype.p);
      mb("Zlib.Inflate.BufferType", {
        ADAPTIVE: Ca.C,
        BLOCK: Ca.D
      });
      A("Zlib.Deflate", lb);
      A("Zlib.Deflate.compress", function (d, a) {
        return new lb(d, a).j();
      });
      A("Zlib.Deflate.prototype.compress", lb.prototype.j);
      mb("Zlib.Deflate.CompressionType", {
        NONE: X.NONE,
        FIXED: X.r,
        DYNAMIC: X.k
      });
    }).call(this);
  }).call(root);
})( // The environment-specific global.
function () {
  if (typeof globalThis !== 'undefined') return globalThis;
  if (typeof self !== 'undefined') return self;
  if (typeof window !== 'undefined') return window;
  if (typeof global !== 'undefined') return global;
  if (typeof this !== 'undefined') return this;
  return {};
}.call(this));