@hinkal/common 0.0.115 → 0.0.117

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/wasmcurves/src/bls12381/build_bls12381.mjs

@@ -0,0 +1,917 @@
+import "../utils.mjs";
+import { b as c2 } from "../build_f1m.mjs";
+import { b as t2 } from "../build_f1.mjs";
+import { b as a2 } from "../build_f2m.mjs";
+import { b as l2 } from "../build_f3m.mjs";
+import { b as n2 } from "../build_curve_jacobian_a0.mjs";
+import { b as o2 } from "../build_fft.mjs";
+import { b as i2 } from "../build_pol.mjs";
+import { b as s2 } from "../build_qap.mjs";
+import { b as _2 } from "../build_applykey.mjs";
+import "../bigint.mjs";
+import { __exports as e2 } from "../../../../../../../../../_virtual/utils10.mjs";
+import { __exports as d2 } from "../../../../../../../../../_virtual/bigint.mjs";
+const b = e2, r2 = c2, p2 = t2, fc = a2, f2 = l2, gc = n2, nc = o2, g2 = i2, u2 = s2, U = _2, { bitLength: uc, isOdd: bc, isNegative: b2 } = d2;
+var N2 = function(a, Lc) {
+  const L = Lc || "bls12381";
+  if (a.modules[L])
+    return L;
+  const w = 0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaabn, Y = 0x73eda753299d7d483339d80809a1d80553bda402fffe5bfeffffffff00000001n, oc = Math.floor((uc(w - 1n) - 1) / 64) + 1, x = oc * 8, s = x, u = s * 2, h = s * 12, ic = Math.floor((uc(Y - 1n) - 1) / 64) + 1, Q = ic * 8, mc = Q, yc = a.alloc(b.bigInt2BytesLE(Y, mc)), A = r2(a, w, "f1m", "intq");
+  p2(a, Y, "fr", "frm", "intr");
+  const sc = a.alloc(b.bigInt2BytesLE(m(4n), s)), R = gc(a, "g1m", "f1m", sc);
+  nc(a, "frm", "frm", "frm", "frm_mul"), g2(a, "pol", "frm"), u2(a, "qap", "frm");
+  const t = fc(a, "f1m_neg", "f2m", "f1m"), _c = a.alloc([
+    ...b.bigInt2BytesLE(m(4n), s),
+    ...b.bigInt2BytesLE(m(4n), s)
+  ]), z = gc(a, "g2m", "f2m", _c);
+  function V(l, c) {
+    const o = a.addFunction(l);
+    o.addParam("pG", "i32"), o.addParam("pFr", "i32"), o.addParam("pr", "i32");
+    const _ = o.getCodeBuilder(), i = _.i32_const(a.alloc(Q));
+    o.addCode(
+      _.call("frm_fromMontgomery", _.getLocal("pFr"), i),
+      _.call(
+        c,
+        _.getLocal("pG"),
+        i,
+        _.i32_const(Q),
+        _.getLocal("pr")
+      )
+    ), a.exportFunction(l);
+  }
+  V("g1m_timesFr", "g1m_timesScalar"), nc(a, "g1m", "g1m", "frm", "g1m_timesFr"), V("g2m_timesFr", "g2m_timesScalar"), nc(a, "g2m", "g2m", "frm", "g2m_timesFr"), V("g1m_timesFrAffine", "g1m_timesScalarAffine"), V("g2m_timesFrAffine", "g2m_timesScalarAffine"), U(a, "frm_batchApplyKey", "fmr", "frm", Q, Q, Q, "frm_mul"), U(a, "g1m_batchApplyKey", "g1m", "frm", x * 3, x * 3, Q, "g1m_timesFr"), U(a, "g1m_batchApplyKeyMixed", "g1m", "frm", x * 2, x * 3, Q, "g1m_timesFrAffine"), U(a, "g2m_batchApplyKey", "g2m", "frm", x * 2 * 3, x * 3 * 2, Q, "g2m_timesFr"), U(a, "g2m_batchApplyKeyMixed", "g2m", "frm", x * 2 * 2, x * 3 * 2, Q, "g2m_timesFrAffine");
+  function m(l) {
+    return BigInt(l) * (1n << BigInt(s * 8)) % w;
+  }
+  const H = [
+    3685416753713387016781088315183077757961620795782546409894578378688607592378376318836054947676345821548104185464507n,
+    1339506544944476473020471379941921221584933875938349620426543736416511423956333506472724655353366534992391756441569n,
+    1n
+  ], xc = a.alloc(
+    [
+      ...b.bigInt2BytesLE(m(H[0]), s),
+      ...b.bigInt2BytesLE(m(H[1]), s),
+      ...b.bigInt2BytesLE(m(H[2]), s)
+    ]
+  ), J = [
+    0n,
+    1n,
+    0n
+  ], Cc = a.alloc(
+    [
+      ...b.bigInt2BytesLE(m(J[0]), s),
+      ...b.bigInt2BytesLE(m(J[1]), s),
+      ...b.bigInt2BytesLE(m(J[2]), s)
+    ]
+  ), v = [
+    [
+      352701069587466618187139116011060144890029952792775240219908644239793785735715026873347600343865175952761926303160n,
+      3059144344244213709971259814753781636986470325476647558659373206291635324768958432433509563104347017837885763365758n
+    ],
+    [
+      1985150602287291935568054521177171638300868978215655730859378665066344726373823718423869104263333984641494340347905n,
+      927553665492332455747201965776037880757740193453592970025027978793976877002675564980949289727957565575433344219582n
+    ],
+    [
+      1n,
+      0n
+    ]
+  ], Bc = a.alloc(
+    [
+      ...b.bigInt2BytesLE(m(v[0][0]), s),
+      ...b.bigInt2BytesLE(m(v[0][1]), s),
+      ...b.bigInt2BytesLE(m(v[1][0]), s),
+      ...b.bigInt2BytesLE(m(v[1][1]), s),
+      ...b.bigInt2BytesLE(m(v[2][0]), s),
+      ...b.bigInt2BytesLE(m(v[2][1]), s)
+    ]
+  ), O = [
+    [
+      0n,
+      0n
+    ],
+    [
+      1n,
+      0n
+    ],
+    [
+      0n,
+      0n
+    ]
+  ], Pc = a.alloc(
+    [
+      ...b.bigInt2BytesLE(m(O[0][0]), s),
+      ...b.bigInt2BytesLE(m(O[0][1]), s),
+      ...b.bigInt2BytesLE(m(O[1][0]), s),
+      ...b.bigInt2BytesLE(m(O[1][1]), s),
+      ...b.bigInt2BytesLE(m(O[2][0]), s),
+      ...b.bigInt2BytesLE(m(O[2][1]), s)
+    ]
+  ), Ec = a.alloc([
+    ...b.bigInt2BytesLE(m(1n), s),
+    ...b.bigInt2BytesLE(m(0n), s),
+    ...b.bigInt2BytesLE(m(0n), s),
+    ...b.bigInt2BytesLE(m(0n), s),
+    ...b.bigInt2BytesLE(m(0n), s),
+    ...b.bigInt2BytesLE(m(0n), s),
+    ...b.bigInt2BytesLE(m(0n), s),
+    ...b.bigInt2BytesLE(m(0n), s),
+    ...b.bigInt2BytesLE(m(0n), s),
+    ...b.bigInt2BytesLE(m(0n), s),
+    ...b.bigInt2BytesLE(m(0n), s),
+    ...b.bigInt2BytesLE(m(0n), s)
+  ]), Fc = a.alloc([
+    ...b.bigInt2BytesLE(m(1n), s),
+    ...b.bigInt2BytesLE(m(1n), s)
+  ]);
+  function Ac() {
+    const l = a.addFunction(t + "_mulNR");
+    l.addParam("x", "i32"), l.addParam("pr", "i32");
+    const c = l.getCodeBuilder(), o = c.i32_const(a.alloc(s)), _ = c.getLocal("x"), i = c.i32_add(c.getLocal("x"), c.i32_const(s)), e = c.getLocal("pr"), n = c.i32_add(c.getLocal("pr"), c.i32_const(s));
+    l.addCode(
+      c.call(A + "_copy", _, o),
+      c.call(A + "_sub", _, i, e),
+      c.call(A + "_add", o, i, n)
+    );
+  }
+  Ac();
+  const G = f2(a, t + "_mulNR", "f6m", "f2m");
+  function Ic() {
+    const l = a.addFunction(G + "_mulNR");
+    l.addParam("x", "i32"), l.addParam("pr", "i32");
+    const c = l.getCodeBuilder(), o = c.i32_const(a.alloc(s * 2));
+    l.addCode(
+      c.call(
+        t + "_copy",
+        c.getLocal("x"),
+        o
+      ),
+      c.call(
+        t + "_mulNR",
+        c.i32_add(c.getLocal("x"), c.i32_const(x * 4)),
+        c.getLocal("pr")
+      ),
+      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))
+      ),
+      c.call(
+        t + "_copy",
+        o,
+        c.i32_add(c.getLocal("pr"), c.i32_const(x * 2))
+      )
+    );
+  }
+  Ic();
+  const y = fc(a, G + "_mulNR", "ftm", G), j = Mc(0xd201000000010000n), ec = a.alloc(j), X = 3 * u, qc = j.length - 1, Rc = j.reduce((l, c) => l + (c != 0 ? 1 : 0), 0) + qc + 1, dc = 3 * 2 * x, rc = 3 * x * 2 + Rc * X, Gc = !0, W = 15132376222941642752n;
+  a.modules[L] = {
+    n64q: oc,
+    n64r: ic,
+    n8q: x,
+    n8r: Q,
+    pG1gen: xc,
+    pG1zero: Cc,
+    pG1b: sc,
+    pG2gen: Bc,
+    pG2zero: Pc,
+    pG2b: _c,
+    pq: a.modules.f1m.pq,
+    pr: yc,
+    pOneT: Ec,
+    r: Y,
+    q: w,
+    prePSize: dc,
+    preQSize: rc
+  };
+  function zc(l) {
+    let c = l;
+    const o = [];
+    for (; c > 0n; ) {
+      if (bc(c)) {
+        const _ = 2 - Number(c % 4n);
+        o.push(_), c = c - BigInt(_);
+      } else
+        o.push(0);
+      c = c >> 1n;
+    }
+    return o;
+  }
+  function Mc(l) {
+    let c = l;
+    const o = [];
+    for (; c > 0n; )
+      bc(c) ? o.push(1) : o.push(0), c = c >> 1n;
+    return o;
+  }
+  function Nc() {
+    const l = a.addFunction(L + "_prepareG1");
+    l.addParam("pP", "i32"), l.addParam("ppreP", "i32");
+    const c = l.getCodeBuilder();
+    l.addCode(
+      c.call(R + "_normalize", c.getLocal("pP"), c.getLocal("ppreP"))
+      // TODO Remove if already in affine
+    );
+  }
+  function Sc() {
+    const l = a.addFunction(L + "_prepDblStep");
+    l.addParam("R", "i32"), l.addParam("r", "i32");
+    const c = l.getCodeBuilder(), o = c.getLocal("R"), _ = c.i32_add(c.getLocal("R"), c.i32_const(2 * x)), i = c.i32_add(c.getLocal("R"), c.i32_const(4 * x)), e = c.getLocal("r"), n = c.i32_add(c.getLocal("r"), c.i32_const(2 * x)), r = c.i32_add(c.getLocal("r"), c.i32_const(4 * x)), d = c.i32_const(a.alloc(u)), f = c.i32_const(a.alloc(u)), p = c.i32_const(a.alloc(u)), g = c.i32_const(a.alloc(u)), B = c.i32_const(a.alloc(u));
+    l.addCode(
+      // tmp0 = r.x.square();
+      c.call(t + "_square", o, e),
+      // tmp1 = r.y.square();
+      c.call(t + "_square", _, f),
+      // tmp2 = tmp1.square();
+      c.call(t + "_square", f, p),
+      // tmp3 = (tmp1 + r.x).square() - tmp0 - tmp2;
+      c.call(t + "_add", f, o, n),
+      c.call(t + "_square", n, n),
+      c.call(t + "_sub", n, e, n),
+      c.call(t + "_sub", n, p, n),
+      // tmp3 = tmp3 + tmp3;
+      c.call(t + "_add", n, n, n),
+      // tmp4 = tmp0 + tmp0 + tmp0;
+      c.call(t + "_add", e, e, g),
+      c.call(t + "_add", g, e, g),
+      // tmp6 = r.x + tmp4;
+      c.call(t + "_add", o, g, r),
+      // tmp5 = tmp4.square();
+      c.call(t + "_square", g, B),
+      // zsquared = r.z.square();
+      c.call(t + "_square", i, d),
+      // r.x = tmp5 - tmp3 - tmp3;
+      c.call(t + "_sub", B, n, o),
+      c.call(t + "_sub", o, n, o),
+      // r.z = (r.z + r.y).square() - tmp1 - zsquared;
+      c.call(t + "_add", i, _, i),
+      c.call(t + "_square", i, i),
+      c.call(t + "_sub", i, f, i),
+      c.call(t + "_sub", i, d, i),
+      // r.y = (tmp3 - r.x) * tmp4;
+      c.call(t + "_sub", n, o, _),
+      c.call(t + "_mul", _, g, _),
+      // tmp2 = tmp2 + tmp2;
+      c.call(t + "_add", p, p, p),
+      // tmp2 = tmp2 + tmp2;
+      c.call(t + "_add", p, p, p),
+      // tmp2 = tmp2 + tmp2;
+      c.call(t + "_add", p, p, p),
+      // r.y -= tmp2;
+      c.call(t + "_sub", _, p, _),
+      // tmp3 = tmp4 * zsquared;
+      c.call(t + "_mul", g, d, n),
+      // tmp3 = tmp3 + tmp3;
+      c.call(t + "_add", n, n, n),
+      // tmp3 = -tmp3;
+      c.call(t + "_neg", n, n),
+      // tmp6 = tmp6.square() - tmp0 - tmp5;
+      c.call(t + "_square", r, r),
+      c.call(t + "_sub", r, e, r),
+      c.call(t + "_sub", r, B, r),
+      // tmp1 = tmp1 + tmp1;
+      c.call(t + "_add", f, f, f),
+      // tmp1 = tmp1 + tmp1;
+      c.call(t + "_add", f, f, f),
+      // tmp6 = tmp6 - tmp1;
+      c.call(t + "_sub", r, f, r),
+      // tmp0 = r.z * zsquared;
+      c.call(t + "_mul", i, d, e),
+      // tmp0 = tmp0 + tmp0;
+      c.call(t + "_add", e, e, e)
+    );
+  }
+  function hc() {
+    const l = a.addFunction(L + "_prepAddStep");
+    l.addParam("R", "i32"), l.addParam("Q", "i32"), l.addParam("r", "i32");
+    const c = l.getCodeBuilder(), o = c.getLocal("R"), _ = c.i32_add(c.getLocal("R"), c.i32_const(2 * x)), i = c.i32_add(c.getLocal("R"), c.i32_const(4 * x)), e = c.getLocal("Q"), n = c.i32_add(c.getLocal("Q"), c.i32_const(2 * x)), r = c.getLocal("r"), d = c.i32_add(c.getLocal("r"), c.i32_const(2 * x)), f = c.i32_add(c.getLocal("r"), c.i32_const(4 * x)), p = c.i32_const(a.alloc(u)), g = c.i32_const(a.alloc(u)), B = c.i32_const(a.alloc(u)), E = c.i32_const(a.alloc(u)), C = c.i32_const(a.alloc(u)), M = c.i32_const(a.alloc(u)), q = c.i32_const(a.alloc(u)), N = c.i32_const(a.alloc(u)), P = c.i32_const(a.alloc(u)), S = c.i32_const(a.alloc(u)), F = c.i32_const(a.alloc(u));
+    l.addCode(
+      // zsquared = r.z.square();
+      c.call(t + "_square", i, p),
+      // ysquared = q.y.square();
+      c.call(t + "_square", n, g),
+      // t0 = zsquared * q.x;
+      c.call(t + "_mul", p, e, E),
+      // t1 = ((q.y + r.z).square() - ysquared - zsquared) * zsquared;
+      c.call(t + "_add", n, i, d),
+      c.call(t + "_square", d, d),
+      c.call(t + "_sub", d, g, d),
+      c.call(t + "_sub", d, p, d),
+      c.call(t + "_mul", d, p, d),
+      // t2 = t0 - r.x;
+      c.call(t + "_sub", E, o, C),
+      // t3 = t2.square();
+      c.call(t + "_square", C, M),
+      // t4 = t3 + t3;
+      c.call(t + "_add", M, M, q),
+      // t4 = t4 + t4;
+      c.call(t + "_add", q, q, q),
+      // t5 = t4 * t2;
+      c.call(t + "_mul", q, C, N),
+      // t6 = t1 - r.y - r.y;
+      c.call(t + "_sub", d, _, P),
+      c.call(t + "_sub", P, _, P),
+      // t9 = t6 * q.x;
+      c.call(t + "_mul", P, e, f),
+      // t7 = t4 * r.x;
+      c.call(t + "_mul", q, o, S),
+      // r.x = t6.square() - t5 - t7 - t7;
+      c.call(t + "_square", P, o),
+      c.call(t + "_sub", o, N, o),
+      c.call(t + "_sub", o, S, o),
+      c.call(t + "_sub", o, S, o),
+      // r.z = (r.z + t2).square() - zsquared - t3;
+      c.call(t + "_add", i, C, i),
+      c.call(t + "_square", i, i),
+      c.call(t + "_sub", i, p, i),
+      c.call(t + "_sub", i, M, i),
+      // t10 = q.y + r.z;
+      c.call(t + "_add", n, i, r),
+      // t8 = (t7 - r.x) * t6;
+      c.call(t + "_sub", S, o, F),
+      c.call(t + "_mul", F, P, F),
+      // t0 = r.y * t5;
+      c.call(t + "_mul", _, N, E),
+      // t0 = t0 + t0;
+      c.call(t + "_add", E, E, E),
+      // r.y = t8 - t0;
+      c.call(t + "_sub", F, E, _),
+      // t10 = t10.square() - ysquared;
+      c.call(t + "_square", r, r),
+      c.call(t + "_sub", r, g, r),
+      // ztsquared = r.z.square();
+      c.call(t + "_square", i, B),
+      // t10 = t10 - ztsquared;
+      c.call(t + "_sub", r, B, r),
+      // t9 = t9 + t9 - t10;
+      c.call(t + "_add", f, f, f),
+      c.call(t + "_sub", f, r, f),
+      // t10 = r.z + r.z;
+      c.call(t + "_add", i, i, r),
+      // t6 = -t6;
+      c.call(t + "_neg", P, P),
+      // t1 = t6 + t6;
+      c.call(t + "_add", P, P, d)
+    );
+  }
+  function Qc() {
+    const l = a.addFunction(L + "_prepareG2");
+    l.addParam("pQ", "i32"), l.addParam("ppreQ", "i32"), l.addLocal("pCoef", "i32"), l.addLocal("i", "i32");
+    const c = l.getCodeBuilder(), o = c.getLocal("pQ"), _ = a.alloc(u * 3), i = c.i32_const(_), e = c.getLocal("ppreQ");
+    l.addCode(
+      c.call(z + "_normalize", o, e),
+      c.if(
+        c.call(z + "_isZero", e),
+        c.ret([])
+      ),
+      c.call(z + "_copy", e, i),
+      c.setLocal("pCoef", c.i32_add(c.getLocal("ppreQ"), c.i32_const(u * 3)))
+    ), l.addCode(
+      c.setLocal("i", c.i32_const(j.length - 2)),
+      c.block(c.loop(
+        c.call(L + "_prepDblStep", i, c.getLocal("pCoef")),
+        c.setLocal("pCoef", c.i32_add(c.getLocal("pCoef"), c.i32_const(X))),
+        c.if(
+          c.i32_load8_s(c.getLocal("i"), ec),
+          [
+            ...c.call(L + "_prepAddStep", i, e, c.getLocal("pCoef")),
+            ...c.setLocal("pCoef", c.i32_add(c.getLocal("pCoef"), c.i32_const(X)))
+          ]
+        ),
+        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)
+      ))
+    );
+  }
+  function Tc() {
+    const l = a.addFunction(G + "_mul1");
+    l.addParam("pA", "i32"), l.addParam("pC1", "i32"), l.addParam("pR", "i32");
+    const c = l.getCodeBuilder(), o = c.getLocal("pA"), _ = c.i32_add(c.getLocal("pA"), c.i32_const(s * 2)), i = c.i32_add(c.getLocal("pA"), c.i32_const(s * 4)), e = c.getLocal("pC1"), n = c.getLocal("pR"), r = c.i32_add(c.getLocal("pR"), c.i32_const(s * 2)), d = c.i32_add(c.getLocal("pR"), c.i32_const(s * 4)), f = c.i32_const(a.alloc(s * 2)), p = c.i32_const(a.alloc(s * 2));
+    l.addCode(
+      c.call(t + "_add", o, _, f),
+      c.call(t + "_add", _, i, p),
+      // let b_b = self.c1 * c1;
+      c.call(t + "_mul", _, e, d),
+      // let t1 = (self.c1 + self.c2) * c1 - b_b;
+      c.call(t + "_mul", p, e, n),
+      c.call(t + "_sub", n, d, n),
+      // let t1 = t1.mul_by_nonresidue();
+      c.call(t + "_mulNR", n, n),
+      // let t2 = (self.c0 + self.c1) * c1 - b_b;
+      c.call(t + "_mul", f, e, r),
+      c.call(t + "_sub", r, d, r)
+    );
+  }
+  Tc();
+  function wc() {
+    const l = a.addFunction(G + "_mul01");
+    l.addParam("pA", "i32"), l.addParam("pC0", "i32"), l.addParam("pC1", "i32"), l.addParam("pR", "i32");
+    const c = l.getCodeBuilder(), o = c.getLocal("pA"), _ = c.i32_add(c.getLocal("pA"), c.i32_const(s * 2)), i = c.i32_add(c.getLocal("pA"), c.i32_const(s * 4)), e = c.getLocal("pC0"), n = c.getLocal("pC1"), r = c.getLocal("pR"), d = c.i32_add(c.getLocal("pR"), c.i32_const(s * 2)), f = c.i32_add(c.getLocal("pR"), c.i32_const(s * 4)), p = c.i32_const(a.alloc(s * 2)), g = c.i32_const(a.alloc(s * 2)), B = c.i32_const(a.alloc(s * 2)), E = c.i32_const(a.alloc(s * 2));
+    l.addCode(
+      // let a_a = self.c0 * c0;
+      c.call(t + "_mul", o, e, p),
+      // let b_b = self.c1 * c1;
+      c.call(t + "_mul", _, n, g),
+      c.call(t + "_add", o, _, B),
+      c.call(t + "_add", o, i, E),
+      // let t1 = (self.c1 + self.c2) * c1 - b_b;
+      c.call(t + "_add", _, i, r),
+      c.call(t + "_mul", r, n, r),
+      c.call(t + "_sub", r, g, r),
+      // let t1 = t1.mul_by_nonresidue() + a_a;
+      c.call(t + "_mulNR", r, r),
+      c.call(t + "_add", r, p, r),
+      // let t2 = (c0 + c1) * (self.c0 + self.c1) - a_a - b_b;
+      c.call(t + "_add", e, n, d),
+      c.call(t + "_mul", d, B, d),
+      c.call(t + "_sub", d, p, d),
+      c.call(t + "_sub", d, g, d),
+      // let t3 = (self.c0 + self.c2) * c0 - a_a + b_b;
+      c.call(t + "_mul", E, e, f),
+      c.call(t + "_sub", f, p, f),
+      c.call(t + "_add", f, g, f)
+    );
+  }
+  wc();
+  function vc() {
+    const l = a.addFunction(y + "_mul014");
+    l.addParam("pA", "i32"), l.addParam("pC0", "i32"), l.addParam("pC1", "i32"), l.addParam("pC4", "i32"), l.addParam("pR", "i32");
+    const c = l.getCodeBuilder(), o = c.getLocal("pA"), _ = c.i32_add(c.getLocal("pA"), c.i32_const(s * 6)), i = c.getLocal("pC0"), e = c.getLocal("pC1"), n = c.getLocal("pC4"), r = c.i32_const(a.alloc(s * 6)), d = c.i32_const(a.alloc(s * 6)), f = c.i32_const(a.alloc(s * 2)), p = c.getLocal("pR"), g = c.i32_add(c.getLocal("pR"), c.i32_const(s * 6));
+    l.addCode(
+      // let aa = self.c0.mul_by_01(c0, c1);
+      c.call(G + "_mul01", o, i, e, r),
+      // let bb = self.c1.mul_by_1(c4);
+      c.call(G + "_mul1", _, n, d),
+      // let o = c1 + c4;
+      c.call(t + "_add", e, n, f),
+      // let c1 = self.c1 + self.c0;
+      c.call(G + "_add", _, o, g),
+      // let c1 = c1.mul_by_01(c0, &o);
+      c.call(G + "_mul01", g, i, f, g),
+      // let c1 = c1 - aa - bb;
+      c.call(G + "_sub", g, r, g),
+      c.call(G + "_sub", g, d, g),
+      // let c0 = bb;
+      c.call(G + "_copy", d, p),
+      // let c0 = c0.mul_by_nonresidue();
+      c.call(G + "_mulNR", p, p),
+      // let c0 = c0 + aa;
+      c.call(G + "_add", p, r, p)
+    );
+  }
+  vc();
+  function Oc() {
+    const l = a.addFunction(L + "_ell");
+    l.addParam("pP", "i32"), l.addParam("pCoefs", "i32"), l.addParam("pF", "i32");
+    const c = l.getCodeBuilder(), o = c.getLocal("pP"), _ = c.i32_add(c.getLocal("pP"), c.i32_const(x)), i = c.getLocal("pF"), e = c.getLocal("pCoefs"), n = c.i32_add(c.getLocal("pCoefs"), c.i32_const(s)), r = c.i32_add(c.getLocal("pCoefs"), c.i32_const(s * 2)), d = c.i32_add(c.getLocal("pCoefs"), c.i32_const(s * 3)), f = c.i32_add(c.getLocal("pCoefs"), c.i32_const(s * 4)), p = a.alloc(s * 2), g = c.i32_const(p), B = c.i32_const(p), E = c.i32_const(p + s), C = a.alloc(s * 2), M = c.i32_const(C), q = c.i32_const(C), N = c.i32_const(C + s);
+    l.addCode(
+      //     let mut c0 = coeffs.0;
+      //     let mut c1 = coeffs.1;
+      //
+      //    c0.c0 *= p.y;
+      //    c0.c1 *= p.y;
+      //
+      //    c1.c0 *= p.x;
+      //    c1.c1 *= p.x;
+      //
+      //     f.mul_by_014(&coeffs.2, &c1, &c0)
+      c.call(A + "_mul", e, _, B),
+      c.call(A + "_mul", n, _, E),
+      c.call(A + "_mul", r, o, q),
+      c.call(A + "_mul", d, o, N),
+      c.call(y + "_mul014", i, f, M, g, i)
+    );
+  }
+  Oc();
+  function jc() {
+    const l = a.addFunction(L + "_millerLoop");
+    l.addParam("ppreP", "i32"), l.addParam("ppreQ", "i32"), l.addParam("r", "i32"), l.addLocal("pCoef", "i32"), l.addLocal("i", "i32");
+    const c = l.getCodeBuilder(), o = c.getLocal("ppreP"), _ = c.getLocal("pCoef"), i = c.getLocal("r");
+    l.addCode(
+      c.call(y + "_one", i),
+      c.if(
+        c.call(R + "_isZero", o),
+        c.ret([])
+      ),
+      c.if(
+        c.call(R + "_isZero", c.getLocal("ppreQ")),
+        c.ret([])
+      ),
+      c.setLocal("pCoef", c.i32_add(c.getLocal("ppreQ"), c.i32_const(u * 3))),
+      c.setLocal("i", c.i32_const(j.length - 2)),
+      c.block(c.loop(
+        c.call(L + "_ell", o, _, i),
+        c.setLocal("pCoef", c.i32_add(c.getLocal("pCoef"), c.i32_const(X))),
+        c.if(
+          c.i32_load8_s(c.getLocal("i"), ec),
+          [
+            ...c.call(L + "_ell", o, _, i),
+            ...c.setLocal("pCoef", c.i32_add(c.getLocal("pCoef"), c.i32_const(X)))
+          ]
+        ),
+        c.call(y + "_square", i, i),
+        c.br_if(1, c.i32_eq(c.getLocal("i"), c.i32_const(1))),
+        c.setLocal("i", c.i32_sub(c.getLocal("i"), c.i32_const(1))),
+        c.br(0)
+      )),
+      c.call(L + "_ell", o, _, i)
+    ), l.addCode(
+      c.call(y + "_conjugate", i, i)
+    );
+  }
+  function Xc(l) {
+    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],
+        [3850754370037169011952147076051364057158807420970682438676050522613628423219637725072182697113062777891589506424760n, 151655185184498381465642749684540099398075398968325446656007613510403227271200139370504932015952886146304766135027n],
+        [793479390729215512621379701633421447060886740281060493010456487427281649075476305620758731620351n, 0n],
+        [2973677408986561043442465346520108879172042883009249989176415018091420807192182638567116318576472649347015917690530n, 1028732146235106349975324479215795277384839936929757896155643118032610843298655225875571310552543014690878354869257n],
+        [793479390729215512621379701633421447060886740281060493010456487427281649075476305620758731620350n, 0n],
+        [3125332594171059424908108096204648978570118281977575435832422631601824034463382777937621250592425535493320683825557n, 877076961050607968509681729531255177986764537961432449499635504522207616027455086505066378536590128544573588734230n],
+        [4002409555221667393417789825735904156556882819939007885332058136124031650490837864442687629129015664037894272559786n, 0n],
+        [151655185184498381465642749684540099398075398968325446656007613510403227271200139370504932015952886146304766135027n, 3850754370037169011952147076051364057158807420970682438676050522613628423219637725072182697113062777891589506424760n],
+        [4002409555221667392624310435006688643935503118305586438271171395842971157480381377015405980053539358417135540939436n, 0n],
+        [1028732146235106349975324479215795277384839936929757896155643118032610843298655225875571310552543014690878354869257n, 2973677408986561043442465346520108879172042883009249989176415018091420807192182638567116318576472649347015917690530n],
+        [4002409555221667392624310435006688643935503118305586438271171395842971157480381377015405980053539358417135540939437n, 0n],
+        [877076961050607968509681729531255177986764537961432449499635504522207616027455086505066378536590128544573588734230n, 3125332594171059424908108096204648978570118281977575435832422631601824034463382777937621250592425535493320683825557n]
+      ]
+    ], o = [
+      [
+        [1n, 0n],
+        [1n, 0n],
+        [1n, 0n],
+        [1n, 0n],
+        [1n, 0n],
+        [1n, 0n]
+      ],
+      [
+        [1n, 0n],
+        [0n, 4002409555221667392624310435006688643935503118305586438271171395842971157480381377015405980053539358417135540939436n],
+        [793479390729215512621379701633421447060886740281060493010456487427281649075476305620758731620350n, 0n],
+        [0n, 1n],
+        [4002409555221667392624310435006688643935503118305586438271171395842971157480381377015405980053539358417135540939436n, 0n],
+        [0n, 793479390729215512621379701633421447060886740281060493010456487427281649075476305620758731620350n]
+      ],
+      [
+        [1n, 0n],
+        [4002409555221667392624310435006688643935503118305586438271171395842971157480381377015405980053539358417135540939437n, 0n],
+        [4002409555221667392624310435006688643935503118305586438271171395842971157480381377015405980053539358417135540939436n, 0n],
+        [4002409555221667393417789825735904156556882819939007885332058136124031650490837864442687629129015664037894272559786n, 0n],
+        [793479390729215512621379701633421447060886740281060493010456487427281649075476305620758731620350n, 0n],
+        [793479390729215512621379701633421447060886740281060493010456487427281649075476305620758731620351n, 0n]
+      ]
+    ], _ = a.addFunction(y + "_frobeniusMap" + l);
+    _.addParam("x", "i32"), _.addParam("r", "i32");
+    const i = _.getCodeBuilder();
+    for (let n = 0; n < 6; n++) {
+      const r = n == 0 ? i.getLocal("x") : i.i32_add(i.getLocal("x"), i.i32_const(n * u)), d = r, f = i.i32_add(i.getLocal("x"), i.i32_const(n * u + s)), p = n == 0 ? i.getLocal("r") : i.i32_add(i.getLocal("r"), i.i32_const(n * u)), g = p, B = i.i32_add(i.getLocal("r"), i.i32_const(n * u + s)), E = e(c[Math.floor(n / 3)][l % 12], o[n % 3][l % 6]), C = a.alloc([
+        ...b.bigInt2BytesLE(m(E[0]), x),
+        ...b.bigInt2BytesLE(m(E[1]), x)
+      ]);
+      l % 2 == 1 ? _.addCode(
+        i.call(A + "_copy", d, g),
+        i.call(A + "_neg", f, B),
+        i.call(t + "_mul", p, i.i32_const(C), p)
+      ) : _.addCode(i.call(t + "_mul", r, i.i32_const(C), p));
+    }
+    function e(n, r) {
+      const d = n[0], f = n[1], p = r[0], g = r[1], B = [
+        (d * p - f * g) % w,
+        (d * g + f * p) % w
+      ];
+      return b2(B[0]) && (B[0] = B[0] + w), B;
+    }
+  }
+  function Zc() {
+    const l = a.addFunction(L + "__cyclotomicSquare");
+    l.addParam("x", "i32"), l.addParam("r", "i32");
+    const c = l.getCodeBuilder(), o = c.getLocal("x"), _ = c.i32_add(c.getLocal("x"), c.i32_const(u)), i = c.i32_add(c.getLocal("x"), c.i32_const(2 * u)), e = c.i32_add(c.getLocal("x"), c.i32_const(3 * u)), n = c.i32_add(c.getLocal("x"), c.i32_const(4 * u)), r = c.i32_add(c.getLocal("x"), c.i32_const(5 * u)), d = c.getLocal("r"), f = c.i32_add(c.getLocal("r"), c.i32_const(u)), p = c.i32_add(c.getLocal("r"), c.i32_const(2 * u)), g = c.i32_add(c.getLocal("r"), c.i32_const(3 * u)), B = c.i32_add(c.getLocal("r"), c.i32_const(4 * u)), E = c.i32_add(c.getLocal("r"), c.i32_const(5 * u)), C = c.i32_const(a.alloc(u)), M = c.i32_const(a.alloc(u)), q = c.i32_const(a.alloc(u)), N = c.i32_const(a.alloc(u)), P = c.i32_const(a.alloc(u)), S = c.i32_const(a.alloc(u)), F = c.i32_const(a.alloc(u)), I = c.i32_const(a.alloc(u));
+    l.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", o, n, F),
+      c.call(t + "_mulNR", n, C),
+      c.call(t + "_add", o, C, C),
+      c.call(t + "_add", o, n, I),
+      c.call(t + "_mul", I, C, C),
+      c.call(t + "_mulNR", F, I),
+      c.call(t + "_add", F, I, I),
+      c.call(t + "_sub", C, I, C),
+      c.call(t + "_add", F, F, M),
+      //  // 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", e, i, F),
+      c.call(t + "_mulNR", i, q),
+      c.call(t + "_add", e, q, q),
+      c.call(t + "_add", e, i, I),
+      c.call(t + "_mul", I, q, q),
+      c.call(t + "_mulNR", F, I),
+      c.call(t + "_add", F, I, I),
+      c.call(t + "_sub", q, I, q),
+      c.call(t + "_add", F, F, N),
+      //  // 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", _, r, F),
+      c.call(t + "_mulNR", r, P),
+      c.call(t + "_add", _, P, P),
+      c.call(t + "_add", _, r, I),
+      c.call(t + "_mul", I, P, P),
+      c.call(t + "_mulNR", F, I),
+      c.call(t + "_add", F, I, I),
+      c.call(t + "_sub", P, I, P),
+      c.call(t + "_add", F, F, S),
+      // For A
+      // z0 = 3 * t0 - 2 * z0
+      c.call(t + "_sub", C, o, d),
+      c.call(t + "_add", d, d, d),
+      c.call(t + "_add", C, d, d),
+      // z1 = 3 * t1 + 2 * z1
+      c.call(t + "_add", M, n, B),
+      c.call(t + "_add", B, B, B),
+      c.call(t + "_add", M, B, B),
+      // For B
+      // z2 = 3 * (xi * t5) + 2 * z2
+      c.call(t + "_mul", S, c.i32_const(Fc), I),
+      c.call(t + "_add", I, e, g),
+      c.call(t + "_add", g, g, g),
+      c.call(t + "_add", I, g, g),
+      // z3 = 3 * t4 - 2 * z3
+      c.call(t + "_sub", P, i, p),
+      c.call(t + "_add", p, p, p),
+      c.call(t + "_add", P, p, p),
+      // For C
+      // z4 = 3 * t2 - 2 * z4
+      c.call(t + "_sub", q, _, f),
+      c.call(t + "_add", f, f, f),
+      c.call(t + "_add", q, f, f),
+      // z5 = 3 * t3 + 2 * z5
+      c.call(t + "_add", N, r, E),
+      c.call(t + "_add", E, E, E),
+      c.call(t + "_add", N, E, E)
+    );
+  }
+  function Kc(l, c, o) {
+    const _ = zc(l).map((p) => p == -1 ? 255 : p), i = a.alloc(_), e = a.addFunction(L + "__cyclotomicExp_" + o);
+    e.addParam("x", "i32"), e.addParam("r", "i32"), e.addLocal("bit", "i32"), e.addLocal("i", "i32");
+    const n = e.getCodeBuilder(), r = n.getLocal("x"), d = n.getLocal("r"), f = n.i32_const(a.alloc(h));
+    e.addCode(
+      n.call(y + "_conjugate", r, f),
+      n.call(y + "_one", d),
+      n.if(
+        n.teeLocal("bit", n.i32_load8_s(n.i32_const(_.length - 1), i)),
+        n.if(
+          n.i32_eq(
+            n.getLocal("bit"),
+            n.i32_const(1)
+          ),
+          n.call(y + "_mul", d, r, d),
+          n.call(y + "_mul", d, f, d)
+        )
+      ),
+      n.setLocal("i", n.i32_const(_.length - 2)),
+      n.block(n.loop(
+        n.call(L + "__cyclotomicSquare", d, d),
+        n.if(
+          n.teeLocal("bit", n.i32_load8_s(n.getLocal("i"), i)),
+          n.if(
+            n.i32_eq(
+              n.getLocal("bit"),
+              n.i32_const(1)
+            ),
+            n.call(y + "_mul", d, r, d),
+            n.call(y + "_mul", d, f, d)
+          )
+        ),
+        n.br_if(1, n.i32_eqz(n.getLocal("i"))),
+        n.setLocal("i", n.i32_sub(n.getLocal("i"), n.i32_const(1))),
+        n.br(0)
+      ))
+    ), c && e.addCode(
+      n.call(y + "_conjugate", d, d)
+    );
+  }
+  function Dc() {
+    Zc(), Kc(W, Gc, "w0");
+    const l = a.addFunction(L + "_finalExponentiation");
+    l.addParam("x", "i32"), l.addParam("r", "i32");
+    const c = l.getCodeBuilder(), o = c.getLocal("x"), _ = c.getLocal("r"), i = c.i32_const(a.alloc(h)), e = c.i32_const(a.alloc(h)), n = c.i32_const(a.alloc(h)), r = c.i32_const(a.alloc(h)), d = c.i32_const(a.alloc(h)), f = c.i32_const(a.alloc(h)), p = c.i32_const(a.alloc(h));
+    l.addCode(
+      // let mut t0 = f.frobenius_map(6)
+      c.call(y + "_frobeniusMap6", o, i),
+      // let t1 = f.invert()
+      c.call(y + "_inverse", o, e),
+      // let mut t2 = t0 * t1;
+      c.call(y + "_mul", i, e, n),
+      // t1 = t2.clone();
+      c.call(y + "_copy", n, e),
+      // t2 = t2.frobenius_map().frobenius_map();
+      c.call(y + "_frobeniusMap2", n, n),
+      // t2 *= t1;
+      c.call(y + "_mul", n, e, n),
+      // t1 = cyclotomic_square(t2).conjugate();
+      c.call(L + "__cyclotomicSquare", n, e),
+      c.call(y + "_conjugate", e, e),
+      // let mut t3 = cycolotomic_exp(t2);
+      c.call(L + "__cyclotomicExp_w0", n, r),
+      // let mut t4 = cyclotomic_square(t3);
+      c.call(L + "__cyclotomicSquare", r, d),
+      // let mut t5 = t1 * t3;
+      c.call(y + "_mul", e, r, f),
+      // t1 = cycolotomic_exp(t5);
+      c.call(L + "__cyclotomicExp_w0", f, e),
+      // t0 = cycolotomic_exp(t1);
+      c.call(L + "__cyclotomicExp_w0", e, i),
+      // let mut t6 = cycolotomic_exp(t0);
+      c.call(L + "__cyclotomicExp_w0", i, p),
+      // t6 *= t4;
+      c.call(y + "_mul", p, d, p),
+      // t4 = cycolotomic_exp(t6);
+      c.call(L + "__cyclotomicExp_w0", p, d),
+      // t5 = t5.conjugate();
+      c.call(y + "_conjugate", f, f),
+      // t4 *= t5 * t2;
+      c.call(y + "_mul", d, f, d),
+      c.call(y + "_mul", d, n, d),
+      // t5 = t2.conjugate();
+      c.call(y + "_conjugate", n, f),
+      // t1 *= t2;
+      c.call(y + "_mul", e, n, e),
+      // t1 = t1.frobenius_map().frobenius_map().frobenius_map();
+      c.call(y + "_frobeniusMap3", e, e),
+      // t6 *= t5;
+      c.call(y + "_mul", p, f, p),
+      // t6 = t6.frobenius_map();
+      c.call(y + "_frobeniusMap1", p, p),
+      // t3 *= t0;
+      c.call(y + "_mul", r, i, r),
+      // t3 = t3.frobenius_map().frobenius_map();
+      c.call(y + "_frobeniusMap2", r, r),
+      // t3 *= t1;
+      c.call(y + "_mul", r, e, r),
+      // t3 *= t6;
+      c.call(y + "_mul", r, p, r),
+      // f = t3 * t4;
+      c.call(y + "_mul", r, d, _)
+    );
+  }
+  function kc() {
+    const l = a.addFunction(L + "_finalExponentiationOld");
+    l.addParam("x", "i32"), l.addParam("r", "i32");
+    const o = a.alloc(b.bigInt2BytesLE(322277361516934140462891564586510139908379969514828494218366688025288661041104682794998680497580008899973249814104447692778988208376779573819485263026159588510513834876303014016798809919343532899164848730280942609956670917565618115867287399623286813270357901731510188149934363360381614501334086825442271920079363289954510565375378443704372994881406797882676971082200626541916413184642520269678897559532260949334760604962086348898118982248842634379637598665468817769075878555493752214492790122785850202957575200176084204422751485957336465472324810982833638490904279282696134323072515220044451592646885410572234451732790590013479358343841220074174848221722017083597872017638514103174122784843925578370430843522959600095676285723737049438346544753168912974976791528535276317256904336520179281145394686565050419250614107803233314658825463117900250701199181529205942363159325765991819433914303908860460720581408201373164047773794825411011922305820065611121544561808414055302212057471395719432072209245600258134364584636810093520285711072578721435517884103526483832733289802426157301542744476740008494780363354305116978805620671467071400711358839553375340724899735460480144599782014906586543813292157922220645089192130209334926661588737007768565838519456601560804957985667880395221049249803753582637708560n, 544)), _ = l.getCodeBuilder();
+    l.addCode(
+      _.call(y + "_exp", _.getLocal("x"), _.i32_const(o), _.i32_const(544), _.getLocal("r"))
+    );
+  }
+  const Z = a.alloc(dc), K = a.alloc(rc);
+  function Uc(l) {
+    const c = a.addFunction(L + "_pairingEq" + l);
+    for (let e = 0; e < l; e++)
+      c.addParam("p_" + e, "i32"), c.addParam("q_" + e, "i32");
+    c.addParam("c", "i32"), c.setReturnType("i32");
+    const o = c.getCodeBuilder(), _ = o.i32_const(a.alloc(h)), i = o.i32_const(a.alloc(h));
+    c.addCode(o.call(y + "_one", _));
+    for (let e = 0; e < l; e++)
+      c.addCode(o.call(L + "_prepareG1", o.getLocal("p_" + e), o.i32_const(Z))), c.addCode(o.call(L + "_prepareG2", o.getLocal("q_" + e), o.i32_const(K))), c.addCode(
+        o.if(
+          o.i32_eqz(o.call(R + "_inGroupAffine", o.i32_const(Z))),
+          o.ret(o.i32_const(0))
+        ),
+        o.if(
+          o.i32_eqz(o.call(z + "_inGroupAffine", o.i32_const(K))),
+          o.ret(o.i32_const(0))
+        )
+      ), c.addCode(o.call(L + "_millerLoop", o.i32_const(Z), o.i32_const(K), i)), c.addCode(o.call(y + "_mul", _, i, _));
+    c.addCode(o.call(L + "_finalExponentiation", _, _)), c.addCode(o.call(y + "_eq", _, o.getLocal("c")));
+  }
+  function Yc() {
+    const l = a.addFunction(L + "_pairing");
+    l.addParam("p", "i32"), l.addParam("q", "i32"), l.addParam("r", "i32");
+    const c = l.getCodeBuilder(), o = c.i32_const(a.alloc(h));
+    l.addCode(c.call(L + "_prepareG1", c.getLocal("p"), c.i32_const(Z))), l.addCode(c.call(L + "_prepareG2", c.getLocal("q"), c.i32_const(K))), l.addCode(c.call(L + "_millerLoop", c.i32_const(Z), c.i32_const(K), o)), l.addCode(c.call(L + "_finalExponentiation", o, c.getLocal("r")));
+  }
+  function Vc() {
+    const l = a.addFunction(z + "_inGroupAffine");
+    l.addParam("p", "i32"), l.setReturnType("i32");
+    const c = l.getCodeBuilder(), o = [
+      2001204777610833696708894912867952078278441409969503942666029068062015825245418932221343814564507832018947136279894n,
+      2001204777610833696708894912867952078278441409969503942666029068062015825245418932221343814564507832018947136279893n
+    ], _ = 4002409555221667392624310435006688643935503118305586438271171395842971157480381377015405980053539358417135540939436n, i = [
+      2973677408986561043442465346520108879172042883009249989176415018091420807192182638567116318576472649347015917690530n,
+      2973677408986561043442465346520108879172042883009249989176415018091420807192182638567116318576472649347015917690530n
+    ], e = c.i32_const(a.alloc([
+      ...b.bigInt2BytesLE(m(o[0]), x),
+      ...b.bigInt2BytesLE(m(o[1]), x)
+    ])), n = c.i32_const(a.alloc(b.bigInt2BytesLE(m(_), x))), r = c.i32_const(a.alloc([
+      ...b.bigInt2BytesLE(m(i[0]), x),
+      ...b.bigInt2BytesLE(m(i[1]), x)
+    ])), d = c.i32_const(a.alloc(b.bigInt2BytesLE(W, 8))), f = c.getLocal("p"), p = c.i32_add(c.getLocal("p"), c.i32_const(u)), g = c.i32_const(a.alloc(s)), B = c.i32_const(a.alloc(u)), E = c.i32_const(a.alloc(u)), C = a.alloc(u * 2), M = c.i32_const(C), q = c.i32_const(C), N = c.i32_const(C), P = c.i32_const(C + s), S = c.i32_const(C + u), F = c.i32_const(C + u), I = c.i32_const(C + u + s), T = a.alloc(u * 3), D = c.i32_const(T), $c = c.i32_const(T), cc = c.i32_const(T), tc = c.i32_const(T + s), Hc = c.i32_const(T + u), ac = c.i32_const(T + u), lc = c.i32_const(T + u + s), Jc = c.i32_const(T + u * 2);
+    l.addCode(
+      c.if(
+        c.call(z + "_isZeroAffine", c.getLocal("p")),
+        c.ret(c.i32_const(1))
+      ),
+      c.if(
+        c.i32_eqz(c.call(z + "_inCurveAffine", c.getLocal("p"))),
+        c.ret(c.i32_const(0))
+      ),
+      c.call(t + "_mul", f, e, B),
+      c.call(t + "_mul", p, e, E),
+      c.call(t + "_mul1", B, n, q),
+      c.call(t + "_neg", E, S),
+      c.call(t + "_neg", B, $c),
+      c.call(t + "_mul", E, r, Hc),
+      c.call(A + "_sub", N, P, g),
+      c.call(A + "_add", N, P, P),
+      c.call(A + "_copy", g, N),
+      c.call(A + "_sub", F, I, g),
+      c.call(A + "_add", F, I, I),
+      c.call(A + "_copy", g, F),
+      c.call(A + "_add", cc, tc, g),
+      c.call(A + "_sub", cc, tc, tc),
+      c.call(A + "_copy", g, cc),
+      c.call(A + "_sub", lc, ac, g),
+      c.call(A + "_add", ac, lc, lc),
+      c.call(A + "_copy", g, ac),
+      c.call(t + "_one", Jc),
+      c.call(z + "_timesScalar", D, d, c.i32_const(8), D),
+      c.call(z + "_addMixed", D, M, D),
+      c.ret(
+        c.call(z + "_eqMixed", D, c.getLocal("p"))
+      )
+    );
+    const $ = a.addFunction(z + "_inGroup");
+    $.addParam("pIn", "i32"), $.setReturnType("i32");
+    const k = $.getCodeBuilder(), pc = k.i32_const(a.alloc(u * 2));
+    $.addCode(
+      k.call(z + "_toAffine", k.getLocal("pIn"), pc),
+      k.ret(
+        k.call(z + "_inGroupAffine", pc)
+      )
+    );
+  }
+  function Wc() {
+    const l = a.addFunction(R + "_inGroupAffine");
+    l.addParam("p", "i32"), l.setReturnType("i32");
+    const c = l.getCodeBuilder(), o = 4002409555221667392624310435006688643935503118305586438271171395842971157480381377015405980053539358417135540939436n, _ = 793479390729215512621379701633421447060886740281060493010456487427281649075476305620758731620350n, i = (W * W - 1n) / 3n, e = c.i32_const(a.alloc(b.bigInt2BytesLE(m(o), x))), n = c.i32_const(a.alloc(b.bigInt2BytesLE(m(_), x))), r = c.i32_const(a.alloc(b.bigInt2BytesLE(i, 16))), d = c.getLocal("p"), f = c.i32_add(c.getLocal("p"), c.i32_const(s)), p = a.alloc(s * 3), g = c.i32_const(p), B = c.i32_const(p), E = c.i32_const(p + s), C = a.alloc(s * 2), M = c.i32_const(C), q = c.i32_const(C), N = c.i32_const(C + s);
+    l.addCode(
+      c.if(
+        c.call(R + "_isZeroAffine", c.getLocal("p")),
+        c.ret(c.i32_const(1))
+      ),
+      c.if(
+        c.i32_eqz(c.call(R + "_inCurveAffine", c.getLocal("p"))),
+        c.ret(c.i32_const(0))
+      ),
+      c.call(A + "_mul", d, e, B),
+      c.call(A + "_copy", f, E),
+      c.call(A + "_mul", d, n, q),
+      c.call(A + "_copy", f, N),
+      c.call(R + "_doubleAffine", g, g),
+      c.call(R + "_subMixed", g, c.getLocal("p"), g),
+      c.call(R + "_subMixed", g, M, g),
+      c.call(R + "_timesScalar", g, r, c.i32_const(16), g),
+      c.ret(
+        c.call(R + "_eqMixed", g, M)
+      )
+    );
+    const P = a.addFunction(R + "_inGroup");
+    P.addParam("pIn", "i32"), P.setReturnType("i32");
+    const S = P.getCodeBuilder(), F = S.i32_const(a.alloc(s * 2));
+    P.addCode(
+      S.call(R + "_toAffine", S.getLocal("pIn"), F),
+      S.ret(
+        S.call(R + "_inGroupAffine", F)
+      )
+    );
+  }
+  for (let l = 0; l < 10; l++)
+    Xc(l), a.exportFunction(y + "_frobeniusMap" + l);
+  Wc(), Vc(), hc(), Sc(), Nc(), Qc(), jc(), kc(), Dc();
+  for (let l = 1; l <= 5; l++)
+    Uc(l), a.exportFunction(L + "_pairingEq" + l);
+  Yc(), a.exportFunction(L + "_pairing"), a.exportFunction(L + "_prepareG1"), a.exportFunction(L + "_prepareG2"), a.exportFunction(L + "_millerLoop"), a.exportFunction(L + "_finalExponentiation"), a.exportFunction(L + "_finalExponentiationOld"), a.exportFunction(L + "__cyclotomicSquare"), a.exportFunction(L + "__cyclotomicExp_w0"), a.exportFunction(G + "_mul1"), a.exportFunction(G + "_mul01"), a.exportFunction(y + "_mul014"), a.exportFunction(R + "_inGroupAffine"), a.exportFunction(R + "_inGroup"), a.exportFunction(z + "_inGroupAffine"), a.exportFunction(z + "_inGroup");
+};
+export {
+  N2 as b
+};