@hinkal/common 0.0.116 → 0.0.118

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/wasmcurves/src/bn128/build_bn128.mjs

@@ -0,0 +1,836 @@
+import "../utils.mjs";
+import { b as Dc } from "../build_f1m.mjs";
+import { b as wc } from "../build_f1.mjs";
+import { b as Oc } from "../build_f2m.mjs";
+import { b as Wc } from "../build_f3m.mjs";
+import { b as vc } from "../build_curve_jacobian_a0.mjs";
+import { b as Yc } from "../build_fft.mjs";
+import { b as Kc } from "../build_pol.mjs";
+import { b as Zc } from "../build_qap.mjs";
+import { b as Hc } from "../build_applykey.mjs";
+import "../bigint.mjs";
+import { __exports as Jc } from "../../../../../../../../../_virtual/utils10.mjs";
+import { __exports as $c } from "../../../../../../../../../_virtual/bigint.mjs";
+const b = Jc, c2 = Dc, t2 = wc, nc = Oc, l2 = Wc, ic = vc, v = Yc, a2 = Kc, o2 = Zc, N = Hc, { bitLength: n2, modInv: i2, isOdd: sc, isNegative: s2 } = $c;
+var P2 = function(l, _c) {
+  const e = _c || "bn128";
+  if (l.modules[e])
+    return e;
+  const V = 21888242871839275222246405745257275088696311157297823662689037894645226208583n, k = 21888242871839275222246405745257275088548364400416034343698204186575808495617n, Y = Math.floor((n2(V - 1n) - 1) / 64) + 1, x = Y * 8, ec = x, u = x, n = u * 2, I = u * 12, dc = l.alloc(b.bigInt2BytesLE(k, ec)), K = c2(l, V, "f1m");
+  t2(l, k, "fr", "frm");
+  const Z = l.alloc(b.bigInt2BytesLE(m(3n), u)), rc = ic(l, "g1m", "f1m", Z);
+  v(l, "frm", "frm", "frm", "frm_mul"), a2(l, "pol", "frm"), o2(l, "qap", "frm");
+  const t = nc(l, "f1m_neg", "f2m", "f1m"), H = l.alloc([
+    ...b.bigInt2BytesLE(m(19485874751759354771024239261021720505790618469301721065564631296452457478373n), u),
+    ...b.bigInt2BytesLE(m(266929791119991161246907387137283842545076965332900288569378510910307636690n), u)
+  ]), pc = ic(l, "g2m", "f2m", H);
+  function T(a, c) {
+    const i = l.addFunction(a);
+    i.addParam("pG", "i32"), i.addParam("pFr", "i32"), i.addParam("pr", "i32");
+    const _ = i.getCodeBuilder(), s = _.i32_const(l.alloc(x));
+    i.addCode(
+      _.call("frm_fromMontgomery", _.getLocal("pFr"), s),
+      _.call(
+        c,
+        _.getLocal("pG"),
+        s,
+        _.i32_const(x),
+        _.getLocal("pr")
+      )
+    ), l.exportFunction(a);
+  }
+  T("g1m_timesFr", "g1m_timesScalar"), v(l, "g1m", "g1m", "frm", "g1m_timesFr"), T("g2m_timesFr", "g2m_timesScalar"), v(l, "g2m", "g2m", "frm", "g2m_timesFr"), T("g1m_timesFrAffine", "g1m_timesScalarAffine"), T("g2m_timesFrAffine", "g2m_timesScalarAffine"), N(l, "frm_batchApplyKey", "fmr", "frm", x, x, x, "frm_mul"), N(l, "g1m_batchApplyKey", "g1m", "frm", x * 3, x * 3, x, "g1m_timesFr"), N(l, "g1m_batchApplyKeyMixed", "g1m", "frm", x * 2, x * 3, x, "g1m_timesFrAffine"), N(l, "g2m_batchApplyKey", "g2m", "frm", x * 2 * 3, x * 3 * 2, x, "g2m_timesFr"), N(l, "g2m_batchApplyKeyMixed", "g2m", "frm", x * 2 * 2, x * 3 * 2, x, "g2m_timesFrAffine");
+  function m(a) {
+    return BigInt(a) * (1n << BigInt(u * 8)) % V;
+  }
+  const D = [
+    1n,
+    2n,
+    1n
+  ], gc = l.alloc(
+    [
+      ...b.bigInt2BytesLE(m(D[0]), u),
+      ...b.bigInt2BytesLE(m(D[1]), u),
+      ...b.bigInt2BytesLE(m(D[2]), u)
+    ]
+  ), w = [
+    0n,
+    1n,
+    0n
+  ], Lc = l.alloc(
+    [
+      ...b.bigInt2BytesLE(m(w[0]), u),
+      ...b.bigInt2BytesLE(m(w[1]), u),
+      ...b.bigInt2BytesLE(m(w[2]), u)
+    ]
+  ), h = [
+    [
+      10857046999023057135944570762232829481370756359578518086990519993285655852781n,
+      11559732032986387107991004021392285783925812861821192530917403151452391805634n
+    ],
+    [
+      8495653923123431417604973247489272438418190587263600148770280649306958101930n,
+      4082367875863433681332203403145435568316851327593401208105741076214120093531n
+    ],
+    [
+      1n,
+      0n
+    ]
+  ], fc = l.alloc(
+    [
+      ...b.bigInt2BytesLE(m(h[0][0]), u),
+      ...b.bigInt2BytesLE(m(h[0][1]), u),
+      ...b.bigInt2BytesLE(m(h[1][0]), u),
+      ...b.bigInt2BytesLE(m(h[1][1]), u),
+      ...b.bigInt2BytesLE(m(h[2][0]), u),
+      ...b.bigInt2BytesLE(m(h[2][1]), u)
+    ]
+  ), X = [
+    [
+      0n,
+      0n
+    ],
+    [
+      1n,
+      0n
+    ],
+    [
+      0n,
+      0n
+    ]
+  ], uc = l.alloc(
+    [
+      ...b.bigInt2BytesLE(m(X[0][0]), u),
+      ...b.bigInt2BytesLE(m(X[0][1]), u),
+      ...b.bigInt2BytesLE(m(X[1][0]), u),
+      ...b.bigInt2BytesLE(m(X[1][1]), u),
+      ...b.bigInt2BytesLE(m(X[2][0]), u),
+      ...b.bigInt2BytesLE(m(X[2][1]), u)
+    ]
+  ), bc = l.alloc([
+    ...b.bigInt2BytesLE(m(1), u),
+    ...b.bigInt2BytesLE(m(0), u),
+    ...b.bigInt2BytesLE(m(0), u),
+    ...b.bigInt2BytesLE(m(0), u),
+    ...b.bigInt2BytesLE(m(0), u),
+    ...b.bigInt2BytesLE(m(0), u),
+    ...b.bigInt2BytesLE(m(0), u),
+    ...b.bigInt2BytesLE(m(0), u),
+    ...b.bigInt2BytesLE(m(0), u),
+    ...b.bigInt2BytesLE(m(0), u),
+    ...b.bigInt2BytesLE(m(0), u),
+    ...b.bigInt2BytesLE(m(0), u)
+  ]), Q = l.alloc([
+    ...b.bigInt2BytesLE(m(9), u),
+    ...b.bigInt2BytesLE(m(1), u)
+  ]), J = l.alloc([
+    ...b.bigInt2BytesLE(m(i2(2n, V)), u),
+    ...b.bigInt2BytesLE(0n, u)
+  ]), O = Q, mc = l.alloc([
+    ...b.bigInt2BytesLE(m(19485874751759354771024239261021720505790618469301721065564631296452457478373n), u),
+    ...b.bigInt2BytesLE(m(266929791119991161246907387137283842545076965332900288569378510910307636690n), u)
+  ]);
+  function Cc() {
+    const a = l.addFunction(e + "_mulNR6");
+    a.addParam("x", "i32"), a.addParam("pr", "i32");
+    const c = a.getCodeBuilder();
+    a.addCode(
+      c.call(
+        t + "_mul",
+        c.i32_const(Q),
+        c.getLocal("x"),
+        c.getLocal("pr")
+      )
+    );
+  }
+  Cc();
+  const W = l2(l, e + "_mulNR6", "f6m", "f2m");
+  function yc() {
+    const a = l.addFunction(e + "_mulNR12");
+    a.addParam("x", "i32"), a.addParam("pr", "i32");
+    const c = a.getCodeBuilder();
+    a.addCode(
+      c.call(
+        t + "_mul",
+        c.i32_const(Q),
+        c.i32_add(c.getLocal("x"), c.i32_const(x * 4)),
+        c.getLocal("pr")
+      ),
+      c.call(
+        t + "_copy",
+        c.getLocal("x"),
+        c.i32_add(c.getLocal("pr"), c.i32_const(x * 2))
+      ),
+      c.call(
+        t + "_copy",
+        c.i32_add(c.getLocal("x"), c.i32_const(x * 2)),
+        c.i32_add(c.getLocal("pr"), c.i32_const(x * 4))
+      )
+    );
+  }
+  yc();
+  const P = nc(l, e + "_mulNR12", "ftm", W), M = Fc(29793968203157093288n), $ = l.alloc(M), S = 3 * n, Bc = M.length - 1, Ec = M.reduce((a, c) => a + (c != 0 ? 1 : 0), 0) + Bc + 1, cc = 3 * 2 * x, tc = 3 * x * 2 + Ec * S;
+  l.modules[e] = {
+    n64: Y,
+    pG1gen: gc,
+    pG1zero: Lc,
+    pG1b: Z,
+    pG2gen: fc,
+    pG2zero: uc,
+    pG2b: H,
+    pq: l.modules.f1m.pq,
+    pr: dc,
+    pOneT: bc,
+    prePSize: cc,
+    preQSize: tc,
+    r: k.toString(),
+    q: V.toString()
+  };
+  const xc = 4965661367192848881n;
+  function Pc(a) {
+    let c = a;
+    const i = [];
+    for (; c > 0n; ) {
+      if (sc(c)) {
+        const _ = 2 - Number(c % 4n);
+        i.push(_), c = c - BigInt(_);
+      } else
+        i.push(0);
+      c = c >> 1n;
+    }
+    return i;
+  }
+  function Fc(a) {
+    let c = a;
+    const i = [];
+    for (; c > 0n; )
+      sc(c) ? i.push(1) : i.push(0), c = c >> 1n;
+    return i;
+  }
+  function Ic() {
+    const a = l.addFunction(e + "_prepareG1");
+    a.addParam("pP", "i32"), a.addParam("ppreP", "i32");
+    const c = a.getCodeBuilder();
+    a.addCode(
+      c.call(rc + "_normalize", c.getLocal("pP"), c.getLocal("ppreP"))
+      // TODO Remove if already in affine
+    );
+  }
+  function Ac() {
+    const a = l.addFunction(e + "_prepAddStep");
+    a.addParam("pQ", "i32"), a.addParam("pR", "i32"), a.addParam("pCoef", "i32");
+    const c = a.getCodeBuilder(), i = c.getLocal("pQ"), _ = c.i32_add(c.getLocal("pQ"), c.i32_const(n)), s = c.getLocal("pR"), o = c.i32_add(c.getLocal("pR"), c.i32_const(n)), d = c.i32_add(c.getLocal("pR"), c.i32_const(2 * n)), L = c.getLocal("pCoef"), p = c.i32_add(c.getLocal("pCoef"), c.i32_const(n)), C = c.i32_add(c.getLocal("pCoef"), c.i32_const(2 * n)), g = p, r = c.i32_const(l.alloc(n)), y = c.i32_const(l.alloc(n)), q = c.i32_const(l.alloc(n)), B = c.i32_const(l.alloc(n)), f = c.i32_const(l.alloc(n)), E = c.i32_const(l.alloc(n)), R = c.i32_const(l.alloc(n));
+    a.addCode(
+      // D = X1 - X2*Z1
+      c.call(t + "_mul", i, d, g),
+      c.call(t + "_sub", s, g, g),
+      // E = Y1 - Y2*Z1
+      c.call(t + "_mul", _, d, r),
+      c.call(t + "_sub", o, r, r),
+      // F = D^2
+      c.call(t + "_square", g, y),
+      // G = E^2
+      c.call(t + "_square", r, q),
+      // H = D*F
+      c.call(t + "_mul", g, y, B),
+      // I = X1 * F
+      c.call(t + "_mul", s, y, f),
+      // J = H + Z1*G - (I+I)
+      c.call(t + "_add", f, f, R),
+      c.call(t + "_mul", d, q, E),
+      c.call(t + "_add", B, E, E),
+      c.call(t + "_sub", E, R, E),
+      // X3 (X1) = D*J
+      c.call(t + "_mul", g, E, s),
+      // Y3 (Y1) = E*(I-J)-(H*Y1)
+      c.call(t + "_mul", B, o, o),
+      c.call(t + "_sub", f, E, R),
+      c.call(t + "_mul", r, R, R),
+      c.call(t + "_sub", R, o, o),
+      // Z3 (Z1) = Z1*H
+      c.call(t + "_mul", d, B, d),
+      // ell_0 = xi * (E * X2 - D * Y2)
+      c.call(t + "_mul", g, _, R),
+      c.call(t + "_mul", r, i, L),
+      c.call(t + "_sub", L, R, L),
+      c.call(t + "_mul", L, c.i32_const(O), L),
+      // ell_VV = - E (later: * xP)
+      c.call(t + "_neg", r, C)
+      // ell_VW = D (later: * yP    )
+      // Already assigned
+    );
+  }
+  function qc() {
+    const a = l.addFunction(e + "_prepDblStep");
+    a.addParam("pR", "i32"), a.addParam("pCoef", "i32");
+    const c = a.getCodeBuilder(), i = c.getLocal("pR"), _ = c.i32_add(c.getLocal("pR"), c.i32_const(n)), s = c.i32_add(c.getLocal("pR"), c.i32_const(2 * n)), o = c.getLocal("pCoef"), d = c.i32_add(c.getLocal("pCoef"), c.i32_const(n)), L = c.i32_add(c.getLocal("pCoef"), c.i32_const(2 * n)), p = c.i32_const(l.alloc(n)), C = c.i32_const(l.alloc(n)), g = c.i32_const(l.alloc(n)), r = c.i32_const(l.alloc(n)), y = c.i32_const(l.alloc(n)), q = c.i32_const(l.alloc(n)), B = c.i32_const(l.alloc(n)), f = c.i32_const(l.alloc(n)), E = c.i32_const(l.alloc(n)), R = c.i32_const(l.alloc(n)), z = c.i32_const(l.alloc(n)), G = c.i32_const(l.alloc(n));
+    a.addCode(
+      // A = X1 * Y1 / 2
+      c.call(t + "_mul", _, c.i32_const(J), p),
+      c.call(t + "_mul", i, p, p),
+      // B = Y1^2
+      c.call(t + "_square", _, C),
+      // C = Z1^2
+      c.call(t + "_square", s, g),
+      // D = 3 * C
+      c.call(t + "_add", g, g, r),
+      c.call(t + "_add", r, g, r),
+      // E = twist_b * D
+      c.call(t + "_mul", c.i32_const(mc), r, y),
+      // F = 3 * E
+      c.call(t + "_add", y, y, q),
+      c.call(t + "_add", y, q, q),
+      // G = (B+F)/2
+      c.call(t + "_add", C, q, B),
+      c.call(t + "_mul", B, c.i32_const(J), B),
+      // H = (Y1+Z1)^2-(B+C)
+      c.call(t + "_add", C, g, G),
+      c.call(t + "_add", _, s, f),
+      c.call(t + "_square", f, f),
+      c.call(t + "_sub", f, G, f),
+      // I = E-B
+      c.call(t + "_sub", y, C, E),
+      // J = X1^2
+      c.call(t + "_square", i, R),
+      // E_squared = E^2
+      c.call(t + "_square", y, z),
+      // X3 (X1) = A * (B-F)
+      c.call(t + "_sub", C, q, G),
+      c.call(t + "_mul", p, G, i),
+      // Y3 (Y1) = G^2 - 3*E^2
+      c.call(t + "_add", z, z, G),
+      c.call(t + "_add", z, G, G),
+      c.call(t + "_square", B, _),
+      c.call(t + "_sub", _, G, _),
+      // Z3 (Z1) = B * H
+      c.call(t + "_mul", C, f, s),
+      // ell_0 = xi * I
+      c.call(t + "_mul", c.i32_const(O), E, o),
+      // ell_VW = - H (later: * yP)
+      c.call(t + "_neg", f, d),
+      // ell_VV = 3*J (later: * xP)
+      c.call(t + "_add", R, R, L),
+      c.call(t + "_add", R, L, L)
+    );
+  }
+  function Rc() {
+    const a = l.addFunction(e + "_mulByQ");
+    a.addParam("p1", "i32"), a.addParam("pr", "i32");
+    const c = a.getCodeBuilder(), i = c.getLocal("p1"), _ = c.i32_add(c.getLocal("p1"), c.i32_const(n)), s = c.i32_add(c.getLocal("p1"), c.i32_const(n * 2)), o = c.getLocal("pr"), d = c.i32_add(c.getLocal("pr"), c.i32_const(n)), L = c.i32_add(c.getLocal("pr"), c.i32_const(n * 2)), p = c.i32_const(l.alloc([
+      ...b.bigInt2BytesLE(m("21575463638280843010398324269430826099269044274347216827212613867836435027261"), u),
+      ...b.bigInt2BytesLE(m("10307601595873709700152284273816112264069230130616436755625194854815875713954"), u)
+    ])), C = c.i32_const(l.alloc([
+      ...b.bigInt2BytesLE(m("2821565182194536844548159561693502659359617185244120367078079554186484126554"), u),
+      ...b.bigInt2BytesLE(m("3505843767911556378687030309984248845540243509899259641013678093033130930403"), u)
+    ]));
+    a.addCode(
+      // The frobeniusMap(1) in this field, is the conjugate
+      c.call(t + "_conjugate", i, o),
+      c.call(t + "_mul", p, o, o),
+      c.call(t + "_conjugate", _, d),
+      c.call(t + "_mul", C, d, d),
+      c.call(t + "_conjugate", s, L)
+    );
+  }
+  function zc() {
+    Rc();
+    const a = l.addFunction(e + "_prepareG2");
+    a.addParam("pQ", "i32"), a.addParam("ppreQ", "i32"), a.addLocal("pCoef", "i32"), a.addLocal("i", "i32");
+    const c = a.getCodeBuilder(), i = c.getLocal("pQ"), _ = l.alloc(n * 3), s = c.i32_const(_), o = c.i32_const(_), d = c.i32_const(_ + n), L = c.i32_const(_ + 2 * n), p = c.i32_add(c.getLocal("ppreQ"), c.i32_const(0)), C = c.i32_add(c.getLocal("ppreQ"), c.i32_const(n)), g = l.alloc(n * 3), r = c.i32_const(g), y = l.alloc(n * 3), q = c.i32_const(y), B = c.i32_const(y + n);
+    a.addCode(
+      c.call(pc + "_normalize", i, p),
+      // TODO Remove if already in affine
+      c.call(t + "_copy", p, o),
+      c.call(t + "_copy", C, d),
+      c.call(t + "_one", L)
+    ), a.addCode(
+      c.setLocal("pCoef", c.i32_add(c.getLocal("ppreQ"), c.i32_const(n * 3))),
+      c.setLocal("i", c.i32_const(M.length - 2)),
+      c.block(c.loop(
+        c.call(e + "_prepDblStep", s, c.getLocal("pCoef")),
+        c.setLocal("pCoef", c.i32_add(c.getLocal("pCoef"), c.i32_const(S))),
+        c.if(
+          c.i32_load8_s(c.getLocal("i"), $),
+          [
+            ...c.call(e + "_prepAddStep", p, s, c.getLocal("pCoef")),
+            ...c.setLocal("pCoef", c.i32_add(c.getLocal("pCoef"), c.i32_const(S)))
+          ]
+        ),
+        c.br_if(1, c.i32_eqz(c.getLocal("i"))),
+        c.setLocal("i", c.i32_sub(c.getLocal("i"), c.i32_const(1))),
+        c.br(0)
+      ))
+    ), a.addCode(
+      c.call(e + "_mulByQ", p, r),
+      c.call(e + "_mulByQ", r, q)
+    ), a.addCode(
+      c.call(t + "_neg", B, B),
+      c.call(e + "_prepAddStep", r, s, c.getLocal("pCoef")),
+      c.setLocal("pCoef", c.i32_add(c.getLocal("pCoef"), c.i32_const(S))),
+      c.call(e + "_prepAddStep", q, s, c.getLocal("pCoef")),
+      c.setLocal("pCoef", c.i32_add(c.getLocal("pCoef"), c.i32_const(S)))
+    );
+  }
+  function Gc() {
+    const a = l.addFunction(e + "__mulBy024Old");
+    a.addParam("pEll0", "i32"), a.addParam("pEllVW", "i32"), a.addParam("pEllVV", "i32"), a.addParam("pR", "i32");
+    const c = a.getCodeBuilder(), i = c.getLocal("pEll0"), _ = c.getLocal("pEllVV"), s = c.getLocal("pEllVW"), o = c.getLocal("pR"), d = l.alloc(I), L = c.i32_const(d), p = c.i32_const(d), C = c.i32_const(d + n), g = c.i32_const(d + n * 2), r = c.i32_const(d + n * 3), y = c.i32_const(d + n * 4), q = c.i32_const(d + n * 5);
+    a.addCode(
+      c.call(t + "_copy", i, p),
+      c.call(t + "_zero", C),
+      c.call(t + "_copy", _, g),
+      c.call(t + "_zero", r),
+      c.call(t + "_copy", s, y),
+      c.call(t + "_zero", q),
+      c.call(P + "_mul", L, o, o)
+    );
+  }
+  function Qc() {
+    const a = l.addFunction(e + "__mulBy024");
+    a.addParam("pEll0", "i32"), a.addParam("pEllVW", "i32"), a.addParam("pEllVV", "i32"), a.addParam("pR", "i32");
+    const c = a.getCodeBuilder(), i = c.getLocal("pEll0"), _ = c.getLocal("pEllVV"), s = c.getLocal("pEllVW"), o = c.getLocal("pR"), d = c.i32_add(c.getLocal("pR"), c.i32_const(2 * x)), L = c.i32_add(c.getLocal("pR"), c.i32_const(4 * x)), p = c.i32_add(c.getLocal("pR"), c.i32_const(6 * x)), C = c.i32_add(c.getLocal("pR"), c.i32_const(8 * x)), g = c.i32_add(c.getLocal("pR"), c.i32_const(10 * x)), r = c.i32_const(l.alloc(n)), y = c.i32_const(l.alloc(n)), q = c.i32_const(l.alloc(n)), B = c.i32_const(l.alloc(n)), f = c.i32_const(l.alloc(n)), E = c.i32_const(l.alloc(n)), R = c.i32_const(l.alloc(n)), z = c.i32_const(l.alloc(n)), G = c.i32_const(l.alloc(n)), F = c.i32_const(l.alloc(n)), A = c.i32_const(l.alloc(n));
+    a.addCode(
+      // D0 = z0 * x0;
+      c.call(t + "_mul", o, i, R),
+      // D2 = z2 * x2;
+      c.call(t + "_mul", L, _, z),
+      // D4 = z4 * x4;
+      c.call(t + "_mul", C, s, G),
+      // t2 = z0 + z4;
+      c.call(t + "_add", o, C, q),
+      // t1 = z0 + z2;
+      c.call(t + "_add", o, L, y),
+      // s0 = z1 + z3 + z5;
+      c.call(t + "_add", d, p, B),
+      c.call(t + "_add", B, g, B),
+      // For z.a_.a_ = z0.
+      // S1 = z1 * x2;
+      c.call(t + "_mul", d, _, F),
+      // T3 = S1 + D4;
+      c.call(t + "_add", F, G, f),
+      // T4 = my_Fp6::non_residue * T3 + D0;
+      c.call(t + "_mul", c.i32_const(Q), f, E),
+      c.call(t + "_add", E, R, o),
+      // z0 = T4;
+      // For z.a_.b_ = z1
+      // T3 = z5 * x4;
+      c.call(t + "_mul", g, s, f),
+      // S1 = S1 + T3;
+      c.call(t + "_add", F, f, F),
+      // T3 = T3 + D2;
+      c.call(t + "_add", f, z, f),
+      // T4 = my_Fp6::non_residue * T3;
+      c.call(t + "_mul", c.i32_const(Q), f, E),
+      // T3 = z1 * x0;
+      c.call(t + "_mul", d, i, f),
+      // S1 = S1 + T3;
+      c.call(t + "_add", F, f, F),
+      // T4 = T4 + T3;
+      c.call(t + "_add", E, f, d),
+      // z1 = T4;
+      // For z.a_.c_ = z2
+      // t0 = x0 + x2;
+      c.call(t + "_add", i, _, r),
+      // T3 = t1 * t0 - D0 - D2;
+      c.call(t + "_mul", y, r, f),
+      c.call(t + "_add", R, z, A),
+      c.call(t + "_sub", f, A, f),
+      // T4 = z3 * x4;
+      c.call(t + "_mul", p, s, E),
+      // S1 = S1 + T4;
+      c.call(t + "_add", F, E, F),
+      // For z.b_.a_ = z3 (z3 needs z2)
+      // t0 = z2 + z4;
+      c.call(t + "_add", L, C, r),
+      // T3 = T3 + T4;
+      // z2 = T3;
+      c.call(t + "_add", f, E, L),
+      // t1 = x2 + x4;
+      c.call(t + "_add", _, s, y),
+      // T3 = t0 * t1 - D2 - D4;
+      c.call(t + "_mul", y, r, f),
+      c.call(t + "_add", z, G, A),
+      c.call(t + "_sub", f, A, f),
+      // T4 = my_Fp6::non_residue * T3;
+      c.call(t + "_mul", c.i32_const(Q), f, E),
+      // T3 = z3 * x0;
+      c.call(t + "_mul", p, i, f),
+      // S1 = S1 + T3;
+      c.call(t + "_add", F, f, F),
+      // T4 = T4 + T3;
+      c.call(t + "_add", E, f, p),
+      // z3 = T4;
+      // For z.b_.b_ = z4
+      // T3 = z5 * x2;
+      c.call(t + "_mul", g, _, f),
+      // S1 = S1 + T3;
+      c.call(t + "_add", F, f, F),
+      // T4 = my_Fp6::non_residue * T3;
+      c.call(t + "_mul", c.i32_const(Q), f, E),
+      // t0 = x0 + x4;
+      c.call(t + "_add", i, s, r),
+      // T3 = t2 * t0 - D0 - D4;
+      c.call(t + "_mul", q, r, f),
+      c.call(t + "_add", R, G, A),
+      c.call(t + "_sub", f, A, f),
+      // T4 = T4 + T3;
+      c.call(t + "_add", E, f, C),
+      // z4 = T4;
+      // For z.b_.c_ = z5.
+      // t0 = x0 + x2 + x4;
+      c.call(t + "_add", i, _, r),
+      c.call(t + "_add", r, s, r),
+      // T3 = s0 * t0 - S1;
+      c.call(t + "_mul", B, r, f),
+      c.call(t + "_sub", f, F, g)
+      // z5 = T3;
+    );
+  }
+  function Sc() {
+    const a = l.addFunction(e + "_millerLoop");
+    a.addParam("ppreP", "i32"), a.addParam("ppreQ", "i32"), a.addParam("r", "i32"), a.addLocal("pCoef", "i32"), a.addLocal("i", "i32");
+    const c = a.getCodeBuilder(), i = c.getLocal("ppreP"), _ = c.i32_add(c.getLocal("ppreP"), c.i32_const(u)), s = c.getLocal("pCoef"), o = c.i32_add(c.getLocal("pCoef"), c.i32_const(n)), d = c.i32_add(c.getLocal("pCoef"), c.i32_const(2 * n)), L = l.alloc(n), p = c.i32_const(L), C = l.alloc(n), g = c.i32_const(C), r = c.getLocal("r");
+    a.addCode(
+      c.call(P + "_one", r),
+      c.setLocal("pCoef", c.i32_add(c.getLocal("ppreQ"), c.i32_const(n * 3))),
+      c.setLocal("i", c.i32_const(M.length - 2)),
+      c.block(c.loop(
+        c.call(P + "_square", r, r),
+        c.call(t + "_mul1", o, _, p),
+        c.call(t + "_mul1", d, i, g),
+        c.call(e + "__mulBy024", s, p, g, r),
+        c.setLocal("pCoef", c.i32_add(c.getLocal("pCoef"), c.i32_const(S))),
+        c.if(
+          c.i32_load8_s(c.getLocal("i"), $),
+          [
+            ...c.call(t + "_mul1", o, _, p),
+            ...c.call(t + "_mul1", d, i, g),
+            ...c.call(e + "__mulBy024", s, p, g, r),
+            ...c.setLocal("pCoef", c.i32_add(c.getLocal("pCoef"), c.i32_const(S)))
+          ]
+        ),
+        c.br_if(1, c.i32_eqz(c.getLocal("i"))),
+        c.setLocal("i", c.i32_sub(c.getLocal("i"), c.i32_const(1))),
+        c.br(0)
+      ))
+    ), a.addCode(
+      c.call(t + "_mul1", o, _, p),
+      c.call(t + "_mul1", d, i, g),
+      c.call(e + "__mulBy024", s, p, g, r),
+      c.setLocal("pCoef", c.i32_add(c.getLocal("pCoef"), c.i32_const(S))),
+      c.call(t + "_mul1", o, _, p),
+      c.call(t + "_mul1", d, i, g),
+      c.call(e + "__mulBy024", s, p, g, r),
+      c.setLocal("pCoef", c.i32_add(c.getLocal("pCoef"), c.i32_const(S)))
+    );
+  }
+  function Vc(a) {
+    const c = [
+      [
+        [1n, 0n],
+        [1n, 0n],
+        [1n, 0n],
+        [1n, 0n],
+        [1n, 0n],
+        [1n, 0n],
+        [1n, 0n],
+        [1n, 0n],
+        [1n, 0n],
+        [1n, 0n],
+        [1n, 0n],
+        [1n, 0n]
+      ],
+      [
+        [1n, 0n],
+        [8376118865763821496583973867626364092589906065868298776909617916018768340080n, 16469823323077808223889137241176536799009286646108169935659301613961712198316n],
+        [21888242871839275220042445260109153167277707414472061641714758635765020556617n, 0n],
+        [11697423496358154304825782922584725312912383441159505038794027105778954184319n, 303847389135065887422783454877609941456349188919719272345083954437860409601n],
+        [21888242871839275220042445260109153167277707414472061641714758635765020556616n, 0n],
+        [3321304630594332808241809054958361220322477375291206261884409189760185844239n, 5722266937896532885780051958958348231143373700109372999374820235121374419868n],
+        [21888242871839275222246405745257275088696311157297823662689037894645226208582n, 0n],
+        [13512124006075453725662431877630910996106405091429524885779419978626457868503n, 5418419548761466998357268504080738289687024511189653727029736280683514010267n],
+        [2203960485148121921418603742825762020974279258880205651966n, 0n],
+        [10190819375481120917420622822672549775783927716138318623895010788866272024264n, 21584395482704209334823622290379665147239961968378104390343953940207365798982n],
+        [2203960485148121921418603742825762020974279258880205651967n, 0n],
+        [18566938241244942414004596690298913868373833782006617400804628704885040364344n, 16165975933942742336466353786298926857552937457188450663314217659523851788715n]
+      ]
+    ], i = [
+      [
+        [1n, 0n],
+        [1n, 0n],
+        [1n, 0n],
+        [1n, 0n],
+        [1n, 0n],
+        [1n, 0n]
+      ],
+      [
+        [1n, 0n],
+        [21575463638280843010398324269430826099269044274347216827212613867836435027261n, 10307601595873709700152284273816112264069230130616436755625194854815875713954n],
+        [21888242871839275220042445260109153167277707414472061641714758635765020556616n, 0n],
+        [3772000881919853776433695186713858239009073593817195771773381919316419345261n, 2236595495967245188281701248203181795121068902605861227855261137820944008926n],
+        [2203960485148121921418603742825762020974279258880205651966n, 0n],
+        [18429021223477853657660792034369865839114504446431234726392080002137598044644n, 9344045779998320333812420223237981029506012124075525679208581902008406485703n]
+      ],
+      [
+        [1n, 0n],
+        [2581911344467009335267311115468803099551665605076196740867805258568234346338n, 19937756971775647987995932169929341994314640652964949448313374472400716661030n],
+        [2203960485148121921418603742825762020974279258880205651966n, 0n],
+        [5324479202449903542726783395506214481928257762400643279780343368557297135718n, 16208900380737693084919495127334387981393726419856888799917914180988844123039n],
+        [21888242871839275220042445260109153167277707414472061641714758635765020556616n, 0n],
+        [13981852324922362344252311234282257507216387789820983642040889267519694726527n, 7629828391165209371577384193250820201684255241773809077146787135900891633097n]
+      ]
+    ], _ = l.addFunction(e + "__frobeniusMap" + a);
+    _.addParam("x", "i32"), _.addParam("r", "i32");
+    const s = _.getCodeBuilder();
+    for (let d = 0; d < 6; d++) {
+      const L = d == 0 ? s.getLocal("x") : s.i32_add(s.getLocal("x"), s.i32_const(d * n)), p = L, C = s.i32_add(s.getLocal("x"), s.i32_const(d * n + u)), g = d == 0 ? s.getLocal("r") : s.i32_add(s.getLocal("r"), s.i32_const(d * n)), r = g, y = s.i32_add(s.getLocal("r"), s.i32_const(d * n + u)), q = o(c[Math.floor(d / 3)][a % 12], i[d % 3][a % 6]), B = l.alloc([
+        ...b.bigInt2BytesLE(m(q[0]), 32),
+        ...b.bigInt2BytesLE(m(q[1]), 32)
+      ]);
+      a % 2 == 1 ? _.addCode(
+        s.call(K + "_copy", p, r),
+        s.call(K + "_neg", C, y),
+        s.call(t + "_mul", g, s.i32_const(B), g)
+      ) : _.addCode(s.call(t + "_mul", L, s.i32_const(B), g));
+    }
+    function o(d, L) {
+      const p = BigInt(d[0]), C = BigInt(d[1]), g = BigInt(L[0]), r = BigInt(L[1]), y = [
+        (p * g - C * r) % V,
+        (p * r + C * g) % V
+      ];
+      return s2(y[0]) && (y[0] = y[0] + V), y;
+    }
+  }
+  function hc() {
+    const a = l.addFunction(e + "__finalExponentiationFirstChunk");
+    a.addParam("x", "i32"), a.addParam("r", "i32");
+    const c = a.getCodeBuilder(), i = c.getLocal("x"), _ = i, s = c.i32_add(i, c.i32_const(x * 6)), o = c.getLocal("r"), d = l.alloc(I), L = c.i32_const(d), p = L, C = c.i32_const(d + x * 6), g = c.i32_const(l.alloc(I)), r = c.i32_const(l.alloc(I)), y = c.i32_const(l.alloc(I));
+    a.addCode(
+      // const alt_bn128_Fq12 A = alt_bn128_Fq12(elt.c0,-elt.c1);
+      c.call(W + "_copy", _, p),
+      c.call(W + "_neg", s, C),
+      // const alt_bn128_Fq12 B = elt.inverse();
+      c.call(P + "_inverse", i, g),
+      // const alt_bn128_Fq12 C = A * B;
+      c.call(P + "_mul", L, g, r),
+      // const alt_bn128_Fq12 D = C.Frobenius_map(2);
+      c.call(e + "__frobeniusMap2", r, y),
+      // const alt_bn128_Fq12 result = D * C;
+      c.call(P + "_mul", r, y, o)
+    );
+  }
+  function Xc() {
+    const a = l.addFunction(e + "__cyclotomicSquare");
+    a.addParam("x", "i32"), a.addParam("r", "i32");
+    const c = a.getCodeBuilder(), i = c.getLocal("x"), _ = c.i32_add(c.getLocal("x"), c.i32_const(n)), s = c.i32_add(c.getLocal("x"), c.i32_const(2 * n)), o = c.i32_add(c.getLocal("x"), c.i32_const(3 * n)), d = c.i32_add(c.getLocal("x"), c.i32_const(4 * n)), L = c.i32_add(c.getLocal("x"), c.i32_const(5 * n)), p = c.getLocal("r"), C = c.i32_add(c.getLocal("r"), c.i32_const(n)), g = c.i32_add(c.getLocal("r"), c.i32_const(2 * n)), r = c.i32_add(c.getLocal("r"), c.i32_const(3 * n)), y = c.i32_add(c.getLocal("r"), c.i32_const(4 * n)), q = c.i32_add(c.getLocal("r"), c.i32_const(5 * n)), B = c.i32_const(l.alloc(n)), f = c.i32_const(l.alloc(n)), E = c.i32_const(l.alloc(n)), R = c.i32_const(l.alloc(n)), z = c.i32_const(l.alloc(n)), G = c.i32_const(l.alloc(n)), F = c.i32_const(l.alloc(n)), A = c.i32_const(l.alloc(n));
+    a.addCode(
+      //    // t0 + t1*y = (z0 + z1*y)^2 = a^2
+      //    tmp = z0 * z1;
+      //    t0 = (z0 + z1) * (z0 + my_Fp6::non_residue * z1) - tmp - my_Fp6::non_residue * tmp;
+      //    t1 = tmp + tmp;
+      c.call(t + "_mul", i, d, F),
+      c.call(t + "_mul", d, c.i32_const(Q), B),
+      c.call(t + "_add", i, B, B),
+      c.call(t + "_add", i, d, A),
+      c.call(t + "_mul", A, B, B),
+      c.call(t + "_mul", c.i32_const(Q), F, A),
+      c.call(t + "_add", F, A, A),
+      c.call(t + "_sub", B, A, B),
+      c.call(t + "_add", F, F, f),
+      //  // t2 + t3*y = (z2 + z3*y)^2 = b^2
+      //  tmp = z2 * z3;
+      //  t2 = (z2 + z3) * (z2 + my_Fp6::non_residue * z3) - tmp - my_Fp6::non_residue * tmp;
+      //  t3 = tmp + tmp;
+      c.call(t + "_mul", o, s, F),
+      c.call(t + "_mul", s, c.i32_const(Q), E),
+      c.call(t + "_add", o, E, E),
+      c.call(t + "_add", o, s, A),
+      c.call(t + "_mul", A, E, E),
+      c.call(t + "_mul", c.i32_const(Q), F, A),
+      c.call(t + "_add", F, A, A),
+      c.call(t + "_sub", E, A, E),
+      c.call(t + "_add", F, F, R),
+      //  // t4 + t5*y = (z4 + z5*y)^2 = c^2
+      //  tmp = z4 * z5;
+      //  t4 = (z4 + z5) * (z4 + my_Fp6::non_residue * z5) - tmp - my_Fp6::non_residue * tmp;
+      //  t5 = tmp + tmp;
+      c.call(t + "_mul", _, L, F),
+      c.call(t + "_mul", L, c.i32_const(Q), z),
+      c.call(t + "_add", _, z, z),
+      c.call(t + "_add", _, L, A),
+      c.call(t + "_mul", A, z, z),
+      c.call(t + "_mul", c.i32_const(Q), F, A),
+      c.call(t + "_add", F, A, A),
+      c.call(t + "_sub", z, A, z),
+      c.call(t + "_add", F, F, G),
+      // For A
+      // z0 = 3 * t0 - 2 * z0
+      c.call(t + "_sub", B, i, p),
+      c.call(t + "_add", p, p, p),
+      c.call(t + "_add", B, p, p),
+      // z1 = 3 * t1 + 2 * z1
+      c.call(t + "_add", f, d, y),
+      c.call(t + "_add", y, y, y),
+      c.call(t + "_add", f, y, y),
+      // For B
+      // z2 = 3 * (xi * t5) + 2 * z2
+      c.call(t + "_mul", G, c.i32_const(O), A),
+      c.call(t + "_add", A, o, r),
+      c.call(t + "_add", r, r, r),
+      c.call(t + "_add", A, r, r),
+      // z3 = 3 * t4 - 2 * z3
+      c.call(t + "_sub", z, s, g),
+      c.call(t + "_add", g, g, g),
+      c.call(t + "_add", z, g, g),
+      // For C
+      // z4 = 3 * t2 - 2 * z4
+      c.call(t + "_sub", E, _, C),
+      c.call(t + "_add", C, C, C),
+      c.call(t + "_add", E, C, C),
+      // z5 = 3 * t3 + 2 * z5
+      c.call(t + "_add", R, L, q),
+      c.call(t + "_add", q, q, q),
+      c.call(t + "_add", R, q, q)
+    );
+  }
+  function Mc(a, c) {
+    const i = Pc(a).map((C) => C == -1 ? 255 : C), _ = l.alloc(i), s = l.addFunction(e + "__cyclotomicExp_" + c);
+    s.addParam("x", "i32"), s.addParam("r", "i32"), s.addLocal("bit", "i32"), s.addLocal("i", "i32");
+    const o = s.getCodeBuilder(), d = o.getLocal("x"), L = o.getLocal("r"), p = o.i32_const(l.alloc(I));
+    s.addCode(
+      o.call(P + "_conjugate", d, p),
+      o.call(P + "_one", L),
+      o.if(
+        o.teeLocal("bit", o.i32_load8_s(o.i32_const(i.length - 1), _)),
+        o.if(
+          o.i32_eq(
+            o.getLocal("bit"),
+            o.i32_const(1)
+          ),
+          o.call(P + "_mul", L, d, L),
+          o.call(P + "_mul", L, p, L)
+        )
+      ),
+      o.setLocal("i", o.i32_const(i.length - 2)),
+      o.block(o.loop(
+        o.call(e + "__cyclotomicSquare", L, L),
+        o.if(
+          o.teeLocal("bit", o.i32_load8_s(o.getLocal("i"), _)),
+          o.if(
+            o.i32_eq(
+              o.getLocal("bit"),
+              o.i32_const(1)
+            ),
+            o.call(P + "_mul", L, d, L),
+            o.call(P + "_mul", L, p, L)
+          )
+        ),
+        o.br_if(1, o.i32_eqz(o.getLocal("i"))),
+        o.setLocal("i", o.i32_sub(o.getLocal("i"), o.i32_const(1))),
+        o.br(0)
+      ))
+    );
+  }
+  function Nc() {
+    Xc(), Mc(xc, "w0");
+    const a = l.addFunction(e + "__finalExponentiationLastChunk");
+    a.addParam("x", "i32"), a.addParam("r", "i32");
+    const c = a.getCodeBuilder(), i = c.getLocal("x"), _ = c.getLocal("r"), s = c.i32_const(l.alloc(I)), o = c.i32_const(l.alloc(I)), d = c.i32_const(l.alloc(I)), L = c.i32_const(l.alloc(I)), p = c.i32_const(l.alloc(I)), C = c.i32_const(l.alloc(I)), g = c.i32_const(l.alloc(I)), r = c.i32_const(l.alloc(I)), y = c.i32_const(l.alloc(I)), q = c.i32_const(l.alloc(I)), B = c.i32_const(l.alloc(I)), f = c.i32_const(l.alloc(I)), E = c.i32_const(l.alloc(I)), R = c.i32_const(l.alloc(I)), z = c.i32_const(l.alloc(I)), G = c.i32_const(l.alloc(I)), F = c.i32_const(l.alloc(I)), A = c.i32_const(l.alloc(I)), lc = c.i32_const(l.alloc(I)), ac = c.i32_const(l.alloc(I)), oc = c.i32_const(l.alloc(I));
+    a.addCode(
+      // A = exp_by_neg_z(elt)  // = elt^(-z)
+      c.call(e + "__cyclotomicExp_w0", i, s),
+      c.call(P + "_conjugate", s, s),
+      // B = A^2                // = elt^(-2*z)
+      c.call(e + "__cyclotomicSquare", s, o),
+      // C = B^2                // = elt^(-4*z)
+      c.call(e + "__cyclotomicSquare", o, d),
+      // D = C * B              // = elt^(-6*z)
+      c.call(P + "_mul", d, o, L),
+      // E = exp_by_neg_z(D)    // = elt^(6*z^2)
+      c.call(e + "__cyclotomicExp_w0", L, p),
+      c.call(P + "_conjugate", p, p),
+      // F = E^2                // = elt^(12*z^2)
+      c.call(e + "__cyclotomicSquare", p, C),
+      // G = epx_by_neg_z(F)    // = elt^(-12*z^3)
+      c.call(e + "__cyclotomicExp_w0", C, g),
+      c.call(P + "_conjugate", g, g),
+      // H = conj(D)            // = elt^(6*z)
+      c.call(P + "_conjugate", L, r),
+      // I = conj(G)            // = elt^(12*z^3)
+      c.call(P + "_conjugate", g, y),
+      // J = I * E              // = elt^(12*z^3 + 6*z^2)
+      c.call(P + "_mul", y, p, q),
+      // K = J * H              // = elt^(12*z^3 + 6*z^2 + 6*z)
+      c.call(P + "_mul", q, r, B),
+      // L = K * B              // = elt^(12*z^3 + 6*z^2 + 4*z)
+      c.call(P + "_mul", B, o, f),
+      // M = K * E              // = elt^(12*z^3 + 12*z^2 + 6*z)
+      c.call(P + "_mul", B, p, E),
+      // N = M * elt            // = elt^(12*z^3 + 12*z^2 + 6*z + 1)
+      c.call(P + "_mul", E, i, R),
+      // O = L.Frobenius_map(1) // = elt^(q*(12*z^3 + 6*z^2 + 4*z))
+      c.call(e + "__frobeniusMap1", f, z),
+      // P = O * N              // = elt^(q*(12*z^3 + 6*z^2 + 4*z) * (12*z^3 + 12*z^2 + 6*z + 1))
+      c.call(P + "_mul", z, R, G),
+      // Q = K.Frobenius_map(2) // = elt^(q^2 * (12*z^3 + 6*z^2 + 6*z))
+      c.call(e + "__frobeniusMap2", B, F),
+      // R = Q * P              // = elt^(q^2 * (12*z^3 + 6*z^2 + 6*z) + q*(12*z^3 + 6*z^2 + 4*z) * (12*z^3 + 12*z^2 + 6*z + 1))
+      c.call(P + "_mul", F, G, A),
+      // S = conj(elt)          // = elt^(-1)
+      c.call(P + "_conjugate", i, lc),
+      // T = S * L              // = elt^(12*z^3 + 6*z^2 + 4*z - 1)
+      c.call(P + "_mul", lc, f, ac),
+      // U = T.Frobenius_map(3) // = elt^(q^3(12*z^3 + 6*z^2 + 4*z - 1))
+      c.call(e + "__frobeniusMap3", ac, oc),
+      // V = U * R              // = elt^(q^3(12*z^3 + 6*z^2 + 4*z - 1) + q^2 * (12*z^3 + 6*z^2 + 6*z) + q*(12*z^3 + 6*z^2 + 4*z) * (12*z^3 + 12*z^2 + 6*z + 1))
+      c.call(P + "_mul", oc, A, _)
+      // result = V
+    );
+  }
+  function Tc() {
+    hc(), Nc();
+    const a = l.addFunction(e + "_finalExponentiation");
+    a.addParam("x", "i32"), a.addParam("r", "i32");
+    const c = a.getCodeBuilder(), i = c.getLocal("x"), _ = c.getLocal("r"), s = c.i32_const(l.alloc(I));
+    a.addCode(
+      c.call(e + "__finalExponentiationFirstChunk", i, s),
+      c.call(e + "__finalExponentiationLastChunk", s, _)
+    );
+  }
+  function Uc() {
+    const a = l.addFunction(e + "_finalExponentiationOld");
+    a.addParam("x", "i32"), a.addParam("r", "i32");
+    const i = l.alloc(b.bigInt2BytesLE(552484233613224096312617126783173147097382103762957654188882734314196910839907541213974502761540629817009608548654680343627701153829446747810907373256841551006201639677726139946029199968412598804882391702273019083653272047566316584365559776493027495458238373902875937659943504873220554161550525926302303331747463515644711876653177129578303191095900909191624817826566688241804408081892785725967931714097716709526092261278071952560171111444072049229123565057483750161460024353346284167282452756217662335528813519139808291170539072125381230815729071544861602750936964829313608137325426383735122175229541155376346436093930287402089517426973178917569713384748081827255472576937471496195752727188261435633271238710131736096299798168852925540549342330775279877006784354801422249722573783561685179618816480037695005515426162362431072245638324744480n, 352)), _ = a.getCodeBuilder();
+    a.addCode(
+      _.call(P + "_exp", _.getLocal("x"), _.i32_const(i), _.i32_const(352), _.getLocal("r"))
+    );
+  }
+  const U = l.alloc(cc), j = l.alloc(tc);
+  function jc(a) {
+    const c = l.addFunction(e + "_pairingEq" + a);
+    for (let o = 0; o < a; o++)
+      c.addParam("p_" + o, "i32"), c.addParam("q_" + o, "i32");
+    c.addParam("c", "i32"), c.setReturnType("i32");
+    const i = c.getCodeBuilder(), _ = i.i32_const(l.alloc(I)), s = i.i32_const(l.alloc(I));
+    c.addCode(i.call(P + "_one", _));
+    for (let o = 0; o < a; o++)
+      c.addCode(i.call(e + "_prepareG1", i.getLocal("p_" + o), i.i32_const(U))), c.addCode(i.call(e + "_prepareG2", i.getLocal("q_" + o), i.i32_const(j))), c.addCode(i.call(e + "_millerLoop", i.i32_const(U), i.i32_const(j), s)), c.addCode(i.call(P + "_mul", _, s, _));
+    c.addCode(i.call(e + "_finalExponentiation", _, _)), c.addCode(i.call(P + "_eq", _, i.getLocal("c")));
+  }
+  function kc() {
+    const a = l.addFunction(e + "_pairing");
+    a.addParam("p", "i32"), a.addParam("q", "i32"), a.addParam("r", "i32");
+    const c = a.getCodeBuilder(), i = c.i32_const(l.alloc(I));
+    a.addCode(c.call(e + "_prepareG1", c.getLocal("p"), c.i32_const(U))), a.addCode(c.call(e + "_prepareG2", c.getLocal("q"), c.i32_const(j))), a.addCode(c.call(e + "_millerLoop", c.i32_const(U), c.i32_const(j), i)), a.addCode(c.call(e + "_finalExponentiation", i, c.getLocal("r")));
+  }
+  Ac(), qc(), Ic(), zc(), Qc(), Gc(), Sc();
+  for (let a = 0; a < 10; a++)
+    Vc(a), l.exportFunction(e + "__frobeniusMap" + a);
+  Uc(), Tc();
+  for (let a = 1; a <= 5; a++)
+    jc(a), l.exportFunction(e + "_pairingEq" + a);
+  kc(), l.exportFunction(e + "_pairing"), l.exportFunction(e + "_prepareG1"), l.exportFunction(e + "_prepareG2"), l.exportFunction(e + "_millerLoop"), l.exportFunction(e + "_finalExponentiation"), l.exportFunction(e + "_finalExponentiationOld"), l.exportFunction(e + "__mulBy024"), l.exportFunction(e + "__mulBy024Old"), l.exportFunction(e + "__cyclotomicSquare"), l.exportFunction(e + "__cyclotomicExp_w0");
+};
+export {
+  P2 as b
+};