diff --git a/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/README.md b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/README.md
new file mode 100644
index 0000000..582ff37
--- /dev/null
+++ b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/README.md
@@ -0,0 +1,35 @@
+# Under-Constrained
+
+* Id: succinctlabs/telepathy-circuits/veridise-V-SUC-VUL-002-simplified
+* Project: https://github.com/succinctlabs/telepathy-circuits
+* Commit: 9c84fb0f38531718296d9b611f8bd6107f61a9b8
+* Fix Commit: b0c839cef30c3c25ef41d1ad3000081784766934
+* DSL: Circom
+* Vulnerability: Under-Constrained
+* Location
+  - Path: circuits/bls_signature.circom
+  - Function: CoreVerifyPubkeyG1ToyExample
+  - Line: 77-95
+* Source: Audit Report
+  - Source Link: https://veridise.com/wp-content/uploads/2023/04/VAR-Succinct.pdf
+  - Bug ID: V-SUC-VUL-002: Template CoreVerifyPubkeyG1 does not perform input validation
+* Commands
+  - Setup Environment: `./zkbugs_setup.sh`
+  - Reproduce: `./zkbugs_exploit.sh`
+  - Compile and Preprocess: `./zkbugs_compile_setup.sh`
+  - Positive Test: `./zkbugs_positive_test.sh`
+  - Find Exploit: `./zkbugs_find_exploit.sh`
+  - Clean: `./zkbugs_clean.sh`
+
+## Short Description of the Vulnerability
+
+This bug is in the circom-pairing BLS signature verification logic. pubkey, signature and hash are divided into 7-entry chunks of 55-bit data, and each entry is checked against according entry in `p`. When calling `BigLessThan()`, the output isn't verified therefore attacker can manipulate the input so that it overflows p.
+
+## Short Description of the Exploit
+
+The circuit had been simplified to demonstrate the bug, the attack idea is calculating a `delta` such that it makes the input overflow but still bounded by 2**55 - 1 to pass the range check inside `BigLessThan()`. In reality, attacker would bruteforce a special set of inputs satisfying a list of constraints. The details are explained in the PR comment.
+
+## Proposed Mitigation
+
+In each iteration of the for loop, add a constraint `lt[idx].out === 1` to make sure the input is indeed bounded by `p`.
+
diff --git a/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/bigint.circom b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/bigint.circom
new file mode 100644
index 0000000..9c0b9c3
--- /dev/null
+++ b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/bigint.circom
@@ -0,0 +1,989 @@
+pragma circom 2.0.3;
+
+include "../../../dependencies/circomlib/circuits/comparators.circom";
+include "../../../dependencies/circomlib/circuits/bitify.circom";
+include "../../../dependencies/circomlib/circuits/gates.circom";
+
+include "bigint_func.circom";
+
+// addition mod 2**n with carry bit
+template ModSum(n) {
+    assert(n <= 252);
+    signal input a;
+    signal input b;
+    signal output sum;
+    signal output carry;
+
+    component n2b = Num2Bits(n + 1);
+    n2b.in <== a + b;
+    carry <== n2b.out[n];
+    sum <== a + b - carry * (1 << n);
+}
+
+// check if k-register variables a, b are equal everywhere
+template BigIsEqual(k) {
+    signal input a[k];
+    signal input b[k];
+    signal output out;
+
+    component isEquals[k];
+    var total = k;
+    for (var i = 0; i < k; i ++) {
+        isEquals[i] = IsEqual();
+        isEquals[i].in[0] <== a[i];
+        isEquals[i].in[1] <== b[i];
+        total -= isEquals[i].out;
+    }
+    component checkZero = IsZero();
+    checkZero.in <== total;
+    out <== checkZero.out;
+}
+
+// check if k-register variable a is equal to zero
+template BigIsZero(k) {
+    signal input in[k];
+    signal output out;
+
+    component isZeros[k];
+    var total = k;
+    for (var i = 0; i < k; i ++) {
+        isZeros[i] = IsZero();
+        isZeros[i].in <== in[i];
+        total -= isZeros[i].out;
+    }
+    component checkZero = IsZero();
+    checkZero.in <== total;
+    out <== checkZero.out;
+}
+
+
+// a - b
+template ModSub(n) {
+    assert(n <= 252);
+    signal input a;
+    signal input b;
+    signal output out;
+    signal output borrow;
+    component lt = LessThan(n);
+    lt.in[0] <== a;
+    lt.in[1] <== b;
+    borrow <== lt.out;
+    out <== borrow * (1 << n) + a - b;
+}
+
+// a - b - c
+// assume a - b - c + 2**n >= 0
+template ModSubThree(n) {
+    assert(n + 2 <= 253);
+    signal input a;
+    signal input b;
+    signal input c;
+    assert(a - b - c + (1 << n) >= 0);
+    signal output out;
+    signal output borrow;
+    signal b_plus_c;
+    b_plus_c <== b + c;
+    component lt = LessThan(n + 1);
+    lt.in[0] <== a;
+    lt.in[1] <== b_plus_c;
+    borrow <== lt.out;
+    out <== borrow * (1 << n) + a - b_plus_c;
+}
+
+template ModSumThree(n) {
+    assert(n + 2 <= 253);
+    signal input a;
+    signal input b;
+    signal input c;
+    signal output sum;
+    signal output carry;
+
+    component n2b = Num2Bits(n + 2);
+    n2b.in <== a + b + c;
+    carry <== n2b.out[n] + 2 * n2b.out[n + 1];
+    sum <== a + b + c - carry * (1 << n);
+}
+
+template ModSumFour(n) {
+    assert(n + 2 <= 253);
+    signal input a;
+    signal input b;
+    signal input c;
+    signal input d;
+    signal output sum;
+    signal output carry;
+
+    component n2b = Num2Bits(n + 2);
+    n2b.in <== a + b + c + d;
+    carry <== n2b.out[n] + 2 * n2b.out[n + 1];
+    sum <== a + b + c + d - carry * (1 << n);
+}
+
+// product mod 2**n with carry
+template ModProd(n) {
+    assert(n <= 126);
+    signal input a;
+    signal input b;
+    signal output prod;
+    signal output carry;
+
+    component n2b = Num2Bits(2 * n);
+    n2b.in <== a * b;
+
+    component b2n1 = Bits2Num(n);
+    component b2n2 = Bits2Num(n);
+    var i;
+    for (i = 0; i < n; i++) {
+        b2n1.in[i] <== n2b.out[i];
+        b2n2.in[i] <== n2b.out[i + n];
+    }
+    prod <== b2n1.out;
+    carry <== b2n2.out;
+}
+
+// split a n + m bit input into two outputs
+template Split(n, m) {
+    assert(n <= 126);
+    signal input in;
+    signal output small;
+    signal output big;
+
+    small <-- in % (1 << n);
+    big <-- in \ (1 << n);
+
+    component n2b_small = Num2Bits(n);
+    n2b_small.in <== small;
+    component n2b_big = Num2Bits(m);
+    n2b_big.in <== big;
+
+    in === small + big * (1 << n);
+}
+
+// split a n + m + k bit input into three outputs
+template SplitThree(n, m, k) {
+    assert(n <= 126);
+    signal input in;
+    signal output small;
+    signal output medium;
+    signal output big;
+
+    small <-- in % (1 << n);
+    medium <-- (in \ (1 << n)) % (1 << m);
+    big <-- in \ (1 << n + m);
+
+    component n2b_small = Num2Bits(n);
+    n2b_small.in <== small;
+    component n2b_medium = Num2Bits(m);
+    n2b_medium.in <== medium;
+    component n2b_big = Num2Bits(k);
+    n2b_big.in <== big;
+
+    in === small + medium * (1 << n) + big * (1 << n + m);
+}
+
+// a[i], b[i] in 0... 2**n-1
+// represent a = a[0] + a[1] * 2**n + .. + a[k - 1] * 2**(n * k)
+template BigAdd(n, k) {
+    assert(n <= 252);
+    signal input a[k];
+    signal input b[k];
+    signal output out[k + 1];
+
+    component unit0 = ModSum(n);
+    unit0.a <== a[0];
+    unit0.b <== b[0];
+    out[0] <== unit0.sum;
+
+    component unit[k - 1];
+    for (var i = 1; i < k; i++) {
+        unit[i - 1] = ModSumThree(n);
+        unit[i - 1].a <== a[i];
+        unit[i - 1].b <== b[i];
+        if (i == 1) {
+            unit[i - 1].c <== unit0.carry;
+        } else {
+            unit[i - 1].c <== unit[i - 2].carry;
+        }
+        out[i] <== unit[i - 1].sum;
+    }
+    out[k] <== unit[k - 2].carry;
+}
+
+/* 
+Polynomial Multiplication
+Inputs:
+    - a = a[0] + a[1] * X + ... + a[k-1] * X^{k-1}
+    - b = b[0] + b[1] * X + ... + b[k-1] * X^{k-1}
+Output:
+    - out = out[0] + out[1] * X + ... + out[2 * k - 2] * X^{2*k - 2}
+    - out = a * b as polynomials in X 
+Notes:
+    - Optimization due to xJsnark:
+    -- witness is calculated by normal polynomial multiplication
+    -- out is contrained by evaluating out(X) === a(X) * b(X) at X = 0, ..., 2*k - 2
+    - If a[i], b[j] have absolute value < B, then out[i] has absolute value < k * B^2 
+m_out is the expected max number of bits in the output registers
+*/
+template BigMultShortLong(n, k, m_out) {
+   assert(n <= 126);
+   signal input a[k];
+   signal input b[k];
+   signal output out[2 * k - 1];
+
+   var prod_val[2 * k - 1];
+   for (var i = 0; i < 2 * k - 1; i++) {
+       prod_val[i] = 0;
+       if (i < k) {
+           for (var a_idx = 0; a_idx <= i; a_idx++) {
+               prod_val[i] = prod_val[i] + a[a_idx] * b[i - a_idx];
+           }
+       } else {
+           for (var a_idx = i - k + 1; a_idx < k; a_idx++) {
+               prod_val[i] = prod_val[i] + a[a_idx] * b[i - a_idx];
+           }
+       }
+       out[i] <-- prod_val[i];
+   }
+
+   var k2 = 2 * k - 1;
+   var pow[k2][k2]; // we cache the exponent values because it makes a big difference in witness generation time
+   for(var i = 0; i<k2; i++)for(var j=0; j<k2; j++)
+       pow[i][j] = i ** j; 
+
+   var a_poly[2 * k - 1];
+   var b_poly[2 * k - 1];
+   var out_poly[2 * k - 1];
+   for (var i = 0; i < 2 * k - 1; i++) {
+       out_poly[i] = 0;
+       a_poly[i] = 0;
+       b_poly[i] = 0;
+       for (var j = 0; j < 2 * k - 1; j++) {
+           out_poly[i] = out_poly[i] + out[j] * pow[i][j];
+       }
+       for (var j = 0; j < k; j++) {
+           a_poly[i] = a_poly[i] + a[j] * pow[i][j];
+           b_poly[i] = b_poly[i] + b[j] * pow[i][j];
+       }
+   }
+   for (var i = 0; i < 2 * k - 1; i++) {
+      out_poly[i] === a_poly[i] * b_poly[i];
+   }
+}
+
+/*
+same as BigMultShortLong except a has degree ka - 1, b has degree kb - 1
+    - If a[i], b[j] have absolute value < B, then out[i] has absolute value < min(ka, kb) * B^2 
+*/
+template BigMultShortLongUnequal(n, ka, kb, m_out) {
+    assert(n <= 126);
+    signal input a[ka];
+    signal input b[kb];
+    signal output out[ka + kb - 1];
+    
+    var prod_val[ka + kb - 1];
+    for (var i = 0; i < ka + kb - 1; i++) {
+	prod_val[i] = 0;
+    }
+    for (var i = 0; i < ka; i++) {
+	for (var j = 0; j < kb; j++) {
+	    prod_val[i + j] = prod_val[i + j] + a[i] * b[j];
+	}
+    }
+    for (var i = 0; i < ka + kb - 1; i++) {
+       out[i] <-- prod_val[i];
+   }
+
+   var k2 = ka + kb - 1;
+   var pow[k2][k2]; 
+   for(var i = 0; i<k2; i++)for(var j=0; j<k2; j++)
+       pow[i][j] = i ** j; 
+
+   var a_poly[ka + kb - 1];
+   var b_poly[ka + kb - 1];
+   var out_poly[ka + kb - 1];
+   for (var i = 0; i < ka + kb - 1; i++) {
+       out_poly[i] = 0;
+       a_poly[i] = 0;
+       b_poly[i] = 0;
+       for (var j = 0; j < ka + kb - 1; j++) {
+           out_poly[i] = out_poly[i] + out[j] * pow[i][j];
+       }
+       for (var j = 0; j < ka; j++) {
+           a_poly[i] = a_poly[i] + a[j] * pow[i][j];
+       }
+       for (var j = 0; j < kb; j++) {
+           b_poly[i] = b_poly[i] + b[j] * pow[i][j];
+       }
+   }
+   for (var i = 0; i < ka + kb - 1; i++) {
+      out_poly[i] === a_poly[i] * b_poly[i];
+   }
+}
+
+
+// in[i] contains longs
+// out[i] contains shorts
+template LongToShortNoEndCarry(n, k) {
+    assert(n <= 126);
+    signal input in[k];
+    signal output out[k+1];
+
+    var split[k][3];
+    for (var i = 0; i < k; i++) {
+        split[i] = SplitThreeFn(in[i], n, n, n);
+    }
+
+    var carry[k];
+    carry[0] = 0;
+    out[0] <-- split[0][0];
+    if (k > 1) {
+        var sumAndCarry[2] = SplitFn(split[0][1] + split[1][0], n, n);
+        out[1] <-- sumAndCarry[0];
+        carry[1] = sumAndCarry[1];
+    }
+    if (k > 2) {
+        for (var i = 2; i < k; i++) {
+            var sumAndCarry[2] = SplitFn(split[i][0] + split[i-1][1] + split[i-2][2] + carry[i-1], n, n);
+            out[i] <-- sumAndCarry[0];
+            carry[i] = sumAndCarry[1];
+        }
+        out[k] <-- split[k-1][1] + split[k-2][2] + carry[k-1];
+    }
+
+    component outRangeChecks[k+1];
+    for (var i = 0; i < k+1; i++) {
+        outRangeChecks[i] = Num2Bits(n);
+        outRangeChecks[i].in <== out[i];
+    }
+
+    signal runningCarry[k];
+    component runningCarryRangeChecks[k];
+    runningCarry[0] <-- (in[0] - out[0]) / (1 << n);
+    runningCarryRangeChecks[0] = Num2Bits(n + log_ceil(k));
+    runningCarryRangeChecks[0].in <== runningCarry[0];
+    runningCarry[0] * (1 << n) === in[0] - out[0];
+    for (var i = 1; i < k; i++) {
+        runningCarry[i] <-- (in[i] - out[i] + runningCarry[i-1]) / (1 << n);
+        runningCarryRangeChecks[i] = Num2Bits(n + log_ceil(k));
+        runningCarryRangeChecks[i].in <== runningCarry[i];
+        runningCarry[i] * (1 << n) === in[i] - out[i] + runningCarry[i-1];
+    }
+    runningCarry[k-1] === out[k];
+}
+
+template BigMult(n, k) {
+    signal input a[k];
+    signal input b[k];
+    signal output out[2 * k];
+
+    var LOGK = log_ceil(k);
+    component mult = BigMultShortLong(n, k, 2*n + LOGK);
+    for (var i = 0; i < k; i++) {
+        mult.a[i] <== a[i];
+        mult.b[i] <== b[i];
+    }
+
+    // no carry is possible in the highest order register
+    component longshort = LongToShortNoEndCarry(n, 2 * k - 1);
+    for (var i = 0; i < 2 * k - 1; i++) {
+        longshort.in[i] <== mult.out[i];
+    }
+    for (var i = 0; i < 2 * k; i++) {
+        out[i] <== longshort.out[i];
+    }
+}
+
+/*
+Inputs:
+    - BigInts a, b
+Output:
+    - out = (a < b) ? 1 : 0
+*/
+template BigLessThan(n, k){
+    signal input a[k];
+    signal input b[k];
+    signal output out;
+
+    component lt[k];
+    component eq[k];
+    for (var i = 0; i < k; i++) {
+        lt[i] = LessThan(n);
+        lt[i].in[0] <== a[i];
+        lt[i].in[1] <== b[i];
+        eq[i] = IsEqual();
+        eq[i].in[0] <== a[i];
+        eq[i].in[1] <== b[i];
+    }
+
+    // ors[i] holds (lt[k - 1] || (eq[k - 1] && lt[k - 2]) .. || (eq[k - 1] && .. && lt[i]))
+    // ands[i] holds (eq[k - 1] && .. && lt[i])
+    // eq_ands[i] holds (eq[k - 1] && .. && eq[i])
+    component ors[k - 1];
+    component ands[k - 1];
+    component eq_ands[k - 1];
+    for (var i = k - 2; i >= 0; i--) {
+        ands[i] = AND();
+        eq_ands[i] = AND();
+        ors[i] = OR();
+
+        if (i == k - 2) {
+           ands[i].a <== eq[k - 1].out;
+           ands[i].b <== lt[k - 2].out;
+           eq_ands[i].a <== eq[k - 1].out;
+           eq_ands[i].b <== eq[k - 2].out;
+           ors[i].a <== lt[k - 1].out;
+           ors[i].b <== ands[i].out;
+        } else {
+           ands[i].a <== eq_ands[i + 1].out;
+           ands[i].b <== lt[i].out;
+           eq_ands[i].a <== eq_ands[i + 1].out;
+           eq_ands[i].b <== eq[i].out;
+           ors[i].a <== ors[i + 1].out;
+           ors[i].b <== ands[i].out;
+        }
+     }
+     out <== ors[0].out;
+}
+
+// leading register of b should be non-zero
+template BigMod(n, k) {
+    assert(n <= 126);
+    signal input a[2 * k];
+    signal input b[k];
+
+    signal output div[k + 1];
+    signal output mod[k];
+
+    var longdiv[2][50] = long_div(n, k, a, b);
+    for (var i = 0; i < k; i++) {
+        div[i] <-- longdiv[0][i];
+        mod[i] <-- longdiv[1][i];
+    }
+    div[k] <-- longdiv[0][k];
+    component div_range_checks[k + 1];
+    for (var i = 0; i <= k; i++) {
+        div_range_checks[i] = Num2Bits(n);
+        div_range_checks[i].in <== div[i];
+    }
+    component mod_range_checks[k];
+    for (var i = 0; i < k; i++) {
+        mod_range_checks[i] = Num2Bits(n);
+        mod_range_checks[i].in <== mod[i];
+    }
+
+    component mul = BigMult(n, k + 1);
+    for (var i = 0; i < k; i++) {
+        mul.a[i] <== div[i];
+        mul.b[i] <== b[i];
+    }
+    mul.a[k] <== div[k];
+    mul.b[k] <== 0;
+
+    for (var i = 0; i < 2 * k + 2; i++) {
+        //log(mul.out[i]);
+    }
+
+    component add = BigAdd(n, 2 * k + 2);
+    for (var i = 0; i < 2 * k; i++) {
+        add.a[i] <== mul.out[i];
+        if (i < k) {
+            add.b[i] <== mod[i];
+        } else {
+            add.b[i] <== 0;
+        }
+    }
+    add.a[2 * k] <== mul.out[2 * k];
+    add.a[2 * k + 1] <== mul.out[2 * k + 1];
+    add.b[2 * k] <== 0;
+    add.b[2 * k + 1] <== 0;
+
+    for (var i = 0; i < 2 * k + 2; i++) {
+        //log(add.out[i]);
+    }
+
+    for (var i = 0; i < 2 * k; i++) {
+        add.out[i] === a[i];
+    }
+    add.out[2 * k] === 0;
+    add.out[2 * k + 1] === 0;
+
+    component lt = BigLessThan(n, k);
+    for (var i = 0; i < k; i++) {
+        lt.a[i] <== mod[i];
+        lt.b[i] <== b[i];
+    }
+    lt.out === 1;
+}
+
+// copied from BigMod to allow a to have m registers and use long_div2
+template BigMod2(n, k, m) {
+    assert(n <= 126);
+    signal input a[m];
+    signal input b[k];
+
+    signal output div[m - k + 1];
+    signal output mod[k];
+
+    var longdiv[2][50] = long_div2(n, k, m-k, a, b);
+    for (var i = 0; i < k; i++) {
+        mod[i] <-- longdiv[1][i];
+    }
+    for (var i = 0; i <= m-k; i++) {
+        div[i] <-- longdiv[0][i];
+    }
+    component div_range_checks[m - k + 1];
+    for (var i = 0; i <= m-k; i++) {
+        div_range_checks[i] = Num2Bits(n);
+        div_range_checks[i].in <== div[i];
+    }
+    component mod_range_checks[k];
+    for (var i = 0; i < k; i++) {
+        mod_range_checks[i] = Num2Bits(n);
+        mod_range_checks[i].in <== mod[i];
+    }
+
+    component mul = BigMult(n, m-k + 1);
+    // this might need to be optimized since b has less registers than div
+    for (var i = 0; i < k; i++) {
+        mul.a[i] <== div[i];
+        mul.b[i] <== b[i];
+    }
+    for (var i = k; i <= m-k; i++) {
+        mul.a[i] <== div[i];
+        mul.b[i] <== 0;
+    }
+
+    // mul shouldn't have more registers than a
+    for (var i = m; i < 2*(m-k)+2; i++) {
+        mul.out[i] === 0;
+    }
+
+    component add = BigAdd(n, m);
+    for (var i = 0; i < m; i++) {
+        add.a[i] <== mul.out[i];
+        if (i < k) {
+            add.b[i] <== mod[i];
+        } else {
+            add.b[i] <== 0;
+        }
+    }
+
+    for (var i = 0; i < m; i++) {
+        add.out[i] === a[i];
+    }
+    add.out[m] === 0;
+
+    component lt = BigLessThan(n, k);
+    for (var i = 0; i < k; i++) {
+        lt.a[i] <== mod[i];
+        lt.b[i] <== b[i];
+    }
+    lt.out === 1;
+}
+
+
+
+// a[i], b[i] in 0... 2**n-1
+// represent a = a[0] + a[1] * 2**n + .. + a[k - 1] * 2**(n * k)
+// calculates (a+b)%p, where 0<= a,b < p 
+template BigAddModP(n, k){
+    assert(n <= 252);
+    signal input a[k];
+    signal input b[k];
+    signal input p[k];
+    signal output out[k];
+
+    component add = BigAdd(n,k);
+    for (var i = 0; i < k; i++) {
+        add.a[i] <== a[i];
+        add.b[i] <== b[i];
+    }
+    component lt = BigLessThan(n, k+1);
+    for (var i = 0; i < k; i++) {
+        lt.a[i] <== add.out[i];
+        lt.b[i] <== p[i];
+    }
+    lt.a[k] <== add.out[k];
+    lt.b[k] <== 0; 
+
+    component sub = BigSub(n,k+1);
+    for (var i = 0; i < k; i++) {
+        sub.a[i] <== add.out[i];
+        sub.b[i] <== (1-lt.out) * p[i];
+    }
+    sub.a[k] <== add.out[k];
+    sub.b[k] <== 0;
+    
+    sub.out[k] === 0;
+    for (var i = 0; i < k; i++) {
+        out[i] <== sub.out[i];
+    }
+}
+
+/*
+Inputs:
+    - BigInts a, b
+    - Assume a >= b
+Output:
+    - BigInt out = a - b
+    - underflow = how much is borrowed at the highest digit of subtraction, only nonzero if a < b
+*/
+template BigSub(n, k) {
+    assert(n <= 252);
+    signal input a[k];
+    signal input b[k];
+    signal output out[k];
+    signal output underflow;
+
+    component unit0 = ModSub(n);
+    unit0.a <== a[0];
+    unit0.b <== b[0];
+    out[0] <== unit0.out;
+
+    component unit[k - 1];
+    for (var i = 1; i < k; i++) {
+        unit[i - 1] = ModSubThree(n);
+        unit[i - 1].a <== a[i];
+        unit[i - 1].b <== b[i];
+        if (i == 1) {
+            unit[i - 1].c <== unit0.borrow;
+        } else {
+            unit[i - 1].c <== unit[i - 2].borrow;
+        }
+        out[i] <== unit[i - 1].out;
+    }
+    underflow <== unit[k - 2].borrow;
+}
+
+// calculates (a - b) % p, where a, b < p
+// note: does not assume a >= b
+template BigSubModP(n, k){
+    assert(n <= 252);
+    signal input a[k];
+    signal input b[k];
+    signal input p[k];
+    signal output out[k];
+    component sub = BigSub(n, k);
+    for (var i = 0; i < k; i++){
+        sub.a[i] <== a[i];
+        sub.b[i] <== b[i];
+    }
+    signal flag;
+    flag <== sub.underflow;
+    component add = BigAdd(n, k);
+    for (var i = 0; i < k; i++){
+        add.a[i] <== sub.out[i];
+        add.b[i] <== p[i];
+    }
+    signal tmp[k];
+    for (var i = 0; i < k; i++){
+        tmp[i] <== (1 - flag) * sub.out[i];
+        out[i] <== tmp[i] + flag * add.out[i];
+    }
+}
+
+// Note: deprecated
+template BigMultModP(n, k) {
+    assert(n <= 252);
+    signal input a[k];
+    signal input b[k];
+    signal input p[k];
+    signal output out[k];
+
+    component big_mult = BigMult(n, k);
+    for (var i = 0; i < k; i++) {
+        big_mult.a[i] <== a[i];
+        big_mult.b[i] <== b[i];
+    }
+    component big_mod = BigMod(n, k);
+    for (var i = 0; i < 2 * k; i++) {
+        big_mod.a[i] <== big_mult.out[i];
+    }
+    for (var i = 0; i < k; i++) {
+        big_mod.b[i] <== p[i];
+    }
+    for (var i = 0; i < k; i++) {
+        out[i] <== big_mod.mod[i];
+    }
+}
+
+template BigModInv(n, k) {
+    assert(n <= 252);
+    signal input in[k];
+    signal input p[k];
+    signal output out[k];
+
+    // length k
+    var inv[50] = mod_inv(n, k, in, p);
+    for (var i = 0; i < k; i++) {
+        out[i] <-- inv[i];
+    }
+    component range_checks[k];
+    for (var i = 0; i < k; i++) {
+        range_checks[i] = Num2Bits(n);
+        range_checks[i].in <== out[i];
+    }
+
+    component mult = BigMult(n, k);
+    for (var i = 0; i < k; i++) {
+        mult.a[i] <== in[i];
+        mult.b[i] <== out[i];
+    }
+    component mod = BigMod(n, k);
+    for (var i = 0; i < 2 * k; i++) {
+        mod.a[i] <== mult.out[i];
+    }
+    for (var i = 0; i < k; i++) {
+        mod.b[i] <== p[i];
+    }
+    mod.mod[0] === 1;
+    for (var i = 1; i < k; i++) {
+        mod.mod[i] === 0;
+    }
+}
+
+/* Taken from circom-ecdsa
+Input: 
+    - in = in[0] + in[1] * X + ... + in[k-1] * X^{k-1} as signed overflow representation
+    - Assume each in[i] is in range (-2^{m-1}, 2^{m-1})
+Implements:
+    - constrain that in[] evaluated at X = 2^n as a big integer equals zero
+*/
+template CheckCarryToZero(n, m, k) {
+    assert(k >= 2);
+    
+    var EPSILON = 1; // see below for why 1 is ok
+    
+    signal input in[k];
+    
+    signal carry[k];
+    component carryRangeChecks[k];
+    for (var i = 0; i < k-1; i++){
+        carryRangeChecks[i] = Num2Bits(m + EPSILON - n); 
+        if( i == 0 ){
+            carry[i] <-- in[i] / (1<<n);
+            in[i] === carry[i] * (1<<n);
+        }
+        else{
+            carry[i] <-- (in[i]+carry[i-1]) / (1<<n);
+            in[i] + carry[i-1] === carry[i] * (1<<n);
+        }
+        // checking carry is in the range of -2^(m-n-1+eps), 2^(m-n-1+eps)
+        carryRangeChecks[i].in <== carry[i] + ( 1<< (m + EPSILON - n - 1));
+        // carry[i] is bounded by 2^{m-1} * (2^{-n} + 2^{-2n} + ... ) = 2^{m-n-1} * ( 1/ (1-2^{-n})) < 2^{m-n} by geometric series 
+    }
+    
+    in[k-1] + carry[k-2] === 0;
+    
+}
+
+/* 
+Let X = 2^n 
+Input:
+    - in is length k + m array in signed overflow representation
+    - in = in[0] + in[1] * X + ... + in[k+m-1] * X^{k+m-1}
+    - Assume each in[i] is a signed integer such that abs(in[i] * 2^n) < 2^252
+    - p is prime in BigInt format passed as parameter
+Output:
+    - out = out[0] + out[1] * X + ... + out[k-1] * X^{k-1} is BigInt congruent to in (mod p)
+Implementation:
+    - For i >= k, we precompute X^i = r[i] mod p, where r[i] represented as k registers with r[i][j] in [0, 2^n) 
+    - in[i] * X^i is replaced by sum_j in[i] * r[i][j] * X^j
+Notes:
+    - If each in[i] has absolute value <B, then out[i] has absolute value < (m+1) * 2^n * B
+m_out is the expected max number of bits in the output registers
+*/
+template PrimeReduce(n, k, m, p, m_out){
+    signal input in[m+k]; 
+    signal output out[k];
+
+    var two[k]; 
+    var e[k];
+    for(var i=1; i<k; i++){
+        two[i]=0;
+        e[i]=0;
+    }
+    two[0] = 2;
+
+    
+    e[0] = n;
+    var pow2n[50] = mod_exp(n, k, two, p, e); 
+    e[0] = k;
+    assert(k < (1<<n) );
+    var pow2nk[50] = mod_exp(n, k, pow2n, p, e);
+    
+    var r[m][50]; 
+    for(var i=0; i<m; i++){
+        // r[i] = 2^{n(k+i)} mod p 
+        if(i==0){
+            r[i] = pow2nk;
+        }else{
+            r[i] = prod_mod(n, k, r[i-1], pow2n, p);  
+        }
+    } 
+    var out_sum[k]; 
+    for(var i=0; i<k; i++)
+        out_sum[i] = in[i];
+    for(var i=0; i<m; i++)
+        for(var j=0; j<k; j++)
+            out_sum[j] += in[i+k] * r[i][j]; // linear constraint 
+    for(var i=0; i<k; i++)
+        out[i] <== out_sum[i]; 
+    /*component range_checks[k];
+    for (var i = 0; i < k; i++) {
+        range_checks[i] = Num2Bits(m_out+1);
+        range_checks[i].in <== out[i] + (1 << m_out);
+    }*/
+}
+
+/* 
+Polynomial multiplication in 2 variables
+Input:
+    - a = sum_{i=0}^{l-1} sum_{j=0}^{k-1} a[i][j] * w^i * X^j 
+    - b = sum_{i=0}^{l-1} sum_{j=0}^{k-1} b[i][j] * w^i * X^j 
+Output:
+    - out = sum_{i=0}^{2*l-2} sum_{j=0}^{2*k-1} out[i][j] * w^i * X^j 
+    - out = a * b as product of polynomials in two variables w, X 
+Notes:
+    - Uses same xJsnark optimization as BigMultShortLong
+    - If a[i][j], b[i][j] have absolute value < B, then out[i][j] has absolute value < l * k * B^2 
+Use case: one variable will end up being 2^n; the other will be the field extension generator
+*/
+template BigMultShortLong2D(n, k, l) {
+    signal input a[l][k];
+    signal input b[l][k];
+    signal output out[2*l-1][2*k-1];
+
+    var prod_val[2*l-1][2*k-1];
+    for (var i = 0; i < 2*l-1; i++) {
+        for (var j = 0; j < 2*k-1; j++) {
+            prod_val[i][j] = 0;
+        }
+    }
+
+    for (var i1 = 0; i1 < l; i1 ++) {
+        for (var i2 = 0; i2 < l; i2 ++) {
+            for (var j1 = 0; j1 < k; j1 ++) {
+                for (var j2 = 0; j2 < k; j2 ++) {
+                    var i = i1 + i2;
+                    var j = j1 + j2;
+                    prod_val[i][j] += a[i1][j1] * b[i2][j2];
+                }
+            }
+        }
+    }
+
+    for (var i = 0; i < 2*l-1; i++) {
+        for (var j = 0; j < 2*k-1; j++) {
+            out[i][j] <-- prod_val[i][j];
+        }
+    }
+    
+    var k2 = (2*k-1 > 2*l-1) ? 2*k-1 : 2*l-1;
+    var pow[k2][k2]; 
+    for(var i = 0; i<k2; i++)for(var j=0; j<k2; j++)
+        pow[i][j] = i ** j; 
+
+    var a_poly[2*l-1][2*k-1];
+    var b_poly[2*l-1][2*k-1];
+    var out_poly[2*l-1][2*k-1];
+    for (var i = 0; i < 2*l-1; i++) {
+        for (var j = 0; j < 2*k-1; j++) {
+            a_poly[i][j] = 0;
+            b_poly[i][j] = 0;
+            out_poly[i][j] = 0;
+            for (var deg1 = 0; deg1 < l; deg1 ++) {
+                for (var deg2 = 0; deg2 < k; deg2 ++) {
+                    a_poly[i][j] = a_poly[i][j] + a[deg1][deg2] * pow[i][deg1] * pow[j][deg2]; // (i ** deg1) * (j ** deg2);
+                    b_poly[i][j] = b_poly[i][j] + b[deg1][deg2] * pow[i][deg1] * pow[j][deg2]; // (i ** deg1) * (j ** deg2);
+                }
+            }
+            for (var deg1 = 0; deg1 < 2*l-1; deg1 ++) {
+                for (var deg2 = 0; deg2 < 2*k-1; deg2 ++) {
+                    out_poly[i][j] = out_poly[i][j] + out[deg1][deg2] * pow[i][deg1] * pow[j][deg2];// (i ** deg1) * (j ** deg2);
+                }
+            }
+        }
+    }
+    
+    for (var i = 0; i < 2*l-1; i++) {
+        for (var j = 0; j < 2*k-1; j++) {
+            out_poly[i][j] === a_poly[i][j] * b_poly[i][j];
+        }
+    }
+}
+
+/* 
+Same as BigMultShortLong2D except a has degrees la - 1, ka - 1 and b has degrees lb - 1, kb - 1
+Notes:
+    - If a[i][j], b[i][j] have absolute value < B, then out[i][j] has absolute value < min(la, lb) * min(ka, kb) * B^2 
+*/
+template BigMultShortLong2DUnequal(n, ka, kb, la, lb) {
+    signal input a[la][ka];
+    signal input b[lb][kb];
+    signal output out[la + lb -1][ka + kb -1];
+
+    var prod_val[la + lb -1][ka + kb -1];
+    for (var i = 0; i < la + lb -1; i++) {
+        for (var j = 0; j < ka + kb -1; j++) {
+            prod_val[i][j] = 0;
+        }
+    }
+
+    for (var i1 = 0; i1 < la; i1 ++) {
+        for (var i2 = 0; i2 < lb; i2 ++) {
+            for (var j1 = 0; j1 < ka; j1 ++) {
+                for (var j2 = 0; j2 < kb; j2 ++) {
+                    var i = i1 + i2;
+                    var j = j1 + j2;
+                    prod_val[i][j] += a[i1][j1] * b[i2][j2];
+                }
+            }
+        }
+    }
+
+    for (var i = 0; i < la + lb -1; i++) {
+        for (var j = 0; j < ka + kb -1; j++) {
+            out[i][j] <-- prod_val[i][j];
+        }
+    }
+
+    var k2 = (ka + kb -1 > la + lb -1) ? ka + kb - 1 : la + lb -1;
+    var pow[k2][k2]; 
+    for(var i = 0; i<k2; i++)for(var j=0; j<k2; j++)
+        pow[i][j] = i ** j; 
+
+    var a_poly[la + lb - 1][ka + kb -1];
+    var b_poly[la + lb - 1][ka + kb -1];
+    var out_poly[la + lb - 1][ka + kb -1];
+    for (var i = 0; i < la + lb - 1; i++) {
+        for (var j = 0; j < ka + kb - 1; j++) {
+            a_poly[i][j] = 0;
+            b_poly[i][j] = 0;
+            out_poly[i][j] = 0;
+            for (var deg1 = 0; deg1 < la + lb - 1; deg1 ++) {
+                if (deg1 < la) {
+                    for (var deg2 = 0; deg2 < ka; deg2 ++) {
+                        a_poly[i][j] = a_poly[i][j] + a[deg1][deg2] * pow[i][deg1] * pow[j][deg2]; //(i ** deg1) * (j ** deg2);
+                    }
+                }
+                if (deg1 < lb) {
+                    for (var deg2 = 0; deg2 < kb; deg2 ++) {
+                        b_poly[i][j] = b_poly[i][j] + b[deg1][deg2] * pow[i][deg1] * pow[j][deg2]; // (i ** deg1) * (j ** deg2);
+                    }
+		        }
+                for (var deg2 = 0; deg2 < ka + kb -1; deg2 ++) {
+                    out_poly[i][j] = out_poly[i][j] + out[deg1][deg2] * pow[i][deg1] * pow[j][deg2]; // (i ** deg1) * (j ** deg2);
+                }
+            }
+        }
+    }
+
+    for (var i = 0; i < la + lb - 1; i++) {
+        for (var j = 0; j < ka + kb - 1; j++) {
+            out_poly[i][j] === a_poly[i][j] * b_poly[i][j];
+        }
+    }
+}
+
+
diff --git a/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/bigint_func.circom b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/bigint_func.circom
new file mode 100644
index 0000000..26738ff
--- /dev/null
+++ b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/bigint_func.circom
@@ -0,0 +1,520 @@
+pragma circom 2.0.3;
+
+function min(a, b) {
+    if(a < b)
+        return a;
+    return b;
+}
+
+function max(a, b) {
+    if(a > b)
+        return a;
+    return b;
+}
+
+function log_ceil(n) {
+   var n_temp = n;
+   for (var i = 0; i < 254; i++) {
+       if (n_temp == 0) {
+          return i;
+       }
+       n_temp = n_temp \ 2;
+   }
+   return 254;
+}
+
+function SplitFn(in, n, m) {
+    return [in % (1 << n), (in \ (1 << n)) % (1 << m)];
+}
+
+function SplitThreeFn(in, n, m, k) {
+    return [in % (1 << n), (in \ (1 << n)) % (1 << m), (in \ (1 << n + m)) % (1 << k)];
+}
+
+// 1 if true, 0 if false
+function long_gt(n, k, a, b) {
+    for (var i = k - 1; i >= 0; i--) {
+        if (a[i] > b[i]) {
+            return 1;
+        }
+        if (a[i] < b[i]) {
+            return 0;
+        }
+    }
+    return 0;
+}
+
+function long_is_zero(k, a){
+    for(var idx=0; idx<k; idx++){
+        if(a[idx] != 0)
+            return 0;
+    }
+    return 1;
+}
+
+// n bits per register
+// a has k registers
+// b has k registers
+// output has k+1 registers
+function long_add(n, k, a, b){
+    var carry = 0;
+    var sum[50];
+    for(var i=0; i<k; i++){
+        var sumAndCarry[2] = SplitFn(a[i] + b[i] + carry, n, n);
+        sum[i] = sumAndCarry[0];
+        carry = sumAndCarry[1];
+    }
+    sum[k] = carry;
+    return sum;
+}
+
+// n bits per register
+// a has k registers
+// b has k registers
+// c has k registers
+// d has k registers
+// output has k+1 registers
+function long_add4(n, k, a, b, c, d){
+    var carry = 0;
+    var sum[50];
+    for(var i=0; i < k; i++){
+        var sumAndCarry[2] = SplitFn(a[i] + b[i] + c[i] + d[i] + carry, n, n);
+        sum[i] = sumAndCarry[0];
+        carry = sumAndCarry[1];
+    }
+    sum[k] = carry;
+    return sum;
+}
+
+// n bits per register
+// a has k1 registers
+// b has k2 registers
+// assume k1 > k2
+// output has k1+1 registers
+function long_add_unequal(n, k1, k2, a, b){
+    var carry = 0;
+    var sum[50];
+    for(var i=0; i<k1; i++){
+        if (i < k2) {
+            var sumAndCarry[2] = SplitFn(a[i] + b[i] + carry, n, n);
+            sum[i] = sumAndCarry[0];
+            carry = sumAndCarry[1];
+        } else {
+            var sumAndCarry[2] = SplitFn(a[i] + carry, n, n);
+            sum[i] = sumAndCarry[0];
+            carry = sumAndCarry[1];
+        }
+    }
+    sum[k1] = carry;
+    return sum;
+}
+
+// n bits per register
+// a has k registers
+// b has k registers
+// a >= b
+function long_sub(n, k, a, b) {
+    var diff[50];
+    var borrow[50];
+    for (var i = 0; i < k; i++) {
+        if (i == 0) {
+           if (a[i] >= b[i]) {
+               diff[i] = a[i] - b[i];
+               borrow[i] = 0;
+            } else {
+               diff[i] = a[i] - b[i] + (1 << n);
+               borrow[i] = 1;
+            }
+        } else {
+            if (a[i] >= b[i] + borrow[i - 1]) {
+               diff[i] = a[i] - b[i] - borrow[i - 1];
+               borrow[i] = 0;
+            } else {
+               diff[i] = (1 << n) + a[i] - b[i] - borrow[i - 1];
+               borrow[i] = 1;
+            }
+        }
+    }
+    return diff;
+}
+
+// a is a n-bit scalar
+// b has k registers
+function long_scalar_mult(n, k, a, b) {
+    var out[50];
+    for (var i = 0; i < 50; i++) {
+        out[i] = 0;
+    }
+    for (var i = 0; i < k; i++) {
+        var temp = out[i] + (a * b[i]);
+        out[i] = temp % (1 << n);
+        out[i + 1] = out[i + 1] + temp \ (1 << n);
+    }
+    return out;
+}
+
+
+// n bits per register
+// a has k + m registers
+// b has k registers
+// out[0] has length m + 1 -- quotient
+// out[1] has length k -- remainder
+// implements algorithm of https://people.eecs.berkeley.edu/~fateman/282/F%20Wright%20notes/week4.pdf
+// b[k-1] must be nonzero!
+function long_div2(n, k, m, a, b){
+    var out[2][50];
+    // assume k+m < 50
+    var remainder[50];
+    for (var i = 0; i < m + k; i++) {
+        remainder[i] = a[i];
+    }
+
+    var dividend[50];
+    for (var i = m; i >= 0; i--) {
+        if (i == m) {
+            dividend[k] = 0;
+            for (var j = k - 1; j >= 0; j--) {
+                dividend[j] = remainder[j + m];
+            }
+        } else {
+            for (var j = k; j >= 0; j--) {
+                dividend[j] = remainder[j + i];
+            }
+        }
+        out[0][i] = short_div(n, k, dividend, b);
+        var mult_shift[50] = long_scalar_mult(n, k, out[0][i], b);
+        var subtrahend[50];
+        for (var j = 0; j < m + k; j++) {
+            subtrahend[j] = 0;
+        }
+        for (var j = 0; j <= k; j++) {
+            if (i + j < m + k) {
+               subtrahend[i + j] = mult_shift[j];
+            }
+        }
+        remainder = long_sub(n, m + k, remainder, subtrahend);
+    }
+    for (var i = 0; i < k; i++) {
+        out[1][i] = remainder[i];
+    }
+    out[1][k] = 0;
+    return out;
+}
+
+function long_div(n, k, a, b) {
+    return long_div2(n, k, k, a, b);
+}
+
+// n bits per register
+// a has k + 1 registers
+// b has k registers
+// assumes leading digit of b is at least 2^(n - 1)
+// 0 <= a < (2**n) * b
+function short_div_norm(n, k, a, b) {
+   var qhat = (a[k] * (1 << n) + a[k - 1]) \ b[k - 1];
+   if (qhat > (1 << n) - 1) {
+      qhat = (1 << n) - 1;
+   }
+
+   var mult[50] = long_scalar_mult(n, k, qhat, b);
+   if (long_gt(n, k + 1, mult, a) == 1) {
+      mult = long_sub(n, k + 1, mult, b);
+      if (long_gt(n, k + 1, mult, a) == 1) {
+         return qhat - 2;
+      } else {
+         return qhat - 1;
+      }
+   } else {
+       return qhat;
+   }
+}
+
+// n bits per register
+// a has k + 1 registers
+// b has k registers
+// assumes leading digit of b is non-zero
+// 0 <= a < b * 2^n
+function short_div(n, k, a, b) {
+    var scale = (1 << n) \ (1 + b[k - 1]);
+    // k + 2 registers now
+    var norm_a[50] = long_scalar_mult(n, k + 1, scale, a);
+    // k + 1 registers now
+    var norm_b[50] = long_scalar_mult(n, k, scale, b);
+    
+    var ret;
+    if (norm_b[k] != 0) {
+	ret = short_div_norm(n, k + 1, norm_a, norm_b);
+    } else {
+	ret = short_div_norm(n, k, norm_a, norm_b);
+    }
+    return ret;
+}
+
+// a = a0 + a1 * X + ... + a[k-1] * X^{k-1} with X = 2^n
+//  a_i can be "negative" assume a_i in (-2^251, 2^251) 
+// output is the value of a with a_i all of the same sign 
+// out[50] = 0 if positive, 1 if negative
+function signed_long_to_short(n, k, a){
+    var out[51];
+    var MAXL = 50;
+    var temp[51];
+
+    // is a positive?
+    for(var i=0; i<k; i++) temp[i] = a[i];
+    for(var i=k; i<=MAXL; i++) temp[i] = 0;
+
+    var X = (1<<n); 
+    for(var i=0; i<MAXL; i++){
+        if(temp[i] >= 0){ // circom automatically takes care of signs in comparator 
+            out[i] = temp[i] % X;
+            temp[i+1] += temp[i] \ X;
+        }else{
+            var borrow = (-temp[i] + X - 1 ) \ X; 
+            out[i] = temp[i] + borrow * X;
+            temp[i+1] -= borrow;
+        }
+    }
+    if(temp[MAXL] >= 0){
+        assert(temp[MAXL]==0); // otherwise not enough registers!
+        out[MAXL] = 0;
+        return out;
+    }
+    
+    // must be negative then, reset
+    for(var i=0; i<k; i++) temp[i] = a[i];
+    for(var i=k; i<=MAXL; i++) temp[i] = 0;
+
+    for(var i=0; i<MAXL; i++){
+        if(temp[i] < 0){
+            var carry = (-temp[i]) \ X; 
+            out[i] = temp[i] + carry * X;
+            temp[i+1] -= carry;
+        }else{
+            var borrow = (temp[i] + X - 1 ) \ X; 
+            out[i] = temp[i] - borrow * X;
+            temp[i+1] += borrow;
+        }
+    }
+    assert( temp[MAXL] == 0 ); 
+    out[MAXL] = 1;
+    return out;
+}
+
+// n bits per register
+// a and b both have k registers
+// out[0] has length 2 * k
+// adapted from BigMulShortLong and LongToShortNoEndCarry witness computation
+function prod(n, k, a, b) {
+    // first compute the intermediate values. taken from BigMulShortLong
+    var prod_val[50]; // length is 2 * k - 1
+    for (var i = 0; i < 2 * k - 1; i++) {
+        prod_val[i] = 0;
+        if (i < k) {
+            for (var a_idx = 0; a_idx <= i; a_idx++) {
+                prod_val[i] = prod_val[i] + a[a_idx] * b[i - a_idx];
+            }
+        } else {
+            for (var a_idx = i - k + 1; a_idx < k; a_idx++) {
+                prod_val[i] = prod_val[i] + a[a_idx] * b[i - a_idx];
+            }
+        }
+    }
+
+    // now do a bunch of carrying to make sure registers not overflowed. taken from LongToShortNoEndCarry
+    var out[50]; // length is 2 * k
+
+    var split[50][3]; // first dimension has length 2 * k - 1
+    for (var i = 0; i < 2 * k - 1; i++) {
+        split[i] = SplitThreeFn(prod_val[i], n, n, n);
+    }
+
+    var carry[50]; // length is 2 * k - 1
+    carry[0] = 0;
+    out[0] = split[0][0];
+    if (2 * k - 1 > 1) {
+        var sumAndCarry[2] = SplitFn(split[0][1] + split[1][0], n, n);
+        out[1] = sumAndCarry[0];
+        carry[1] = sumAndCarry[1];
+    }
+    if (2 * k - 1 > 2) {
+        for (var i = 2; i < 2 * k - 1; i++) {
+            var sumAndCarry[2] = SplitFn(split[i][0] + split[i-1][1] + split[i-2][2] + carry[i-1], n, n);
+            out[i] = sumAndCarry[0];
+            carry[i] = sumAndCarry[1];
+        }
+        out[2 * k - 1] = split[2*k-2][1] + split[2*k-3][2] + carry[2*k-2];
+    }
+    return out;
+}
+
+
+// n bits per register
+// a and b both have l x k registers
+// out has length 2l - 1 x 2k
+// adapted from BigMultShortLong2D and LongToShortNoEndCarry2 witness computation
+function prod2D(n, k, l, a, b) {
+    // first compute the intermediate values. taken from BigMulShortLong
+    var prod_val[20][50]; // length is 2l - 1 by 2k - 1
+    for (var i = 0; i < 2 * k - 1; i++) {
+        for (var j = 0; j < 2 * l - 1; j ++) {
+            prod_val[j][i] = 0;
+        }
+    }
+    for (var i1 = 0; i1 < k; i1 ++) {
+        for (var i2 = 0; i2 < k; i2 ++) {
+            for (var j1 = 0; j1 < l; j1 ++) {
+                for (var j2 = 0; j2 < l; j2 ++) {
+                    prod_val[j1+j2][i1+i2] = prod_val[j1+j2][i1+i2] + a[j1][i1] * b[j2][i2];
+                }
+            }
+        }
+    }
+
+    // now do a bunch of carrying to make sure registers not overflowed. taken from LongToShortNoEndCarry2
+    var out[20][50]; // length is 2 * l by 2 * k
+
+    var split[20][50][3]; // second dimension has length 2 * k - 1
+    for (var j = 0; j < 2 * l - 1; j ++) {
+        for (var i = 0; i < 2 * k - 1; i++) {
+            split[j][i] = SplitThreeFn(prod_val[j][i], n, n, n);
+        }
+    }
+
+    var carry[20][50]; // length is 2l-1 x 2k
+    var sumAndCarry[20][2];
+    for ( var j = 0; j < 2 * l - 1; j ++) {
+        carry[j][0] = 0;
+        out[j][0] = split[j][0][0];
+        if (2 * k - 1 > 1) {
+            sumAndCarry[j] = SplitFn(split[j][0][1] + split[j][1][0], n, n);
+            out[j][1] = sumAndCarry[j][0];
+            carry[j][1] = sumAndCarry[j][1];
+        }
+        if (2 * k - 1 > 2) {
+            for (var i = 2; i < 2 * k - 1; i++) {
+                sumAndCarry[j] = SplitFn(split[j][i][0] + split[j][i-1][1] + split[j][i-2][2] + carry[j][i-1], n, n);
+                out[j][i] = sumAndCarry[j][0];
+                carry[j][i] = sumAndCarry[j][1];
+            }
+            out[j][2 * k - 1] = split[j][2*k-2][1] + split[j][2*k-3][2] + carry[j][2*k-2];
+        }
+    }
+
+    return out;
+}
+
+// Put all modular arithmetic, aka F_p field stuff, at the end
+
+function long_add_mod(n, k, a, b, p) {
+    var sum[50] = long_add(n,k,a,b); 
+    var temp[2][50] = long_div2(n,k,1,sum,p);
+    return temp[1];
+}
+
+function long_sub_mod(n, k, a, b, p) {
+    if(long_gt(n, k, b, a) == 1){
+        return long_add(n, k, a, long_sub(n,k,p,b));
+    }else{
+        return long_sub(n, k, a, b);
+    }
+}
+
+function prod_mod(n, k, a, b, p) {
+    var prod[50] = prod(n,k,a,b);
+    var temp[2][50] = long_div(n,k,prod,p);
+    return temp[1];
+}
+
+
+// n bits per register
+// a has k registers
+// p has k registers
+// e has k registers
+// k * n <= 500
+// p is a prime
+// computes a^e mod p
+function mod_exp(n, k, a, p, e) {
+    var eBits[500]; // length is k * n
+    var bitlength; 
+    for (var i = 0; i < k; i++) {
+        for (var j = 0; j < n; j++) {
+            eBits[j + n * i] = (e[i] >> j) & 1;
+            if(eBits[j + n * i] == 1)
+                bitlength = j + n * i + 1;
+        }
+    }
+
+    var out[50]; // length is k
+    for (var i = 0; i < 50; i++) {
+        out[i] = 0;
+    }
+    out[0] = 1;
+
+    // repeated squaring
+    for (var i = bitlength-1; i >= 0; i--) {
+        // multiply by a if bit is 0
+        if (eBits[i] == 1) {
+            var temp[50]; // length 2 * k
+            temp = prod(n, k, out, a);
+            var temp2[2][50];
+            temp2 = long_div(n, k, temp, p);
+            out = temp2[1];
+        }
+
+        // square, unless we're at the end
+        if (i > 0) {
+            var temp[50]; // length 2 * k
+            temp = prod(n, k, out, out);
+            var temp2[2][50];
+            temp2 = long_div(n, k, temp, p);
+            out = temp2[1];
+        }
+
+    }
+    return out;
+}
+
+// n bits per register
+// a has k registers
+// p has k registers
+// k * n <= 500
+// p is a prime
+// if a == 0 mod p, returns 0
+// else computes inv = a^(p-2) mod p
+function mod_inv(n, k, a, p) {
+    var isZero = 1;
+    for (var i = 0; i < k; i++) {
+        if (a[i] != 0) {
+            isZero = 0;
+        }
+    }
+    if (isZero == 1) {
+        var ret[50];
+        for (var i = 0; i < k; i++) {
+            ret[i] = 0;
+        }
+        return ret;
+    }
+
+    var pCopy[50];
+    for (var i = 0; i < 50; i++) {
+        if (i < k) {
+            pCopy[i] = p[i];
+        } else {
+            pCopy[i] = 0;
+        }
+    }
+
+    var two[50];
+    for (var i = 0; i < 50; i++) {
+        two[i] = 0;
+    }
+    two[0] = 2;
+
+    var pMinusTwo[50];
+    pMinusTwo = long_sub(n, k, pCopy, two); // length k
+    var out[50];
+    out = mod_exp(n, k, a, pCopy, pMinusTwo);
+    return out;
+}
+
diff --git a/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/bls12_381_func.circom b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/bls12_381_func.circom
new file mode 100644
index 0000000..19ed1f7
--- /dev/null
+++ b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/bls12_381_func.circom
@@ -0,0 +1,2933 @@
+pragma circom 2.0.3;
+
+
+function get_BLS12_381_parameter(){
+    return 15132376222941642752;
+}
+
+function get_BLS12_381_prime(n, k){
+    var p[50];
+    assert( (n==96 && k==4) || (n==77 && k==5) || (n==55 && k==7));
+    if( n==96 && k==4 ){
+        p = [54880396502181392957329877675, 31935979117156477062286671870, 20826981314825584179608359615, 8047903782086192180586325942];
+    }
+    if( n==77 && k==5 ){
+        p = [151110683138771015150251, 101672770061349971921567, 5845403419599137187901, 110079541992039310225047, 7675079137884323292337];
+    }
+    if( n==55 && k==7 ){
+        p = [35747322042231467, 36025922209447795, 1084959616957103, 7925923977987733, 16551456537884751, 23443114579904617, 1829881462546425];
+    }
+    return p;
+}
+
+// half of 8th roots of unity, up to negation
+function get_roots_of_unity(n, k){
+    assert( n == 55 && k == 7 );
+    var roots[4][2][50];
+    for(var idx=0; idx<k; idx++){
+        roots[0][0][idx] = 0;
+        roots[0][1][idx] = 0;
+        roots[1][0][idx] = 0;
+        roots[1][1][idx] = 0;
+    }
+    roots[0][0][0] = 1; // roots[0] = 1
+    roots[1][1][0] = 1; // roots[1] = sqrt(-1)
+
+    if( n == 55 && k == 7 ){
+        roots[2][0] = [4649817190157321,
+                    14178090100713872,
+                    25898210532243870,
+                    6361890036890480,
+                    6755281389607612,
+                    401348527762810,
+                    470331148861392];
+        roots[2][1] = [4649817190157321,
+                    14178090100713872,
+                    25898210532243870,
+                    6361890036890480,
+                    6755281389607612,
+                    401348527762810,
+                    470331148861392];
+        roots[3][0] = [4649817190157321,
+                    14178090100713872,
+                    25898210532243870,
+                    6361890036890480,
+                    6755281389607612,
+                    401348527762810,
+                    470331148861392];
+        roots[3][1] = [31097504852074146,
+                    21847832108733923,
+                    11215546103677201,
+                    1564033941097252,
+                    9796175148277139,
+                    23041766052141807,
+                    1359550313685033];
+    }
+    return roots;
+}
+
+function get_etas(n, k){
+    assert( n == 55 && k == 7 );
+    var p[50] = get_BLS12_381_prime(n, k);
+    var etas[4][2][50];
+     
+    if( n == 55 && k == 7 ){
+        etas[0][0] = [15111404105178256,
+                     12179658998385743,
+                     23072200951145993,
+                     9032482684664404,
+                     23305776986956055,
+                     5290624451499435,
+                     464473045539356];
+        etas[0][1] = [12283190417025461,
+                     20834464198811383,
+                     18619727854230373,
+                     19507968258096915,
+                     5803508121078619,
+                     11236708505185735,
+                     568856440213905];
+        etas[2][0] = [25832285470060055,
+                     4957529455978525,
+                     11309477484109628,
+                     34786223745332771,
+                     32011200050324214,
+                     11140434959259260,
+                     752550210394889];
+        etas[2][1] = [17831328741298113,
+                     28196239014888719,
+                     105869995940733,
+                     9669258860454335,
+                     12680438922771573,
+                     19435555960961745,
+                     748772277207452];
+        etas[1][0] = long_sub(n, k, p, etas[0][1]);
+        etas[1][1] = etas[0][0];
+        etas[3][0] = long_sub(n, k, p, etas[2][1]);
+        etas[3][1] = etas[2][0];
+    } 
+    return etas;
+}
+
+// coefficients for the 3-isogeny map from E2' to E2 
+// taken from E.3 of https://cfrg.github.io/draft-irtf-cfrg-hash-to-curve/draft-irtf-cfrg-hash-to-curve.html#appendix-E.3
+function get_iso3_coeffs(n, k){
+    assert( n == 55 && k == 7 );
+    var coeffs[4][4][2][50];
+    if( n == 55 && k == 7 ){
+        coeffs[0][0][0] = [15950248680265686, 32024958503631044, 4244301805875352, 29783714120969249, 35703698803053471, 29228779030399226, 406640325010316];
+        coeffs[0][0][1] = [15950248680265686, 32024958503631044, 4244301805875352, 29783714120969249, 35703698803053471, 29228779030399226, 406640325010316];
+        coeffs[0][1][0] = [0, 0, 0, 0, 0, 0, 0];
+        coeffs[0][1][1] = [11821949021832986, 24017281472965197, 12732905417626058, 17293548324979811, 35053502371232479, 15628743053269744, 1219920975030950];
+        coeffs[0][2][0] = [11821949021832990, 24017281472965197, 12732905417626058, 17293548324979811, 35053502371232479, 15628743053269744, 1219920975030950];
+        coeffs[0][2][1] = [23925373020398477, 12008640736482598, 24380851218295013, 26661172671971889, 17526751185616239, 7814371526634872, 609960487515475];
+        coeffs[0][3][0] = [27772197702098641, 20013442957632273, 16977207223501411, 11048465426985092, 34728404155321983, 8828725064705003, 1626561300041267];
+        coeffs[0][3][1] = [0, 0, 0, 0, 0, 0, 0];
+        coeffs[1][0][0] = [0, 0, 0, 0, 0, 0, 0];
+        coeffs[1][0][1] = [35747322042231395, 36025922209447795, 1084959616957103, 7925923977987733, 16551456537884751, 23443114579904617, 1829881462546425];
+        coeffs[1][1][0] = [12, 0, 0, 0, 0, 0, 0];
+        coeffs[1][1][1] = [35747322042231455, 36025922209447795, 1084959616957103, 7925923977987733, 16551456537884751, 23443114579904617, 1829881462546425];
+        coeffs[1][2][0] = [1, 0, 0, 0, 0, 0, 0];
+        coeffs[1][2][1] = [0, 0, 0, 0, 0, 0, 0];
+        coeffs[1][3][0] = [0, 0, 0, 0, 0, 0, 0];
+        coeffs[1][3][1] = [0, 0, 0, 0, 0, 0, 0];
+        coeffs[2][0][0] = [22455448142010118, 21348055796076581, 27572038961197616, 1120560719995342, 22827171220970826, 11095397727559917, 1491014525037828];
+        coeffs[2][0][1] = [22455448142010118, 21348055796076581, 27572038961197616, 1120560719995342, 22827171220970826, 11095397727559917, 1491014525037828];
+        coeffs[2][1][0] = [0, 0, 0, 0, 0, 0, 0];
+        coeffs[2][1][1] = [15950248680265662, 32024958503631044, 4244301805875352, 29783714120969249, 35703698803053471, 29228779030399226, 406640325010316];
+        coeffs[2][2][0] = [11821949021832988, 24017281472965197, 12732905417626058, 17293548324979811, 35053502371232479, 15628743053269744, 1219920975030950];
+        coeffs[2][2][1] = [23925373020398479, 12008640736482598, 24380851218295013, 26661172671971889, 17526751185616239, 7814371526634872, 609960487515475];
+        coeffs[2][3][0] = [14480323801877264, 5335576544261059, 7435489548777956, 4243102168992702, 4975321819444090, 32509805231324272, 1287694362532669];
+        coeffs[2][3][1] = [0, 0, 0, 0, 0, 0, 0];
+        coeffs[3][0][0] = [35747322042231035, 36025922209447795, 1084959616957103, 7925923977987733, 16551456537884751, 23443114579904617, 1829881462546425];
+        coeffs[3][0][1] = [35747322042231035, 36025922209447795, 1084959616957103, 7925923977987733, 16551456537884751, 23443114579904617, 1829881462546425];
+        coeffs[3][1][0] = [0, 0, 0, 0, 0, 0, 0];
+        coeffs[3][1][1] = [35747322042231251, 36025922209447795, 1084959616957103, 7925923977987733, 16551456537884751, 23443114579904617, 1829881462546425];
+        coeffs[3][2][0] = [18, 0, 0, 0, 0, 0, 0];
+        coeffs[3][2][1] = [35747322042231449, 36025922209447795, 1084959616957103, 7925923977987733, 16551456537884751, 23443114579904617, 1829881462546425];
+        coeffs[3][3][0] = [1, 0, 0, 0, 0, 0, 0];
+        coeffs[3][3][1] = [0, 0, 0, 0, 0, 0, 0];
+    }
+    return coeffs;
+}
+
+function get_generator_G1(n, k){
+    assert( n == 55 && k == 7 );
+    var g1[2][50];
+
+    g1[0] = [16589478066046651,
+             22658679592837110,
+             35004527604248919,
+             16789302793630161,
+             7530538873701625,
+             32234187716135413,
+             1684953952445941];
+    g1[1] = [11860609209853921,
+             4091579406338073,
+             12578493816062195,
+             13088963032438982,
+             24961455755233629,
+             8501508834176643,
+             612415636564648];
+    
+    return g1;
+}
+
+function get_generator_G2(n, k){
+    assert( n == 55 && k == 7 );
+    var g2[2][2][50];
+
+    g2[0][0] = [95420233661880, 1773856045391785, 5044075188989616, 23082975677810779, 22805092780977487, 23121359448368568, 161253150172098];
+    g2[0][1] = [12522360964131710, 27624298323292107, 31369054948478259, 20553930357265165, 32921944760061193, 30416570139545860, 1398625365433447];
+    g2[1][0] = [5440959206139905, 5515662923731907, 10491004233861355, 28691331721860307, 27955817036233384, 18631882631076677, 907600843284315];
+    g2[1][1] = [11548582681213374, 7404909498155861, 12768329608264924, 12731371725497493, 11463081752430568, 7184576637437304, 424072857758157];
+    
+    return g2;    
+}
+
+function get_Fp12_frobenius(n, k){
+    assert( (n==96 && k==4) || (n==77 && k==5) || (n==55 && k==7) );
+    var coeff[12][6][2][20]; // 
+    // coeff[j][i] represents an element in F_q^2
+    // F_q^12 = F_q^2[w] / (w^6 - (u+1)) 
+    // Apply Frobenius j times to w^i: (w^i)^(q^j) = coeff[j][i] * w^i 
+    if( n==96 && k==4 ){
+        coeff[0][0][0][0] = 1;
+        coeff[0][0][0][1] = 0;
+        coeff[0][0][0][2] = 0;
+        coeff[0][0][0][3] = 0;
+
+        coeff[0][0][1][0] = 0;
+        coeff[0][0][1][1] = 0;
+        coeff[0][0][1][2] = 0;
+        coeff[0][0][1][3] = 0;
+
+        coeff[0][1][0][0] = 1;
+        coeff[0][1][0][1] = 0;
+        coeff[0][1][0][2] = 0;
+        coeff[0][1][0][3] = 0;
+
+        coeff[0][1][1][0] = 0;
+        coeff[0][1][1][1] = 0;
+        coeff[0][1][1][2] = 0;
+        coeff[0][1][1][3] = 0;
+
+        coeff[0][2][0][0] = 1;
+        coeff[0][2][0][1] = 0;
+        coeff[0][2][0][2] = 0;
+        coeff[0][2][0][3] = 0;
+
+        coeff[0][2][1][0] = 0;
+        coeff[0][2][1][1] = 0;
+        coeff[0][2][1][2] = 0;
+        coeff[0][2][1][3] = 0;
+
+        coeff[0][3][0][0] = 1;
+        coeff[0][3][0][1] = 0;
+        coeff[0][3][0][2] = 0;
+        coeff[0][3][0][3] = 0;
+
+        coeff[0][3][1][0] = 0;
+        coeff[0][3][1][1] = 0;
+        coeff[0][3][1][2] = 0;
+        coeff[0][3][1][3] = 0;
+
+        coeff[0][4][0][0] = 1;
+        coeff[0][4][0][1] = 0;
+        coeff[0][4][0][2] = 0;
+        coeff[0][4][0][3] = 0;
+
+        coeff[0][4][1][0] = 0;
+        coeff[0][4][1][1] = 0;
+        coeff[0][4][1][2] = 0;
+        coeff[0][4][1][3] = 0;
+
+        coeff[0][5][0][0] = 1;
+        coeff[0][5][0][1] = 0;
+        coeff[0][5][0][2] = 0;
+        coeff[0][5][0][3] = 0;
+
+        coeff[0][5][1][0] = 0;
+        coeff[0][5][1][1] = 0;
+        coeff[0][5][1][2] = 0;
+        coeff[0][5][1][3] = 0;
+
+        coeff[1][0][0][0] = 1;
+        coeff[1][0][0][1] = 0;
+        coeff[1][0][0][2] = 0;
+        coeff[1][0][0][3] = 0;
+
+        coeff[1][0][1][0] = 0;
+        coeff[1][0][1][1] = 0;
+        coeff[1][0][1][2] = 0;
+        coeff[1][0][1][3] = 0;
+
+        coeff[1][1][0][0] = 30918888157334040571029970872;
+        coeff[1][1][0][1] = 38110497911700059231495300413;
+        coeff[1][1][0][2] = 9956775014100533415029595983;
+        coeff[1][1][0][3] = 7742960891664846859912986292;
+
+        coeff[1][1][1][0] = 23961508344847352386299906803;
+        coeff[1][1][1][1] = 73053643719720755424335321793;
+        coeff[1][1][1][2] = 10870206300725050764578763631;
+        coeff[1][1][1][3] = 304942890421345320673339650;
+
+        coeff[1][2][0][0] = 0;
+        coeff[1][2][0][1] = 0;
+        coeff[1][2][0][2] = 0;
+        coeff[1][2][0][3] = 0;
+
+        coeff[1][2][1][0] = 24538776241284729507437128364;
+        coeff[1][2][1][1] = 42550757554255812588943452139;
+        coeff[1][2][1][2] = 30896359077101218988767419092;
+        coeff[1][2][1][3] = 8047903782086192178990825606;
+
+        coeff[1][3][0][0] = 35566625740316527277988105225;
+        coeff[1][3][0][1] = 37127840730814273605658450223;
+        coeff[1][3][0][2] = 33368165978403992854926148446;
+        coeff[1][3][0][3] = 2068538268313381196677636973;
+
+        coeff[1][3][1][0] = 35566625740316527277988105225;
+        coeff[1][3][1][1] = 37127840730814273605658450223;
+        coeff[1][3][1][2] = 33368165978403992854926148446;
+        coeff[1][3][1][3] = 2068538268313381196677636973;
+
+        coeff[1][4][0][0] = 24538776241284729507437128365;
+        coeff[1][4][0][1] = 42550757554255812588943452139;
+        coeff[1][4][0][2] = 30896359077101218988767419092;
+        coeff[1][4][0][3] = 8047903782086192178990825606;
+
+        coeff[1][4][1][0] = 0;
+        coeff[1][4][1][1] = 0;
+        coeff[1][4][1][2] = 0;
+        coeff[1][4][1][3] = 0;
+
+        coeff[1][5][0][0] = 11605117395469174891688198422;
+        coeff[1][5][0][1] = 43302359525357855774867078766;
+        coeff[1][5][0][2] = 22497959677678942090347384814;
+        coeff[1][5][0][3] = 1763595377892035876004297323;
+
+        coeff[1][5][1][0] = 43275279106712218065641679253;
+        coeff[1][5][1][1] = 67861782106062958880963543440;
+        coeff[1][5][1][2] = 77557184151410979682804925136;
+        coeff[1][5][1][3] = 6284308404194156304582028618;
+
+        coeff[2][0][0][0] = 1;
+        coeff[2][0][0][1] = 0;
+        coeff[2][0][0][2] = 0;
+        coeff[2][0][0][3] = 0;
+
+        coeff[2][0][1][0] = 0;
+        coeff[2][0][1][1] = 0;
+        coeff[2][0][1][2] = 0;
+        coeff[2][0][1][3] = 0;
+
+        coeff[2][1][0][0] = 30341620260896663449892749311;
+        coeff[2][1][0][1] = 68613384077165002066887170067;
+        coeff[2][1][0][2] = 69158784751988702784384890858;
+        coeff[2][1][0][3] = 1595500335;
+
+        coeff[2][1][1][0] = 0;
+        coeff[2][1][1][1] = 0;
+        coeff[2][1][1][2] = 0;
+        coeff[2][1][1][3] = 0;
+
+        coeff[2][2][0][0] = 30341620260896663449892749310;
+        coeff[2][2][0][1] = 68613384077165002066887170067;
+        coeff[2][2][0][2] = 69158784751988702784384890858;
+        coeff[2][2][0][3] = 1595500335;
+
+        coeff[2][2][1][0] = 0;
+        coeff[2][2][1][1] = 0;
+        coeff[2][2][1][2] = 0;
+        coeff[2][2][1][3] = 0;
+
+        coeff[2][3][0][0] = 54880396502181392957329877674;
+        coeff[2][3][0][1] = 31935979117156477062286671870;
+        coeff[2][3][0][2] = 20826981314825584179608359615;
+        coeff[2][3][0][3] = 8047903782086192180586325942;
+
+        coeff[2][3][1][0] = 0;
+        coeff[2][3][1][1] = 0;
+        coeff[2][3][1][2] = 0;
+        coeff[2][3][1][3] = 0;
+
+        coeff[2][4][0][0] = 24538776241284729507437128364;
+        coeff[2][4][0][1] = 42550757554255812588943452139;
+        coeff[2][4][0][2] = 30896359077101218988767419092;
+        coeff[2][4][0][3] = 8047903782086192178990825606;
+
+        coeff[2][4][1][0] = 0;
+        coeff[2][4][1][1] = 0;
+        coeff[2][4][1][2] = 0;
+        coeff[2][4][1][3] = 0;
+
+        coeff[2][5][0][0] = 24538776241284729507437128365;
+        coeff[2][5][0][1] = 42550757554255812588943452139;
+        coeff[2][5][0][2] = 30896359077101218988767419092;
+        coeff[2][5][0][3] = 8047903782086192178990825606;
+
+        coeff[2][5][1][0] = 0;
+        coeff[2][5][1][1] = 0;
+        coeff[2][5][1][2] = 0;
+        coeff[2][5][1][3] = 0;
+
+        coeff[3][0][0][0] = 1;
+        coeff[3][0][0][1] = 0;
+        coeff[3][0][0][2] = 0;
+        coeff[3][0][0][3] = 0;
+
+        coeff[3][0][1][0] = 0;
+        coeff[3][0][1][1] = 0;
+        coeff[3][0][1][2] = 0;
+        coeff[3][0][1][3] = 0;
+
+        coeff[3][1][0][0] = 19313770761864865679341772450;
+        coeff[3][1][0][1] = 74036300900606541050172171983;
+        coeff[3][1][0][2] = 66686977850685928918226161504;
+        coeff[3][1][0][3] = 5979365513772810983908688968;
+
+        coeff[3][1][1][0] = 35566625740316527277988105225;
+        coeff[3][1][1][1] = 37127840730814273605658450223;
+        coeff[3][1][1][2] = 33368165978403992854926148446;
+        coeff[3][1][1][3] = 2068538268313381196677636973;
+
+        coeff[3][2][0][0] = 0;
+        coeff[3][2][0][1] = 0;
+        coeff[3][2][0][2] = 0;
+        coeff[3][2][0][3] = 0;
+
+        coeff[3][2][1][0] = 1;
+        coeff[3][2][1][1] = 0;
+        coeff[3][2][1][2] = 0;
+        coeff[3][2][1][3] = 0;
+
+        coeff[3][3][0][0] = 19313770761864865679341772450;
+        coeff[3][3][0][1] = 74036300900606541050172171983;
+        coeff[3][3][0][2] = 66686977850685928918226161504;
+        coeff[3][3][0][3] = 5979365513772810983908688968;
+
+        coeff[3][3][1][0] = 19313770761864865679341772450;
+        coeff[3][3][1][1] = 74036300900606541050172171983;
+        coeff[3][3][1][2] = 66686977850685928918226161504;
+        coeff[3][3][1][3] = 5979365513772810983908688968;
+
+        coeff[3][4][0][0] = 54880396502181392957329877674;
+        coeff[3][4][0][1] = 31935979117156477062286671870;
+        coeff[3][4][0][2] = 20826981314825584179608359615;
+        coeff[3][4][0][3] = 8047903782086192180586325942;
+
+        coeff[3][4][1][0] = 0;
+        coeff[3][4][1][1] = 0;
+        coeff[3][4][1][2] = 0;
+        coeff[3][4][1][3] = 0;
+
+        coeff[3][5][0][0] = 35566625740316527277988105225;
+        coeff[3][5][0][1] = 37127840730814273605658450223;
+        coeff[3][5][0][2] = 33368165978403992854926148446;
+        coeff[3][5][0][3] = 2068538268313381196677636973;
+
+        coeff[3][5][1][0] = 19313770761864865679341772450;
+        coeff[3][5][1][1] = 74036300900606541050172171983;
+        coeff[3][5][1][2] = 66686977850685928918226161504;
+        coeff[3][5][1][3] = 5979365513772810983908688968;
+
+        coeff[4][0][0][0] = 1;
+        coeff[4][0][0][1] = 0;
+        coeff[4][0][0][2] = 0;
+        coeff[4][0][0][3] = 0;
+
+        coeff[4][0][1][0] = 0;
+        coeff[4][0][1][1] = 0;
+        coeff[4][0][1][2] = 0;
+        coeff[4][0][1][3] = 0;
+
+        coeff[4][1][0][0] = 30341620260896663449892749310;
+        coeff[4][1][0][1] = 68613384077165002066887170067;
+        coeff[4][1][0][2] = 69158784751988702784384890858;
+        coeff[4][1][0][3] = 1595500335;
+
+        coeff[4][1][1][0] = 0;
+        coeff[4][1][1][1] = 0;
+        coeff[4][1][1][2] = 0;
+        coeff[4][1][1][3] = 0;
+
+        coeff[4][2][0][0] = 24538776241284729507437128364;
+        coeff[4][2][0][1] = 42550757554255812588943452139;
+        coeff[4][2][0][2] = 30896359077101218988767419092;
+        coeff[4][2][0][3] = 8047903782086192178990825606;
+
+        coeff[4][2][1][0] = 0;
+        coeff[4][2][1][1] = 0;
+        coeff[4][2][1][2] = 0;
+        coeff[4][2][1][3] = 0;
+
+        coeff[4][3][0][0] = 1;
+        coeff[4][3][0][1] = 0;
+        coeff[4][3][0][2] = 0;
+        coeff[4][3][0][3] = 0;
+
+        coeff[4][3][1][0] = 0;
+        coeff[4][3][1][1] = 0;
+        coeff[4][3][1][2] = 0;
+        coeff[4][3][1][3] = 0;
+
+        coeff[4][4][0][0] = 30341620260896663449892749310;
+        coeff[4][4][0][1] = 68613384077165002066887170067;
+        coeff[4][4][0][2] = 69158784751988702784384890858;
+        coeff[4][4][0][3] = 1595500335;
+
+        coeff[4][4][1][0] = 0;
+        coeff[4][4][1][1] = 0;
+        coeff[4][4][1][2] = 0;
+        coeff[4][4][1][3] = 0;
+
+        coeff[4][5][0][0] = 24538776241284729507437128364;
+        coeff[4][5][0][1] = 42550757554255812588943452139;
+        coeff[4][5][0][2] = 30896359077101218988767419092;
+        coeff[4][5][0][3] = 8047903782086192178990825606;
+
+        coeff[4][5][1][0] = 0;
+        coeff[4][5][1][1] = 0;
+        coeff[4][5][1][2] = 0;
+        coeff[4][5][1][3] = 0;
+
+        coeff[5][0][0][0] = 1;
+        coeff[5][0][0][1] = 0;
+        coeff[5][0][0][2] = 0;
+        coeff[5][0][0][3] = 0;
+
+        coeff[5][0][1][0] = 0;
+        coeff[5][0][1][1] = 0;
+        coeff[5][0][1][2] = 0;
+        coeff[5][0][1][3] = 0;
+
+        coeff[5][1][0][0] = 43275279106712218065641679253;
+        coeff[5][1][0][1] = 67861782106062958880963543440;
+        coeff[5][1][0][2] = 77557184151410979682804925136;
+        coeff[5][1][0][3] = 6284308404194156304582028618;
+
+        coeff[5][1][1][0] = 11605117395469174891688198422;
+        coeff[5][1][1][1] = 43302359525357855774867078766;
+        coeff[5][1][1][2] = 22497959677678942090347384814;
+        coeff[5][1][1][3] = 1763595377892035876004297323;
+
+        coeff[5][2][0][0] = 0;
+        coeff[5][2][0][1] = 0;
+        coeff[5][2][0][2] = 0;
+        coeff[5][2][0][3] = 0;
+
+        coeff[5][2][1][0] = 30341620260896663449892749310;
+        coeff[5][2][1][1] = 68613384077165002066887170067;
+        coeff[5][2][1][2] = 69158784751988702784384890858;
+        coeff[5][2][1][3] = 1595500335;
+
+        coeff[5][3][0][0] = 35566625740316527277988105225;
+        coeff[5][3][0][1] = 37127840730814273605658450223;
+        coeff[5][3][0][2] = 33368165978403992854926148446;
+        coeff[5][3][0][3] = 2068538268313381196677636973;
+
+        coeff[5][3][1][0] = 35566625740316527277988105225;
+        coeff[5][3][1][1] = 37127840730814273605658450223;
+        coeff[5][3][1][2] = 33368165978403992854926148446;
+        coeff[5][3][1][3] = 2068538268313381196677636973;
+
+        coeff[5][4][0][0] = 30341620260896663449892749311;
+        coeff[5][4][0][1] = 68613384077165002066887170067;
+        coeff[5][4][0][2] = 69158784751988702784384890858;
+        coeff[5][4][0][3] = 1595500335;
+
+        coeff[5][4][1][0] = 0;
+        coeff[5][4][1][1] = 0;
+        coeff[5][4][1][2] = 0;
+        coeff[5][4][1][3] = 0;
+
+        coeff[5][5][0][0] = 23961508344847352386299906803;
+        coeff[5][5][0][1] = 73053643719720755424335321793;
+        coeff[5][5][0][2] = 10870206300725050764578763631;
+        coeff[5][5][0][3] = 304942890421345320673339650;
+
+        coeff[5][5][1][0] = 30918888157334040571029970872;
+        coeff[5][5][1][1] = 38110497911700059231495300413;
+        coeff[5][5][1][2] = 9956775014100533415029595983;
+        coeff[5][5][1][3] = 7742960891664846859912986292;
+
+        coeff[6][0][0][0] = 1;
+        coeff[6][0][0][1] = 0;
+        coeff[6][0][0][2] = 0;
+        coeff[6][0][0][3] = 0;
+
+        coeff[6][0][1][0] = 0;
+        coeff[6][0][1][1] = 0;
+        coeff[6][0][1][2] = 0;
+        coeff[6][0][1][3] = 0;
+
+        coeff[6][1][0][0] = 54880396502181392957329877674;
+        coeff[6][1][0][1] = 31935979117156477062286671870;
+        coeff[6][1][0][2] = 20826981314825584179608359615;
+        coeff[6][1][0][3] = 8047903782086192180586325942;
+
+        coeff[6][1][1][0] = 0;
+        coeff[6][1][1][1] = 0;
+        coeff[6][1][1][2] = 0;
+        coeff[6][1][1][3] = 0;
+
+        coeff[6][2][0][0] = 1;
+        coeff[6][2][0][1] = 0;
+        coeff[6][2][0][2] = 0;
+        coeff[6][2][0][3] = 0;
+
+        coeff[6][2][1][0] = 0;
+        coeff[6][2][1][1] = 0;
+        coeff[6][2][1][2] = 0;
+        coeff[6][2][1][3] = 0;
+
+        coeff[6][3][0][0] = 54880396502181392957329877674;
+        coeff[6][3][0][1] = 31935979117156477062286671870;
+        coeff[6][3][0][2] = 20826981314825584179608359615;
+        coeff[6][3][0][3] = 8047903782086192180586325942;
+
+        coeff[6][3][1][0] = 0;
+        coeff[6][3][1][1] = 0;
+        coeff[6][3][1][2] = 0;
+        coeff[6][3][1][3] = 0;
+
+        coeff[6][4][0][0] = 1;
+        coeff[6][4][0][1] = 0;
+        coeff[6][4][0][2] = 0;
+        coeff[6][4][0][3] = 0;
+
+        coeff[6][4][1][0] = 0;
+        coeff[6][4][1][1] = 0;
+        coeff[6][4][1][2] = 0;
+        coeff[6][4][1][3] = 0;
+
+        coeff[6][5][0][0] = 54880396502181392957329877674;
+        coeff[6][5][0][1] = 31935979117156477062286671870;
+        coeff[6][5][0][2] = 20826981314825584179608359615;
+        coeff[6][5][0][3] = 8047903782086192180586325942;
+
+        coeff[6][5][1][0] = 0;
+        coeff[6][5][1][1] = 0;
+        coeff[6][5][1][2] = 0;
+        coeff[6][5][1][3] = 0;
+
+        coeff[7][0][0][0] = 1;
+        coeff[7][0][0][1] = 0;
+        coeff[7][0][0][2] = 0;
+        coeff[7][0][0][3] = 0;
+
+        coeff[7][0][1][0] = 0;
+        coeff[7][0][1][1] = 0;
+        coeff[7][0][1][2] = 0;
+        coeff[7][0][1][3] = 0;
+
+        coeff[7][1][0][0] = 23961508344847352386299906803;
+        coeff[7][1][0][1] = 73053643719720755424335321793;
+        coeff[7][1][0][2] = 10870206300725050764578763631;
+        coeff[7][1][0][3] = 304942890421345320673339650;
+
+        coeff[7][1][1][0] = 30918888157334040571029970872;
+        coeff[7][1][1][1] = 38110497911700059231495300413;
+        coeff[7][1][1][2] = 9956775014100533415029595983;
+        coeff[7][1][1][3] = 7742960891664846859912986292;
+
+        coeff[7][2][0][0] = 0;
+        coeff[7][2][0][1] = 0;
+        coeff[7][2][0][2] = 0;
+        coeff[7][2][0][3] = 0;
+
+        coeff[7][2][1][0] = 24538776241284729507437128364;
+        coeff[7][2][1][1] = 42550757554255812588943452139;
+        coeff[7][2][1][2] = 30896359077101218988767419092;
+        coeff[7][2][1][3] = 8047903782086192178990825606;
+
+        coeff[7][3][0][0] = 19313770761864865679341772450;
+        coeff[7][3][0][1] = 74036300900606541050172171983;
+        coeff[7][3][0][2] = 66686977850685928918226161504;
+        coeff[7][3][0][3] = 5979365513772810983908688968;
+
+        coeff[7][3][1][0] = 19313770761864865679341772450;
+        coeff[7][3][1][1] = 74036300900606541050172171983;
+        coeff[7][3][1][2] = 66686977850685928918226161504;
+        coeff[7][3][1][3] = 5979365513772810983908688968;
+
+        coeff[7][4][0][0] = 24538776241284729507437128365;
+        coeff[7][4][0][1] = 42550757554255812588943452139;
+        coeff[7][4][0][2] = 30896359077101218988767419092;
+        coeff[7][4][0][3] = 8047903782086192178990825606;
+
+        coeff[7][4][1][0] = 0;
+        coeff[7][4][1][1] = 0;
+        coeff[7][4][1][2] = 0;
+        coeff[7][4][1][3] = 0;
+
+        coeff[7][5][0][0] = 43275279106712218065641679253;
+        coeff[7][5][0][1] = 67861782106062958880963543440;
+        coeff[7][5][0][2] = 77557184151410979682804925136;
+        coeff[7][5][0][3] = 6284308404194156304582028618;
+
+        coeff[7][5][1][0] = 11605117395469174891688198422;
+        coeff[7][5][1][1] = 43302359525357855774867078766;
+        coeff[7][5][1][2] = 22497959677678942090347384814;
+        coeff[7][5][1][3] = 1763595377892035876004297323;
+
+        coeff[8][0][0][0] = 1;
+        coeff[8][0][0][1] = 0;
+        coeff[8][0][0][2] = 0;
+        coeff[8][0][0][3] = 0;
+
+        coeff[8][0][1][0] = 0;
+        coeff[8][0][1][1] = 0;
+        coeff[8][0][1][2] = 0;
+        coeff[8][0][1][3] = 0;
+
+        coeff[8][1][0][0] = 24538776241284729507437128364;
+        coeff[8][1][0][1] = 42550757554255812588943452139;
+        coeff[8][1][0][2] = 30896359077101218988767419092;
+        coeff[8][1][0][3] = 8047903782086192178990825606;
+
+        coeff[8][1][1][0] = 0;
+        coeff[8][1][1][1] = 0;
+        coeff[8][1][1][2] = 0;
+        coeff[8][1][1][3] = 0;
+
+        coeff[8][2][0][0] = 30341620260896663449892749310;
+        coeff[8][2][0][1] = 68613384077165002066887170067;
+        coeff[8][2][0][2] = 69158784751988702784384890858;
+        coeff[8][2][0][3] = 1595500335;
+
+        coeff[8][2][1][0] = 0;
+        coeff[8][2][1][1] = 0;
+        coeff[8][2][1][2] = 0;
+        coeff[8][2][1][3] = 0;
+
+        coeff[8][3][0][0] = 1;
+        coeff[8][3][0][1] = 0;
+        coeff[8][3][0][2] = 0;
+        coeff[8][3][0][3] = 0;
+
+        coeff[8][3][1][0] = 0;
+        coeff[8][3][1][1] = 0;
+        coeff[8][3][1][2] = 0;
+        coeff[8][3][1][3] = 0;
+
+        coeff[8][4][0][0] = 24538776241284729507437128364;
+        coeff[8][4][0][1] = 42550757554255812588943452139;
+        coeff[8][4][0][2] = 30896359077101218988767419092;
+        coeff[8][4][0][3] = 8047903782086192178990825606;
+
+        coeff[8][4][1][0] = 0;
+        coeff[8][4][1][1] = 0;
+        coeff[8][4][1][2] = 0;
+        coeff[8][4][1][3] = 0;
+
+        coeff[8][5][0][0] = 30341620260896663449892749310;
+        coeff[8][5][0][1] = 68613384077165002066887170067;
+        coeff[8][5][0][2] = 69158784751988702784384890858;
+        coeff[8][5][0][3] = 1595500335;
+
+        coeff[8][5][1][0] = 0;
+        coeff[8][5][1][1] = 0;
+        coeff[8][5][1][2] = 0;
+        coeff[8][5][1][3] = 0;
+
+        coeff[9][0][0][0] = 1;
+        coeff[9][0][0][1] = 0;
+        coeff[9][0][0][2] = 0;
+        coeff[9][0][0][3] = 0;
+
+        coeff[9][0][1][0] = 0;
+        coeff[9][0][1][1] = 0;
+        coeff[9][0][1][2] = 0;
+        coeff[9][0][1][3] = 0;
+
+        coeff[9][1][0][0] = 35566625740316527277988105225;
+        coeff[9][1][0][1] = 37127840730814273605658450223;
+        coeff[9][1][0][2] = 33368165978403992854926148446;
+        coeff[9][1][0][3] = 2068538268313381196677636973;
+
+        coeff[9][1][1][0] = 19313770761864865679341772450;
+        coeff[9][1][1][1] = 74036300900606541050172171983;
+        coeff[9][1][1][2] = 66686977850685928918226161504;
+        coeff[9][1][1][3] = 5979365513772810983908688968;
+
+        coeff[9][2][0][0] = 0;
+        coeff[9][2][0][1] = 0;
+        coeff[9][2][0][2] = 0;
+        coeff[9][2][0][3] = 0;
+
+        coeff[9][2][1][0] = 1;
+        coeff[9][2][1][1] = 0;
+        coeff[9][2][1][2] = 0;
+        coeff[9][2][1][3] = 0;
+
+        coeff[9][3][0][0] = 35566625740316527277988105225;
+        coeff[9][3][0][1] = 37127840730814273605658450223;
+        coeff[9][3][0][2] = 33368165978403992854926148446;
+        coeff[9][3][0][3] = 2068538268313381196677636973;
+
+        coeff[9][3][1][0] = 35566625740316527277988105225;
+        coeff[9][3][1][1] = 37127840730814273605658450223;
+        coeff[9][3][1][2] = 33368165978403992854926148446;
+        coeff[9][3][1][3] = 2068538268313381196677636973;
+
+        coeff[9][4][0][0] = 54880396502181392957329877674;
+        coeff[9][4][0][1] = 31935979117156477062286671870;
+        coeff[9][4][0][2] = 20826981314825584179608359615;
+        coeff[9][4][0][3] = 8047903782086192180586325942;
+
+        coeff[9][4][1][0] = 0;
+        coeff[9][4][1][1] = 0;
+        coeff[9][4][1][2] = 0;
+        coeff[9][4][1][3] = 0;
+
+        coeff[9][5][0][0] = 19313770761864865679341772450;
+        coeff[9][5][0][1] = 74036300900606541050172171983;
+        coeff[9][5][0][2] = 66686977850685928918226161504;
+        coeff[9][5][0][3] = 5979365513772810983908688968;
+
+        coeff[9][5][1][0] = 35566625740316527277988105225;
+        coeff[9][5][1][1] = 37127840730814273605658450223;
+        coeff[9][5][1][2] = 33368165978403992854926148446;
+        coeff[9][5][1][3] = 2068538268313381196677636973;
+
+        coeff[10][0][0][0] = 1;
+        coeff[10][0][0][1] = 0;
+        coeff[10][0][0][2] = 0;
+        coeff[10][0][0][3] = 0;
+
+        coeff[10][0][1][0] = 0;
+        coeff[10][0][1][1] = 0;
+        coeff[10][0][1][2] = 0;
+        coeff[10][0][1][3] = 0;
+
+        coeff[10][1][0][0] = 24538776241284729507437128365;
+        coeff[10][1][0][1] = 42550757554255812588943452139;
+        coeff[10][1][0][2] = 30896359077101218988767419092;
+        coeff[10][1][0][3] = 8047903782086192178990825606;
+
+        coeff[10][1][1][0] = 0;
+        coeff[10][1][1][1] = 0;
+        coeff[10][1][1][2] = 0;
+        coeff[10][1][1][3] = 0;
+
+        coeff[10][2][0][0] = 24538776241284729507437128364;
+        coeff[10][2][0][1] = 42550757554255812588943452139;
+        coeff[10][2][0][2] = 30896359077101218988767419092;
+        coeff[10][2][0][3] = 8047903782086192178990825606;
+
+        coeff[10][2][1][0] = 0;
+        coeff[10][2][1][1] = 0;
+        coeff[10][2][1][2] = 0;
+        coeff[10][2][1][3] = 0;
+
+        coeff[10][3][0][0] = 54880396502181392957329877674;
+        coeff[10][3][0][1] = 31935979117156477062286671870;
+        coeff[10][3][0][2] = 20826981314825584179608359615;
+        coeff[10][3][0][3] = 8047903782086192180586325942;
+
+        coeff[10][3][1][0] = 0;
+        coeff[10][3][1][1] = 0;
+        coeff[10][3][1][2] = 0;
+        coeff[10][3][1][3] = 0;
+
+        coeff[10][4][0][0] = 30341620260896663449892749310;
+        coeff[10][4][0][1] = 68613384077165002066887170067;
+        coeff[10][4][0][2] = 69158784751988702784384890858;
+        coeff[10][4][0][3] = 1595500335;
+
+        coeff[10][4][1][0] = 0;
+        coeff[10][4][1][1] = 0;
+        coeff[10][4][1][2] = 0;
+        coeff[10][4][1][3] = 0;
+
+        coeff[10][5][0][0] = 30341620260896663449892749311;
+        coeff[10][5][0][1] = 68613384077165002066887170067;
+        coeff[10][5][0][2] = 69158784751988702784384890858;
+        coeff[10][5][0][3] = 1595500335;
+
+        coeff[10][5][1][0] = 0;
+        coeff[10][5][1][1] = 0;
+        coeff[10][5][1][2] = 0;
+        coeff[10][5][1][3] = 0;
+
+        coeff[11][0][0][0] = 1;
+        coeff[11][0][0][1] = 0;
+        coeff[11][0][0][2] = 0;
+        coeff[11][0][0][3] = 0;
+
+        coeff[11][0][1][0] = 0;
+        coeff[11][0][1][1] = 0;
+        coeff[11][0][1][2] = 0;
+        coeff[11][0][1][3] = 0;
+
+        coeff[11][1][0][0] = 11605117395469174891688198422;
+        coeff[11][1][0][1] = 43302359525357855774867078766;
+        coeff[11][1][0][2] = 22497959677678942090347384814;
+        coeff[11][1][0][3] = 1763595377892035876004297323;
+
+        coeff[11][1][1][0] = 43275279106712218065641679253;
+        coeff[11][1][1][1] = 67861782106062958880963543440;
+        coeff[11][1][1][2] = 77557184151410979682804925136;
+        coeff[11][1][1][3] = 6284308404194156304582028618;
+
+        coeff[11][2][0][0] = 0;
+        coeff[11][2][0][1] = 0;
+        coeff[11][2][0][2] = 0;
+        coeff[11][2][0][3] = 0;
+
+        coeff[11][2][1][0] = 30341620260896663449892749310;
+        coeff[11][2][1][1] = 68613384077165002066887170067;
+        coeff[11][2][1][2] = 69158784751988702784384890858;
+        coeff[11][2][1][3] = 1595500335;
+
+        coeff[11][3][0][0] = 19313770761864865679341772450;
+        coeff[11][3][0][1] = 74036300900606541050172171983;
+        coeff[11][3][0][2] = 66686977850685928918226161504;
+        coeff[11][3][0][3] = 5979365513772810983908688968;
+
+        coeff[11][3][1][0] = 19313770761864865679341772450;
+        coeff[11][3][1][1] = 74036300900606541050172171983;
+        coeff[11][3][1][2] = 66686977850685928918226161504;
+        coeff[11][3][1][3] = 5979365513772810983908688968;
+
+        coeff[11][4][0][0] = 30341620260896663449892749311;
+        coeff[11][4][0][1] = 68613384077165002066887170067;
+        coeff[11][4][0][2] = 69158784751988702784384890858;
+        coeff[11][4][0][3] = 1595500335;
+
+        coeff[11][4][1][0] = 0;
+        coeff[11][4][1][1] = 0;
+        coeff[11][4][1][2] = 0;
+        coeff[11][4][1][3] = 0;
+
+        coeff[11][5][0][0] = 30918888157334040571029970872;
+        coeff[11][5][0][1] = 38110497911700059231495300413;
+        coeff[11][5][0][2] = 9956775014100533415029595983;
+        coeff[11][5][0][3] = 7742960891664846859912986292;
+
+        coeff[11][5][1][0] = 23961508344847352386299906803;
+        coeff[11][5][1][1] = 73053643719720755424335321793;
+        coeff[11][5][1][2] = 10870206300725050764578763631;
+        coeff[11][5][1][3] = 304942890421345320673339650;
+    }
+    if( n==77 && k==5){
+        coeff[0][0][0][0] = 1;
+        coeff[0][0][0][1] = 0;
+        coeff[0][0][0][2] = 0;
+        coeff[0][0][0][3] = 0;
+        coeff[0][0][0][4] = 0;
+
+        coeff[0][0][1][0] = 0;
+        coeff[0][0][1][1] = 0;
+        coeff[0][0][1][2] = 0;
+        coeff[0][0][1][3] = 0;
+        coeff[0][0][1][4] = 0;
+
+        coeff[0][1][0][0] = 1;
+        coeff[0][1][0][1] = 0;
+        coeff[0][1][0][2] = 0;
+        coeff[0][1][0][3] = 0;
+        coeff[0][1][0][4] = 0;
+
+        coeff[0][1][1][0] = 0;
+        coeff[0][1][1][1] = 0;
+        coeff[0][1][1][2] = 0;
+        coeff[0][1][1][3] = 0;
+        coeff[0][1][1][4] = 0;
+
+        coeff[0][2][0][0] = 1;
+        coeff[0][2][0][1] = 0;
+        coeff[0][2][0][2] = 0;
+        coeff[0][2][0][3] = 0;
+        coeff[0][2][0][4] = 0;
+
+        coeff[0][2][1][0] = 0;
+        coeff[0][2][1][1] = 0;
+        coeff[0][2][1][2] = 0;
+        coeff[0][2][1][3] = 0;
+        coeff[0][2][1][4] = 0;
+
+        coeff[0][3][0][0] = 1;
+        coeff[0][3][0][1] = 0;
+        coeff[0][3][0][2] = 0;
+        coeff[0][3][0][3] = 0;
+        coeff[0][3][0][4] = 0;
+
+        coeff[0][3][1][0] = 0;
+        coeff[0][3][1][1] = 0;
+        coeff[0][3][1][2] = 0;
+        coeff[0][3][1][3] = 0;
+        coeff[0][3][1][4] = 0;
+
+        coeff[0][4][0][0] = 1;
+        coeff[0][4][0][1] = 0;
+        coeff[0][4][0][2] = 0;
+        coeff[0][4][0][3] = 0;
+        coeff[0][4][0][4] = 0;
+
+        coeff[0][4][1][0] = 0;
+        coeff[0][4][1][1] = 0;
+        coeff[0][4][1][2] = 0;
+        coeff[0][4][1][3] = 0;
+        coeff[0][4][1][4] = 0;
+
+        coeff[0][5][0][0] = 1;
+        coeff[0][5][0][1] = 0;
+        coeff[0][5][0][2] = 0;
+        coeff[0][5][0][3] = 0;
+        coeff[0][5][0][4] = 0;
+
+        coeff[0][5][1][0] = 0;
+        coeff[0][5][1][1] = 0;
+        coeff[0][5][1][2] = 0;
+        coeff[0][5][1][3] = 0;
+        coeff[0][5][1][4] = 0;
+
+        coeff[1][0][0][0] = 1;
+        coeff[1][0][0][1] = 0;
+        coeff[1][0][0][2] = 0;
+        coeff[1][0][0][3] = 0;
+        coeff[1][0][0][4] = 0;
+
+        coeff[1][0][1][0] = 0;
+        coeff[1][0][1][1] = 0;
+        coeff[1][0][1][2] = 0;
+        coeff[1][0][1][3] = 0;
+        coeff[1][0][1][4] = 0;
+
+        coeff[1][1][0][0] = 5857780092113332166584;
+        coeff[1][1][0][1] = 27555843941809817067324;
+        coeff[1][1][0][2] = 147854065178978622174689;
+        coeff[1][1][0][3] = 16480454558870818237447;
+        coeff[1][1][0][4] = 7384262935318800792611;
+
+        coeff[1][1][1][0] = 145252903046657682983667;
+        coeff[1][1][1][1] = 74116926119540154854243;
+        coeff[1][1][1][2] = 9107065692449161851484;
+        coeff[1][1][1][3] = 93599087433168491987599;
+        coeff[1][1][1][4] = 290816202565522499726;
+
+        coeff[1][2][0][0] = 0;
+        coeff[1][2][0][1] = 0;
+        coeff[1][2][0][2] = 0;
+        coeff[1][2][0][3] = 0;
+        coeff[1][2][0][4] = 0;
+
+        coeff[1][2][1][0] = 151070474438347898006188;
+        coeff[1][2][1][1] = 140545516233852444113487;
+        coeff[1][2][1][2] = 148207872154034921691459;
+        coeff[1][2][1][3] = 21270016808265337543434;
+        coeff[1][2][1][4] = 7675079137884323290816;
+
+        coeff[1][3][0][0] = 28127254136958132407305;
+        coeff[1][3][0][1] = 21583712728585527334752;
+        coeff[1][3][0][2] = 51663912557182296229312;
+        coeff[1][3][0][3] = 17835324027044025627323;
+        coeff[1][3][0][4] = 1972711818993931957891;
+
+        coeff[1][3][1][0] = 28127254136958132407305;
+        coeff[1][3][1][1] = 21583712728585527334752;
+        coeff[1][3][1][2] = 51663912557182296229312;
+        coeff[1][3][1][3] = 17835324027044025627323;
+        coeff[1][3][1][4] = 1972711818993931957891;
+
+        coeff[1][4][0][0] = 151070474438347898006189;
+        coeff[1][4][0][1] = 140545516233852444113487;
+        coeff[1][4][0][2] = 148207872154034921691459;
+        coeff[1][4][0][3] = 21270016808265337543434;
+        coeff[1][4][0][4] = 7675079137884323290816;
+
+        coeff[1][4][1][0] = 0;
+        coeff[1][4][1][1] = 0;
+        coeff[1][4][1][2] = 0;
+        coeff[1][4][1][3] = 0;
+        coeff[1][4][1][4] = 0;
+
+        coeff[1][5][0][0] = 33990078542129096261910;
+        coeff[1][5][0][1] = 98582514060874019318780;
+        coeff[1][5][0][2] = 42556846864733134377827;
+        coeff[1][5][0][3] = 75351964045704180477996;
+        coeff[1][5][0][4] = 1681895616428409458164;
+
+        coeff[1][5][1][0] = 117120604596641918888341;
+        coeff[1][5][1][1] = 3090256000475952602787;
+        coeff[1][5][1][2] = 114404284006694649648346;
+        coeff[1][5][1][3] = 34727577946335129747050;
+        coeff[1][5][1][4] = 5993183521455913834173;
+
+        coeff[2][0][0][0] = 1;
+        coeff[2][0][0][1] = 0;
+        coeff[2][0][0][2] = 0;
+        coeff[2][0][0][3] = 0;
+        coeff[2][0][0][4] = 0;
+
+        coeff[2][0][1][0] = 0;
+        coeff[2][0][1][1] = 0;
+        coeff[2][0][1][2] = 0;
+        coeff[2][0][1][3] = 0;
+        coeff[2][0][1][4] = 0;
+
+        coeff[2][1][0][0] = 40208700423117144063;
+        coeff[2][1][0][1] = 112242981279326174646352;
+        coeff[2][1][0][2] = 8753258717392862334713;
+        coeff[2][1][0][3] = 88809525183773972681612;
+        coeff[2][1][0][4] = 1521;
+
+        coeff[2][1][1][0] = 0;
+        coeff[2][1][1][1] = 0;
+        coeff[2][1][1][2] = 0;
+        coeff[2][1][1][3] = 0;
+        coeff[2][1][1][4] = 0;
+
+        coeff[2][2][0][0] = 40208700423117144062;
+        coeff[2][2][0][1] = 112242981279326174646352;
+        coeff[2][2][0][2] = 8753258717392862334713;
+        coeff[2][2][0][3] = 88809525183773972681612;
+        coeff[2][2][0][4] = 1521;
+
+        coeff[2][2][1][0] = 0;
+        coeff[2][2][1][1] = 0;
+        coeff[2][2][1][2] = 0;
+        coeff[2][2][1][3] = 0;
+        coeff[2][2][1][4] = 0;
+
+        coeff[2][3][0][0] = 151110683138771015150250;
+        coeff[2][3][0][1] = 101672770061349971921567;
+        coeff[2][3][0][2] = 5845403419599137187901;
+        coeff[2][3][0][3] = 110079541992039310225047;
+        coeff[2][3][0][4] = 7675079137884323292337;
+
+        coeff[2][3][1][0] = 0;
+        coeff[2][3][1][1] = 0;
+        coeff[2][3][1][2] = 0;
+        coeff[2][3][1][3] = 0;
+        coeff[2][3][1][4] = 0;
+
+        coeff[2][4][0][0] = 151070474438347898006188;
+        coeff[2][4][0][1] = 140545516233852444113487;
+        coeff[2][4][0][2] = 148207872154034921691459;
+        coeff[2][4][0][3] = 21270016808265337543434;
+        coeff[2][4][0][4] = 7675079137884323290816;
+
+        coeff[2][4][1][0] = 0;
+        coeff[2][4][1][1] = 0;
+        coeff[2][4][1][2] = 0;
+        coeff[2][4][1][3] = 0;
+        coeff[2][4][1][4] = 0;
+
+        coeff[2][5][0][0] = 151070474438347898006189;
+        coeff[2][5][0][1] = 140545516233852444113487;
+        coeff[2][5][0][2] = 148207872154034921691459;
+        coeff[2][5][0][3] = 21270016808265337543434;
+        coeff[2][5][0][4] = 7675079137884323290816;
+
+        coeff[2][5][1][0] = 0;
+        coeff[2][5][1][1] = 0;
+        coeff[2][5][1][2] = 0;
+        coeff[2][5][1][3] = 0;
+        coeff[2][5][1][4] = 0;
+
+        coeff[3][0][0][0] = 1;
+        coeff[3][0][0][1] = 0;
+        coeff[3][0][0][2] = 0;
+        coeff[3][0][0][3] = 0;
+        coeff[3][0][0][4] = 0;
+
+        coeff[3][0][1][0] = 0;
+        coeff[3][0][1][1] = 0;
+        coeff[3][0][1][2] = 0;
+        coeff[3][0][1][3] = 0;
+        coeff[3][0][1][4] = 0;
+
+        coeff[3][1][0][0] = 122983429001812882742946;
+        coeff[3][1][0][1] = 80089057332764444586815;
+        coeff[3][1][0][2] = 105297218314245487796861;
+        coeff[3][1][0][3] = 92244217964995284597723;
+        coeff[3][1][0][4] = 5702367318890391334446;
+
+        coeff[3][1][1][0] = 28127254136958132407305;
+        coeff[3][1][1][1] = 21583712728585527334752;
+        coeff[3][1][1][2] = 51663912557182296229312;
+        coeff[3][1][1][3] = 17835324027044025627323;
+        coeff[3][1][1][4] = 1972711818993931957891;
+
+        coeff[3][2][0][0] = 0;
+        coeff[3][2][0][1] = 0;
+        coeff[3][2][0][2] = 0;
+        coeff[3][2][0][3] = 0;
+        coeff[3][2][0][4] = 0;
+
+        coeff[3][2][1][0] = 1;
+        coeff[3][2][1][1] = 0;
+        coeff[3][2][1][2] = 0;
+        coeff[3][2][1][3] = 0;
+        coeff[3][2][1][4] = 0;
+
+        coeff[3][3][0][0] = 122983429001812882742946;
+        coeff[3][3][0][1] = 80089057332764444586815;
+        coeff[3][3][0][2] = 105297218314245487796861;
+        coeff[3][3][0][3] = 92244217964995284597723;
+        coeff[3][3][0][4] = 5702367318890391334446;
+
+        coeff[3][3][1][0] = 122983429001812882742946;
+        coeff[3][3][1][1] = 80089057332764444586815;
+        coeff[3][3][1][2] = 105297218314245487796861;
+        coeff[3][3][1][3] = 92244217964995284597723;
+        coeff[3][3][1][4] = 5702367318890391334446;
+
+        coeff[3][4][0][0] = 151110683138771015150250;
+        coeff[3][4][0][1] = 101672770061349971921567;
+        coeff[3][4][0][2] = 5845403419599137187901;
+        coeff[3][4][0][3] = 110079541992039310225047;
+        coeff[3][4][0][4] = 7675079137884323292337;
+
+        coeff[3][4][1][0] = 0;
+        coeff[3][4][1][1] = 0;
+        coeff[3][4][1][2] = 0;
+        coeff[3][4][1][3] = 0;
+        coeff[3][4][1][4] = 0;
+
+        coeff[3][5][0][0] = 28127254136958132407305;
+        coeff[3][5][0][1] = 21583712728585527334752;
+        coeff[3][5][0][2] = 51663912557182296229312;
+        coeff[3][5][0][3] = 17835324027044025627323;
+        coeff[3][5][0][4] = 1972711818993931957891;
+
+        coeff[3][5][1][0] = 122983429001812882742946;
+        coeff[3][5][1][1] = 80089057332764444586815;
+        coeff[3][5][1][2] = 105297218314245487796861;
+        coeff[3][5][1][3] = 92244217964995284597723;
+        coeff[3][5][1][4] = 5702367318890391334446;
+
+        coeff[4][0][0][0] = 1;
+        coeff[4][0][0][1] = 0;
+        coeff[4][0][0][2] = 0;
+        coeff[4][0][0][3] = 0;
+        coeff[4][0][0][4] = 0;
+
+        coeff[4][0][1][0] = 0;
+        coeff[4][0][1][1] = 0;
+        coeff[4][0][1][2] = 0;
+        coeff[4][0][1][3] = 0;
+        coeff[4][0][1][4] = 0;
+
+        coeff[4][1][0][0] = 40208700423117144062;
+        coeff[4][1][0][1] = 112242981279326174646352;
+        coeff[4][1][0][2] = 8753258717392862334713;
+        coeff[4][1][0][3] = 88809525183773972681612;
+        coeff[4][1][0][4] = 1521;
+
+        coeff[4][1][1][0] = 0;
+        coeff[4][1][1][1] = 0;
+        coeff[4][1][1][2] = 0;
+        coeff[4][1][1][3] = 0;
+        coeff[4][1][1][4] = 0;
+
+        coeff[4][2][0][0] = 151070474438347898006188;
+        coeff[4][2][0][1] = 140545516233852444113487;
+        coeff[4][2][0][2] = 148207872154034921691459;
+        coeff[4][2][0][3] = 21270016808265337543434;
+        coeff[4][2][0][4] = 7675079137884323290816;
+
+        coeff[4][2][1][0] = 0;
+        coeff[4][2][1][1] = 0;
+        coeff[4][2][1][2] = 0;
+        coeff[4][2][1][3] = 0;
+        coeff[4][2][1][4] = 0;
+
+        coeff[4][3][0][0] = 1;
+        coeff[4][3][0][1] = 0;
+        coeff[4][3][0][2] = 0;
+        coeff[4][3][0][3] = 0;
+        coeff[4][3][0][4] = 0;
+
+        coeff[4][3][1][0] = 0;
+        coeff[4][3][1][1] = 0;
+        coeff[4][3][1][2] = 0;
+        coeff[4][3][1][3] = 0;
+        coeff[4][3][1][4] = 0;
+
+        coeff[4][4][0][0] = 40208700423117144062;
+        coeff[4][4][0][1] = 112242981279326174646352;
+        coeff[4][4][0][2] = 8753258717392862334713;
+        coeff[4][4][0][3] = 88809525183773972681612;
+        coeff[4][4][0][4] = 1521;
+
+        coeff[4][4][1][0] = 0;
+        coeff[4][4][1][1] = 0;
+        coeff[4][4][1][2] = 0;
+        coeff[4][4][1][3] = 0;
+        coeff[4][4][1][4] = 0;
+
+        coeff[4][5][0][0] = 151070474438347898006188;
+        coeff[4][5][0][1] = 140545516233852444113487;
+        coeff[4][5][0][2] = 148207872154034921691459;
+        coeff[4][5][0][3] = 21270016808265337543434;
+        coeff[4][5][0][4] = 7675079137884323290816;
+
+        coeff[4][5][1][0] = 0;
+        coeff[4][5][1][1] = 0;
+        coeff[4][5][1][2] = 0;
+        coeff[4][5][1][3] = 0;
+        coeff[4][5][1][4] = 0;
+
+        coeff[5][0][0][0] = 1;
+        coeff[5][0][0][1] = 0;
+        coeff[5][0][0][2] = 0;
+        coeff[5][0][0][3] = 0;
+        coeff[5][0][0][4] = 0;
+
+        coeff[5][0][1][0] = 0;
+        coeff[5][0][1][1] = 0;
+        coeff[5][0][1][2] = 0;
+        coeff[5][0][1][3] = 0;
+        coeff[5][0][1][4] = 0;
+
+        coeff[5][1][0][0] = 117120604596641918888341;
+        coeff[5][1][0][1] = 3090256000475952602787;
+        coeff[5][1][0][2] = 114404284006694649648346;
+        coeff[5][1][0][3] = 34727577946335129747050;
+        coeff[5][1][0][4] = 5993183521455913834173;
+
+        coeff[5][1][1][0] = 33990078542129096261910;
+        coeff[5][1][1][1] = 98582514060874019318780;
+        coeff[5][1][1][2] = 42556846864733134377827;
+        coeff[5][1][1][3] = 75351964045704180477996;
+        coeff[5][1][1][4] = 1681895616428409458164;
+
+        coeff[5][2][0][0] = 0;
+        coeff[5][2][0][1] = 0;
+        coeff[5][2][0][2] = 0;
+        coeff[5][2][0][3] = 0;
+        coeff[5][2][0][4] = 0;
+
+        coeff[5][2][1][0] = 40208700423117144062;
+        coeff[5][2][1][1] = 112242981279326174646352;
+        coeff[5][2][1][2] = 8753258717392862334713;
+        coeff[5][2][1][3] = 88809525183773972681612;
+        coeff[5][2][1][4] = 1521;
+
+        coeff[5][3][0][0] = 28127254136958132407305;
+        coeff[5][3][0][1] = 21583712728585527334752;
+        coeff[5][3][0][2] = 51663912557182296229312;
+        coeff[5][3][0][3] = 17835324027044025627323;
+        coeff[5][3][0][4] = 1972711818993931957891;
+
+        coeff[5][3][1][0] = 28127254136958132407305;
+        coeff[5][3][1][1] = 21583712728585527334752;
+        coeff[5][3][1][2] = 51663912557182296229312;
+        coeff[5][3][1][3] = 17835324027044025627323;
+        coeff[5][3][1][4] = 1972711818993931957891;
+
+        coeff[5][4][0][0] = 40208700423117144063;
+        coeff[5][4][0][1] = 112242981279326174646352;
+        coeff[5][4][0][2] = 8753258717392862334713;
+        coeff[5][4][0][3] = 88809525183773972681612;
+        coeff[5][4][0][4] = 1521;
+
+        coeff[5][4][1][0] = 0;
+        coeff[5][4][1][1] = 0;
+        coeff[5][4][1][2] = 0;
+        coeff[5][4][1][3] = 0;
+        coeff[5][4][1][4] = 0;
+
+        coeff[5][5][0][0] = 145252903046657682983667;
+        coeff[5][5][0][1] = 74116926119540154854243;
+        coeff[5][5][0][2] = 9107065692449161851484;
+        coeff[5][5][0][3] = 93599087433168491987599;
+        coeff[5][5][0][4] = 290816202565522499726;
+
+        coeff[5][5][1][0] = 5857780092113332166584;
+        coeff[5][5][1][1] = 27555843941809817067324;
+        coeff[5][5][1][2] = 147854065178978622174689;
+        coeff[5][5][1][3] = 16480454558870818237447;
+        coeff[5][5][1][4] = 7384262935318800792611;
+
+        coeff[6][0][0][0] = 1;
+        coeff[6][0][0][1] = 0;
+        coeff[6][0][0][2] = 0;
+        coeff[6][0][0][3] = 0;
+        coeff[6][0][0][4] = 0;
+
+        coeff[6][0][1][0] = 0;
+        coeff[6][0][1][1] = 0;
+        coeff[6][0][1][2] = 0;
+        coeff[6][0][1][3] = 0;
+        coeff[6][0][1][4] = 0;
+
+        coeff[6][1][0][0] = 151110683138771015150250;
+        coeff[6][1][0][1] = 101672770061349971921567;
+        coeff[6][1][0][2] = 5845403419599137187901;
+        coeff[6][1][0][3] = 110079541992039310225047;
+        coeff[6][1][0][4] = 7675079137884323292337;
+
+        coeff[6][1][1][0] = 0;
+        coeff[6][1][1][1] = 0;
+        coeff[6][1][1][2] = 0;
+        coeff[6][1][1][3] = 0;
+        coeff[6][1][1][4] = 0;
+
+        coeff[6][2][0][0] = 1;
+        coeff[6][2][0][1] = 0;
+        coeff[6][2][0][2] = 0;
+        coeff[6][2][0][3] = 0;
+        coeff[6][2][0][4] = 0;
+
+        coeff[6][2][1][0] = 0;
+        coeff[6][2][1][1] = 0;
+        coeff[6][2][1][2] = 0;
+        coeff[6][2][1][3] = 0;
+        coeff[6][2][1][4] = 0;
+
+        coeff[6][3][0][0] = 151110683138771015150250;
+        coeff[6][3][0][1] = 101672770061349971921567;
+        coeff[6][3][0][2] = 5845403419599137187901;
+        coeff[6][3][0][3] = 110079541992039310225047;
+        coeff[6][3][0][4] = 7675079137884323292337;
+
+        coeff[6][3][1][0] = 0;
+        coeff[6][3][1][1] = 0;
+        coeff[6][3][1][2] = 0;
+        coeff[6][3][1][3] = 0;
+        coeff[6][3][1][4] = 0;
+
+        coeff[6][4][0][0] = 1;
+        coeff[6][4][0][1] = 0;
+        coeff[6][4][0][2] = 0;
+        coeff[6][4][0][3] = 0;
+        coeff[6][4][0][4] = 0;
+
+        coeff[6][4][1][0] = 0;
+        coeff[6][4][1][1] = 0;
+        coeff[6][4][1][2] = 0;
+        coeff[6][4][1][3] = 0;
+        coeff[6][4][1][4] = 0;
+
+        coeff[6][5][0][0] = 151110683138771015150250;
+        coeff[6][5][0][1] = 101672770061349971921567;
+        coeff[6][5][0][2] = 5845403419599137187901;
+        coeff[6][5][0][3] = 110079541992039310225047;
+        coeff[6][5][0][4] = 7675079137884323292337;
+
+        coeff[6][5][1][0] = 0;
+        coeff[6][5][1][1] = 0;
+        coeff[6][5][1][2] = 0;
+        coeff[6][5][1][3] = 0;
+        coeff[6][5][1][4] = 0;
+
+        coeff[7][0][0][0] = 1;
+        coeff[7][0][0][1] = 0;
+        coeff[7][0][0][2] = 0;
+        coeff[7][0][0][3] = 0;
+        coeff[7][0][0][4] = 0;
+
+        coeff[7][0][1][0] = 0;
+        coeff[7][0][1][1] = 0;
+        coeff[7][0][1][2] = 0;
+        coeff[7][0][1][3] = 0;
+        coeff[7][0][1][4] = 0;
+
+        coeff[7][1][0][0] = 145252903046657682983667;
+        coeff[7][1][0][1] = 74116926119540154854243;
+        coeff[7][1][0][2] = 9107065692449161851484;
+        coeff[7][1][0][3] = 93599087433168491987599;
+        coeff[7][1][0][4] = 290816202565522499726;
+
+        coeff[7][1][1][0] = 5857780092113332166584;
+        coeff[7][1][1][1] = 27555843941809817067324;
+        coeff[7][1][1][2] = 147854065178978622174689;
+        coeff[7][1][1][3] = 16480454558870818237447;
+        coeff[7][1][1][4] = 7384262935318800792611;
+
+        coeff[7][2][0][0] = 0;
+        coeff[7][2][0][1] = 0;
+        coeff[7][2][0][2] = 0;
+        coeff[7][2][0][3] = 0;
+        coeff[7][2][0][4] = 0;
+
+        coeff[7][2][1][0] = 151070474438347898006188;
+        coeff[7][2][1][1] = 140545516233852444113487;
+        coeff[7][2][1][2] = 148207872154034921691459;
+        coeff[7][2][1][3] = 21270016808265337543434;
+        coeff[7][2][1][4] = 7675079137884323290816;
+
+        coeff[7][3][0][0] = 122983429001812882742946;
+        coeff[7][3][0][1] = 80089057332764444586815;
+        coeff[7][3][0][2] = 105297218314245487796861;
+        coeff[7][3][0][3] = 92244217964995284597723;
+        coeff[7][3][0][4] = 5702367318890391334446;
+
+        coeff[7][3][1][0] = 122983429001812882742946;
+        coeff[7][3][1][1] = 80089057332764444586815;
+        coeff[7][3][1][2] = 105297218314245487796861;
+        coeff[7][3][1][3] = 92244217964995284597723;
+        coeff[7][3][1][4] = 5702367318890391334446;
+
+        coeff[7][4][0][0] = 151070474438347898006189;
+        coeff[7][4][0][1] = 140545516233852444113487;
+        coeff[7][4][0][2] = 148207872154034921691459;
+        coeff[7][4][0][3] = 21270016808265337543434;
+        coeff[7][4][0][4] = 7675079137884323290816;
+
+        coeff[7][4][1][0] = 0;
+        coeff[7][4][1][1] = 0;
+        coeff[7][4][1][2] = 0;
+        coeff[7][4][1][3] = 0;
+        coeff[7][4][1][4] = 0;
+
+        coeff[7][5][0][0] = 117120604596641918888341;
+        coeff[7][5][0][1] = 3090256000475952602787;
+        coeff[7][5][0][2] = 114404284006694649648346;
+        coeff[7][5][0][3] = 34727577946335129747050;
+        coeff[7][5][0][4] = 5993183521455913834173;
+
+        coeff[7][5][1][0] = 33990078542129096261910;
+        coeff[7][5][1][1] = 98582514060874019318780;
+        coeff[7][5][1][2] = 42556846864733134377827;
+        coeff[7][5][1][3] = 75351964045704180477996;
+        coeff[7][5][1][4] = 1681895616428409458164;
+
+        coeff[8][0][0][0] = 1;
+        coeff[8][0][0][1] = 0;
+        coeff[8][0][0][2] = 0;
+        coeff[8][0][0][3] = 0;
+        coeff[8][0][0][4] = 0;
+
+        coeff[8][0][1][0] = 0;
+        coeff[8][0][1][1] = 0;
+        coeff[8][0][1][2] = 0;
+        coeff[8][0][1][3] = 0;
+        coeff[8][0][1][4] = 0;
+
+        coeff[8][1][0][0] = 151070474438347898006188;
+        coeff[8][1][0][1] = 140545516233852444113487;
+        coeff[8][1][0][2] = 148207872154034921691459;
+        coeff[8][1][0][3] = 21270016808265337543434;
+        coeff[8][1][0][4] = 7675079137884323290816;
+
+        coeff[8][1][1][0] = 0;
+        coeff[8][1][1][1] = 0;
+        coeff[8][1][1][2] = 0;
+        coeff[8][1][1][3] = 0;
+        coeff[8][1][1][4] = 0;
+
+        coeff[8][2][0][0] = 40208700423117144062;
+        coeff[8][2][0][1] = 112242981279326174646352;
+        coeff[8][2][0][2] = 8753258717392862334713;
+        coeff[8][2][0][3] = 88809525183773972681612;
+        coeff[8][2][0][4] = 1521;
+
+        coeff[8][2][1][0] = 0;
+        coeff[8][2][1][1] = 0;
+        coeff[8][2][1][2] = 0;
+        coeff[8][2][1][3] = 0;
+        coeff[8][2][1][4] = 0;
+
+        coeff[8][3][0][0] = 1;
+        coeff[8][3][0][1] = 0;
+        coeff[8][3][0][2] = 0;
+        coeff[8][3][0][3] = 0;
+        coeff[8][3][0][4] = 0;
+
+        coeff[8][3][1][0] = 0;
+        coeff[8][3][1][1] = 0;
+        coeff[8][3][1][2] = 0;
+        coeff[8][3][1][3] = 0;
+        coeff[8][3][1][4] = 0;
+
+        coeff[8][4][0][0] = 151070474438347898006188;
+        coeff[8][4][0][1] = 140545516233852444113487;
+        coeff[8][4][0][2] = 148207872154034921691459;
+        coeff[8][4][0][3] = 21270016808265337543434;
+        coeff[8][4][0][4] = 7675079137884323290816;
+
+        coeff[8][4][1][0] = 0;
+        coeff[8][4][1][1] = 0;
+        coeff[8][4][1][2] = 0;
+        coeff[8][4][1][3] = 0;
+        coeff[8][4][1][4] = 0;
+
+        coeff[8][5][0][0] = 40208700423117144062;
+        coeff[8][5][0][1] = 112242981279326174646352;
+        coeff[8][5][0][2] = 8753258717392862334713;
+        coeff[8][5][0][3] = 88809525183773972681612;
+        coeff[8][5][0][4] = 1521;
+
+        coeff[8][5][1][0] = 0;
+        coeff[8][5][1][1] = 0;
+        coeff[8][5][1][2] = 0;
+        coeff[8][5][1][3] = 0;
+        coeff[8][5][1][4] = 0;
+
+        coeff[9][0][0][0] = 1;
+        coeff[9][0][0][1] = 0;
+        coeff[9][0][0][2] = 0;
+        coeff[9][0][0][3] = 0;
+        coeff[9][0][0][4] = 0;
+
+        coeff[9][0][1][0] = 0;
+        coeff[9][0][1][1] = 0;
+        coeff[9][0][1][2] = 0;
+        coeff[9][0][1][3] = 0;
+        coeff[9][0][1][4] = 0;
+
+        coeff[9][1][0][0] = 28127254136958132407305;
+        coeff[9][1][0][1] = 21583712728585527334752;
+        coeff[9][1][0][2] = 51663912557182296229312;
+        coeff[9][1][0][3] = 17835324027044025627323;
+        coeff[9][1][0][4] = 1972711818993931957891;
+
+        coeff[9][1][1][0] = 122983429001812882742946;
+        coeff[9][1][1][1] = 80089057332764444586815;
+        coeff[9][1][1][2] = 105297218314245487796861;
+        coeff[9][1][1][3] = 92244217964995284597723;
+        coeff[9][1][1][4] = 5702367318890391334446;
+
+        coeff[9][2][0][0] = 0;
+        coeff[9][2][0][1] = 0;
+        coeff[9][2][0][2] = 0;
+        coeff[9][2][0][3] = 0;
+        coeff[9][2][0][4] = 0;
+
+        coeff[9][2][1][0] = 1;
+        coeff[9][2][1][1] = 0;
+        coeff[9][2][1][2] = 0;
+        coeff[9][2][1][3] = 0;
+        coeff[9][2][1][4] = 0;
+
+        coeff[9][3][0][0] = 28127254136958132407305;
+        coeff[9][3][0][1] = 21583712728585527334752;
+        coeff[9][3][0][2] = 51663912557182296229312;
+        coeff[9][3][0][3] = 17835324027044025627323;
+        coeff[9][3][0][4] = 1972711818993931957891;
+
+        coeff[9][3][1][0] = 28127254136958132407305;
+        coeff[9][3][1][1] = 21583712728585527334752;
+        coeff[9][3][1][2] = 51663912557182296229312;
+        coeff[9][3][1][3] = 17835324027044025627323;
+        coeff[9][3][1][4] = 1972711818993931957891;
+
+        coeff[9][4][0][0] = 151110683138771015150250;
+        coeff[9][4][0][1] = 101672770061349971921567;
+        coeff[9][4][0][2] = 5845403419599137187901;
+        coeff[9][4][0][3] = 110079541992039310225047;
+        coeff[9][4][0][4] = 7675079137884323292337;
+
+        coeff[9][4][1][0] = 0;
+        coeff[9][4][1][1] = 0;
+        coeff[9][4][1][2] = 0;
+        coeff[9][4][1][3] = 0;
+        coeff[9][4][1][4] = 0;
+
+        coeff[9][5][0][0] = 122983429001812882742946;
+        coeff[9][5][0][1] = 80089057332764444586815;
+        coeff[9][5][0][2] = 105297218314245487796861;
+        coeff[9][5][0][3] = 92244217964995284597723;
+        coeff[9][5][0][4] = 5702367318890391334446;
+
+        coeff[9][5][1][0] = 28127254136958132407305;
+        coeff[9][5][1][1] = 21583712728585527334752;
+        coeff[9][5][1][2] = 51663912557182296229312;
+        coeff[9][5][1][3] = 17835324027044025627323;
+        coeff[9][5][1][4] = 1972711818993931957891;
+
+        coeff[10][0][0][0] = 1;
+        coeff[10][0][0][1] = 0;
+        coeff[10][0][0][2] = 0;
+        coeff[10][0][0][3] = 0;
+        coeff[10][0][0][4] = 0;
+
+        coeff[10][0][1][0] = 0;
+        coeff[10][0][1][1] = 0;
+        coeff[10][0][1][2] = 0;
+        coeff[10][0][1][3] = 0;
+        coeff[10][0][1][4] = 0;
+
+        coeff[10][1][0][0] = 151070474438347898006189;
+        coeff[10][1][0][1] = 140545516233852444113487;
+        coeff[10][1][0][2] = 148207872154034921691459;
+        coeff[10][1][0][3] = 21270016808265337543434;
+        coeff[10][1][0][4] = 7675079137884323290816;
+
+        coeff[10][1][1][0] = 0;
+        coeff[10][1][1][1] = 0;
+        coeff[10][1][1][2] = 0;
+        coeff[10][1][1][3] = 0;
+        coeff[10][1][1][4] = 0;
+
+        coeff[10][2][0][0] = 151070474438347898006188;
+        coeff[10][2][0][1] = 140545516233852444113487;
+        coeff[10][2][0][2] = 148207872154034921691459;
+        coeff[10][2][0][3] = 21270016808265337543434;
+        coeff[10][2][0][4] = 7675079137884323290816;
+
+        coeff[10][2][1][0] = 0;
+        coeff[10][2][1][1] = 0;
+        coeff[10][2][1][2] = 0;
+        coeff[10][2][1][3] = 0;
+        coeff[10][2][1][4] = 0;
+
+        coeff[10][3][0][0] = 151110683138771015150250;
+        coeff[10][3][0][1] = 101672770061349971921567;
+        coeff[10][3][0][2] = 5845403419599137187901;
+        coeff[10][3][0][3] = 110079541992039310225047;
+        coeff[10][3][0][4] = 7675079137884323292337;
+
+        coeff[10][3][1][0] = 0;
+        coeff[10][3][1][1] = 0;
+        coeff[10][3][1][2] = 0;
+        coeff[10][3][1][3] = 0;
+        coeff[10][3][1][4] = 0;
+
+        coeff[10][4][0][0] = 40208700423117144062;
+        coeff[10][4][0][1] = 112242981279326174646352;
+        coeff[10][4][0][2] = 8753258717392862334713;
+        coeff[10][4][0][3] = 88809525183773972681612;
+        coeff[10][4][0][4] = 1521;
+
+        coeff[10][4][1][0] = 0;
+        coeff[10][4][1][1] = 0;
+        coeff[10][4][1][2] = 0;
+        coeff[10][4][1][3] = 0;
+        coeff[10][4][1][4] = 0;
+
+        coeff[10][5][0][0] = 40208700423117144063;
+        coeff[10][5][0][1] = 112242981279326174646352;
+        coeff[10][5][0][2] = 8753258717392862334713;
+        coeff[10][5][0][3] = 88809525183773972681612;
+        coeff[10][5][0][4] = 1521;
+
+        coeff[10][5][1][0] = 0;
+        coeff[10][5][1][1] = 0;
+        coeff[10][5][1][2] = 0;
+        coeff[10][5][1][3] = 0;
+        coeff[10][5][1][4] = 0;
+
+        coeff[11][0][0][0] = 1;
+        coeff[11][0][0][1] = 0;
+        coeff[11][0][0][2] = 0;
+        coeff[11][0][0][3] = 0;
+        coeff[11][0][0][4] = 0;
+
+        coeff[11][0][1][0] = 0;
+        coeff[11][0][1][1] = 0;
+        coeff[11][0][1][2] = 0;
+        coeff[11][0][1][3] = 0;
+        coeff[11][0][1][4] = 0;
+
+        coeff[11][1][0][0] = 33990078542129096261910;
+        coeff[11][1][0][1] = 98582514060874019318780;
+        coeff[11][1][0][2] = 42556846864733134377827;
+        coeff[11][1][0][3] = 75351964045704180477996;
+        coeff[11][1][0][4] = 1681895616428409458164;
+
+        coeff[11][1][1][0] = 117120604596641918888341;
+        coeff[11][1][1][1] = 3090256000475952602787;
+        coeff[11][1][1][2] = 114404284006694649648346;
+        coeff[11][1][1][3] = 34727577946335129747050;
+        coeff[11][1][1][4] = 5993183521455913834173;
+
+        coeff[11][2][0][0] = 0;
+        coeff[11][2][0][1] = 0;
+        coeff[11][2][0][2] = 0;
+        coeff[11][2][0][3] = 0;
+        coeff[11][2][0][4] = 0;
+
+        coeff[11][2][1][0] = 40208700423117144062;
+        coeff[11][2][1][1] = 112242981279326174646352;
+        coeff[11][2][1][2] = 8753258717392862334713;
+        coeff[11][2][1][3] = 88809525183773972681612;
+        coeff[11][2][1][4] = 1521;
+
+        coeff[11][3][0][0] = 122983429001812882742946;
+        coeff[11][3][0][1] = 80089057332764444586815;
+        coeff[11][3][0][2] = 105297218314245487796861;
+        coeff[11][3][0][3] = 92244217964995284597723;
+        coeff[11][3][0][4] = 5702367318890391334446;
+
+        coeff[11][3][1][0] = 122983429001812882742946;
+        coeff[11][3][1][1] = 80089057332764444586815;
+        coeff[11][3][1][2] = 105297218314245487796861;
+        coeff[11][3][1][3] = 92244217964995284597723;
+        coeff[11][3][1][4] = 5702367318890391334446;
+
+        coeff[11][4][0][0] = 40208700423117144063;
+        coeff[11][4][0][1] = 112242981279326174646352;
+        coeff[11][4][0][2] = 8753258717392862334713;
+        coeff[11][4][0][3] = 88809525183773972681612;
+        coeff[11][4][0][4] = 1521;
+
+        coeff[11][4][1][0] = 0;
+        coeff[11][4][1][1] = 0;
+        coeff[11][4][1][2] = 0;
+        coeff[11][4][1][3] = 0;
+        coeff[11][4][1][4] = 0;
+
+        coeff[11][5][0][0] = 5857780092113332166584;
+        coeff[11][5][0][1] = 27555843941809817067324;
+        coeff[11][5][0][2] = 147854065178978622174689;
+        coeff[11][5][0][3] = 16480454558870818237447;
+        coeff[11][5][0][4] = 7384262935318800792611;
+
+        coeff[11][5][1][0] = 145252903046657682983667;
+        coeff[11][5][1][1] = 74116926119540154854243;
+        coeff[11][5][1][2] = 9107065692449161851484;
+        coeff[11][5][1][3] = 93599087433168491987599;
+        coeff[11][5][1][4] = 290816202565522499726;
+    }
+    if( n == 55 && k == 7 ){
+        coeff[0][0][0][0] = 1;
+        coeff[0][0][0][1] = 0;
+        coeff[0][0][0][2] = 0;
+        coeff[0][0][0][3] = 0;
+        coeff[0][0][0][4] = 0;
+        coeff[0][0][0][5] = 0;
+        coeff[0][0][0][6] = 0;
+
+        coeff[0][0][1][0] = 0;
+        coeff[0][0][1][1] = 0;
+        coeff[0][0][1][2] = 0;
+        coeff[0][0][1][3] = 0;
+        coeff[0][0][1][4] = 0;
+        coeff[0][0][1][5] = 0;
+        coeff[0][0][1][6] = 0;
+
+        coeff[0][1][0][0] = 1;
+        coeff[0][1][0][1] = 0;
+        coeff[0][1][0][2] = 0;
+        coeff[0][1][0][3] = 0;
+        coeff[0][1][0][4] = 0;
+        coeff[0][1][0][5] = 0;
+        coeff[0][1][0][6] = 0;
+
+        coeff[0][1][1][0] = 0;
+        coeff[0][1][1][1] = 0;
+        coeff[0][1][1][2] = 0;
+        coeff[0][1][1][3] = 0;
+        coeff[0][1][1][4] = 0;
+        coeff[0][1][1][5] = 0;
+        coeff[0][1][1][6] = 0;
+
+        coeff[0][2][0][0] = 1;
+        coeff[0][2][0][1] = 0;
+        coeff[0][2][0][2] = 0;
+        coeff[0][2][0][3] = 0;
+        coeff[0][2][0][4] = 0;
+        coeff[0][2][0][5] = 0;
+        coeff[0][2][0][6] = 0;
+
+        coeff[0][2][1][0] = 0;
+        coeff[0][2][1][1] = 0;
+        coeff[0][2][1][2] = 0;
+        coeff[0][2][1][3] = 0;
+        coeff[0][2][1][4] = 0;
+        coeff[0][2][1][5] = 0;
+        coeff[0][2][1][6] = 0;
+
+        coeff[0][3][0][0] = 1;
+        coeff[0][3][0][1] = 0;
+        coeff[0][3][0][2] = 0;
+        coeff[0][3][0][3] = 0;
+        coeff[0][3][0][4] = 0;
+        coeff[0][3][0][5] = 0;
+        coeff[0][3][0][6] = 0;
+
+        coeff[0][3][1][0] = 0;
+        coeff[0][3][1][1] = 0;
+        coeff[0][3][1][2] = 0;
+        coeff[0][3][1][3] = 0;
+        coeff[0][3][1][4] = 0;
+        coeff[0][3][1][5] = 0;
+        coeff[0][3][1][6] = 0;
+
+        coeff[0][4][0][0] = 1;
+        coeff[0][4][0][1] = 0;
+        coeff[0][4][0][2] = 0;
+        coeff[0][4][0][3] = 0;
+        coeff[0][4][0][4] = 0;
+        coeff[0][4][0][5] = 0;
+        coeff[0][4][0][6] = 0;
+
+        coeff[0][4][1][0] = 0;
+        coeff[0][4][1][1] = 0;
+        coeff[0][4][1][2] = 0;
+        coeff[0][4][1][3] = 0;
+        coeff[0][4][1][4] = 0;
+        coeff[0][4][1][5] = 0;
+        coeff[0][4][1][6] = 0;
+
+        coeff[0][5][0][0] = 1;
+        coeff[0][5][0][1] = 0;
+        coeff[0][5][0][2] = 0;
+        coeff[0][5][0][3] = 0;
+        coeff[0][5][0][4] = 0;
+        coeff[0][5][0][5] = 0;
+        coeff[0][5][0][6] = 0;
+
+        coeff[0][5][1][0] = 0;
+        coeff[0][5][1][1] = 0;
+        coeff[0][5][1][2] = 0;
+        coeff[0][5][1][3] = 0;
+        coeff[0][5][1][4] = 0;
+        coeff[0][5][1][5] = 0;
+        coeff[0][5][1][6] = 0;
+
+        coeff[1][0][0][0] = 1;
+        coeff[1][0][0][1] = 0;
+        coeff[1][0][0][2] = 0;
+        coeff[1][0][0][3] = 0;
+        coeff[1][0][0][4] = 0;
+        coeff[1][0][0][5] = 0;
+        coeff[1][0][0][6] = 0;
+
+        coeff[1][0][1][0] = 0;
+        coeff[1][0][1][1] = 0;
+        coeff[1][0][1][2] = 0;
+        coeff[1][0][1][3] = 0;
+        coeff[1][0][1][4] = 0;
+        coeff[1][0][1][5] = 0;
+        coeff[1][0][1][6] = 0;
+
+        coeff[1][1][0][0] = 2099988056465336;
+        coeff[1][1][0][1] = 20964146866715418;
+        coeff[1][1][0][2] = 26479447919286778;
+        coeff[1][1][0][3] = 28687334188327454;
+        coeff[1][1][0][4] = 18245231482781651;
+        coeff[1][1][0][5] = 21665078698214405;
+        coeff[1][1][0][6] = 1760545476751041;
+
+        coeff[1][1][1][0] = 33647333985766131;
+        coeff[1][1][1][1] = 15061775342732377;
+        coeff[1][1][1][2] = 10634308716634293;
+        coeff[1][1][1][3] = 15267386808624246;
+        coeff[1][1][1][4] = 34335022074067067;
+        coeff[1][1][1][5] = 1778035881690211;
+        coeff[1][1][1][6] = 69335985795384;
+
+        coeff[1][2][0][0] = 0;
+        coeff[1][2][0][1] = 0;
+        coeff[1][2][0][2] = 0;
+        coeff[1][2][0][3] = 0;
+        coeff[1][2][0][4] = 0;
+        coeff[1][2][0][5] = 0;
+        coeff[1][2][0][6] = 0;
+
+        coeff[1][2][1][0] = 35184372088875692;
+        coeff[1][2][1][1] = 22472499736345367;
+        coeff[1][2][1][2] = 5698637743850064;
+        coeff[1][2][1][3] = 21300661132716363;
+        coeff[1][2][1][4] = 21929049149954008;
+        coeff[1][2][1][5] = 23430044241153146;
+        coeff[1][2][1][6] = 1829881462546425;
+
+        coeff[1][3][0][0] = 4649817190157321;
+        coeff[1][3][0][1] = 14178090100713872;
+        coeff[1][3][0][2] = 25898210532243870;
+        coeff[1][3][0][3] = 6361890036890480;
+        coeff[1][3][0][4] = 6755281389607612;
+        coeff[1][3][0][5] = 401348527762810;
+        coeff[1][3][0][6] = 470331148861392;
+
+        coeff[1][3][1][0] = 4649817190157321;
+        coeff[1][3][1][1] = 14178090100713872;
+        coeff[1][3][1][2] = 25898210532243870;
+        coeff[1][3][1][3] = 6361890036890480;
+        coeff[1][3][1][4] = 6755281389607612;
+        coeff[1][3][1][5] = 401348527762810;
+        coeff[1][3][1][6] = 470331148861392;
+
+        coeff[1][4][0][0] = 35184372088875693;
+        coeff[1][4][0][1] = 22472499736345367;
+        coeff[1][4][0][2] = 5698637743850064;
+        coeff[1][4][0][3] = 21300661132716363;
+        coeff[1][4][0][4] = 21929049149954008;
+        coeff[1][4][0][5] = 23430044241153146;
+        coeff[1][4][0][6] = 1829881462546425;
+
+        coeff[1][4][1][0] = 0;
+        coeff[1][4][1][1] = 0;
+        coeff[1][4][1][2] = 0;
+        coeff[1][4][1][3] = 0;
+        coeff[1][4][1][4] = 0;
+        coeff[1][4][1][5] = 0;
+        coeff[1][4][1][6] = 0;
+
+        coeff[1][5][0][0] = 7031280223355158;
+        coeff[1][5][0][1] = 35145111776945462;
+        coeff[1][5][0][2] = 15263901815609576;
+        coeff[1][5][0][3] = 27123300247230202;
+        coeff[1][5][0][4] = 8449056334504512;
+        coeff[1][5][0][5] = 34652109665036566;
+        coeff[1][5][0][6] = 400995163066007;
+
+        coeff[1][5][1][0] = 28716041818876309;
+        coeff[1][5][1][1] = 880810432502333;
+        coeff[1][5][1][2] = 21849854820311495;
+        coeff[1][5][1][3] = 16831420749721498;
+        coeff[1][5][1][4] = 8102400203380238;
+        coeff[1][5][1][5] = 24819801933832019;
+        coeff[1][5][1][6] = 1428886299480417;
+
+        coeff[2][0][0][0] = 1;
+        coeff[2][0][0][1] = 0;
+        coeff[2][0][0][2] = 0;
+        coeff[2][0][0][3] = 0;
+        coeff[2][0][0][4] = 0;
+        coeff[2][0][0][5] = 0;
+        coeff[2][0][0][6] = 0;
+
+        coeff[2][0][1][0] = 0;
+        coeff[2][0][1][1] = 0;
+        coeff[2][0][1][2] = 0;
+        coeff[2][0][1][3] = 0;
+        coeff[2][0][1][4] = 0;
+        coeff[2][0][1][5] = 0;
+        coeff[2][0][1][6] = 0;
+
+        coeff[2][1][0][0] = 562949953355775;
+        coeff[2][1][0][1] = 13553422473102428;
+        coeff[2][1][0][2] = 31415118892071007;
+        coeff[2][1][0][3] = 22654059864235337;
+        coeff[2][1][0][4] = 30651204406894710;
+        coeff[2][1][0][5] = 13070338751470;
+        coeff[2][1][0][6] = 0;
+
+        coeff[2][1][1][0] = 0;
+        coeff[2][1][1][1] = 0;
+        coeff[2][1][1][2] = 0;
+        coeff[2][1][1][3] = 0;
+        coeff[2][1][1][4] = 0;
+        coeff[2][1][1][5] = 0;
+        coeff[2][1][1][6] = 0;
+
+        coeff[2][2][0][0] = 562949953355774;
+        coeff[2][2][0][1] = 13553422473102428;
+        coeff[2][2][0][2] = 31415118892071007;
+        coeff[2][2][0][3] = 22654059864235337;
+        coeff[2][2][0][4] = 30651204406894710;
+        coeff[2][2][0][5] = 13070338751470;
+        coeff[2][2][0][6] = 0;
+
+        coeff[2][2][1][0] = 0;
+        coeff[2][2][1][1] = 0;
+        coeff[2][2][1][2] = 0;
+        coeff[2][2][1][3] = 0;
+        coeff[2][2][1][4] = 0;
+        coeff[2][2][1][5] = 0;
+        coeff[2][2][1][6] = 0;
+
+        coeff[2][3][0][0] = 35747322042231466;
+        coeff[2][3][0][1] = 36025922209447795;
+        coeff[2][3][0][2] = 1084959616957103;
+        coeff[2][3][0][3] = 7925923977987733;
+        coeff[2][3][0][4] = 16551456537884751;
+        coeff[2][3][0][5] = 23443114579904617;
+        coeff[2][3][0][6] = 1829881462546425;
+
+        coeff[2][3][1][0] = 0;
+        coeff[2][3][1][1] = 0;
+        coeff[2][3][1][2] = 0;
+        coeff[2][3][1][3] = 0;
+        coeff[2][3][1][4] = 0;
+        coeff[2][3][1][5] = 0;
+        coeff[2][3][1][6] = 0;
+
+        coeff[2][4][0][0] = 35184372088875692;
+        coeff[2][4][0][1] = 22472499736345367;
+        coeff[2][4][0][2] = 5698637743850064;
+        coeff[2][4][0][3] = 21300661132716363;
+        coeff[2][4][0][4] = 21929049149954008;
+        coeff[2][4][0][5] = 23430044241153146;
+        coeff[2][4][0][6] = 1829881462546425;
+
+        coeff[2][4][1][0] = 0;
+        coeff[2][4][1][1] = 0;
+        coeff[2][4][1][2] = 0;
+        coeff[2][4][1][3] = 0;
+        coeff[2][4][1][4] = 0;
+        coeff[2][4][1][5] = 0;
+        coeff[2][4][1][6] = 0;
+
+        coeff[2][5][0][0] = 35184372088875693;
+        coeff[2][5][0][1] = 22472499736345367;
+        coeff[2][5][0][2] = 5698637743850064;
+        coeff[2][5][0][3] = 21300661132716363;
+        coeff[2][5][0][4] = 21929049149954008;
+        coeff[2][5][0][5] = 23430044241153146;
+        coeff[2][5][0][6] = 1829881462546425;
+
+        coeff[2][5][1][0] = 0;
+        coeff[2][5][1][1] = 0;
+        coeff[2][5][1][2] = 0;
+        coeff[2][5][1][3] = 0;
+        coeff[2][5][1][4] = 0;
+        coeff[2][5][1][5] = 0;
+        coeff[2][5][1][6] = 0;
+
+        coeff[3][0][0][0] = 1;
+        coeff[3][0][0][1] = 0;
+        coeff[3][0][0][2] = 0;
+        coeff[3][0][0][3] = 0;
+        coeff[3][0][0][4] = 0;
+        coeff[3][0][0][5] = 0;
+        coeff[3][0][0][6] = 0;
+
+        coeff[3][0][1][0] = 0;
+        coeff[3][0][1][1] = 0;
+        coeff[3][0][1][2] = 0;
+        coeff[3][0][1][3] = 0;
+        coeff[3][0][1][4] = 0;
+        coeff[3][0][1][5] = 0;
+        coeff[3][0][1][6] = 0;
+
+        coeff[3][1][0][0] = 31097504852074146;
+        coeff[3][1][0][1] = 21847832108733923;
+        coeff[3][1][0][2] = 11215546103677201;
+        coeff[3][1][0][3] = 1564033941097252;
+        coeff[3][1][0][4] = 9796175148277139;
+        coeff[3][1][0][5] = 23041766052141807;
+        coeff[3][1][0][6] = 1359550313685033;
+
+        coeff[3][1][1][0] = 4649817190157321;
+        coeff[3][1][1][1] = 14178090100713872;
+        coeff[3][1][1][2] = 25898210532243870;
+        coeff[3][1][1][3] = 6361890036890480;
+        coeff[3][1][1][4] = 6755281389607612;
+        coeff[3][1][1][5] = 401348527762810;
+        coeff[3][1][1][6] = 470331148861392;
+
+        coeff[3][2][0][0] = 0;
+        coeff[3][2][0][1] = 0;
+        coeff[3][2][0][2] = 0;
+        coeff[3][2][0][3] = 0;
+        coeff[3][2][0][4] = 0;
+        coeff[3][2][0][5] = 0;
+        coeff[3][2][0][6] = 0;
+
+        coeff[3][2][1][0] = 1;
+        coeff[3][2][1][1] = 0;
+        coeff[3][2][1][2] = 0;
+        coeff[3][2][1][3] = 0;
+        coeff[3][2][1][4] = 0;
+        coeff[3][2][1][5] = 0;
+        coeff[3][2][1][6] = 0;
+
+        coeff[3][3][0][0] = 31097504852074146;
+        coeff[3][3][0][1] = 21847832108733923;
+        coeff[3][3][0][2] = 11215546103677201;
+        coeff[3][3][0][3] = 1564033941097252;
+        coeff[3][3][0][4] = 9796175148277139;
+        coeff[3][3][0][5] = 23041766052141807;
+        coeff[3][3][0][6] = 1359550313685033;
+
+        coeff[3][3][1][0] = 31097504852074146;
+        coeff[3][3][1][1] = 21847832108733923;
+        coeff[3][3][1][2] = 11215546103677201;
+        coeff[3][3][1][3] = 1564033941097252;
+        coeff[3][3][1][4] = 9796175148277139;
+        coeff[3][3][1][5] = 23041766052141807;
+        coeff[3][3][1][6] = 1359550313685033;
+
+        coeff[3][4][0][0] = 35747322042231466;
+        coeff[3][4][0][1] = 36025922209447795;
+        coeff[3][4][0][2] = 1084959616957103;
+        coeff[3][4][0][3] = 7925923977987733;
+        coeff[3][4][0][4] = 16551456537884751;
+        coeff[3][4][0][5] = 23443114579904617;
+        coeff[3][4][0][6] = 1829881462546425;
+
+        coeff[3][4][1][0] = 0;
+        coeff[3][4][1][1] = 0;
+        coeff[3][4][1][2] = 0;
+        coeff[3][4][1][3] = 0;
+        coeff[3][4][1][4] = 0;
+        coeff[3][4][1][5] = 0;
+        coeff[3][4][1][6] = 0;
+
+        coeff[3][5][0][0] = 4649817190157321;
+        coeff[3][5][0][1] = 14178090100713872;
+        coeff[3][5][0][2] = 25898210532243870;
+        coeff[3][5][0][3] = 6361890036890480;
+        coeff[3][5][0][4] = 6755281389607612;
+        coeff[3][5][0][5] = 401348527762810;
+        coeff[3][5][0][6] = 470331148861392;
+
+        coeff[3][5][1][0] = 31097504852074146;
+        coeff[3][5][1][1] = 21847832108733923;
+        coeff[3][5][1][2] = 11215546103677201;
+        coeff[3][5][1][3] = 1564033941097252;
+        coeff[3][5][1][4] = 9796175148277139;
+        coeff[3][5][1][5] = 23041766052141807;
+        coeff[3][5][1][6] = 1359550313685033;
+
+        coeff[4][0][0][0] = 1;
+        coeff[4][0][0][1] = 0;
+        coeff[4][0][0][2] = 0;
+        coeff[4][0][0][3] = 0;
+        coeff[4][0][0][4] = 0;
+        coeff[4][0][0][5] = 0;
+        coeff[4][0][0][6] = 0;
+
+        coeff[4][0][1][0] = 0;
+        coeff[4][0][1][1] = 0;
+        coeff[4][0][1][2] = 0;
+        coeff[4][0][1][3] = 0;
+        coeff[4][0][1][4] = 0;
+        coeff[4][0][1][5] = 0;
+        coeff[4][0][1][6] = 0;
+
+        coeff[4][1][0][0] = 562949953355774;
+        coeff[4][1][0][1] = 13553422473102428;
+        coeff[4][1][0][2] = 31415118892071007;
+        coeff[4][1][0][3] = 22654059864235337;
+        coeff[4][1][0][4] = 30651204406894710;
+        coeff[4][1][0][5] = 13070338751470;
+        coeff[4][1][0][6] = 0;
+
+        coeff[4][1][1][0] = 0;
+        coeff[4][1][1][1] = 0;
+        coeff[4][1][1][2] = 0;
+        coeff[4][1][1][3] = 0;
+        coeff[4][1][1][4] = 0;
+        coeff[4][1][1][5] = 0;
+        coeff[4][1][1][6] = 0;
+
+        coeff[4][2][0][0] = 35184372088875692;
+        coeff[4][2][0][1] = 22472499736345367;
+        coeff[4][2][0][2] = 5698637743850064;
+        coeff[4][2][0][3] = 21300661132716363;
+        coeff[4][2][0][4] = 21929049149954008;
+        coeff[4][2][0][5] = 23430044241153146;
+        coeff[4][2][0][6] = 1829881462546425;
+
+        coeff[4][2][1][0] = 0;
+        coeff[4][2][1][1] = 0;
+        coeff[4][2][1][2] = 0;
+        coeff[4][2][1][3] = 0;
+        coeff[4][2][1][4] = 0;
+        coeff[4][2][1][5] = 0;
+        coeff[4][2][1][6] = 0;
+
+        coeff[4][3][0][0] = 1;
+        coeff[4][3][0][1] = 0;
+        coeff[4][3][0][2] = 0;
+        coeff[4][3][0][3] = 0;
+        coeff[4][3][0][4] = 0;
+        coeff[4][3][0][5] = 0;
+        coeff[4][3][0][6] = 0;
+
+        coeff[4][3][1][0] = 0;
+        coeff[4][3][1][1] = 0;
+        coeff[4][3][1][2] = 0;
+        coeff[4][3][1][3] = 0;
+        coeff[4][3][1][4] = 0;
+        coeff[4][3][1][5] = 0;
+        coeff[4][3][1][6] = 0;
+
+        coeff[4][4][0][0] = 562949953355774;
+        coeff[4][4][0][1] = 13553422473102428;
+        coeff[4][4][0][2] = 31415118892071007;
+        coeff[4][4][0][3] = 22654059864235337;
+        coeff[4][4][0][4] = 30651204406894710;
+        coeff[4][4][0][5] = 13070338751470;
+        coeff[4][4][0][6] = 0;
+
+        coeff[4][4][1][0] = 0;
+        coeff[4][4][1][1] = 0;
+        coeff[4][4][1][2] = 0;
+        coeff[4][4][1][3] = 0;
+        coeff[4][4][1][4] = 0;
+        coeff[4][4][1][5] = 0;
+        coeff[4][4][1][6] = 0;
+
+        coeff[4][5][0][0] = 35184372088875692;
+        coeff[4][5][0][1] = 22472499736345367;
+        coeff[4][5][0][2] = 5698637743850064;
+        coeff[4][5][0][3] = 21300661132716363;
+        coeff[4][5][0][4] = 21929049149954008;
+        coeff[4][5][0][5] = 23430044241153146;
+        coeff[4][5][0][6] = 1829881462546425;
+
+        coeff[4][5][1][0] = 0;
+        coeff[4][5][1][1] = 0;
+        coeff[4][5][1][2] = 0;
+        coeff[4][5][1][3] = 0;
+        coeff[4][5][1][4] = 0;
+        coeff[4][5][1][5] = 0;
+        coeff[4][5][1][6] = 0;
+
+        coeff[5][0][0][0] = 1;
+        coeff[5][0][0][1] = 0;
+        coeff[5][0][0][2] = 0;
+        coeff[5][0][0][3] = 0;
+        coeff[5][0][0][4] = 0;
+        coeff[5][0][0][5] = 0;
+        coeff[5][0][0][6] = 0;
+
+        coeff[5][0][1][0] = 0;
+        coeff[5][0][1][1] = 0;
+        coeff[5][0][1][2] = 0;
+        coeff[5][0][1][3] = 0;
+        coeff[5][0][1][4] = 0;
+        coeff[5][0][1][5] = 0;
+        coeff[5][0][1][6] = 0;
+
+        coeff[5][1][0][0] = 28716041818876309;
+        coeff[5][1][0][1] = 880810432502333;
+        coeff[5][1][0][2] = 21849854820311495;
+        coeff[5][1][0][3] = 16831420749721498;
+        coeff[5][1][0][4] = 8102400203380238;
+        coeff[5][1][0][5] = 24819801933832019;
+        coeff[5][1][0][6] = 1428886299480417;
+
+        coeff[5][1][1][0] = 7031280223355158;
+        coeff[5][1][1][1] = 35145111776945462;
+        coeff[5][1][1][2] = 15263901815609576;
+        coeff[5][1][1][3] = 27123300247230202;
+        coeff[5][1][1][4] = 8449056334504512;
+        coeff[5][1][1][5] = 34652109665036566;
+        coeff[5][1][1][6] = 400995163066007;
+
+        coeff[5][2][0][0] = 0;
+        coeff[5][2][0][1] = 0;
+        coeff[5][2][0][2] = 0;
+        coeff[5][2][0][3] = 0;
+        coeff[5][2][0][4] = 0;
+        coeff[5][2][0][5] = 0;
+        coeff[5][2][0][6] = 0;
+
+        coeff[5][2][1][0] = 562949953355774;
+        coeff[5][2][1][1] = 13553422473102428;
+        coeff[5][2][1][2] = 31415118892071007;
+        coeff[5][2][1][3] = 22654059864235337;
+        coeff[5][2][1][4] = 30651204406894710;
+        coeff[5][2][1][5] = 13070338751470;
+        coeff[5][2][1][6] = 0;
+
+        coeff[5][3][0][0] = 4649817190157321;
+        coeff[5][3][0][1] = 14178090100713872;
+        coeff[5][3][0][2] = 25898210532243870;
+        coeff[5][3][0][3] = 6361890036890480;
+        coeff[5][3][0][4] = 6755281389607612;
+        coeff[5][3][0][5] = 401348527762810;
+        coeff[5][3][0][6] = 470331148861392;
+
+        coeff[5][3][1][0] = 4649817190157321;
+        coeff[5][3][1][1] = 14178090100713872;
+        coeff[5][3][1][2] = 25898210532243870;
+        coeff[5][3][1][3] = 6361890036890480;
+        coeff[5][3][1][4] = 6755281389607612;
+        coeff[5][3][1][5] = 401348527762810;
+        coeff[5][3][1][6] = 470331148861392;
+
+        coeff[5][4][0][0] = 562949953355775;
+        coeff[5][4][0][1] = 13553422473102428;
+        coeff[5][4][0][2] = 31415118892071007;
+        coeff[5][4][0][3] = 22654059864235337;
+        coeff[5][4][0][4] = 30651204406894710;
+        coeff[5][4][0][5] = 13070338751470;
+        coeff[5][4][0][6] = 0;
+
+        coeff[5][4][1][0] = 0;
+        coeff[5][4][1][1] = 0;
+        coeff[5][4][1][2] = 0;
+        coeff[5][4][1][3] = 0;
+        coeff[5][4][1][4] = 0;
+        coeff[5][4][1][5] = 0;
+        coeff[5][4][1][6] = 0;
+
+        coeff[5][5][0][0] = 33647333985766131;
+        coeff[5][5][0][1] = 15061775342732377;
+        coeff[5][5][0][2] = 10634308716634293;
+        coeff[5][5][0][3] = 15267386808624246;
+        coeff[5][5][0][4] = 34335022074067067;
+        coeff[5][5][0][5] = 1778035881690211;
+        coeff[5][5][0][6] = 69335985795384;
+
+        coeff[5][5][1][0] = 2099988056465336;
+        coeff[5][5][1][1] = 20964146866715418;
+        coeff[5][5][1][2] = 26479447919286778;
+        coeff[5][5][1][3] = 28687334188327454;
+        coeff[5][5][1][4] = 18245231482781651;
+        coeff[5][5][1][5] = 21665078698214405;
+        coeff[5][5][1][6] = 1760545476751041;
+
+        coeff[6][0][0][0] = 1;
+        coeff[6][0][0][1] = 0;
+        coeff[6][0][0][2] = 0;
+        coeff[6][0][0][3] = 0;
+        coeff[6][0][0][4] = 0;
+        coeff[6][0][0][5] = 0;
+        coeff[6][0][0][6] = 0;
+
+        coeff[6][0][1][0] = 0;
+        coeff[6][0][1][1] = 0;
+        coeff[6][0][1][2] = 0;
+        coeff[6][0][1][3] = 0;
+        coeff[6][0][1][4] = 0;
+        coeff[6][0][1][5] = 0;
+        coeff[6][0][1][6] = 0;
+
+        coeff[6][1][0][0] = 35747322042231466;
+        coeff[6][1][0][1] = 36025922209447795;
+        coeff[6][1][0][2] = 1084959616957103;
+        coeff[6][1][0][3] = 7925923977987733;
+        coeff[6][1][0][4] = 16551456537884751;
+        coeff[6][1][0][5] = 23443114579904617;
+        coeff[6][1][0][6] = 1829881462546425;
+
+        coeff[6][1][1][0] = 0;
+        coeff[6][1][1][1] = 0;
+        coeff[6][1][1][2] = 0;
+        coeff[6][1][1][3] = 0;
+        coeff[6][1][1][4] = 0;
+        coeff[6][1][1][5] = 0;
+        coeff[6][1][1][6] = 0;
+
+        coeff[6][2][0][0] = 1;
+        coeff[6][2][0][1] = 0;
+        coeff[6][2][0][2] = 0;
+        coeff[6][2][0][3] = 0;
+        coeff[6][2][0][4] = 0;
+        coeff[6][2][0][5] = 0;
+        coeff[6][2][0][6] = 0;
+
+        coeff[6][2][1][0] = 0;
+        coeff[6][2][1][1] = 0;
+        coeff[6][2][1][2] = 0;
+        coeff[6][2][1][3] = 0;
+        coeff[6][2][1][4] = 0;
+        coeff[6][2][1][5] = 0;
+        coeff[6][2][1][6] = 0;
+
+        coeff[6][3][0][0] = 35747322042231466;
+        coeff[6][3][0][1] = 36025922209447795;
+        coeff[6][3][0][2] = 1084959616957103;
+        coeff[6][3][0][3] = 7925923977987733;
+        coeff[6][3][0][4] = 16551456537884751;
+        coeff[6][3][0][5] = 23443114579904617;
+        coeff[6][3][0][6] = 1829881462546425;
+
+        coeff[6][3][1][0] = 0;
+        coeff[6][3][1][1] = 0;
+        coeff[6][3][1][2] = 0;
+        coeff[6][3][1][3] = 0;
+        coeff[6][3][1][4] = 0;
+        coeff[6][3][1][5] = 0;
+        coeff[6][3][1][6] = 0;
+
+        coeff[6][4][0][0] = 1;
+        coeff[6][4][0][1] = 0;
+        coeff[6][4][0][2] = 0;
+        coeff[6][4][0][3] = 0;
+        coeff[6][4][0][4] = 0;
+        coeff[6][4][0][5] = 0;
+        coeff[6][4][0][6] = 0;
+
+        coeff[6][4][1][0] = 0;
+        coeff[6][4][1][1] = 0;
+        coeff[6][4][1][2] = 0;
+        coeff[6][4][1][3] = 0;
+        coeff[6][4][1][4] = 0;
+        coeff[6][4][1][5] = 0;
+        coeff[6][4][1][6] = 0;
+
+        coeff[6][5][0][0] = 35747322042231466;
+        coeff[6][5][0][1] = 36025922209447795;
+        coeff[6][5][0][2] = 1084959616957103;
+        coeff[6][5][0][3] = 7925923977987733;
+        coeff[6][5][0][4] = 16551456537884751;
+        coeff[6][5][0][5] = 23443114579904617;
+        coeff[6][5][0][6] = 1829881462546425;
+
+        coeff[6][5][1][0] = 0;
+        coeff[6][5][1][1] = 0;
+        coeff[6][5][1][2] = 0;
+        coeff[6][5][1][3] = 0;
+        coeff[6][5][1][4] = 0;
+        coeff[6][5][1][5] = 0;
+        coeff[6][5][1][6] = 0;
+
+        coeff[7][0][0][0] = 1;
+        coeff[7][0][0][1] = 0;
+        coeff[7][0][0][2] = 0;
+        coeff[7][0][0][3] = 0;
+        coeff[7][0][0][4] = 0;
+        coeff[7][0][0][5] = 0;
+        coeff[7][0][0][6] = 0;
+
+        coeff[7][0][1][0] = 0;
+        coeff[7][0][1][1] = 0;
+        coeff[7][0][1][2] = 0;
+        coeff[7][0][1][3] = 0;
+        coeff[7][0][1][4] = 0;
+        coeff[7][0][1][5] = 0;
+        coeff[7][0][1][6] = 0;
+
+        coeff[7][1][0][0] = 33647333985766131;
+        coeff[7][1][0][1] = 15061775342732377;
+        coeff[7][1][0][2] = 10634308716634293;
+        coeff[7][1][0][3] = 15267386808624246;
+        coeff[7][1][0][4] = 34335022074067067;
+        coeff[7][1][0][5] = 1778035881690211;
+        coeff[7][1][0][6] = 69335985795384;
+
+        coeff[7][1][1][0] = 2099988056465336;
+        coeff[7][1][1][1] = 20964146866715418;
+        coeff[7][1][1][2] = 26479447919286778;
+        coeff[7][1][1][3] = 28687334188327454;
+        coeff[7][1][1][4] = 18245231482781651;
+        coeff[7][1][1][5] = 21665078698214405;
+        coeff[7][1][1][6] = 1760545476751041;
+
+        coeff[7][2][0][0] = 0;
+        coeff[7][2][0][1] = 0;
+        coeff[7][2][0][2] = 0;
+        coeff[7][2][0][3] = 0;
+        coeff[7][2][0][4] = 0;
+        coeff[7][2][0][5] = 0;
+        coeff[7][2][0][6] = 0;
+
+        coeff[7][2][1][0] = 35184372088875692;
+        coeff[7][2][1][1] = 22472499736345367;
+        coeff[7][2][1][2] = 5698637743850064;
+        coeff[7][2][1][3] = 21300661132716363;
+        coeff[7][2][1][4] = 21929049149954008;
+        coeff[7][2][1][5] = 23430044241153146;
+        coeff[7][2][1][6] = 1829881462546425;
+
+        coeff[7][3][0][0] = 31097504852074146;
+        coeff[7][3][0][1] = 21847832108733923;
+        coeff[7][3][0][2] = 11215546103677201;
+        coeff[7][3][0][3] = 1564033941097252;
+        coeff[7][3][0][4] = 9796175148277139;
+        coeff[7][3][0][5] = 23041766052141807;
+        coeff[7][3][0][6] = 1359550313685033;
+
+        coeff[7][3][1][0] = 31097504852074146;
+        coeff[7][3][1][1] = 21847832108733923;
+        coeff[7][3][1][2] = 11215546103677201;
+        coeff[7][3][1][3] = 1564033941097252;
+        coeff[7][3][1][4] = 9796175148277139;
+        coeff[7][3][1][5] = 23041766052141807;
+        coeff[7][3][1][6] = 1359550313685033;
+
+        coeff[7][4][0][0] = 35184372088875693;
+        coeff[7][4][0][1] = 22472499736345367;
+        coeff[7][4][0][2] = 5698637743850064;
+        coeff[7][4][0][3] = 21300661132716363;
+        coeff[7][4][0][4] = 21929049149954008;
+        coeff[7][4][0][5] = 23430044241153146;
+        coeff[7][4][0][6] = 1829881462546425;
+
+        coeff[7][4][1][0] = 0;
+        coeff[7][4][1][1] = 0;
+        coeff[7][4][1][2] = 0;
+        coeff[7][4][1][3] = 0;
+        coeff[7][4][1][4] = 0;
+        coeff[7][4][1][5] = 0;
+        coeff[7][4][1][6] = 0;
+
+        coeff[7][5][0][0] = 28716041818876309;
+        coeff[7][5][0][1] = 880810432502333;
+        coeff[7][5][0][2] = 21849854820311495;
+        coeff[7][5][0][3] = 16831420749721498;
+        coeff[7][5][0][4] = 8102400203380238;
+        coeff[7][5][0][5] = 24819801933832019;
+        coeff[7][5][0][6] = 1428886299480417;
+
+        coeff[7][5][1][0] = 7031280223355158;
+        coeff[7][5][1][1] = 35145111776945462;
+        coeff[7][5][1][2] = 15263901815609576;
+        coeff[7][5][1][3] = 27123300247230202;
+        coeff[7][5][1][4] = 8449056334504512;
+        coeff[7][5][1][5] = 34652109665036566;
+        coeff[7][5][1][6] = 400995163066007;
+
+        coeff[8][0][0][0] = 1;
+        coeff[8][0][0][1] = 0;
+        coeff[8][0][0][2] = 0;
+        coeff[8][0][0][3] = 0;
+        coeff[8][0][0][4] = 0;
+        coeff[8][0][0][5] = 0;
+        coeff[8][0][0][6] = 0;
+
+        coeff[8][0][1][0] = 0;
+        coeff[8][0][1][1] = 0;
+        coeff[8][0][1][2] = 0;
+        coeff[8][0][1][3] = 0;
+        coeff[8][0][1][4] = 0;
+        coeff[8][0][1][5] = 0;
+        coeff[8][0][1][6] = 0;
+
+        coeff[8][1][0][0] = 35184372088875692;
+        coeff[8][1][0][1] = 22472499736345367;
+        coeff[8][1][0][2] = 5698637743850064;
+        coeff[8][1][0][3] = 21300661132716363;
+        coeff[8][1][0][4] = 21929049149954008;
+        coeff[8][1][0][5] = 23430044241153146;
+        coeff[8][1][0][6] = 1829881462546425;
+
+        coeff[8][1][1][0] = 0;
+        coeff[8][1][1][1] = 0;
+        coeff[8][1][1][2] = 0;
+        coeff[8][1][1][3] = 0;
+        coeff[8][1][1][4] = 0;
+        coeff[8][1][1][5] = 0;
+        coeff[8][1][1][6] = 0;
+
+        coeff[8][2][0][0] = 562949953355774;
+        coeff[8][2][0][1] = 13553422473102428;
+        coeff[8][2][0][2] = 31415118892071007;
+        coeff[8][2][0][3] = 22654059864235337;
+        coeff[8][2][0][4] = 30651204406894710;
+        coeff[8][2][0][5] = 13070338751470;
+        coeff[8][2][0][6] = 0;
+
+        coeff[8][2][1][0] = 0;
+        coeff[8][2][1][1] = 0;
+        coeff[8][2][1][2] = 0;
+        coeff[8][2][1][3] = 0;
+        coeff[8][2][1][4] = 0;
+        coeff[8][2][1][5] = 0;
+        coeff[8][2][1][6] = 0;
+
+        coeff[8][3][0][0] = 1;
+        coeff[8][3][0][1] = 0;
+        coeff[8][3][0][2] = 0;
+        coeff[8][3][0][3] = 0;
+        coeff[8][3][0][4] = 0;
+        coeff[8][3][0][5] = 0;
+        coeff[8][3][0][6] = 0;
+
+        coeff[8][3][1][0] = 0;
+        coeff[8][3][1][1] = 0;
+        coeff[8][3][1][2] = 0;
+        coeff[8][3][1][3] = 0;
+        coeff[8][3][1][4] = 0;
+        coeff[8][3][1][5] = 0;
+        coeff[8][3][1][6] = 0;
+
+        coeff[8][4][0][0] = 35184372088875692;
+        coeff[8][4][0][1] = 22472499736345367;
+        coeff[8][4][0][2] = 5698637743850064;
+        coeff[8][4][0][3] = 21300661132716363;
+        coeff[8][4][0][4] = 21929049149954008;
+        coeff[8][4][0][5] = 23430044241153146;
+        coeff[8][4][0][6] = 1829881462546425;
+
+        coeff[8][4][1][0] = 0;
+        coeff[8][4][1][1] = 0;
+        coeff[8][4][1][2] = 0;
+        coeff[8][4][1][3] = 0;
+        coeff[8][4][1][4] = 0;
+        coeff[8][4][1][5] = 0;
+        coeff[8][4][1][6] = 0;
+
+        coeff[8][5][0][0] = 562949953355774;
+        coeff[8][5][0][1] = 13553422473102428;
+        coeff[8][5][0][2] = 31415118892071007;
+        coeff[8][5][0][3] = 22654059864235337;
+        coeff[8][5][0][4] = 30651204406894710;
+        coeff[8][5][0][5] = 13070338751470;
+        coeff[8][5][0][6] = 0;
+
+        coeff[8][5][1][0] = 0;
+        coeff[8][5][1][1] = 0;
+        coeff[8][5][1][2] = 0;
+        coeff[8][5][1][3] = 0;
+        coeff[8][5][1][4] = 0;
+        coeff[8][5][1][5] = 0;
+        coeff[8][5][1][6] = 0;
+
+        coeff[9][0][0][0] = 1;
+        coeff[9][0][0][1] = 0;
+        coeff[9][0][0][2] = 0;
+        coeff[9][0][0][3] = 0;
+        coeff[9][0][0][4] = 0;
+        coeff[9][0][0][5] = 0;
+        coeff[9][0][0][6] = 0;
+
+        coeff[9][0][1][0] = 0;
+        coeff[9][0][1][1] = 0;
+        coeff[9][0][1][2] = 0;
+        coeff[9][0][1][3] = 0;
+        coeff[9][0][1][4] = 0;
+        coeff[9][0][1][5] = 0;
+        coeff[9][0][1][6] = 0;
+
+        coeff[9][1][0][0] = 4649817190157321;
+        coeff[9][1][0][1] = 14178090100713872;
+        coeff[9][1][0][2] = 25898210532243870;
+        coeff[9][1][0][3] = 6361890036890480;
+        coeff[9][1][0][4] = 6755281389607612;
+        coeff[9][1][0][5] = 401348527762810;
+        coeff[9][1][0][6] = 470331148861392;
+
+        coeff[9][1][1][0] = 31097504852074146;
+        coeff[9][1][1][1] = 21847832108733923;
+        coeff[9][1][1][2] = 11215546103677201;
+        coeff[9][1][1][3] = 1564033941097252;
+        coeff[9][1][1][4] = 9796175148277139;
+        coeff[9][1][1][5] = 23041766052141807;
+        coeff[9][1][1][6] = 1359550313685033;
+
+        coeff[9][2][0][0] = 0;
+        coeff[9][2][0][1] = 0;
+        coeff[9][2][0][2] = 0;
+        coeff[9][2][0][3] = 0;
+        coeff[9][2][0][4] = 0;
+        coeff[9][2][0][5] = 0;
+        coeff[9][2][0][6] = 0;
+
+        coeff[9][2][1][0] = 1;
+        coeff[9][2][1][1] = 0;
+        coeff[9][2][1][2] = 0;
+        coeff[9][2][1][3] = 0;
+        coeff[9][2][1][4] = 0;
+        coeff[9][2][1][5] = 0;
+        coeff[9][2][1][6] = 0;
+
+        coeff[9][3][0][0] = 4649817190157321;
+        coeff[9][3][0][1] = 14178090100713872;
+        coeff[9][3][0][2] = 25898210532243870;
+        coeff[9][3][0][3] = 6361890036890480;
+        coeff[9][3][0][4] = 6755281389607612;
+        coeff[9][3][0][5] = 401348527762810;
+        coeff[9][3][0][6] = 470331148861392;
+
+        coeff[9][3][1][0] = 4649817190157321;
+        coeff[9][3][1][1] = 14178090100713872;
+        coeff[9][3][1][2] = 25898210532243870;
+        coeff[9][3][1][3] = 6361890036890480;
+        coeff[9][3][1][4] = 6755281389607612;
+        coeff[9][3][1][5] = 401348527762810;
+        coeff[9][3][1][6] = 470331148861392;
+
+        coeff[9][4][0][0] = 35747322042231466;
+        coeff[9][4][0][1] = 36025922209447795;
+        coeff[9][4][0][2] = 1084959616957103;
+        coeff[9][4][0][3] = 7925923977987733;
+        coeff[9][4][0][4] = 16551456537884751;
+        coeff[9][4][0][5] = 23443114579904617;
+        coeff[9][4][0][6] = 1829881462546425;
+
+        coeff[9][4][1][0] = 0;
+        coeff[9][4][1][1] = 0;
+        coeff[9][4][1][2] = 0;
+        coeff[9][4][1][3] = 0;
+        coeff[9][4][1][4] = 0;
+        coeff[9][4][1][5] = 0;
+        coeff[9][4][1][6] = 0;
+
+        coeff[9][5][0][0] = 31097504852074146;
+        coeff[9][5][0][1] = 21847832108733923;
+        coeff[9][5][0][2] = 11215546103677201;
+        coeff[9][5][0][3] = 1564033941097252;
+        coeff[9][5][0][4] = 9796175148277139;
+        coeff[9][5][0][5] = 23041766052141807;
+        coeff[9][5][0][6] = 1359550313685033;
+
+        coeff[9][5][1][0] = 4649817190157321;
+        coeff[9][5][1][1] = 14178090100713872;
+        coeff[9][5][1][2] = 25898210532243870;
+        coeff[9][5][1][3] = 6361890036890480;
+        coeff[9][5][1][4] = 6755281389607612;
+        coeff[9][5][1][5] = 401348527762810;
+        coeff[9][5][1][6] = 470331148861392;
+
+        coeff[10][0][0][0] = 1;
+        coeff[10][0][0][1] = 0;
+        coeff[10][0][0][2] = 0;
+        coeff[10][0][0][3] = 0;
+        coeff[10][0][0][4] = 0;
+        coeff[10][0][0][5] = 0;
+        coeff[10][0][0][6] = 0;
+
+        coeff[10][0][1][0] = 0;
+        coeff[10][0][1][1] = 0;
+        coeff[10][0][1][2] = 0;
+        coeff[10][0][1][3] = 0;
+        coeff[10][0][1][4] = 0;
+        coeff[10][0][1][5] = 0;
+        coeff[10][0][1][6] = 0;
+
+        coeff[10][1][0][0] = 35184372088875693;
+        coeff[10][1][0][1] = 22472499736345367;
+        coeff[10][1][0][2] = 5698637743850064;
+        coeff[10][1][0][3] = 21300661132716363;
+        coeff[10][1][0][4] = 21929049149954008;
+        coeff[10][1][0][5] = 23430044241153146;
+        coeff[10][1][0][6] = 1829881462546425;
+
+        coeff[10][1][1][0] = 0;
+        coeff[10][1][1][1] = 0;
+        coeff[10][1][1][2] = 0;
+        coeff[10][1][1][3] = 0;
+        coeff[10][1][1][4] = 0;
+        coeff[10][1][1][5] = 0;
+        coeff[10][1][1][6] = 0;
+
+        coeff[10][2][0][0] = 35184372088875692;
+        coeff[10][2][0][1] = 22472499736345367;
+        coeff[10][2][0][2] = 5698637743850064;
+        coeff[10][2][0][3] = 21300661132716363;
+        coeff[10][2][0][4] = 21929049149954008;
+        coeff[10][2][0][5] = 23430044241153146;
+        coeff[10][2][0][6] = 1829881462546425;
+
+        coeff[10][2][1][0] = 0;
+        coeff[10][2][1][1] = 0;
+        coeff[10][2][1][2] = 0;
+        coeff[10][2][1][3] = 0;
+        coeff[10][2][1][4] = 0;
+        coeff[10][2][1][5] = 0;
+        coeff[10][2][1][6] = 0;
+
+        coeff[10][3][0][0] = 35747322042231466;
+        coeff[10][3][0][1] = 36025922209447795;
+        coeff[10][3][0][2] = 1084959616957103;
+        coeff[10][3][0][3] = 7925923977987733;
+        coeff[10][3][0][4] = 16551456537884751;
+        coeff[10][3][0][5] = 23443114579904617;
+        coeff[10][3][0][6] = 1829881462546425;
+
+        coeff[10][3][1][0] = 0;
+        coeff[10][3][1][1] = 0;
+        coeff[10][3][1][2] = 0;
+        coeff[10][3][1][3] = 0;
+        coeff[10][3][1][4] = 0;
+        coeff[10][3][1][5] = 0;
+        coeff[10][3][1][6] = 0;
+
+        coeff[10][4][0][0] = 562949953355774;
+        coeff[10][4][0][1] = 13553422473102428;
+        coeff[10][4][0][2] = 31415118892071007;
+        coeff[10][4][0][3] = 22654059864235337;
+        coeff[10][4][0][4] = 30651204406894710;
+        coeff[10][4][0][5] = 13070338751470;
+        coeff[10][4][0][6] = 0;
+
+        coeff[10][4][1][0] = 0;
+        coeff[10][4][1][1] = 0;
+        coeff[10][4][1][2] = 0;
+        coeff[10][4][1][3] = 0;
+        coeff[10][4][1][4] = 0;
+        coeff[10][4][1][5] = 0;
+        coeff[10][4][1][6] = 0;
+
+        coeff[10][5][0][0] = 562949953355775;
+        coeff[10][5][0][1] = 13553422473102428;
+        coeff[10][5][0][2] = 31415118892071007;
+        coeff[10][5][0][3] = 22654059864235337;
+        coeff[10][5][0][4] = 30651204406894710;
+        coeff[10][5][0][5] = 13070338751470;
+        coeff[10][5][0][6] = 0;
+
+        coeff[10][5][1][0] = 0;
+        coeff[10][5][1][1] = 0;
+        coeff[10][5][1][2] = 0;
+        coeff[10][5][1][3] = 0;
+        coeff[10][5][1][4] = 0;
+        coeff[10][5][1][5] = 0;
+        coeff[10][5][1][6] = 0;
+
+        coeff[11][0][0][0] = 1;
+        coeff[11][0][0][1] = 0;
+        coeff[11][0][0][2] = 0;
+        coeff[11][0][0][3] = 0;
+        coeff[11][0][0][4] = 0;
+        coeff[11][0][0][5] = 0;
+        coeff[11][0][0][6] = 0;
+
+        coeff[11][0][1][0] = 0;
+        coeff[11][0][1][1] = 0;
+        coeff[11][0][1][2] = 0;
+        coeff[11][0][1][3] = 0;
+        coeff[11][0][1][4] = 0;
+        coeff[11][0][1][5] = 0;
+        coeff[11][0][1][6] = 0;
+
+        coeff[11][1][0][0] = 7031280223355158;
+        coeff[11][1][0][1] = 35145111776945462;
+        coeff[11][1][0][2] = 15263901815609576;
+        coeff[11][1][0][3] = 27123300247230202;
+        coeff[11][1][0][4] = 8449056334504512;
+        coeff[11][1][0][5] = 34652109665036566;
+        coeff[11][1][0][6] = 400995163066007;
+
+        coeff[11][1][1][0] = 28716041818876309;
+        coeff[11][1][1][1] = 880810432502333;
+        coeff[11][1][1][2] = 21849854820311495;
+        coeff[11][1][1][3] = 16831420749721498;
+        coeff[11][1][1][4] = 8102400203380238;
+        coeff[11][1][1][5] = 24819801933832019;
+        coeff[11][1][1][6] = 1428886299480417;
+
+        coeff[11][2][0][0] = 0;
+        coeff[11][2][0][1] = 0;
+        coeff[11][2][0][2] = 0;
+        coeff[11][2][0][3] = 0;
+        coeff[11][2][0][4] = 0;
+        coeff[11][2][0][5] = 0;
+        coeff[11][2][0][6] = 0;
+
+        coeff[11][2][1][0] = 562949953355774;
+        coeff[11][2][1][1] = 13553422473102428;
+        coeff[11][2][1][2] = 31415118892071007;
+        coeff[11][2][1][3] = 22654059864235337;
+        coeff[11][2][1][4] = 30651204406894710;
+        coeff[11][2][1][5] = 13070338751470;
+        coeff[11][2][1][6] = 0;
+
+        coeff[11][3][0][0] = 31097504852074146;
+        coeff[11][3][0][1] = 21847832108733923;
+        coeff[11][3][0][2] = 11215546103677201;
+        coeff[11][3][0][3] = 1564033941097252;
+        coeff[11][3][0][4] = 9796175148277139;
+        coeff[11][3][0][5] = 23041766052141807;
+        coeff[11][3][0][6] = 1359550313685033;
+
+        coeff[11][3][1][0] = 31097504852074146;
+        coeff[11][3][1][1] = 21847832108733923;
+        coeff[11][3][1][2] = 11215546103677201;
+        coeff[11][3][1][3] = 1564033941097252;
+        coeff[11][3][1][4] = 9796175148277139;
+        coeff[11][3][1][5] = 23041766052141807;
+        coeff[11][3][1][6] = 1359550313685033;
+
+        coeff[11][4][0][0] = 562949953355775;
+        coeff[11][4][0][1] = 13553422473102428;
+        coeff[11][4][0][2] = 31415118892071007;
+        coeff[11][4][0][3] = 22654059864235337;
+        coeff[11][4][0][4] = 30651204406894710;
+        coeff[11][4][0][5] = 13070338751470;
+        coeff[11][4][0][6] = 0;
+
+        coeff[11][4][1][0] = 0;
+        coeff[11][4][1][1] = 0;
+        coeff[11][4][1][2] = 0;
+        coeff[11][4][1][3] = 0;
+        coeff[11][4][1][4] = 0;
+        coeff[11][4][1][5] = 0;
+        coeff[11][4][1][6] = 0;
+
+        coeff[11][5][0][0] = 2099988056465336;
+        coeff[11][5][0][1] = 20964146866715418;
+        coeff[11][5][0][2] = 26479447919286778;
+        coeff[11][5][0][3] = 28687334188327454;
+        coeff[11][5][0][4] = 18245231482781651;
+        coeff[11][5][0][5] = 21665078698214405;
+        coeff[11][5][0][6] = 1760545476751041;
+
+        coeff[11][5][1][0] = 33647333985766131;
+        coeff[11][5][1][1] = 15061775342732377;
+        coeff[11][5][1][2] = 10634308716634293;
+        coeff[11][5][1][3] = 15267386808624246;
+        coeff[11][5][1][4] = 34335022074067067;
+        coeff[11][5][1][5] = 1778035881690211;
+        coeff[11][5][1][6] = 69335985795384;
+    }
+    return coeff;
+}
diff --git a/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/bls12_381_hash_to_G2.circom b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/bls12_381_hash_to_G2.circom
new file mode 100644
index 0000000..22899a5
--- /dev/null
+++ b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/bls12_381_hash_to_G2.circom
@@ -0,0 +1,721 @@
+pragma circom 2.0.3;
+
+include "bigint.circom";
+include "bigint_func.circom";
+include "fp.circom";
+include "fp2.circom";
+include "curve.circom";
+include "curve_fp2.circom";
+include "bls12_381_func.circom";
+
+/* 
+implementation of optimized simplified SWU map to BLS12-381 G2
+following Wahby-Boneh: Section 4.2 of https://eprint.iacr.org/2019/403.pdf
+Python reference code: https://github.com/algorand/bls_sigs_ref/blob/master/python-impl/opt_swu_g2.py
+Additional exposition: https://hackmd.io/@benjaminion/bls12-381#Simplified-SWU-map
+
+E2 is y^2 = x^3 + 4(1+u) over Fp2
+E2' is a curve of form y^2 = x^3 + a x + b that is 3-isogenous to E2
+Constants are a = 240 u, b = 1012 + 1012 u where u = sqrt(-1)
+*/
+
+// Simplified SWU map, optimized and adapted to E2' 
+// in = t: 2 x k array, element of Fp2 
+// out: 2 x 2 x k array, point (out[0], out[1]) on curve E2' 
+// 
+// This is osswu2_help(t) in Python reference code
+// See Section 4.2 of Wahby-Boneh: https://eprint.iacr.org/2019/403.pdf
+// circom implementation is slightly different since sqrt and inversion are cheap
+template OptSimpleSWU2(n, k){
+    signal input in[2][k];
+    signal output out[2][2][k]; 
+    //signal output isInfinity; optimized simple SWU should never return point at infinity, exceptional case still returns a normal point 
+    
+    var p[50] = get_BLS12_381_prime(n, k);
+    
+    var a[2] = [0, 240];
+    var b[2] = [1012, 1012];
+    
+    // distinguished non-square in Fp2 for SWU map: xi = -2 - u 
+    // this is Z in the suite 8.8.2 of https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-hash-to-curve-14#section-10
+    var xi[2] = [-2, -1];
+
+    var LOGK = log_ceil(k);
+    // in = t, compute t^2, t^3
+    component t_sq = SignedFp2MultiplyNoCarryCompress(n, k, p, n, 3*n + 2*LOGK + 1 );
+    for(var i=0; i<2; i++)for(var idx=0; idx<k; idx++){
+        t_sq.a[i][idx] <== in[i][idx];
+        t_sq.b[i][idx] <== in[i][idx];
+    }
+    // compute xi * t^2 
+    component xi_t_sq = SignedFp2CarryModP(n, k, 3*n + 2*LOGK + 3, p);
+    for(var idx=0; idx<k; idx++){
+        xi_t_sq.in[0][idx] <== xi[0] * t_sq.out[0][idx] - xi[1] * t_sq.out[1][idx];
+        xi_t_sq.in[1][idx] <== xi[0] * t_sq.out[1][idx] + xi[1] * t_sq.out[0][idx];
+    }
+
+    // xi^2 * t^4
+    component xi2t4 = SignedFp2MultiplyNoCarryCompress(n, k, p, n, 3*n + 2*LOGK + 1); 
+    for(var i=0; i<2; i++)for(var idx=0; idx<k; idx++){
+        xi2t4.a[i][idx] <== xi_t_sq.out[i][idx];
+        xi2t4.b[i][idx] <== xi_t_sq.out[i][idx];
+    }
+    // xi^2 * t^4 + xi * t^2
+    var num_den_common[2][k];
+    for(var i=0; i<2; i++)for(var idx=0; idx<k; idx++)
+        num_den_common[i][idx] = xi2t4.out[i][idx] + xi_t_sq.out[i][idx];
+    
+    // X0(t) = b (xi^2 * t^4 + xi * t^2 + 1) / (-a * (xi^2 * t^4 + xi * t^2)) 
+    component X0_den = SignedFp2CarryModP(n, k, 3*n + 2*LOGK + 2 + 9, p);
+    for(var idx=0; idx<k; idx++){
+        X0_den.in[0][idx] <== -a[0] * num_den_common[0][idx] + a[1] * num_den_common[1][idx];
+        X0_den.in[1][idx] <== -a[0] * num_den_common[1][idx] - a[1] * num_den_common[0][idx];
+    }
+
+    // if X0_den = 0, replace with X1_den = a * xi; this way X1(t) = X0_num / X1_den = b / (xi * a)
+    // X1_den = a * xi = 240 - 480 i 
+    assert( n == 55 && k == 7 );
+    var X1_den[2][k];
+    if( n == 55 && k == 7 ){
+        X1_den = [[240,0,0,0,0,0,0],
+                [35747322042230987,36025922209447795,1084959616957103,7925923977987733,16551456537884751,23443114579904617,1829881462546425]];
+    }
+
+    // Exception if X0_den = 0: 
+    component exception = Fp2IsZero(n, k, p);
+    for(var i=0; i<2; i++)for(var idx=0; idx<k; idx++)
+        exception.in[i][idx] <== X0_den.out[i][idx];
+    //isInfinity <== exception.out; 
+    
+    num_den_common[0][0]++;
+    component X0_num = SignedFp2CarryModP(n, k, 3*n + 2*LOGK + 2 + 11, p);
+    for(var idx=0; idx<k; idx++){
+        X0_num.in[0][idx] <== b[0] * num_den_common[0][idx] - b[1] * num_den_common[1][idx];
+        X0_num.in[1][idx] <== b[0] * num_den_common[1][idx] + b[1] * num_den_common[0][idx];
+    }
+    // division is same cost/constraints as multiplication, so we will compute X0 and avoid using projective coordinates 
+    component X0 = SignedFp2Divide(n, k, n, n, p);
+    for(var i=0; i<2; i++)for(var idx=0; idx<k; idx++){
+        X0.a[i][idx] <== X0_num.out[i][idx];
+        X0.b[i][idx] <== X0_den.out[i][idx] + exception.out * (X1_den[i][idx] - X0_den.out[i][idx]);
+    }
+    
+    // g(x) = x^3 + a x + b 
+    // Compute g(X0(t)) 
+    component gX0 = EllipticCurveFunction(n, k, a, b, p);
+    // X1(t) = xi * t^2 * X0(t)
+    component X1 = Fp2Multiply(n, k, p);
+
+    for(var i=0; i<2; i++)for(var idx=0; idx<k; idx++){
+        gX0.in[i][idx] <== X0.out[i][idx];
+        X1.a[i][idx] <== xi_t_sq.out[i][idx];
+        X1.b[i][idx] <== X0.out[i][idx];
+    }
+    
+    component xi3t6 = Fp2MultiplyThree(n, k, p); // shares a hidden component with xi2t4; I'll let compiler optimize that out for readability
+    for(var i=0; i<2; i++)for(var idx=0; idx<k; idx++){ 
+        xi3t6.a[i][idx] <== xi_t_sq.out[i][idx];
+        xi3t6.b[i][idx] <== xi_t_sq.out[i][idx];
+        xi3t6.c[i][idx] <== xi_t_sq.out[i][idx];
+    }
+    // g(X1(t)) = xi^3 * t^6 * g(X0(t)) 
+    component gX1 = Fp2Multiply(n, k, p);
+    for(var i=0; i<2; i++)for(var idx=0; idx<k; idx++){ 
+        gX1.a[i][idx] <== xi3t6.out[i][idx];
+        gX1.b[i][idx] <== gX0.out[i][idx];
+    }
+    /* 
+    xi^3 is not a square, so one of gX0, gX1 must be a square 
+    isSquare = 1 if gX0 is a square, = 0 if gX1 is a square
+    sqrt = sqrt(gX0) if isSquare = 1, sqrt = sqrt(gX1) if isSquare = 0
+
+    Implementation is special to p^2 = 9 mod 16
+    References:
+        p. 9 of https://eprint.iacr.org/2019/403.pdf
+        F.2.1.1 for general version for any field: https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-hash-to-curve-14#appendix-F.2.1.1
+
+    I do not use the trick for combining division and sqrt from Section 5 of 
+    Bernstein, Duif, Lange, Schwabe, and Yang, "High-speed high-security signatures",
+    since division is cheap in circom
+    */
+    
+    signal isSquare;
+    
+    // Precompute sqrt_candidate = gX0^{(p^2 + 7) / 16} 
+    // p^2 + 7
+    var c1[50] = long_add_unequal(n, 2*k, 1, prod(n, k, p, p), [7]);
+    // (p^2 + 7) // 16
+    var c2[2][50] = long_div2(n, 1, 2*k-1, c1, [16]); 
+
+    assert( c2[1][0] == 0 ); // assert p^2 + 7 is divisible by 16
+
+    var sqrt_candidate[2][50] = find_Fp2_exp(n, k, gX0.out, p, c2[0]);
+    // if gX0 is a square, square root must be sqrt_candidate * (8th-root of unity) 
+    // -1 is a square in Fp2 (because p^2 - 1 is even) so we only need to check half of the 8th roots of unity
+    var roots[4][2][50] = get_roots_of_unity(n, k);
+    var sqrt_witness[2][2][50];
+    for(var i=0; i<2; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+        sqrt_witness[i][j][idx] = 0;
+
+    var is_square = 0;
+    for(var i=0; i<4; i++){
+        var sqrt_tmp[2][50] = find_Fp2_product(n, k, sqrt_candidate, roots[i], p); 
+        if(is_equal_Fp2(n, k, find_Fp2_product(n, k, sqrt_tmp, sqrt_tmp, p), gX0.out) == 1){
+            is_square = 1;
+            sqrt_witness[0] = sqrt_tmp;
+        }
+    }
+    isSquare <-- is_square;
+    isSquare * (1-isSquare) === 0; 
+    
+    var is_square1 = 0;
+    var etas[4][2][50] = get_etas(n, k);
+    // find square root of gX1 
+    // square root of gX1 must be = sqrt_candidate * t^3 * eta 
+    // for one of four precomputed values of eta
+    // eta determined by eta^2 = xi^3 * (-1)^{-1/4}  
+    var t_cu[2][50] = find_Fp2_product(n, k, find_Fp2_product(n, k, in, in, p), in, p);
+    sqrt_candidate = find_Fp2_product(n, k, sqrt_candidate, t_cu, p);
+    
+    for(var i=0; i<4; i++){
+        var sqrt_tmp[2][50] = find_Fp2_product(n, k, sqrt_candidate, etas[i], p); 
+        if(is_equal_Fp2(n, k, find_Fp2_product(n, k, sqrt_tmp, sqrt_tmp, p), gX1.out) == 1){
+            is_square1 = 1;
+            sqrt_witness[1] = sqrt_tmp;
+        }
+    }
+    assert(is_square == 1 || is_square1 == 1); // one of gX0 or gX1 must be a square!
+        
+     
+    // X = out[0] = X0 if isSquare == 1, else X = X1    
+    for(var i=0; i<2; i++)for(var idx=0; idx<k; idx++)
+        out[0][i][idx] <== isSquare * (X0.out[i][idx] - X1.out[i][idx]) + X1.out[i][idx];  
+
+    // sgn0(t) 
+    component sgn_in = Fp2Sgn0(n, k, p);
+    for(var i=0; i<2; i++)for(var idx=0; idx<k; idx++)
+        sgn_in.in[i][idx] <== in[i][idx];
+
+    var Y[2][50];
+    for(var i=0; i<2; i++)for(var idx=0; idx<k; idx++)
+        Y[i][idx] = is_square * sqrt_witness[0][i][idx] + (1-is_square) * sqrt_witness[1][i][idx];
+    // Y = out[1] = +- sqrt_witness; sign determined by sgn0(Y) = sgn0(t) 
+    
+    if(get_fp2_sgn0(k, Y) != sgn_in.out){
+        Y[0] = long_sub(n, k, p, Y[0]);
+        Y[1] = long_sub(n, k, p, Y[1]);
+    } 
+    
+    component Y_sq = Fp2Multiply(n, k, p);
+    // Y^2 == g(X) 
+    for(var i=0; i<2; i++)for(var idx=0; idx<k; idx++){
+        out[1][i][idx] <-- Y[i][idx];
+        Y_sq.a[i][idx] <== out[1][i][idx];
+        Y_sq.b[i][idx] <== out[1][i][idx];
+    }
+    for(var i=0; i<2; i++)for(var idx=0; idx<k; idx++){
+        Y_sq.out[i][idx] === isSquare * (gX0.out[i][idx] - gX1.out[i][idx]) + gX1.out[i][idx]; 
+    }
+
+    // sgn0(Y) == sgn0(t)
+    component sgn_Y = Fp2Sgn0(n, k, p);
+    for(var i=0; i<2; i++)for(var idx=0; idx<k; idx++)
+        sgn_Y.in[i][idx] <== out[1][i][idx];
+
+    sgn_Y.out === sgn_in.out;
+    
+}
+
+/*
+3-Isogeny from E2' to E2
+References:
+    Appendix E.3 of https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-hash-to-curve-14#appendix-E.3
+    Section 4.3 of Wahby-Boneh: https://eprint.iacr.org/2019/403.pdf
+    iso3(P) in Python reference code: https://github.com/algorand/bls_sigs_ref/blob/master/python-impl/opt_swu_g2.py
+*/ 
+
+// Input:
+//  in = (x', y') point on E2' assumed to not be point at infinity
+//  inIsInfinity = 1 if input is point at infinity on E2' (in which case x', y' are arbitrary)
+// Output:
+//  out = (x, y) is point on E2 after applying 3-isogeny to in 
+//  isInfinity = 1 if one of exceptional cases occurs and output should be point at infinity
+// Exceptions:
+//  inIsInfinity = 1
+//  input is a pole of the isogeny, i.e., x_den or y_den = 0 
+template Iso3Map(n, k){
+    signal input in[2][2][k];
+    //signal input inIsInfinity;
+    signal output out[2][2][k];
+    signal output isInfinity;
+    
+    var p[50] = get_BLS12_381_prime(n, k);
+    
+    // load coefficients of the isogeny (precomputed)
+    var coeffs[4][4][2][50] = get_iso3_coeffs(n, k);
+
+    // x = x_num / x_den
+    // y = y' * y_num / y_den
+    // x_num = sum_{i=0}^3 coeffs[0][i] * x'^i
+    // x_den = x'^2 + coeffs[1][1] * x' + coeffs[1][0] 
+    // y_num = sum_{i=0}^3 coeffs[2][i] * x'^i
+    // y_den = x'^3 + sum_{i=0}^2 coeffs[3][i] * x'^i
+  
+    var LOGK = log_ceil(k); 
+    component xp2_nocarry = SignedFp2MultiplyNoCarry(n, k, 2*n + LOGK + 1); 
+    component xp2 = SignedFp2CompressCarry(n, k, k-1, 2*n+LOGK+1, p);
+    component xp3_nocarry = SignedFp2MultiplyNoCarryUnequal(n, 2*k-1, k, 3*n + 2*LOGK + 2); 
+    component xp3 = SignedFp2CompressCarry(n, k, 2*k-2, 3*n+2*LOGK+2, p);
+
+    for(var i=0; i<2; i++)for(var idx=0; idx<k; idx++){
+        xp2_nocarry.a[i][idx] <== in[0][i][idx];
+        xp2_nocarry.b[i][idx] <== in[0][i][idx];
+        xp3_nocarry.b[i][idx] <== in[0][i][idx];
+    }
+    for(var i=0; i<2; i++)for(var idx=0; idx<2*k-1; idx++){
+        xp3_nocarry.a[i][idx] <== xp2_nocarry.out[i][idx];
+        xp2.in[i][idx] <== xp2_nocarry.out[i][idx];
+    }
+    for(var i=0; i<2; i++)for(var idx=0; idx<3*k-2; idx++)
+        xp3.in[i][idx] <== xp3_nocarry.out[i][idx]; 
+
+    signal xp_pow[3][2][k]; 
+    for(var i=0; i<2; i++)for(var idx=0; idx<k; idx++){
+        xp_pow[0][i][idx] <== in[0][i][idx];
+        xp_pow[1][i][idx] <== xp2.out[i][idx];
+        xp_pow[2][i][idx] <== xp3.out[i][idx];
+    }
+     
+    component coeffs_xp[4][3]; 
+    var deg[4] = [3, 1, 3, 2];
+    for(var i=0; i<4; i++)for(var j=0; j<deg[i]; j++){
+        coeffs_xp[i][j] = SignedFp2MultiplyNoCarry(n, k, 2*n + LOGK + 1);
+        for(var l=0; l<2; l++)for(var idx=0; idx<k; idx++){
+            coeffs_xp[i][j].a[l][idx] <== coeffs[i][j+1][l][idx];
+            coeffs_xp[i][j].b[l][idx] <== xp_pow[j][l][idx];
+        }
+    }
+    var x_frac[4][2][50];  
+    for(var i=0; i<4; i++){
+        for(var l=0; l<2; l++)for(var idx=0; idx<2*k-1; idx++){
+            if(idx<k)
+                x_frac[i][l][idx] = coeffs[i][0][l][idx];
+            else
+                x_frac[i][l][idx] = 0;
+        }
+        for(var j=0; j<deg[i]; j++)for(var l=0; l<2; l++)for(var idx=0; idx<2*k-1; idx++)
+            x_frac[i][l][idx] += coeffs_xp[i][j].out[l][idx];
+    } 
+    for(var l=0; l<2; l++)for(var idx=0; idx<k; idx++){
+        x_frac[1][l][idx] += xp2.out[l][idx];
+        x_frac[3][l][idx] += xp3.out[l][idx];
+    }
+    
+    // carry the denominators since we need to check whether they are 0
+    component den[2];
+    component den_is_zero[2];
+    for(var i=0; i<2; i++){
+        den[i] = SignedFp2CompressCarry(n, k, k-1, 2*n + LOGK + 3, p); 
+        for(var l=0; l<2; l++)for(var idx=0; idx<2*k-1; idx++)
+            den[i].in[l][idx] <== x_frac[2*i+1][l][idx];
+
+        den_is_zero[i] = Fp2IsZero(n, k, p);
+        for(var l=0; l<2; l++)for(var idx=0; idx<k; idx++)
+            den_is_zero[i].in[l][idx] <== den[i].out[l][idx];
+    }
+
+    //component exception = IsZero();
+    //exception.in <== inIsInfinity + den_is_zero[0].out + den_is_zero[1].out; 
+    isInfinity <== den_is_zero[0].out + den_is_zero[1].out - den_is_zero[0].out * den_is_zero[1].out; // OR gate: if either denominator is 0, output point at infinity 
+
+    component num[2];
+    for(var i=0; i<2; i++){
+        num[i] = Fp2Compress(n, k, k-1, p, 3*n + 2*LOGK + 3); 
+        for(var l=0; l<2; l++)for(var idx=0; idx<2*k-1; idx++)
+            num[i].in[l][idx] <== x_frac[2*i][l][idx];
+    }
+
+    component x[2];
+    // num / den if den != 0, else num / 1
+    for(var i=0; i<2; i++){
+        x[i] = SignedFp2Divide(n, k, 3*n + 2*LOGK + 3, n, p);
+        for(var l=0; l<2; l++)for(var idx=0; idx<k; idx++){
+            x[i].a[l][idx] <== num[i].out[l][idx];
+            if(l==0 && idx==0)
+                x[i].b[l][idx] <== isInfinity * (1 - den[i].out[l][idx]) + den[i].out[l][idx];
+            else
+                x[i].b[l][idx] <== -isInfinity * den[i].out[l][idx] + den[i].out[l][idx];
+        } 
+    }
+
+    component y = Fp2Multiply(n, k, p);
+    for(var i=0; i<2; i++)for(var idx=0; idx<k; idx++){
+        y.a[i][idx] <== in[1][i][idx];
+        y.b[i][idx] <== x[1].out[i][idx];
+    } 
+
+    for(var i=0; i<2; i++)for(var idx=0; idx<k; idx++){
+        out[0][i][idx] <== x[0].out[i][idx];
+        out[1][i][idx] <== y.out[i][idx];
+    }
+}
+
+/* 
+Cofactor Clearing for BLS12-381 G2
+Implementation below follows Appendix G.3 of https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-hash-to-curve-14#appendix-G.3 
+References:
+    The endomorphism psi of Budroni-Pintore: https://eprint.iacr.org/2017/419.pdf
+    BLS For the Rest of Us: https://hackmd.io/@benjaminion/bls12-381#Cofactor-clearing
+*/
+
+// Input: in, a point on the curve E2 : y^2 = x^3 + 4(1+u)
+//  coordinates of in are in "proper" representation
+// Output: out = psi(in), a point on the same curve.
+template EndomorphismPsi(n, k, p){
+    signal input in[2][2][k];
+    signal output out[2][2][k];
+    
+    var c[2][2][k];
+    // Constants:
+    // c0 = 1 / (1 + I)^((p - 1) / 3)           # in GF(p^2)
+    // c1 = 1 / (1 + I)^((p - 1) / 2)           # in GF(p^2)
+
+    assert( n == 55 && k == 7 );
+    if( n == 55 && k == 7 ){
+        c = [[[0, 0, 0, 0, 0, 0, 0],
+             [35184372088875693,
+              22472499736345367,
+              5698637743850064,
+              21300661132716363,
+              21929049149954008,
+              23430044241153146,
+              1829881462546425]],
+            [[31097504852074146,
+              21847832108733923,
+              11215546103677201,
+              1564033941097252,
+              9796175148277139,
+              23041766052141807,
+              1359550313685033],
+             [4649817190157321,
+              14178090100713872,
+              25898210532243870,
+              6361890036890480,
+              6755281389607612,
+              401348527762810,
+              470331148861392]]]; 
+    }
+    component frob[2];
+    component qx[2];
+    for(var i=0; i<2; i++){
+        frob[i] = Fp2FrobeniusMap(n, k, 1, p);
+        for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+            frob[i].in[j][idx] <== in[i][j][idx];
+        qx[i] = Fp2Multiply(n, k, p);
+        for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+            qx[i].a[j][idx] <== c[i][j][idx]; 
+            qx[i].b[j][idx] <== frob[i].out[j][idx];
+        } 
+    }
+
+    for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+        out[0][j][idx] <== qx[0].out[j][idx];
+        out[1][j][idx] <== qx[1].out[j][idx];
+    }
+}
+
+// Input: in, a point on the curve E2 : y^2 = x^3 + 4(1+u)
+//  coordinates of in are in "proper" representation
+// Output: out = psi(psi(in)), a point on the same curve.
+template EndomorphismPsi2(n, k, p){
+    signal input in[2][2][k];
+    signal output out[2][2][k];
+
+    var c[k];
+    // Third root of unity:
+    // c = 1 / 2^((p - 1) / 3)          # in GF(p)
+    
+    assert( n == 55 && k == 7 );
+    if( n == 55 && k == 7 ){
+        c = [35184372088875692,
+            22472499736345367,
+            5698637743850064,
+            21300661132716363,
+            21929049149954008,
+            23430044241153146,
+            1829881462546425];
+    }
+
+    component qx[2];
+    component qy[2];
+    for(var i=0; i<2; i++){
+        qx[i] = FpMultiply(n, k, p);
+        for(var idx=0; idx<k; idx++){
+            qx[i].a[idx] <== c[idx];
+            qx[i].b[idx] <== in[0][i][idx];
+        }
+        
+        qy[i] = BigSub(n, k);
+        for(var idx=0; idx<k; idx++){
+            qy[i].a[idx] <== p[idx];
+            qy[i].b[idx] <== in[1][i][idx];
+        }
+    }
+    for(var i=0; i<2; i++)for(var idx=0; idx<k; idx++){
+        out[0][i][idx] <== qx[i].out[idx];
+        out[1][i][idx] <== qy[i].out[idx];
+    }
+}
+
+
+// in = P, a point on curve E2
+// out = [x^2 - x - 1]P + [x-1]*psi(P) + psi2(2*P) 
+// where x = -15132376222941642752 is the parameter for BLS12-381
+template ClearCofactorG2(n, k){
+    signal input in[2][2][k];
+    signal input inIsInfinity;
+
+    signal output out[2][2][k];
+    signal output isInfinity;
+    
+    var p[50] = get_BLS12_381_prime(n, k);
+    var x_abs = get_BLS12_381_parameter(); // this is abs(x). remember x is negative!
+    var a[2] = [0,0];
+    var b[2] = [4,4];
+    var dummy_point[2][2][50] = get_generator_G2(n, k);
+    
+    // Output: [|x|^2 + |x| - 1]*P + [-|x|-1]*psi(P) + psi2(2*P) 
+    //       = |x| * (|x|*P + P - psi(P)) - P -psi(P) + psi2(2*P)
+    
+    // replace `in` with dummy_point if inIsInfinity = 1 to ensure P is on the curve 
+    signal P[2][2][k];
+    component xP = EllipticCurveScalarMultiplyFp2(n, k, b, x_abs, p); 
+    component psiP = EndomorphismPsi(n, k, p);
+    component neg_Py = Fp2Negate(n, k, p);
+    component neg_psiPy = Fp2Negate(n, k, p);
+    component doubP = EllipticCurveDoubleFp2(n, k, a, b, p);
+     
+    xP.inIsInfinity <== inIsInfinity; 
+    for(var i=0; i<2; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+        P[i][j][idx] <== in[i][j][idx] + inIsInfinity * (dummy_point[i][j][idx] - in[i][j][idx]);
+        xP.in[i][j][idx] <== P[i][j][idx];
+        psiP.in[i][j][idx] <== P[i][j][idx];
+        doubP.in[i][j][idx] <== P[i][j][idx];
+    }
+    for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+        neg_Py.in[j][idx] <== P[1][j][idx];
+        neg_psiPy.in[j][idx] <== psiP.out[1][j][idx];
+    }
+
+    component psi22P = EndomorphismPsi2(n, k, p);
+    component add[5];
+    for(var i=0; i<5; i++)
+        add[i] = EllipticCurveAddFp2(n, k, a, b, p); 
+    
+    for(var i=0; i<2; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+        psi22P.in[i][j][idx] <== doubP.out[i][j][idx];
+        add[0].a[i][j][idx] <== xP.out[i][j][idx];
+        add[0].b[i][j][idx] <== P[i][j][idx]; 
+    }
+    add[0].aIsInfinity <== xP.isInfinity; 
+    add[0].bIsInfinity <== inIsInfinity;
+
+    for(var i=0; i<2; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+        add[1].a[i][j][idx] <== add[0].out[i][j][idx];
+        if(i==0)
+            add[1].b[i][j][idx] <== psiP.out[i][j][idx];
+        else
+            add[1].b[i][j][idx] <== neg_psiPy.out[j][idx];
+    }
+    add[1].aIsInfinity <== add[0].isInfinity;
+    add[1].bIsInfinity <== inIsInfinity;
+    
+    component xadd1 = EllipticCurveScalarMultiplyFp2(n, k, b, x_abs, p); 
+    for(var i=0; i<2; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+        xadd1.in[i][j][idx] <== add[1].out[i][j][idx];
+    xadd1.inIsInfinity <== add[1].isInfinity; 
+
+    for(var i=0; i<2; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+        add[2].a[i][j][idx] <== xadd1.out[i][j][idx];
+        if(i==0)
+            add[2].b[i][j][idx] <== P[i][j][idx];
+        else
+            add[2].b[i][j][idx] <== neg_Py.out[j][idx];
+    }
+    add[2].aIsInfinity <== xadd1.isInfinity;
+    add[2].bIsInfinity <== inIsInfinity;
+    
+    for(var i=0; i<2; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+        add[3].a[i][j][idx] <== add[2].out[i][j][idx];
+        if(i==0)
+            add[3].b[i][j][idx] <== psiP.out[i][j][idx];
+        else
+            add[3].b[i][j][idx] <== neg_psiPy.out[j][idx];
+    }
+    add[3].aIsInfinity <== add[2].isInfinity;
+    add[3].bIsInfinity <== inIsInfinity;
+
+    for(var i=0; i<2; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+        add[4].a[i][j][idx] <== add[3].out[i][j][idx];
+        add[4].b[i][j][idx] <== psi22P.out[i][j][idx];
+    }
+    add[4].aIsInfinity <== add[3].isInfinity;
+    add[4].bIsInfinity <== inIsInfinity;
+
+    // isInfinity = add[4].isInfinity or inIsInfinity (if starting point was O, output must be O)
+    isInfinity <== add[4].isInfinity + inIsInfinity - inIsInfinity * add[4].isInfinity; 
+    for(var i=0; i<2; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+        out[i][j][idx] <== add[4].out[i][j][idx] + isInfinity * (dummy_point[i][j][idx] - add[4].out[i][j][idx]); 
+}
+
+// `in` is 2 x 2 x k representing two field elements in Fp2 
+// `out` is 2 x 2 x k representing a point in subgroup G2 of E2(Fp2) twisted curve for BLS12-381
+// isInfinity = 1 if `out` is point at infinity
+// Implements steps 2-6 of hash_to_curve as specified in https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-hash-to-curve-14#section-3 
+// In practice `in` = hash_to_field(msg, 2) for an arbitrary-length byte string, in which case `out` = hash_to_curve(msg) 
+template MapToG2(n, k){
+    signal input in[2][2][k];
+    signal output out[2][2][k];
+    signal output isInfinity;
+
+    var p[50] = get_BLS12_381_prime(n, k);
+
+    component Qp[2];
+    for(var i=0; i<2; i++){
+        Qp[i] = OptSimpleSWU2(n, k);
+        for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+            Qp[i].in[j][idx] <== in[i][j][idx];
+    }
+
+    // There is a small optimization we can do: Iso3Map is a group homomorphism, so we can add first and then apply isogeny. This uses EllipticCurveAdd on E2' 
+    component Rp = EllipticCurveAddFp2(n, k, [0, 240], [1012, 1012], p); 
+    for(var i=0; i<2; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+        Rp.a[i][j][idx] <== Qp[0].out[i][j][idx];
+        Rp.b[i][j][idx] <== Qp[1].out[i][j][idx];
+    }
+    Rp.aIsInfinity <== 0;
+    Rp.bIsInfinity <== 0;
+    
+    component R = Iso3Map(n, k);
+    for(var i=0; i<2; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+        R.in[i][j][idx] <== Rp.out[i][j][idx];
+    
+    component P = ClearCofactorG2(n, k);
+    for(var i=0; i<2; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+        P.in[i][j][idx] <== R.out[i][j][idx]; 
+    P.inIsInfinity <== R.isInfinity + Rp.isInfinity - R.isInfinity * Rp.isInfinity; 
+    
+    isInfinity <== P.isInfinity;
+    for(var i=0; i<2; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+        out[i][j][idx] <== P.out[i][j][idx]; 
+}
+
+/*
+Subgroup checks for G1, G2: 
+use the latest methods by Scott: https://eprint.iacr.org/2021/1130.pdf
+Other references:
+    Bowe: https://eprint.iacr.org/2019/814.pdf
+    El Housni: https://hackmd.io/@yelhousni/bls12_subgroup_check
+*/
+
+// `in` = P is 2 x 2 x k, pair of Fp2 elements 
+// check P is on curve twist E2(Fp2)
+// check psi(P) = [x]P where x is parameter for BLS12-381
+template SubgroupCheckG2(n, k){
+    signal input in[2][2][k];
+    
+    var p[50] = get_BLS12_381_prime(n, k);
+    var x_abs = get_BLS12_381_parameter();
+
+    component is_on_curve = PointOnCurveFp2(n, k, [0,0], [4,4], p);
+
+    for(var i=0; i<2; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+        is_on_curve.in[i][j][idx] <== in[i][j][idx]; 
+
+    component psiP = EndomorphismPsi(n, k, p); 
+    component negP = Fp2Negate(n, k, p);
+    component xP = EllipticCurveScalarMultiplyUnequalFp2(n, k, [4, 4], x_abs, p); 
+
+    for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+        negP.in[j][idx] <== in[1][j][idx];
+            
+    for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+        psiP.in[0][j][idx] <== in[0][j][idx];
+        psiP.in[1][j][idx] <== in[1][j][idx];
+        xP.in[0][j][idx] <== in[0][j][idx];
+        xP.in[1][j][idx] <== negP.out[j][idx]; 
+    }
+    
+    // psi(P) == [x]P
+    component is_eq[2];
+    for(var i=0; i<2; i++){
+        is_eq[i] = Fp2IsEqual(n, k, p);
+        for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+            is_eq[i].a[j][idx] <== psiP.out[i][j][idx];
+            is_eq[i].b[j][idx] <== xP.out[i][j][idx];
+        }
+    }
+    is_eq[0].out === 1;
+    is_eq[1].out === 1;
+}
+
+// `in` = P is 2 x k, pair of Fp elements
+// check P is on curve E(Fp)
+// check phi(P) == [-x^2] P where phi(x,y) = (omega * x, y) where omega is a cube root of unity in Fp
+template SubgroupCheckG1(n, k){
+    signal input in[2][k];
+
+    var p[50] = get_BLS12_381_prime(n, k);
+    var x_abs = get_BLS12_381_parameter();
+    var b = 4;
+
+    component is_on_curve = PointOnCurve(n, k, 0, b, p);
+
+    for(var i=0; i<2; i++)for(var idx=0; idx<k; idx++)
+        is_on_curve.in[i][idx] <== in[i][idx];
+         
+    var omega[k];
+    // Third root of unity:
+    // omega = 2^((p - 1) / 3)          # in GF(p)
+    assert( n == 55 && k == 7 );
+    if( n == 55 && k == 7 ){
+        omega = [562949953355774,
+                 13553422473102428,
+                 31415118892071007,
+                 22654059864235337,
+                 30651204406894710,
+                 13070338751470,
+                 0];
+    }
+
+    component phiPx = FpMultiply(n, k, p);
+    for(var idx=0; idx<k; idx++){
+        phiPx.a[idx] <== omega[idx];
+        phiPx.b[idx] <== in[0][idx];
+    }
+    component phiPy_neg = BigSub(n, k);
+    for(var idx=0; idx<k; idx++){
+        phiPy_neg.a[idx] <== p[idx];
+        phiPy_neg.b[idx] <== in[1][idx];
+    }
+    
+    // x has hamming weight 6 while x^2 has hamming weight 17 so better to do double-and-add on x twice
+    component xP = EllipticCurveScalarMultiplyUnequal(n, k, b, x_abs, p); 
+    component x2P = EllipticCurveScalarMultiplyUnequal(n, k, b, x_abs, p);
+    for(var i=0; i<2; i++)for(var idx=0; idx<k; idx++)
+        xP.in[i][idx] <== in[i][idx];
+
+    for(var i=0; i<2; i++)for(var idx=0; idx<k; idx++)
+        x2P.in[i][idx] <== xP.out[i][idx];
+
+    // check -phi(P) == [x^2]P
+    component is_eq = Fp2IsEqual(n, k, p); // using Fp2IsEqual to check two Fp points are equal
+    for(var idx=0; idx<k; idx++){
+        is_eq.a[0][idx] <== phiPx.out[idx];
+        is_eq.a[1][idx] <== phiPy_neg.out[idx];
+
+        is_eq.b[0][idx] <== x2P.out[0][idx];
+        is_eq.b[1][idx] <== x2P.out[1][idx];
+    }
+    is_eq.out === 1;
+}
diff --git a/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/bls_signature.circom b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/bls_signature.circom
new file mode 100644
index 0000000..139e8de
--- /dev/null
+++ b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/bls_signature.circom
@@ -0,0 +1,133 @@
+pragma circom 2.0.3;
+
+include "final_exp.circom";
+include "pairing.circom";
+include "bls12_381_func.circom";
+include "bls12_381_hash_to_G2.circom";
+
+
+// Input: pubkey in G_1 
+//        signature, H(m) in G_2
+// Output: out = 1 if valid signature, else = 0
+// Verifies that e(g1, signature) = e(pubkey, H(m)) by checking e(g1, signature)*e(pubkey, -H(m)) === 1 where e(,) is optimal Ate pairing
+template CoreVerifyPubkeyG1NoCheck(n, k){
+    signal input pubkey[2][k];
+    signal input signature[2][2][k];
+    signal input Hm[2][2][k];
+    signal output out;
+
+    var q[50] = get_BLS12_381_prime(n, k);
+    var x = get_BLS12_381_parameter();
+    var g1[2][50] = get_generator_G1(n, k); 
+
+    signal neg_s[2][2][k];
+    component neg[2];
+    for(var j=0; j<2; j++){
+        neg[j] = FpNegate(n, k, q); 
+        for(var idx=0; idx<k; idx++)
+            neg[j].in[idx] <== signature[1][j][idx];
+        for(var idx=0; idx<k; idx++){
+            neg_s[0][j][idx] <== signature[0][j][idx];
+            neg_s[1][j][idx] <== neg[j].out[idx];
+        }
+    }
+
+    component miller = MillerLoopFp2Two(n, k, [4,4], x, q);
+    for(var i=0; i<2; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+        miller.P[0][i][j][idx] <== neg_s[i][j][idx];
+        miller.P[1][i][j][idx] <== Hm[i][j][idx];
+    }
+    for(var i=0; i<2; i++)for(var idx=0; idx<k; idx++){
+        miller.Q[0][i][idx] <== g1[i][idx];
+        miller.Q[1][i][idx] <== pubkey[i][idx];
+    }
+
+    component finalexp = FinalExponentiate(n, k, q);
+    for(var i=0; i<6; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+        finalexp.in[i][j][idx] <== miller.out[i][j][idx];
+
+    component is_valid[6][2][k];
+    var total = 12*k;
+    for(var i=0; i<6; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+        is_valid[i][j][idx] = IsZero(); 
+        if(i==0 && j==0 && idx==0)
+            is_valid[i][j][idx].in <== finalexp.out[i][j][idx] - 1;
+        else
+            is_valid[i][j][idx].in <== finalexp.out[i][j][idx];
+        total -= is_valid[i][j][idx].out; 
+    }
+    component valid = IsZero(); 
+    valid.in <== total;
+    out <== valid.out;
+}
+
+// Inputs:
+//   - pubkey as element of E(Fq)
+//   - hash represents two field elements in Fp2, in practice hash = hash_to_field(msg,2).
+//   - signature, as element of E2(Fq2) 
+// Assume signature is not point at infinity 
+template CoreVerifyPubkeyG1(n, k){
+    signal input pubkey[2][k];
+    signal input signature[2][2][k];
+    signal input hash[2][2][k];
+    signal output out; // @reproduce a dummy output to suppress "snarkJS: Error: Scalar size does not match" bug
+     
+    var q[50] = get_BLS12_381_prime(n, k);
+
+    component lt[10];
+    // check all len k input arrays are correctly formatted bigints < q (BigLessThan calls Num2Bits)
+    for(var i=0; i<10; i++){
+        lt[i] = BigLessThan(n, k);
+        for(var idx=0; idx<k; idx++)
+            lt[i].b[idx] <== q[idx];
+    }
+    for(var idx=0; idx<k; idx++){
+        lt[0].a[idx] <== pubkey[0][idx];
+        lt[1].a[idx] <== pubkey[1][idx];
+        lt[2].a[idx] <== signature[0][0][idx];
+        lt[3].a[idx] <== signature[0][1][idx];
+        lt[4].a[idx] <== signature[1][0][idx];
+        lt[5].a[idx] <== signature[1][1][idx];
+        lt[6].a[idx] <== hash[0][0][idx];
+        lt[7].a[idx] <== hash[0][1][idx];
+        lt[8].a[idx] <== hash[1][0][idx];
+        lt[9].a[idx] <== hash[1][1][idx];
+    } 
+
+    // check all registers are in [0, 2^n)
+    component check[5]; 
+    for(var i=0; i<5; i++)
+        check[i] = RangeCheck2D(n, k); 
+    for(var i=0; i<2; i++)for(var idx=0; idx<k; idx++){
+        check[0].in[i][idx] <== pubkey[i][idx];
+        check[1].in[i][idx] <== signature[0][i][idx];
+        check[2].in[i][idx] <== signature[1][i][idx];
+        check[3].in[i][idx] <== hash[0][i][idx];
+        check[4].in[i][idx] <== hash[1][i][idx];
+    }
+    
+    component pubkey_valid = SubgroupCheckG1(n, k);
+    for(var i=0; i<2; i++)for(var idx=0; idx<k; idx++)
+        pubkey_valid.in[i][idx] <== pubkey[i][idx];
+
+    component signature_valid = SubgroupCheckG2(n, k);
+    for(var i=0; i<2; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+        signature_valid.in[i][j][idx] <== signature[i][j][idx];
+
+    component Hm = MapToG2(n, k);
+    for(var i=0; i<2; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+        Hm.in[i][j][idx] <== hash[i][j][idx];
+
+    Hm.isInfinity === 0;
+    
+    component verify = CoreVerifyPubkeyG1NoCheck(n, k);
+
+    for(var i=0; i<2; i++)for(var idx=0; idx<k; idx++)
+        verify.pubkey[i][idx] <== pubkey[i][idx];
+    for(var i=0; i<2; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+        verify.signature[i][j][idx] <== signature[i][j][idx];
+        verify.Hm[i][j][idx] <== Hm.out[i][j][idx]; 
+    }
+
+    verify.out === 1;
+}
\ No newline at end of file
diff --git a/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/circuit.circom b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/circuit.circom
new file mode 100644
index 0000000..ef8131b
--- /dev/null
+++ b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/circuit.circom
@@ -0,0 +1,5 @@
+pragma circom 2.0.3;
+
+include "./bls_signature.circom";
+
+component main = CoreVerifyPubkeyG1ToyExample(55, 7);
diff --git a/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/curve.circom b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/curve.circom
new file mode 100644
index 0000000..906d23e
--- /dev/null
+++ b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/curve.circom
@@ -0,0 +1,513 @@
+pragma circom 2.0.3;
+
+include "../../../dependencies/circomlib/circuits/bitify.circom";
+include "fp2.circom";
+
+// in[i] = (x_i, y_i) 
+// Implements constraint: (y_1 + y_3) * (x_2 - x_1) - (y_2 - y_1)*(x_1 - x_3) = 0 mod p
+// used to show (x1, y1), (x2, y2), (x3, -y3) are co-linear
+template PointOnLine(n, k, p) {
+    signal input in[3][2][k]; 
+
+    var LOGK = log_ceil(k);
+    var LOGK2 = log_ceil(3*k*k);
+    assert(3*n + LOGK2 < 251);
+
+    // AKA check point on line 
+    component left = BigMultShortLong(n, k, 2*n + LOGK + 1); // 2k-1 registers abs val < 2k*2^{2n}
+    for(var i = 0; i < k; i++){
+        left.a[i] <== in[0][1][i] + in[2][1][i];
+        left.b[i] <== in[1][0][i] - in[0][0][i]; 
+    }
+
+    component right = BigMultShortLong(n, k, 2*n + LOGK); // 2k-1 registers abs val < k*2^{2n}
+    for(var i = 0; i < k; i++){
+        right.a[i] <== in[1][1][i] - in[0][1][i];
+        right.b[i] <== in[0][0][i] - in[2][0][i];
+    }
+    
+    component diff_red; 
+    diff_red = PrimeReduce(n, k, k-1, p, 3*n + LOGK2);
+    for(var i=0; i<2*k-1; i++)
+        diff_red.in[i] <== left.out[i] - right.out[i];  
+
+    // diff_red has k registers abs val < 3*k^2*2^{3n}
+    component diff_mod = SignedCheckCarryModToZero(n, k, 3*n + LOGK2, p);
+    for(var i=0; i<k; i++)
+        diff_mod.in[i] <== diff_red.out[i]; 
+}
+
+// in = (x, y)
+// Implements:
+// x^3 + ax + b - y^2 = 0 mod p
+// Assume: a, b in [0, 2^n) 
+template PointOnCurve(n, k, a, b, p){
+    signal input in[2][k]; 
+
+    var LOGK = log_ceil(k);
+    var LOGK2 = log_ceil( (2*k-1)*(k*k+1) );
+    assert(4*n + LOGK2 < 251);
+
+    // compute x^3, y^2 
+    component x_sq = BigMultShortLong(n, k, 2*n + LOGK); // 2k-1 registers in [0, k*2^{2n}) 
+    component y_sq = BigMultShortLong(n, k, 2*n + LOGK); // 2k-1 registers in [0, k*2^{2n}) 
+    for(var i=0; i<k; i++){
+        x_sq.a[i] <== in[0][i];
+        x_sq.b[i] <== in[0][i];
+
+        y_sq.a[i] <== in[1][i];
+        y_sq.b[i] <== in[1][i];
+    }
+    component x_cu = BigMultShortLongUnequal(n, 2*k-1, k, 3*n + 2*LOGK); // 3k-2 registers in [0, k^2 * 2^{3n}) 
+    for(var i=0; i<2*k-1; i++)
+        x_cu.a[i] <== x_sq.out[i];
+    for(var i=0; i<k; i++)
+        x_cu.b[i] <== in[0][i];
+
+    // x_cu + a x + b has 3k-2 positive registers < k^2 * 2^{3n} + 2^{2n} + 2^n < (k^2 + 1) * 2^{3n} 
+    component cu_red = PrimeReduce(n, k, 2*k-2, p, 4*n + 3*LOGK + 1);
+    for(var i=0; i<3*k-2; i++){
+        if(i == 0)
+            cu_red.in[i] <== x_cu.out[i] + a * in[0][i] + b; 
+        else{
+            if(i < k)
+                cu_red.in[i] <== x_cu.out[i] + a * in[0][i]; 
+            else
+                cu_red.in[i] <== x_cu.out[i];
+        }
+    }
+    // cu_red has k registers < (k^2 + 1)*(2k-1)*2^{4n}
+
+    component y_sq_red = PrimeReduce(n, k, k-1, p, 3*n + 2*LOGK + 1);
+    for(var i=0; i<2*k-1; i++)
+        y_sq_red.in[i] <== y_sq.out[i]; 
+    // y_sq_red has positive registers, so when we subtract from cu_red it doesn't increase absolute value
+
+    component constraint = SignedCheckCarryModToZero(n, k, 4*n + LOGK2, p);
+    for(var i=0; i<k; i++){
+        constraint.in[i] <== cu_red.out[i] - y_sq_red.out[i]; 
+    }
+}
+
+// in[0] = (x_1, y_1), in[1] = (x_3, y_3) 
+// Checks that the line between (x_1, y_1) and (x_3, -y_3) is equal to the tangent line to the elliptic curve at the point (x_1, y_1)
+// Implements: 
+// (y_1 + y_3) = lambda * (x_1 - x_3)
+// where lambda = (3 x_1^2 + a)/(2 y_1) 
+// Actual constraint is 2y_1 (y_1 + y_3) = (3 x_1^2 + a ) ( x_1 - x_3 )
+template PointOnTangent(n, k, a, p){
+    signal input in[2][2][k];
+    
+    var LOGK = log_ceil(k);
+    var LOGK3 = log_ceil((3*k)*(2*k-1) + 1);
+    assert(4*n + LOGK3 < 251);
+    component x_sq = BigMultShortLong(n, k, 2*n + LOGK); // 2k-1 registers < k*2^{2n}) 
+    for(var i=0; i<k; i++){
+        x_sq.a[i] <== in[0][0][i];
+        x_sq.b[i] <== in[0][0][i];
+    }
+    component right = BigMultShortLongUnequal(n, 2*k-1, k, 3*n + 2*LOGK + 3); // 3k-2 registers < (3*k+1)*k*2^{3n} 
+    for(var i=0; i<2*k-1; i++){
+        if(i == 0)
+            right.a[i] <== 3 * x_sq.out[i] + a; // registers in [0, 3*k*2^{2n} + 2^n = (3k+2^{-n})*2^{2n})  
+        else
+            right.a[i] <== 3 * x_sq.out[i]; 
+    }
+    for(var i=0; i<k; i++){
+        right.b[i] <== in[0][0][i] - in[1][0][i]; 
+    }
+    
+    component left = BigMultShortLong(n, k, 2*n + 2 + LOGK); // 2k-1 registers in [0, 4k * 2^{2n})
+    for(var i=0; i<k; i++){
+        left.a[i] <== 2*in[0][1][i];
+        left.b[i] <== in[0][1][i] + in[1][1][i];  
+    }
+    
+    // prime reduce right - left 
+    component diff_red = PrimeReduce(n, k, 2*k-2, p, 4*n + LOGK3);
+    for(var i=0; i<3*k-2; i++){
+        if(i < 2*k-1) 
+            diff_red.in[i] <== right.out[i] - left.out[i]; 
+        else
+            diff_red.in[i] <== right.out[i];
+    }
+    // inputs of diff_red has registers < (3k+2^{-n})k*2^{3n} + 4k*2^{2n} < (3k^2 + 1)*2^{3n} assuming 5k <= 2^n 
+    // diff_red.out has registers < (3k+1)*(2k-1) * 2^{4n}
+    component constraint = SignedCheckCarryModToZero(n, k, 4*n + LOGK3, p);
+    for(var i=0; i<k; i++)
+        constraint.in[i] <== diff_red.out[i];
+}
+
+// requires x_1 != x_2
+// assume p is size k array, the prime that curve lives over 
+//
+// Implements:
+//  Given a = (x_1, y_1) and b = (x_2, y_2), 
+//      assume x_1 != x_2 and a != -b, 
+//  Find a + b = (x_3, y_3)
+// By solving:
+//  x_1 + x_2 + x_3 - lambda^2 = 0 mod p
+//  y_3 = lambda (x_1 - x_3) - y_1 mod p
+//  where lambda = (y_2-y_1)/(x_2-x_1) is the slope of the line between (x_1, y_1) and (x_2, y_2)
+// these equations are equivalent to:
+//  (x_1 + x_2 + x_3)*(x_2 - x_1)^2 = (y_2 - y_1)^2 mod p
+//  (y_1 + y_3)*(x_2 - x_1) = (y_2 - y_1)*(x_1 - x_3) mod p
+template EllipticCurveAddUnequal(n, k, p) { 
+    signal input a[2][k];
+    signal input b[2][k];
+
+    signal output out[2][k];
+
+    var LOGK = log_ceil(k);
+    var LOGK3 = log_ceil( (3*k*k)*(2*k-1) + 1 ); 
+    assert(4*n + LOGK3 < 251);
+
+    // precompute lambda and x_3 and then y_3
+    var dy[50] = long_sub_mod(n, k, b[1], a[1], p);
+    var dx[50] = long_sub_mod(n, k, b[0], a[0], p); 
+    var dx_inv[50] = mod_inv(n, k, dx, p);
+    var lambda[50] = prod_mod(n, k, dy, dx_inv, p);
+    var lambda_sq[50] = prod_mod(n, k, lambda, lambda, p);
+    // out[0] = x_3 = lamb^2 - a[0] - b[0] % p
+    // out[1] = y_3 = lamb * (a[0] - x_3) - a[1] % p
+    var x3[50] = long_sub_mod(n, k, long_sub_mod(n, k, lambda_sq, a[0], p), b[0], p);
+    var y3[50] = long_sub_mod(n, k, prod_mod(n, k, lambda, long_sub_mod(n, k, a[0], x3, p), p), a[1], p);
+
+    for(var i = 0; i < k; i++){
+        out[0][i] <-- x3[i];
+        out[1][i] <-- y3[i];
+    }
+    
+    // constrain x_3 by CUBIC (x_1 + x_2 + x_3) * (x_2 - x_1)^2 - (y_2 - y_1)^2 = 0 mod p
+    
+    component dx_sq = BigMultShortLong(n, k, 2*n+LOGK+2); // 2k-1 registers abs val < k*2^{2n} 
+    component dy_sq = BigMultShortLong(n, k, 2*n+LOGK+2); // 2k-1 registers < k*2^{2n}
+    for(var i = 0; i < k; i++){
+        dx_sq.a[i] <== b[0][i] - a[0][i];
+        dx_sq.b[i] <== b[0][i] - a[0][i];
+
+        dy_sq.a[i] <== b[1][i] - a[1][i];
+        dy_sq.b[i] <== b[1][i] - a[1][i];
+    } 
+
+    // x_1 + x_2 + x_3 has registers in [0, 3*2^n) 
+    component cubic = BigMultShortLongUnequal(n, k, 2*k-1, 3*n+4+2*LOGK); // 3k-2 registers < 3 * k^2 * 2^{3n} ) 
+    for(var i=0; i<k; i++)
+        cubic.a[i] <== a[0][i] + b[0][i] + out[0][i]; 
+    for(var i=0; i<2*k-1; i++){
+        cubic.b[i] <== dx_sq.out[i];
+    }
+
+    component cubic_red = PrimeReduce(n, k, 2*k-2, p, 4*n + LOGK3);
+    for(var i=0; i<2*k-1; i++)
+        cubic_red.in[i] <== cubic.out[i] - dy_sq.out[i]; // registers abs val < 3k^2*2^{3n} + k*2^{2n} < (3k^2+1)2^{3n}
+    for(var i=2*k-1; i<3*k-2; i++)
+        cubic_red.in[i] <== cubic.out[i]; 
+    // cubic_red has k registers < (3k^2+1)(2k-1) * 2^{4n}
+    
+    component cubic_mod = SignedCheckCarryModToZero(n, k, 4*n + LOGK3, p);
+    for(var i=0; i<k; i++)
+        cubic_mod.in[i] <== cubic_red.out[i]; 
+    // END OF CONSTRAINING x3
+    
+    // constrain y_3 by (y_1 + y_3) * (x_2 - x_1) = (y_2 - y_1)*(x_1 - x_3) mod p
+    component y_constraint = PointOnLine(n, k, p); // 2k-1 registers in [0, k*2^{2n+1})
+    for(var i = 0; i < k; i++)for(var j=0; j<2; j++){
+        y_constraint.in[0][j][i] <== a[j][i];
+        y_constraint.in[1][j][i] <== b[j][i];
+        y_constraint.in[2][j][i] <== out[j][i];
+    }
+    // END OF CONSTRAINING y3
+
+    // check if out[][] has registers in [0, 2^n) 
+    component range_check = RangeCheck2D(n, k);
+    for(var j=0; j<2; j++)for(var i=0; i<k; i++)
+        range_check.in[j][i] <== out[j][i];
+}
+
+
+// Elliptic curve is E : y**2 = x**3 + ax + b
+// assuming a < 2^n for now
+// Note that for BLS12-381, a = 0, b = 4
+
+// Implements:
+// computing 2P on elliptic curve E for P = (x_1, y_1)
+// formula from https://crypto.stanford.edu/pbc/notes/elliptic/explicit.html
+// x_1 = in[0], y_1 = in[1]
+// assume y_1 != 0 (otherwise 2P = O)
+
+// lamb =  (3x_1^2 + a) / (2 y_1) % p
+// x_3 = out[0] = lambda^2 - 2 x_1 % p
+// y_3 = out[1] = lambda (x_1 - x_3) - y_1 % p
+
+// We precompute (x_3, y_3) and then constrain by showing that:
+// * (x_3, y_3) is a valid point on the curve 
+// * (x_3, y_3) is on the tangent line to E at (x_1, y_1) 
+// * x_1 != x_3 
+template EllipticCurveDouble(n, k, a, b, p) {
+    signal input in[2][k];
+    signal output out[2][k];
+
+    var long_a[k];
+    var long_3[k];
+    long_a[0] = a;
+    long_3[0] = 3;
+    for (var i = 1; i < k; i++) {
+        long_a[i] = 0;
+        long_3[i] = 0;
+    }
+
+    // precompute lambda 
+    var lamb_num[50] = long_add_mod(n, k, long_a, prod_mod(n, k, long_3, prod_mod(n, k, in[0], in[0], p), p), p);
+    var lamb_denom[50] = long_add_mod(n, k, in[1], in[1], p);
+    var lamb[50] = prod_mod(n, k, lamb_num, mod_inv(n, k, lamb_denom, p), p);
+
+    // precompute x_3, y_3
+    var x3[50] = long_sub_mod(n, k, prod_mod(n, k, lamb, lamb, p), long_add_mod(n, k, in[0], in[0], p), p);
+    var y3[50] = long_sub_mod(n, k, prod_mod(n, k, lamb, long_sub_mod(n, k, in[0], x3, p), p), in[1], p);
+    
+    for(var i=0; i<k; i++){
+        out[0][i] <-- x3[i];
+        out[1][i] <-- y3[i];
+    }
+    // check if out[][] has registers in [0, 2^n)
+    component range_check = RangeCheck2D(n, k);
+    for(var j=0; j<2; j++)for(var i=0; i<k; i++)
+        range_check.in[j][i] <== out[j][i];
+
+    component point_on_tangent = PointOnTangent(n, k, a, p);
+    for(var j=0; j<2; j++)for(var i=0; i<k; i++){
+        point_on_tangent.in[0][j][i] <== in[j][i];
+        point_on_tangent.in[1][j][i] <== out[j][i];
+    }
+    
+    component point_on_curve = PointOnCurve(n, k, a, b, p);
+    for(var j=0; j<2; j++)for(var i=0; i<k; i++)
+        point_on_curve.in[j][i] <== out[j][i];
+    
+    component x3_eq_x1 = FpIsEqual(n, k, p);
+    for(var i = 0; i < k; i++){
+        x3_eq_x1.in[0][i] <== out[0][i];
+        x3_eq_x1.in[1][i] <== in[0][i];
+    }
+    x3_eq_x1.out === 0;
+}
+
+
+// Fp curve y^2 = x^3 + a1*x + b1 
+// Assume curve has no Fp points of order 2, i.e., x^3 + a1*x + b1 has no Fp roots
+// Fact: ^ this is the case for BLS12-381 and BN254
+// If isInfinity = 1, replace `out` with `a` so if `a` was on curve, so is output
+template EllipticCurveAdd(n, k, a1, b1, p){
+    signal input a[2][k];
+    signal input aIsInfinity;
+    signal input b[2][k];
+    signal input bIsInfinity;
+    
+    signal output out[2][k];
+    signal output isInfinity;
+
+    component x_equal = FpIsEqual(n, k, p);
+    component y_equal = FpIsEqual(n, k, p);
+
+    for(var idx=0; idx<k; idx++){
+        x_equal.in[0][idx] <== a[0][idx];
+        x_equal.in[1][idx] <== b[0][idx];
+
+        y_equal.in[0][idx] <== a[1][idx];
+        y_equal.in[1][idx] <== b[1][idx];
+    }
+    // if a.x = b.x then a = +-b 
+    // if a = b then a + b = 2*a so we need to do point doubling  
+    // if a = -a then out is infinity
+    signal add_is_double;
+    add_is_double <== x_equal.out * y_equal.out; // AND gate
+    
+    // if a.x = b.x, need to replace b.x by a different number just so AddUnequal doesn't break
+    // I will do this in a dumb way: replace b[0][0] by (b[0][0] == 0)
+    component iz = IsZero(); 
+    iz.in <== b[0][0]; 
+    
+    component add = EllipticCurveAddUnequal(n, k, p);
+    component doub = EllipticCurveDouble(n, k, a1, b1, p);
+    for(var i=0; i<2; i++)for(var idx=0; idx<k; idx++){
+        add.a[i][idx] <== a[i][idx];
+        if(i==0 && idx==0)
+            add.b[i][idx] <== b[i][idx] + x_equal.out * (iz.out - b[i][idx]); 
+        else
+            add.b[i][idx] <== b[i][idx]; 
+        
+        doub.in[i][idx] <== a[i][idx];
+    }
+    
+    // out = O iff ( a = O AND b = O ) OR ( x_equal AND NOT y_equal ) 
+    signal ab0;
+    ab0 <== aIsInfinity * bIsInfinity; 
+    signal anegb;
+    anegb <== x_equal.out - x_equal.out * y_equal.out; 
+    isInfinity <== ab0 + anegb - ab0 * anegb; // OR gate
+
+    signal tmp[3][2][k]; 
+    for(var i=0; i<2; i++)for(var idx=0; idx<k; idx++){
+        tmp[0][i][idx] <== add.out[i][idx] + add_is_double * (doub.out[i][idx] - add.out[i][idx]); 
+        // if a = O, then a + b = b 
+        tmp[1][i][idx] <== tmp[0][i][idx] + aIsInfinity * (b[i][idx] - tmp[0][i][idx]);
+        // if b = O, then a + b = a
+        tmp[2][i][idx] <== tmp[1][i][idx] + bIsInfinity * (a[i][idx] - tmp[1][i][idx]);
+        out[i][idx] <== tmp[2][i][idx] + isInfinity * (a[i][idx] - tmp[2][i][idx]);
+    }
+}
+
+// Curve E : y^2 = x^3 + b
+// Inputs:
+//  in is 2 x k array where P = (x, y) is a point in E(Fp) 
+//  inIsInfinity = 1 if P = O, else = 0
+// Output:
+//  out = [x]P is 2 x k array representing a point in E(Fp)
+//  isInfinity = 1 if [x]P = O, else = 0
+// Assume:
+//  x in [0, 2^250) 
+//  `in` is point in E even if inIsInfinity = 1 just so nothing goes wrong
+//  E(Fp) has no points of order 2
+template EllipticCurveScalarMultiply(n, k, b, x, p){
+    signal input in[2][k];
+    signal input inIsInfinity;
+
+    signal output out[2][k];
+    signal output isInfinity;
+
+    var LOGK = log_ceil(k);
+        
+    var Bits[250]; 
+    var BitLength;
+    var SigBits=0;
+    for (var i = 0; i < 250; i++) {
+        Bits[i] = (x >> i) & 1;
+        if(Bits[i] == 1){
+            SigBits++;
+            BitLength = i + 1;
+        }
+    }
+
+    signal R[BitLength][2][k]; 
+    signal R_isO[BitLength]; 
+    component Pdouble[BitLength];
+    component Padd[SigBits];
+    var curid=0;
+
+    // if in = O then [x]O = O so there's no point to any of this
+    signal P[2][k];
+    for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+        P[j][idx] <== in[j][idx];
+    
+    for(var i=BitLength - 1; i>=0; i--){
+        if( i == BitLength - 1 ){
+            for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                R[i][j][idx] <== P[j][idx];
+            R_isO[i] <== 0; 
+        }else{
+            // E(Fp) has no points of order 2, so the only way 2*R[i+1] = O is if R[i+1] = O 
+            Pdouble[i] = EllipticCurveDouble(n, k, 0, b, p);  
+            for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                Pdouble[i].in[j][idx] <== R[i+1][j][idx]; 
+            
+            if(Bits[i] == 0){
+                for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                    R[i][j][idx] <== Pdouble[i].out[j][idx];
+                R_isO[i] <== R_isO[i+1]; 
+            }else{
+                // Padd[curid] = Pdouble[i] + P 
+                Padd[curid] = EllipticCurveAdd(n, k, 0, b, p); 
+                for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+                    Padd[curid].a[j][idx] <== Pdouble[i].out[j][idx]; 
+                    Padd[curid].b[j][idx] <== P[j][idx];
+                }
+                Padd[curid].aIsInfinity <== R_isO[i+1];
+                Padd[curid].bIsInfinity <== 0;
+
+                R_isO[i] <== Padd[curid].isInfinity; 
+                for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                    R[i][j][idx] <== Padd[curid].out[j][idx];
+                
+                curid++;
+            }
+        }
+    }
+    // output = O if input = O or R[0] = O 
+    isInfinity <== inIsInfinity + R_isO[0] - inIsInfinity * R_isO[0];
+    for(var i=0; i<2; i++)for(var idx=0; idx<k; idx++)
+        out[i][idx] <== R[0][i][idx] + isInfinity * (in[i][idx] - R[0][i][idx]);
+}
+
+// Curve E : y^2 = x^3 + b
+// Inputs:
+//  in = P is 2 x k array where P = (x, y) is a point in E(Fp) 
+// Output:
+//  out = [x]P is 2 x k array representing a point in E(Fp)
+// Assume:
+//  x in [0, 2^250) 
+//  E(Fp) has no points of order 2
+//  P has order > x so never hit point at infinity, and can always use add unequal: constraint assertion fails if add unequal fails 
+template EllipticCurveScalarMultiplyUnequal(n, k, b, x, p){
+    signal input in[2][k];
+    signal output out[2][k];
+
+    var LOGK = log_ceil(k);
+        
+    var Bits[250]; 
+    var BitLength;
+    var SigBits=0;
+    for (var i = 0; i < 250; i++) {
+        Bits[i] = (x >> i) & 1;
+        if(Bits[i] == 1){
+            SigBits++;
+            BitLength = i + 1;
+        }
+    }
+
+    signal R[BitLength][2][k]; 
+    component Pdouble[BitLength];
+    component Padd[SigBits];
+    component add_exception[SigBits];
+    var curid=0;
+
+    for(var i=BitLength - 1; i>=0; i--){
+        if( i == BitLength - 1 ){
+            for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                R[i][j][idx] <== in[j][idx];
+        }else{
+            // E(Fp) has no points of order 2, so the only way 2*R[i+1] = O is if R[i+1] = O 
+            Pdouble[i] = EllipticCurveDouble(n, k, 0, b, p);  
+            for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                Pdouble[i].in[j][idx] <== R[i+1][j][idx]; 
+            
+            if(Bits[i] == 0){
+                for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                    R[i][j][idx] <== Pdouble[i].out[j][idx];
+            }else{
+                // Constrain that Pdouble[i].x != P.x 
+                add_exception[curid] = FpIsEqual(n, k, p);
+                for(var idx=0; idx<k; idx++){
+                    add_exception[curid].in[0][idx] <== Pdouble[i].out[0][idx];
+                    add_exception[curid].in[1][idx] <== in[0][idx];
+                }
+                add_exception[curid].out === 0;
+
+                // Padd[curid] = Pdouble[i] + P 
+                Padd[curid] = EllipticCurveAddUnequal(n, k, p); 
+                for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+                    Padd[curid].a[j][idx] <== Pdouble[i].out[j][idx]; 
+                    Padd[curid].b[j][idx] <== in[j][idx];
+                }
+                for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                    R[i][j][idx] <== Padd[curid].out[j][idx];
+                
+                curid++;
+            }
+        }
+    }
+    for(var i=0; i<2; i++)for(var idx=0; idx<k; idx++)
+        out[i][idx] <== R[0][i][idx];
+}
+
+
diff --git a/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/curve_fp2.circom b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/curve_fp2.circom
new file mode 100644
index 0000000..0b21693
--- /dev/null
+++ b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/curve_fp2.circom
@@ -0,0 +1,676 @@
+pragma circom 2.0.3;
+
+include "../../../dependencies/circomlib/circuits/bitify.circom";
+
+include "./bigint.circom";
+include "./bigint_func.circom";
+include "./fp.circom";
+include "./fp2.circom";
+include "./fp12.circom";
+include "./curve.circom";
+include "./bls12_381_func.circom";
+
+// in[i] = (x_i, y_i) 
+// Implements constraint: (y_1 + y_3) * (x_2 - x_1) - (y_2 - y_1)*(x_1 - x_3) = 0 mod p
+// used to show (x1, y1), (x2, y2), (x3, -y3) are co-linear
+template PointOnLineFp2(n, k, p) {
+    signal input in[3][2][2][k]; 
+
+    var LOGK = log_ceil(k);
+    var LOGK2 = log_ceil(6*k*k);
+    assert(3*n + LOGK2 < 251);
+
+    // AKA check point on line 
+    component left = BigMultShortLong2D(n, k, 2); // 3 x 2k-1 registers abs val < 4k*2^{2n}
+    for(var i = 0; i < 2; i ++) {
+        for (var j = 0; j < k; j ++) {
+            left.a[i][j] <== in[0][1][i][j] + in[2][1][i][j];
+            left.b[i][j] <== in[1][0][i][j] - in[0][0][i][j];
+        }
+    }
+
+    component right = BigMultShortLong2D(n, k, 2); // 3 x 2k-1 registers abs val < 2k*2^{2n}
+    for(var i = 0; i < 2; i ++) {
+        for (var j = 0; j < k; j ++) {
+            right.a[i][j] <== in[1][1][i][j] - in[0][1][i][j];
+            right.b[i][j] <== in[0][0][i][j] - in[2][0][i][j];
+        }
+    }
+    
+    component diff_red[2]; 
+    diff_red[0] = PrimeReduce(n, k, k-1, p, 3*n + 2*LOGK + 2);
+    diff_red[1] = PrimeReduce(n, k, k-1, p, 3*n + 2*LOGK + 1);
+    for(var i=0; i<2*k-1; i++) {
+        diff_red[0].in[i] <== left.out[0][i] - left.out[2][i] - right.out[0][i] + right.out[2][i];
+        diff_red[1].in[i] <== left.out[1][i] - right.out[1][i]; 
+    }
+    // diff_red has k registers abs val < 6*k^2*2^{3n} -- to see this, easier to use SignedFp2MultiplyNoCarry instead of BigMultShortLong2D 
+    component diff_mod[2];
+    for (var j = 0; j < 2; j ++) {
+        diff_mod[j] = SignedCheckCarryModToZero(n, k, 3*n + LOGK2, p);
+        for (var i = 0; i < k; i ++) {
+            diff_mod[j].in[i] <== diff_red[j].out[i];
+        }
+    }
+}
+
+// in = (x, y)
+// Implements:
+// x^3 + ax + b - y^2 = 0 mod p
+// Assume: a, b in [0, 2^n). a, b are complex 
+template PointOnCurveFp2(n, k, a, b, p){
+    signal input in[2][2][k]; 
+
+    var LOGK = log_ceil(k);
+    var LOGK3 = log_ceil( (2*k-1)*(4*k*k) + 1 );
+    assert(4*n + LOGK3 < 251);
+
+    // compute x^3, y^2 
+    component x_sq = SignedFp2MultiplyNoCarryUnequal(n, k, k, 2*n+1+LOGK); // 2k-1 registers in [0, 2*k*2^{2n}) 
+    component y_sq = SignedFp2MultiplyNoCarryUnequal(n, k, k, 2*n+1+LOGK); // 2k-1 registers in [0, 2*k*2^{2n}) 
+    for (var i = 0; i < 2; i ++) {
+        for (var j = 0; j < k ; j ++) {
+            x_sq.a[i][j] <== in[0][i][j];
+            x_sq.b[i][j] <== in[0][i][j];
+            y_sq.a[i][j] <== in[1][i][j];
+            y_sq.b[i][j] <== in[1][i][j];
+        }
+    }
+    component x_cu = SignedFp2MultiplyNoCarryUnequal(n, 2*k-1, k, 3*n+2*LOGK+2); // 3k-2 registers in [0, 4*k^2 * 2^{3n}) 
+    for (var i = 0; i < 2; i ++) {
+        for (var j = 0; j < 2*k-1; j ++) {
+            x_cu.a[i][j] <== x_sq.out[i][j];
+        }
+        for (var j = 0; j < k; j ++) {
+            x_cu.b[i][j] <== in[0][i][j];
+        }
+    }
+
+    // x_cu + a x + b has 3k-2 registers < (4k^2 + 1/2^n + 1/2^2n)2^{3n} <= (4*k^2+2/2^n)2^{3n} 
+    component cu_red[2];
+    for (var j = 0; j < 2; j ++) {
+        cu_red[j] = PrimeReduce(n, k, 2*k-2, p, 4*n + 3*LOGK + 4);
+        for(var i=0; i<3*k-2; i++){
+            if(i == 0) {
+                if(j == 0)
+                    cu_red[j].in[i] <== x_cu.out[j][i] + a[0] * in[0][0][i] - a[1] * in[0][1][i] + b[j];
+                else
+                    cu_red[j].in[i] <== x_cu.out[j][i] + a[0] * in[0][1][i] + a[1] * in[0][0][i] + b[j]; 
+            }
+            else{
+                if(i < k){
+                    if(j == 0)
+                        cu_red[j].in[i] <== x_cu.out[j][i] + a[0] * in[0][0][i] - a[1] * in[0][1][i];
+                    else
+                        cu_red[j].in[i] <== x_cu.out[j][i] + a[0] * in[0][1][i] + a[1] * in[0][0][i]; 
+                }
+                else
+                    cu_red[j].in[i] <== x_cu.out[j][i];
+            }
+        }
+    }
+    // cu_red has k registers < (2k-1)*(4*k^2+2/2^n)2^{4n} < 2^{4n + 3LOGK + 4}
+
+    component y_sq_red[2]; // k registers < 2k^2*2^{3n} 
+    for (var i = 0; i < 2; i ++) {
+        y_sq_red[i] = PrimeReduce(n, k, k-1, p, 3*n + 2*LOGK + 1);
+        for(var j=0; j<2*k-1; j++){
+            y_sq_red[i].in[j] <== y_sq.out[i][j];
+        }
+    }
+
+    component constraint[2];
+    constraint[0] = SignedCheckCarryModToZero(n, k, 4*n + LOGK3, p);
+    constraint[1] = SignedCheckCarryModToZero(n, k, 4*n + LOGK3, p);
+    for(var i=0; i<k; i++){
+        constraint[0].in[i] <== cu_red[0].out[i] - y_sq_red[0].out[i]; 
+        constraint[1].in[i] <== cu_red[1].out[i] - y_sq_red[1].out[i];
+    }
+}
+
+// in = x
+// Implements:
+// out = x^3 + ax + b mod p
+// Assume: a, b are in Fp2, coefficients in [0, 2^n)
+template EllipticCurveFunction(n, k, a, b, p){
+    signal input in[2][k]; 
+    signal output out[2][k];
+
+    var LOGK = log_ceil(k);
+    var LOGK3 = log_ceil( (2*k-1)*(4*k*k) + 1 );
+    assert(4*n + LOGK3 < 251);
+
+    // compute x^3, y^2 
+    component x_sq = SignedFp2MultiplyNoCarryUnequal(n, k, k, 2*n+1+LOGK); // 2k-1 registers in [0, 2*k*2^{2n}) 
+    for (var i = 0; i < 2; i ++) {
+        for (var j = 0; j < k ; j ++) {
+            x_sq.a[i][j] <== in[i][j];
+            x_sq.b[i][j] <== in[i][j];
+        }
+    }
+    component x_cu = SignedFp2MultiplyNoCarryUnequal(n, 2*k-1, k, 3*n+2*LOGK+2); // 3k-2 registers in [0, 4*k^2 * 2^{3n}) 
+    for (var i = 0; i < 2; i ++) {
+        for (var j = 0; j < 2*k-1; j ++) {
+            x_cu.a[i][j] <== x_sq.out[i][j];
+        }
+        for (var j = 0; j < k; j ++) {
+            x_cu.b[i][j] <== in[i][j];
+        }
+    }
+
+    // x_cu + a x + b has 3k-2 registers < (4*k^2+1)2^{3n} 
+    component cu_red[2];
+    for (var j = 0; j < 2; j ++) {
+        cu_red[j] = PrimeReduce(n, k, 2*k-2, p, 4*n + 3*LOGK + 4);
+        for(var i=0; i<3*k-2; i++){
+            if(i == 0) {
+                if(j == 0)
+                    cu_red[j].in[i] <== x_cu.out[j][i] + a[0] * in[0][i] - a[1] * in[1][i] + b[j];
+                else
+                    cu_red[j].in[i] <== x_cu.out[j][i] + a[0] * in[1][i] + a[1] * in[0][i] + b[j]; 
+            }
+            else{
+                if(i < k){
+                    if(j == 0)
+                        cu_red[j].in[i] <== x_cu.out[j][i] + a[0] * in[0][i] - a[1] * in[1][i];
+                    else
+                        cu_red[j].in[i] <== x_cu.out[j][i] + a[0] * in[1][i] + a[1] * in[0][i]; 
+                }
+                else
+                    cu_red[j].in[i] <== x_cu.out[j][i];
+            }
+        }
+    }
+    // cu_red has k registers < (2k-1)*(4*k^2+1)2^{4n} < 2^{4n + 3LOGK + 4}
+
+    component carry = SignedFp2CarryModP(n, k, 4*n + LOGK3, p);
+    for(var j=0; j<2; j++)for(var i=0; i<k; i++)
+        carry.in[j][i] <== cu_red[j].out[i];
+    
+    for(var j=0; j<2; j++)for(var i=0; i<k; i++)
+        out[j][i] <== carry.out[j][i];
+}
+
+
+// in[0] = (x_1, y_1), in[1] = (x_3, y_3) 
+// Checks that the line between (x_1, y_1) and (x_3, -y_3) is equal to the tangent line to the elliptic curve at the point (x_1, y_1)
+// Implements: 
+// (y_1 + y_3) = lambda * (x_1 - x_3)
+// where lambda = (3 x_1^2 + a)/(2 y_1) 
+// Actual constraint is 2y_1 (y_1 + y_3) = (3 x_1^2 + a ) ( x_1 - x_3 )
+// a is complex 
+template PointOnTangentFp2(n, k, a, p){
+    signal input in[2][2][2][k];
+    
+    var LOGK = log_ceil(k);
+    var LOGK3 = log_ceil((2*k-1)*(12*k*k) + 1);
+    assert(4*n + LOGK3 < 251);
+    component x_sq = SignedFp2MultiplyNoCarryUnequal(n, k, k, 2*n+1+LOGK); // 2k-1 registers in [0, 2*k*2^{2n}) 
+    for (var i = 0; i < 2; i ++) {
+        for (var j = 0; j < k ; j ++) {
+            x_sq.a[i][j] <== in[0][0][i][j];
+            x_sq.b[i][j] <== in[0][0][i][j];
+        }
+    }
+    component right = SignedFp2MultiplyNoCarryUnequal(n, 2*k-1, k, 3*n + 2*LOGK + 3); // 3k-2 registers < 2(6*k^2 + 2k/2^n)*2^{3n} 
+    for(var i=0; i<2*k-1; i++){
+        if(i == 0) {
+            right.a[0][i] <== 3 * x_sq.out[0][i] + a[0]; // registers in [0, 3*k*2^{2n} + 2^n )  
+            right.a[1][i] <== 3 * x_sq.out[1][i] + a[1];
+        }
+        else {
+            right.a[0][i] <== 3 * x_sq.out[0][i];
+            right.a[1][i] <== 3 * x_sq.out[1][i];
+        }
+    }
+    for(var i=0; i<k; i++){
+        right.b[0][i] <== in[0][0][0][i] - in[1][0][0][i]; 
+        right.b[1][i] <== in[0][0][1][i] - in[1][0][1][i];
+    }
+    
+    component left = SignedFp2MultiplyNoCarryUnequal(n, k, k, 2*n + 3 + LOGK); // 2k-1 registers in [0, 8k * 2^{2n})
+    for(var i=0; i<k; i++){
+        left.a[0][i] <== 2*in[0][1][0][i];
+        left.a[1][i] <== 2*in[0][1][1][i];
+        left.b[0][i] <== in[0][1][0][i] + in[1][1][0][i];
+        left.b[1][i] <== in[0][1][1][i] + in[1][1][1][i];
+    }
+    
+    // prime reduce right - left 
+    component diff_red[2];
+    for (var i = 0; i < 2; i ++) {
+        diff_red[i] = PrimeReduce(n, k, 2*k-2, p, 4*n + LOGK3);
+        for (var j = 0; j < 3*k-2; j ++) {
+            if (j < 2*k-1) {
+                diff_red[i].in[j] <== right.out[i][j] - left.out[i][j];
+            }
+            else {
+                diff_red[i].in[j] <== right.out[i][j];
+            }
+        }
+    }
+    // inputs of diff_red has registers < (12k^2 + 12k/2^n)*2^{3n} 
+    // diff_red.out has registers < ((2k-1)*12k^2 + 1) * 2^{4n} assuming 12k(2k-1) <= 2^n
+    component constraint[2];
+    for (var i = 0; i < 2; i ++) {
+        constraint[i] = SignedCheckCarryModToZero(n, k, 4*n + LOGK3, p);
+        for (var j = 0; j < k; j ++) {
+            constraint[i].in[j] <== diff_red[i].out[j];
+        }
+    }
+}
+
+// requires x_1 != x_2
+// assume p is size k array, the prime that curve lives over 
+//
+// Implements:
+//  Given a = (x_1, y_1) and b = (x_2, y_2), 
+//      assume x_1 != x_2 and a != -b, 
+//  Find a + b = (x_3, y_3)
+// By solving:
+//  x_1 + x_2 + x_3 - lambda^2 = 0 mod p
+//  y_3 = lambda (x_1 - x_3) - y_1 mod p
+//  where lambda = (y_2-y_1)/(x_2-x_1) is the slope of the line between (x_1, y_1) and (x_2, y_2)
+// these equations are equivalent to:
+//  (x_1 + x_2 + x_3)*(x_2 - x_1)^2 = (y_2 - y_1)^2 mod p
+//  (y_1 + y_3)*(x_2 - x_1) = (y_2 - y_1)*(x_1 - x_3) mod p
+template EllipticCurveAddUnequalFp2(n, k, p) { 
+    signal input a[2][2][k];
+    signal input b[2][2][k];
+
+    signal output out[2][2][k];
+
+    var LOGK = log_ceil(k);
+    var LOGK3 = log_ceil( (12*k*k)*(2*k-1) + 1); 
+    assert(4*n + LOGK3 + 2< 251);
+
+    // precompute lambda and x_3 and then y_3
+    var dy[2][50] = find_Fp2_diff(n, k, b[1], a[1], p);
+    var dx[2][50] = find_Fp2_diff(n, k, b[0], a[0], p); 
+    var dx_inv[2][50] = find_Fp2_inverse(n, k, dx, p);
+    var lambda[2][50] = find_Fp2_product(n, k, dy, dx_inv, p);
+    var lambda_sq[2][50] = find_Fp2_product(n, k, lambda, lambda, p);
+    // out[0] = x_3 = lamb^2 - a[0] - b[0] % p
+    // out[1] = y_3 = lamb * (a[0] - x_3) - a[1] % p
+    var x3[2][50] = find_Fp2_diff(n, k, find_Fp2_diff(n, k, lambda_sq, a[0], p), b[0], p);
+    var y3[2][50] = find_Fp2_diff(n, k, find_Fp2_product(n, k, lambda, find_Fp2_diff(n, k, a[0], x3, p), p), a[1], p);
+
+    for(var i = 0; i < k; i++){
+        out[0][0][i] <-- x3[0][i];
+        out[0][1][i] <-- x3[1][i];
+        out[1][0][i] <-- y3[0][i];
+        out[1][1][i] <-- y3[1][i];
+    }
+    
+    // constrain x_3 by CUBIC (x_1 + x_2 + x_3) * (x_2 - x_1)^2 - (y_2 - y_1)^2 = 0 mod p
+    
+    component dx_sq = BigMultShortLong2D(n, k, 2); // 2k-1 registers abs val < 2k*2^{2n} 
+    component dy_sq = BigMultShortLong2D(n, k, 2); // 2k-1 registers abs val < 2k*2^{2n}
+    for (var i = 0; i < 2; i ++) {
+        for (var j = 0; j < k; j ++) {
+            dx_sq.a[i][j] <== b[0][i][j] - a[0][i][j];
+            dx_sq.b[i][j] <== b[0][i][j] - a[0][i][j];
+            dy_sq.a[i][j] <== b[1][i][j] - a[1][i][j];
+            dy_sq.b[i][j] <== b[1][i][j] - a[1][i][j];
+        }
+    }
+
+    // x_1 + x_2 + x_3 has registers in [0, 3*2^n) 
+    component cubic = BigMultShortLong2DUnequal(n, k, 2*k-1, 2, 2); // 3k-2 x 3 registers < 12 * k^2 * 2^{3n} ) 
+    for(var i=0; i<k; i++) {
+        cubic.a[0][i] <== a[0][0][i] + b[0][0][i] + out[0][0][i]; 
+        cubic.a[1][i] <== a[0][1][i] + b[0][1][i] + out[0][1][i];
+    }
+    for(var i=0; i<2*k-1; i++){
+        cubic.b[0][i] <== dx_sq.out[0][i] - dx_sq.out[2][i];
+        cubic.b[1][i] <== dx_sq.out[1][i];
+    }
+
+    component cubic_red[2];
+    cubic_red[0] = PrimeReduce(n, k, 2*k-2, p, 4*n + LOGK3 + 2);
+    cubic_red[1] = PrimeReduce(n, k, 2*k-2, p, 4*n + LOGK3 + 2);
+    for(var i=0; i<2*k-1; i++) {
+        // get i^2 parts too!
+        cubic_red[0].in[i] <== cubic.out[0][i] - cubic.out[2][i] - dy_sq.out[0][i] + dy_sq.out[2][i]; // registers abs val < 12*k^2*2^{3n} + 2k*2^{2n} <= (12k^2 + 2k/2^n) * 2^{3n}
+        cubic_red[1].in[i] <== cubic.out[1][i] - dy_sq.out[1][i]; // registers in < 12*k^2*2^{3n} + 4k*2^{2n} < (12k+1)k * 2^{3n} )
+    }
+    for(var i=2*k-1; i<3*k-2; i++) {
+        cubic_red[0].in[i] <== cubic.out[0][i] - cubic.out[2][i]; 
+        cubic_red[1].in[i] <== cubic.out[1][i];
+    }
+    // cubic_red has k registers < ((2k-1)*12k^2+1) * 2^{4n} assuming 2k(2k-1) <= 2^n
+    
+    component cubic_mod[2];
+    cubic_mod[0] = SignedCheckCarryModToZero(n, k, 4*n + LOGK3 + 2, p);
+    cubic_mod[1] = SignedCheckCarryModToZero(n, k, 4*n + LOGK3 + 2, p);
+    for(var i=0; i<k; i++) {
+        cubic_mod[0].in[i] <== cubic_red[0].out[i];
+        cubic_mod[1].in[i] <== cubic_red[1].out[i];
+    }
+    // END OF CONSTRAINING x3
+    
+    // constrain y_3 by (y_1 + y_3) * (x_2 - x_1) = (y_2 - y_1)*(x_1 - x_3) mod p
+    component y_constraint = PointOnLineFp2(n, k, p); 
+    for(var i = 0; i < k; i++)for(var j=0; j<2; j++){
+        for(var ind = 0; ind < 2; ind ++) {
+            y_constraint.in[0][j][ind][i] <== a[j][ind][i];
+            y_constraint.in[1][j][ind][i] <== b[j][ind][i];
+            y_constraint.in[2][j][ind][i] <== out[j][ind][i];
+        }
+    }
+    // END OF CONSTRAINING y3
+
+    // check if out[][] has registers in [0, 2^n)
+    component range_check[2];
+    range_check[0] = RangeCheck2D(n, k);
+    range_check[1] = RangeCheck2D(n, k);
+    for(var j=0; j<2; j++)for(var i=0; i<k; i++) {
+        range_check[0].in[j][i] <== out[0][j][i];
+        range_check[1].in[j][i] <== out[1][j][i];
+    }
+}
+
+// Elliptic curve is E : y**2 = x**3 + ax + b
+// assuming a < 2^n for now, b is complex
+// Note that for BLS12-381 twisted, a = 0, b = 4+4u
+
+// Implements:
+// computing 2P on elliptic curve E for P = (x_1, y_1)
+// formula from https://crypto.stanford.edu/pbc/notes/elliptic/explicit.html
+// x_1 = in[0], y_1 = in[1]
+// assume y_1 != 0 (otherwise 2P = O)
+
+// lamb =  (3x_1^2 + a) / (2 y_1) % p
+// x_3 = out[0] = lambda^2 - 2 x_1 % p
+// y_3 = out[1] = lambda (x_1 - x_3) - y_1 % p
+
+// We precompute (x_3, y_3) and then constrain by showing that:
+// * (x_3, y_3) is a valid point on the curve 
+// * the slope (y_3 - y_1)/(x_3 - x_1) equals 
+// * x_1 != x_3 
+template EllipticCurveDoubleFp2(n, k, a, b, p) {
+    signal input in[2][2][k];
+    signal output out[2][2][k];
+
+    var long_a[2][k];
+    var long_3[2][k];
+    long_a[0][0] = a[0];
+    long_3[0][0] = 3;
+    long_a[1][0] = a[1];
+    long_3[1][0] = 0;
+    for (var i = 1; i < k; i++) {
+        long_a[0][i] = 0;
+        long_3[0][i] = 0;
+        long_a[1][i] = 0;
+        long_3[1][i] = 0;
+    }
+
+    // precompute lambda 
+    var lamb_num[2][50] = find_Fp2_sum(n, k, long_a, find_Fp2_product(n, k, long_3, find_Fp2_product(n, k, in[0], in[0], p), p), p);
+    var lamb_denom[2][50] = find_Fp2_sum(n, k, in[1], in[1], p);
+    var lamb[2][50] = find_Fp2_product(n, k, lamb_num, find_Fp2_inverse(n, k, lamb_denom, p), p);
+
+    // precompute x_3, y_3
+    var x3[2][50] = find_Fp2_diff(n, k, find_Fp2_product(n, k, lamb, lamb, p), find_Fp2_sum(n, k, in[0], in[0], p), p);
+    var y3[2][50] = find_Fp2_diff(n, k, find_Fp2_product(n, k, lamb, find_Fp2_diff(n, k, in[0], x3, p), p), in[1], p);
+    
+    for(var i=0; i<k; i++){
+        out[0][0][i] <-- x3[0][i];
+        out[0][1][i] <-- x3[1][i];
+        out[1][0][i] <-- y3[0][i];
+        out[1][1][i] <-- y3[1][i];
+    }
+    // check if out[][] has registers in [0, 2^n)
+    component range_check[2];
+    range_check[0] = RangeCheck2D(n, k);
+    range_check[1] = RangeCheck2D(n, k);
+    for(var j=0; j<2; j++)for(var i=0; i<k; i++) {
+        range_check[0].in[j][i] <== out[0][j][i];
+        range_check[1].in[j][i] <== out[1][j][i];
+    }
+
+    component point_on_tangent = PointOnTangentFp2(n, k, a, p);
+    for(var j=0; j<2; j++)for(var i=0; i<k; i++){
+        point_on_tangent.in[0][j][0][i] <== in[j][0][i];
+        point_on_tangent.in[0][j][1][i] <== in[j][1][i];
+        point_on_tangent.in[1][j][0][i] <== out[j][0][i];
+        point_on_tangent.in[1][j][1][i] <== out[j][1][i];
+    }
+    
+    component point_on_curve = PointOnCurveFp2(n, k, a, b, p);
+    for(var j=0; j<2; j++)for(var i=0; i<k; i++) {
+        point_on_curve.in[j][0][i] <== out[j][0][i];
+        point_on_curve.in[j][1][i] <== out[j][1][i];
+    }
+    
+    component x3_eq_x1 = Fp2IsEqual(n, k, p);
+    for(var j=0; j<2; j++)for(var i = 0; i < k; i++){
+        x3_eq_x1.a[j][i] <== out[0][j][i];
+        x3_eq_x1.b[j][i] <== in[0][j][i];
+    }
+    x3_eq_x1.out === 0;
+}
+
+// Fp2 curve y^2 = x^3 + a2*x + b2 with b2 complex
+// Assume curve has no Fp2 points of order 2, i.e., x^3 + a2*x + b2 has no Fp2 roots
+// Fact: ^ this is the case for BLS12-381 twisted E2 and its 3-isogeny E2'
+// If isInfinity = 1, replace `out` with `a` so if `a` was on curve, so is output
+template EllipticCurveAddFp2(n, k, a2, b2, p){
+    signal input a[2][2][k];
+    signal input aIsInfinity;
+    signal input b[2][2][k];
+    signal input bIsInfinity;
+    
+    signal output out[2][2][k];
+    signal output isInfinity;
+
+    component x_equal = Fp2IsEqual(n, k, p);
+    component y_equal = Fp2IsEqual(n, k, p);
+
+    for(var i=0; i<2; i++)for(var idx=0; idx<k; idx++){
+        x_equal.a[i][idx] <== a[0][i][idx];
+        x_equal.b[i][idx] <== b[0][i][idx];
+
+        y_equal.a[i][idx] <== a[1][i][idx];
+        y_equal.b[i][idx] <== b[1][i][idx];
+    }
+    // if a.x = b.x then a = +-b 
+    // if a = b then a + b = 2*a so we need to do point doubling  
+    // if a = -a then out is infinity
+    signal add_is_double;
+    add_is_double <== x_equal.out * y_equal.out; // AND gate
+    
+    // if a.x = b.x, need to replace b.x by a different number just so AddUnequal doesn't break
+    // I will do this in a dumb way: replace b[0][0][0] by (b[0][0][0] == 0)
+    component iz = IsZero(); 
+    iz.in <== b[0][0][0]; 
+    
+    component add = EllipticCurveAddUnequalFp2(n, k, p);
+    component doub = EllipticCurveDoubleFp2(n, k, a2, b2, p);
+    for(var i=0; i<2; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+        add.a[i][j][idx] <== a[i][j][idx];
+        if(i==0 && j==0 && idx==0)
+            add.b[i][j][idx] <== b[i][j][idx] + x_equal.out * (iz.out - b[i][j][idx]); 
+        else
+            add.b[i][j][idx] <== b[i][j][idx]; 
+        
+        doub.in[i][j][idx] <== a[i][j][idx];
+    }
+    
+    // out = O iff ( a = O AND b = O ) OR ( x_equal AND NOT y_equal ) 
+    signal ab0;
+    ab0 <== aIsInfinity * bIsInfinity; 
+    signal anegb;
+    anegb <== x_equal.out - x_equal.out * y_equal.out; 
+    isInfinity <== ab0 + anegb - ab0 * anegb; // OR gate
+
+    signal tmp[3][2][2][k]; 
+    for(var i=0; i<2; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+        tmp[0][i][j][idx] <== add.out[i][j][idx] + add_is_double * (doub.out[i][j][idx] - add.out[i][j][idx]); 
+        // if a = O, then a + b = b 
+        tmp[1][i][j][idx] <== tmp[0][i][j][idx] + aIsInfinity * (b[i][j][idx] - tmp[0][i][j][idx]);
+        // if b = O, then a + b = a
+        tmp[2][i][j][idx] <== tmp[1][i][j][idx] + bIsInfinity * (a[i][j][idx] - tmp[1][i][j][idx]);
+        out[i][j][idx] <== tmp[2][i][j][idx] + isInfinity * (a[i][j][idx] - tmp[2][i][j][idx]);
+    }
+}
+
+
+// Curve E2 : y^2 = x^3 + b
+// Inputs:
+//  in = P is 2 x 2 x k array where P = (x, y) is a point in E2(Fp2) 
+//  inIsInfinity = 1 if P = O, else = 0
+// Output:
+//  out = [x]P is 2 x 2 x k array representing a point in E2(Fp2)
+//  isInfinity = 1 if [x]P = O, else = 0
+// Assume:
+//  E2 has no Fp2 points of order 2
+//  x in [0, 2^250) 
+//  `in` is point in E2 even if inIsInfinity = 1 just so nothing goes wrong
+//  E2(Fp2) has no points of order 2
+template EllipticCurveScalarMultiplyFp2(n, k, b, x, p){
+    signal input in[2][2][k];
+    signal input inIsInfinity;
+
+    signal output out[2][2][k];
+    signal output isInfinity;
+
+    var LOGK = log_ceil(k);
+        
+    var Bits[250]; 
+    var BitLength;
+    var SigBits=0;
+    for (var i = 0; i < 250; i++) {
+        Bits[i] = (x >> i) & 1;
+        if(Bits[i] == 1){
+            SigBits++;
+            BitLength = i + 1;
+        }
+    }
+
+    signal R[BitLength][2][2][k]; 
+    signal R_isO[BitLength]; 
+    component Pdouble[BitLength];
+    component Padd[SigBits];
+    var curid=0;
+
+    // if in = O then [x]O = O so there's no point to any of this
+    signal P[2][2][k];
+    for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)for(var l=0; l<2; l++)
+        P[j][l][idx] <== in[j][l][idx];
+    
+    for(var i=BitLength - 1; i>=0; i--){
+        if( i == BitLength - 1 ){
+            for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)for(var l=0; l<2; l++){
+                R[i][j][l][idx] <== P[j][l][idx];
+            }
+            R_isO[i] <== 0; 
+        }else{
+            // E2(Fp2) has no points of order 2, so the only way 2*R[i+1] = O is if R[i+1] = O 
+            Pdouble[i] = EllipticCurveDoubleFp2(n, k, [0,0], b, p);  
+            for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)for(var l=0; l<2; l++)
+                Pdouble[i].in[j][l][idx] <== R[i+1][j][l][idx]; 
+            
+            if(Bits[i] == 0){
+                for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)for(var l=0; l<2; l++)
+                    R[i][j][l][idx] <== Pdouble[i].out[j][l][idx];
+                R_isO[i] <== R_isO[i+1]; 
+            }else{
+                // Padd[curid] = Pdouble[i] + P 
+                Padd[curid] = EllipticCurveAddFp2(n, k, [0,0], b, p); 
+                for(var j=0; j<2; j++)for(var l=0; l<2; l++)for(var idx=0; idx<k; idx++){
+                    Padd[curid].a[j][l][idx] <== Pdouble[i].out[j][l][idx]; 
+                    Padd[curid].b[j][l][idx] <== P[j][l][idx];
+                }
+                Padd[curid].aIsInfinity <== R_isO[i+1];
+                Padd[curid].bIsInfinity <== 0;
+
+                R_isO[i] <== Padd[curid].isInfinity; 
+                for(var j=0; j<2; j++)for(var l=0; l<2; l++)for(var idx=0; idx<k; idx++){
+                    R[i][j][l][idx] <== Padd[curid].out[j][l][idx];
+                }
+                curid++;
+            }
+        }
+    }
+    // output = O if input = O or R[0] = O 
+    isInfinity <== inIsInfinity + R_isO[0] - inIsInfinity * R_isO[0]; 
+    for(var i=0; i<2; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+        out[i][j][idx] <== R[0][i][j][idx] + isInfinity * (in[i][j][idx] - R[0][i][j][idx]);
+}
+
+
+// Curve E2 : y^2 = x^3 + b
+// Inputs:
+//  in = P is 2 x 2 x k array where P = (x, y) is a point in E2(Fp2) 
+// Output:
+//  out = [x]P is 2 x 2 x k array representing a point in E2(Fp2)
+// Assume:
+//  E2 has no Fp2 points of order 2 
+//  x in [0, 2^250) 
+//  P has order > x, so in double-and-add loop we never hit point at infinity, and only add unequal is allowed: constraint will fail if add unequal fails 
+template EllipticCurveScalarMultiplyUnequalFp2(n, k, b, x, p){
+    signal input in[2][2][k];
+    signal output out[2][2][k];
+
+    var LOGK = log_ceil(k);
+        
+    var Bits[250]; 
+    var BitLength;
+    var SigBits=0;
+    for (var i = 0; i < 250; i++) {
+        Bits[i] = (x >> i) & 1;
+        if(Bits[i] == 1){
+            SigBits++;
+            BitLength = i + 1;
+        }
+    }
+
+    signal R[BitLength][2][2][k]; 
+    component Pdouble[BitLength];
+    component Padd[SigBits];
+    component add_exception[SigBits];
+    var curid=0;
+
+    for(var i=BitLength - 1; i>=0; i--){
+        if( i == BitLength - 1 ){
+            for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)for(var l=0; l<2; l++){
+                R[i][j][l][idx] <== in[j][l][idx];
+            }
+        }else{
+            // Assuming E2 has no points of order 2, so double never fails 
+            // To remove this assumption, just add a check that Pdouble[i].y != 0
+            Pdouble[i] = EllipticCurveDoubleFp2(n, k, [0,0], b, p);  
+            for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)for(var l=0; l<2; l++)
+                Pdouble[i].in[j][l][idx] <== R[i+1][j][l][idx]; 
+            
+            if(Bits[i] == 0){
+                for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)for(var l=0; l<2; l++)
+                    R[i][j][l][idx] <== Pdouble[i].out[j][l][idx];
+            }else{
+                // Constrain Pdouble[i].x != P.x 
+                add_exception[curid] = Fp2IsEqual(n, k, p);
+                for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+                    add_exception[curid].a[j][idx] <== Pdouble[i].out[0][j][idx];
+                    add_exception[curid].b[j][idx] <== in[0][j][idx];
+                }
+                add_exception[curid].out === 0;
+        
+                // Padd[curid] = Pdouble[i] + P 
+                Padd[curid] = EllipticCurveAddUnequalFp2(n, k, p); 
+                for(var j=0; j<2; j++)for(var l=0; l<2; l++)for(var idx=0; idx<k; idx++){
+                    Padd[curid].a[j][l][idx] <== Pdouble[i].out[j][l][idx]; 
+                    Padd[curid].b[j][l][idx] <== in[j][l][idx];
+                }
+                for(var j=0; j<2; j++)for(var l=0; l<2; l++)for(var idx=0; idx<k; idx++){
+                    R[i][j][l][idx] <== Padd[curid].out[j][l][idx];
+                }
+                curid++;
+            }
+        }
+    }
+    for(var i=0; i<2; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+        out[i][j][idx] <== R[0][i][j][idx];
+}
+
+
diff --git a/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/extra_curve.circom b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/extra_curve.circom
new file mode 100644
index 0000000..d9ace42
--- /dev/null
+++ b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/extra_curve.circom
@@ -0,0 +1,748 @@
+pragma circom 2.0.2;
+
+include "../../../dependencies/circomlib/circuits/bitify.circom";
+
+include "./bigint.circom";
+include "./bigint_func.circom";
+include "./fp.circom";
+include "./fp2.circom";
+include "./fp12.circom";
+include "./curve.circom";
+
+// requires a[0] != b[0]
+//
+// Implements:
+// lamb = (b[1] - a[1]) / (b[0] - a[0]) % q
+// out[0] = lamb ** 2 - a[0] - b[0] % q
+// out[1] = lamb * (a[0] - out[0]) - a[1] % q
+template EllipticCurveAddUnequal3Reg(n, q0, q1, q2) {
+    var k = 3;
+    signal input a[2][k];
+    signal input b[2][k];
+
+    signal output out[2][k];
+
+    var q[20];
+    q[0] = q0;
+    q[1] = q1;
+    q[2] = q2;
+    for (var idx = 3; idx < 20; idx++) {
+	q[idx] = 0;
+    }
+    
+    // b[1] - a[1]
+    component sub1 = BigSubModP(n, k);
+    for (var i = 0; i < k; i++) {
+        sub1.a[i] <== b[1][i];
+        sub1.b[i] <== a[1][i];
+        sub1.p[i] <== q[i];
+    }
+
+    // b[0] - a[0]
+    component sub0 = BigSubModP(n, k);
+    for (var i = 0; i < k; i++) {
+        sub0.a[i] <== b[0][i];
+        sub0.b[i] <== a[0][i];
+        sub0.p[i] <== q[i];
+    }
+
+    signal lambda[k];
+    var sub0inv[20] = mod_inv(n, k, sub0.out, q);
+    var sub1_sub0inv[20] = prod(n, k, sub1.out, sub0inv);
+    var lamb_arr[2][20] = long_div(n, k, sub1_sub0inv, q);
+    for (var i = 0; i < k; i++) {
+        lambda[i] <-- lamb_arr[1][i];
+    }
+    component range_checks[k];
+    for (var i = 0; i < k; i++) {
+        range_checks[i] = Num2Bits(n);
+        range_checks[i].in <== lambda[i];
+    }
+    component lt = BigLessThan(n, k);
+    for (var i = 0; i < k; i++) {
+        lt.a[i] <== lambda[i];
+        lt.b[i] <== q[i];
+    }
+    lt.out === 1;
+
+    component lambda_check = BigMultModP(n, k);
+    for (var i = 0; i < k; i++) {
+        lambda_check.a[i] <== sub0.out[i];
+        lambda_check.b[i] <== lambda[i];
+        lambda_check.p[i] <== q[i];
+    }
+    for (var i = 0; i < k; i++) {
+        lambda_check.out[i] === sub1.out[i];
+    }
+
+    component lambdasq = BigMultModP(n, k);
+    for (var i = 0; i < k; i++) {
+        lambdasq.a[i] <== lambda[i];
+        lambdasq.b[i] <== lambda[i];
+        lambdasq.p[i] <== q[i];
+    }
+    component out0_pre = BigSubModP(n, k);
+    for (var i = 0; i < k; i++) {
+        out0_pre.a[i] <== lambdasq.out[i];
+        out0_pre.b[i] <== a[0][i];
+        out0_pre.p[i] <== q[i];
+    }
+    component out0 = BigSubModP(n, k);
+    for (var i = 0; i < k; i++) {
+        out0.a[i] <== out0_pre.out[i];
+        out0.b[i] <== b[0][i];
+        out0.p[i] <== q[i];
+    }
+    for (var i = 0; i < k; i++) {
+        out[0][i] <== out0.out[i];
+    }
+
+    component out1_0 = BigSubModP(n, k);
+    for (var i = 0; i < k; i++) {
+        out1_0.a[i] <== a[0][i];
+        out1_0.b[i] <== out[0][i];
+        out1_0.p[i] <== q[i];
+    }
+    component out1_1 = BigMultModP(n, k);
+    for (var i = 0; i < k; i++) {
+        out1_1.a[i] <== lambda[i];
+        out1_1.b[i] <== out1_0.out[i];
+        out1_1.p[i] <== q[i];
+    }
+    component out1 = BigSubModP(n, k);
+    for (var i = 0; i < k; i++) {
+        out1.a[i] <== out1_1.out[i];
+        out1.b[i] <== a[1][i];
+        out1.p[i] <== q[i];
+    }
+    for (var i = 0; i < k; i++) {
+        out[1][i] <== out1.out[i];
+    }    
+}
+
+// requires a[0] != b[0]
+//
+// Implements:
+// lamb = (b[1] - a[1]) / (b[0] - a[0]) % q
+// out[0] = lamb ** 2 - a[0] - b[0] % q
+// out[1] = lamb * (a[0] - out[0]) - a[1] % q
+template EllipticCurveAddUnequal4Reg(n, q0, q1, q2, q3) {
+    var k = 4;
+    signal input a[2][k];
+    signal input b[2][k];
+
+    signal output out[2][k];
+
+    var q[20];
+    q[0] = q0;
+    q[1] = q1;
+    q[2] = q2;
+    q[3] = q3;
+    for (var idx = 4; idx < 20; idx++) {
+	q[idx] = 0;
+    }
+    
+    // b[1] - a[1]
+    component sub1 = BigSubModP(n, k);
+    for (var i = 0; i < k; i++) {
+        sub1.a[i] <== b[1][i];
+        sub1.b[i] <== a[1][i];
+        sub1.p[i] <== q[i];
+    }
+
+    // b[0] - a[0]
+    component sub0 = BigSubModP(n, k);
+    for (var i = 0; i < k; i++) {
+        sub0.a[i] <== b[0][i];
+        sub0.b[i] <== a[0][i];
+        sub0.p[i] <== q[i];
+    }
+
+    signal lambda[k];
+    var sub0inv[20] = mod_inv(n, k, sub0.out, q);
+    var sub1_sub0inv[20] = prod(n, k, sub1.out, sub0inv);
+    var lamb_arr[2][20] = long_div(n, k, sub1_sub0inv, q);
+    for (var i = 0; i < k; i++) {
+        lambda[i] <-- lamb_arr[1][i];
+    }
+    component range_checks[k];
+    for (var i = 0; i < k; i++) {
+        range_checks[i] = Num2Bits(n);
+        range_checks[i].in <== lambda[i];
+    }
+    component lt = BigLessThan(n, k);
+    for (var i = 0; i < k; i++) {
+        lt.a[i] <== lambda[i];
+        lt.b[i] <== q[i];
+    }
+    lt.out === 1;
+
+    component lambda_check = BigMultModP(n, k);
+    for (var i = 0; i < k; i++) {
+        lambda_check.a[i] <== sub0.out[i];
+        lambda_check.b[i] <== lambda[i];
+        lambda_check.p[i] <== q[i];
+    }
+    for (var i = 0; i < k; i++) {
+        lambda_check.out[i] === sub1.out[i];
+    }
+
+    component lambdasq = BigMultModP(n, k);
+    for (var i = 0; i < k; i++) {
+        lambdasq.a[i] <== lambda[i];
+        lambdasq.b[i] <== lambda[i];
+        lambdasq.p[i] <== q[i];
+    }
+    component out0_pre = BigSubModP(n, k);
+    for (var i = 0; i < k; i++) {
+        out0_pre.a[i] <== lambdasq.out[i];
+        out0_pre.b[i] <== a[0][i];
+        out0_pre.p[i] <== q[i];
+    }
+    component out0 = BigSubModP(n, k);
+    for (var i = 0; i < k; i++) {
+        out0.a[i] <== out0_pre.out[i];
+        out0.b[i] <== b[0][i];
+        out0.p[i] <== q[i];
+    }
+    for (var i = 0; i < k; i++) {
+        out[0][i] <== out0.out[i];
+    }
+
+    component out1_0 = BigSubModP(n, k);
+    for (var i = 0; i < k; i++) {
+        out1_0.a[i] <== a[0][i];
+        out1_0.b[i] <== out[0][i];
+        out1_0.p[i] <== q[i];
+    }
+    component out1_1 = BigMultModP(n, k);
+    for (var i = 0; i < k; i++) {
+        out1_1.a[i] <== lambda[i];
+        out1_1.b[i] <== out1_0.out[i];
+        out1_1.p[i] <== q[i];
+    }
+    component out1 = BigSubModP(n, k);
+    for (var i = 0; i < k; i++) {
+        out1.a[i] <== out1_1.out[i];
+        out1.b[i] <== a[1][i];
+        out1.p[i] <== q[i];
+    }
+    for (var i = 0; i < k; i++) {
+        out[1][i] <== out1.out[i];
+    }    
+}
+
+// Elliptic curve is E : y**2 = x**3 + a x + b
+// Note that for BLS12-381, a = 0, b = 4
+
+// Implements:
+// computing 2P on elliptic curve E for P = (in[0], in[1])
+// formula from https://crypto.stanford.edu/pbc/notes/elliptic/explicit.html
+
+// lamb =  (3 * in[0] ** 2 + a) / (2 * in[1]) % q
+// out[0] = lamb ** 2 - 2 * in[0] % q
+// out[1] = lamb * (in[0] - out[0]) - in[1] % q
+template EllipticCurveDouble0(n, k, a, q0, q1, q2, q3) {
+    signal input in[2][k];
+
+    signal output out[2][k];
+
+    // assuming q < 2**(4n) 
+    // represent q = q0 + q1 * 2**n + q2 * 2**(2n) + q3 * 2**(3n)
+    // not sure how I feel about this convention...
+    var q[20];
+    q[0] = q0;
+    q[1] = q1;
+    q[2] = q2;
+    q[3] = q3;
+    for (var idx = 4; idx < 20; idx++) {
+	    q[idx] = 0;
+    }
+
+    // assuming a is small 
+    var long_a[20];
+    long_a[0] = a;
+    for (var i = 1; i < 20; i++) {
+        long_a[i] = 0;   
+    }
+
+    component in0_sq = BigMultModP(n, k);
+    for (var i = 0; i < k; i++) {
+        in0_sq.a[i] <== in[0][i];
+        in0_sq.b[i] <== in[0][i];
+        in0_sq.p[i] <== q[i];
+    }
+
+    var long_2[20];
+    var long_3[20];
+    long_2[0] = 2;
+    long_3[0] = 3;
+    for (var i = 1; i < k; i++) {
+        long_a[i] = 0;
+        long_2[i] = 0;
+        long_3[i] = 0;
+    }
+    var inv_2[20] = mod_inv(n, k, long_2, q);
+    var long_3_div_2[20] = prod(n, k, long_3, inv_2);
+    var long_3_div_2_mod_q[2][20] = long_div(n, k, long_3_div_2, q);
+
+    // numerator = 3/2 * in[0]**2 + a
+    // numer1 = 3/2 * in[0]**2
+    component numer1 = BigMultModP(n, k);
+    for (var i = 0; i < k; i++) {
+        numer1.a[i] <== long_3_div_2_mod_q[1][i];
+        numer1.b[i] <== in0_sq.out[i];
+        numer1.p[i] <== q[i];
+    }
+    component numer = BigAddModP(n, k);
+    for (var i = 0; i < k; i++) {
+        numer.a[i] <== numer1.out[i];
+        numer.b[i] <== long_a[i];
+        numer.p[i] <== q[i];
+    }
+
+    signal lambda[k];
+    var denom_inv[20] = mod_inv(n, k, in[1], q);
+    var product[20] = prod(n, k, numer.out, denom_inv);
+    var lamb_arr[2][20] = long_div(n, k, product, q);
+    for (var i = 0; i < k; i++) {
+        lambda[i] <-- lamb_arr[1][i];
+    }
+    component lt = BigLessThan(n, k);
+    for (var i = 0; i < k; i++) {
+        lt.a[i] <== lambda[i];
+        lt.b[i] <== q[i];
+    }
+    lt.out === 1;
+
+    component lambda_range_checks[k];
+    component lambda_check = BigMultModP(n, k);
+    for (var i = 0; i < k; i++) {
+        lambda_range_checks[i] = Num2Bits(n);
+        lambda_range_checks[i].in <== lambda[i];
+
+        lambda_check.a[i] <== in[1][i];
+        lambda_check.b[i] <== lambda[i];
+        lambda_check.p[i] <== q[i];
+    }
+    for (var i = 0; i < k; i++) {
+        lambda_check.out[i] === numer.out[i];
+    }
+
+    component lambdasq = BigMultModP(n, k);
+    for (var i = 0; i < k; i++) {
+        lambdasq.a[i] <== lambda[i];
+        lambdasq.b[i] <== lambda[i];
+        lambdasq.p[i] <== q[i];
+    }
+    component out0_pre = BigSubModP(n, k);
+    for (var i = 0; i < k; i++) {
+        out0_pre.a[i] <== lambdasq.out[i];
+        out0_pre.b[i] <== in[0][i];
+        out0_pre.p[i] <== q[i];
+    }
+    // out0 = lambda**2 - 2*in[0]
+    component out0 = BigSubModP(n, k);
+    for (var i = 0; i < k; i++) {
+        out0.a[i] <== out0_pre.out[i];
+        out0.b[i] <== in[0][i];
+        out0.p[i] <== q[i];
+    }
+    for (var i = 0; i < k; i++) {
+        out[0][i] <== out0.out[i];
+    }
+
+    component out1_0 = BigSubModP(n, k);
+    for (var i = 0; i < k; i++) {
+        out1_0.a[i] <== in[0][i];
+        out1_0.b[i] <== out[0][i];
+        out1_0.p[i] <== q[i];
+    }
+    component out1_1 = BigMultModP(n, k);
+    for (var i = 0; i < k; i++) {
+        out1_1.a[i] <== lambda[i];
+        out1_1.b[i] <== out1_0.out[i];
+        out1_1.p[i] <== q[i];
+    }
+    component out1 = BigSubModP(n, k);
+    for (var i = 0; i < k; i++) {
+        out1.a[i] <== out1_1.out[i];
+        out1.b[i] <== in[1][i];
+        out1.p[i] <== q[i];
+    }
+    for (var i = 0; i < k; i++) {
+        out[1][i] <== out1.out[i];
+    }
+}
+
+/*
+// P = (x, y)
+// a = - 3x^2 
+// b = 2 y
+// c = 3 x^3 - 2 y^2 
+// a, c registers in [0, 2^n), b registers in [0, 2^{n})
+// out = [a, b, c]
+template LineEqualCoefficients(n, k, q){
+    signal input P[2][k]; 
+    signal output out[3][k];
+    
+    component xsq3 = BigMultShortLong(n, k); // 2k-1 registers [0, 3*k* 2^{2n})
+    component ysq = BigMultShortLong(n, k); // 2k-1 registers [0, k*2^{2n}) 
+    for(var i=0; i<k; i++){
+        xsq3.a[i] <== 3*P[0][i];
+        xsq3.b[i] <== P[0][i];
+        
+        ysq.a[i] <== P[1][i];
+        ysq.b[i] <== P[1][i];
+    }
+    
+    component xcube3 = BigMultShortLongUnequal(n, 2*k-1, k); // 3k-2 registers [0, 3*k^2* 2^{3n} )
+    for(var i=0; i<2*k-1; i++)
+        xcube3.a[i] <== xsq3.out[i];
+    for(var i=0; i<k; i++)
+        xcube3.b[i] <== P[0][i];
+
+    
+    component xsq3red = PrimeReduce(n, k, k-1, q); // k registers in [0, k^2 * 2^{3n} )
+    for(var i=0; i<2*k-1; i++) 
+        xsq3red.in[i] <== xsq3.out[i];
+    
+    component a = FpCarryModP(n, k, 3*n + log_ceil(k*k), q);
+    for(var i=0; i<k; i++){
+        a.in[0][i] <== 0;
+        a.in[1][i] <== xsq3red.out[i];
+    }
+    for(var i=0; i<k; i++)
+        out[0][i] <== a.out[i];
+    
+    // I think reducing registers of b to [0, 2^n) is still useful for future multiplications
+    component b = BigAddModP(n, k);
+    for(var i=0; i<k; i++){
+        b.a[i] <== P[1][i];
+        b.b[i] <== P[1][i];
+        b.p[i] <== q[i];
+    }
+    for(var i=0; i<k; i++)
+        out[1][i] <== b.out[i];
+    
+    component xcube3red = PrimeReduce(n, k, 2*k-2, q); // k registers in [0, 3*k^2*(2*k-2) * 2^{4n} )
+    for(var i=0; i<3*k-2; i++) 
+        xcube3red.in[i] <== xcube3.out[i];
+    
+    component ysqred = PrimeReduce(n, k, k-1, q); 
+    for(var i=0; i<2*k-1; i++) 
+        ysqred.in[i] <== ysq.out[i];
+
+    component c = FpCarryModP(n, k, 4*n + log_ceil(3*k*k*(2*k-2)), q); 
+    for(var i=0; i<k; i++){
+        c.in[0][i] <== xcube3red.out[i];
+        c.in[1][i] <== 2*ysqred.out[i];
+    }
+    for(var i=0; i<k; i++)
+        out[2][i] <== c.out[i];
+    
+}*/
+
+
+
+// Assuming curve is of form Y^2 = X^3 + b for now (a = 0) for better register bounds 
+// Inputs:
+//  P is 2 x k array where P = (x, y) is a point in E[r](Fq) 
+//  Q is 2 x 6 x 2 x k array representing point (X, Y) in E(Fq12) 
+// Output:
+// f_r(Q) where <f_r> = [r]P - [r]O is computed using Miller's algorithm
+// Assume:
+//  r has k registers in [0, 2^n)
+//  q has k registers in [0, 2^n)
+//  r is prime
+//  P != O so the order of P in E(Fq) is r, so [i]P != [j]P for i != j in Z/r 
+template MillerLoop1(n, k, b, r, q){
+    signal input P[2][k]; 
+    signal input Q[2][6][2][k];
+    signal output out[6][2][k];
+
+    var LOGK = log_ceil(k);
+    var XI0 = 1;
+    var LOGK2 = log_ceil(36*(2+XI0)*(2+XI0) * k*k);
+    var LOGK3 = log_ceil(36*(2+XI0)*(2+XI0) * k*k*(2*k-1));
+    assert( 4*n + LOGK3 < 251 );
+
+
+    var Bits[500]; // length is k * n
+    var BitLength;
+    var SigBits=0;
+    for (var i = 0; i < k; i++) {
+        for (var j = 0; j < n; j++) {
+            Bits[j + n * i] = (r[i] >> j) & 1;
+            if(Bits[j + n * i] == 1){
+                SigBits++;
+                BitLength = j + n * i + 1;
+            }
+        }
+    }
+
+    signal Pintermed[BitLength][2][k]; 
+    signal f[BitLength][6][2][k];
+
+    component Pdouble[BitLength];
+    component fdouble[BitLength];
+    component square[BitLength];
+    component line[BitLength];
+    component compress[BitLength];
+    component nocarry[BitLength];
+    component Padd[SigBits];
+    component fadd[SigBits]; 
+    component fadd_pre[SigBits]; 
+    var curid=0;
+
+    for(var i=BitLength - 1; i>=0; i--){
+        if( i == BitLength - 1 ){
+            // f = 1 
+            for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+                if(l==0 && j==0 && idx==0)
+                    f[i][l][j][idx] <== 1;
+                else    
+                    f[i][l][j][idx] <== 0;
+            }
+            for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                Pintermed[i][j][idx] <== P[j][idx];
+        }else{
+            // compute fdouble[i] = f[i+1]^2 * l_{Pintermed[i+1], Pintermed[i+1]}(Q) 
+            square[i] = SignedFp12MultiplyNoCarry(n, k, 2*n + 4 + LOGK); // 6 x 2 x 2k-1 registers in [0, 6 * k * (2+XI0) * 2^{2n} )
+            for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+                square[i].a[l][j][idx] <== f[i+1][l][j][idx];
+                square[i].b[l][j][idx] <== f[i+1][l][j][idx];
+            }
+
+            line[i] = LineFunctionEqual(n, k, q); // 6 x 2 x k registers in [0, 2^n) 
+            for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                line[i].P[j][idx] <== Pintermed[i+1][j][idx];            
+            for(var eps=0; eps<2; eps++)
+                for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                    line[i].Q[eps][l][j][idx] <== Q[eps][l][j][idx];
+
+            nocarry[i] = SignedFp12MultiplyNoCarryUnequal(n, 2*k-1, k, 3*n + LOGK2); // 6 x 2 x 3k-2 registers < (6 * (2+XI0))^2 * k^2 * 2^{3n} ) 
+            for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<2*k-1; idx++)
+                nocarry[i].a[l][j][idx] <== square[i].out[l][j][idx];
+            
+            for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                nocarry[i].b[l][j][idx] <== line[i].out[l][j][idx];
+            
+            compress[i] = Fp12Compress(n, k, 2*k-2, q, 4*n + LOGK3); // 6 x 2 x k registers < (6 * (2+ XI0))^2 * k^2 * (2k-1) * 2^{4n} )
+            for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<3*k-2; idx++)
+                compress[i].in[l][j][idx] <== nocarry[i].out[l][j][idx];
+
+            fdouble[i] = SignedFp12CarryModP(n, k, 4*n + LOGK3, q);
+            for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                fdouble[i].in[l][j][idx] <== compress[i].out[l][j][idx]; 
+
+            Pdouble[i] = EllipticCurveDouble(n, k, 0, b, q);  
+            for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                Pdouble[i].in[j][idx] <== Pintermed[i+1][j][idx]; 
+            
+            if(Bits[i] == 0){
+                for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                    f[i][l][j][idx] <== fdouble[i].out[l][j][idx]; 
+                for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                    Pintermed[i][j][idx] <== Pdouble[i].out[j][idx];
+            }else{
+                // fadd[curid] = fdouble * l_{Pdouble[i], P}(Q) 
+                fadd[curid] = Fp12MultiplyWithLineUnequal(n, k, k, n, q); 
+                for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                    fadd[curid].g[l][j][idx] <== fdouble[i].out[l][j][idx];
+                
+                for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+                    fadd[curid].P[0][j][idx] <== Pdouble[i].out[j][idx];            
+                    fadd[curid].P[1][j][idx] <== P[j][idx];            
+                }
+                for(var eps=0; eps<2; eps++)for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                    fadd[curid].Q[eps][l][j][idx] <== Q[eps][l][j][idx];
+
+                for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                    f[i][l][j][idx] <== fadd[curid].out[l][j][idx]; 
+
+                // Padd[curid] = Pdouble[i] + P 
+                Padd[curid] = EllipticCurveAddUnequal(n, k, q); 
+                for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+                    Padd[curid].a[j][idx] <== Pdouble[i].out[j][idx];
+                    Padd[curid].b[j][idx] <== P[j][idx];
+                }
+
+                for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                    Pintermed[i][j][idx] <== Padd[curid].out[j][idx];
+                
+                curid++;
+            }
+        }
+    }
+    for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+        out[l][j][idx] <== f[0][l][j][idx];
+    
+}
+
+/*
+// Input:
+//  g is 6 x 4 x kg array representing element of Fp12, allowing overflow and negative
+//  P, Q are as in inputs of LineFunctionEqualNoCarry
+// Assume:
+//  all registers of g are in [0, 2^{overflowg}) 
+//  all registers of P, Q are in [0, 2^n) 
+// Output:
+//  out = g * l_{P, P}(Q) as element of Fp12 with carry 
+//  out is 6 x 2 x k
+template Fp12MultiplyWithLineEqual(n, k, kg, overflowg, q){
+    signal input g[6][4][kg];
+    signal input P[2][k];
+    signal input Q[2][6][2][k];
+    signal output out[6][2][k];
+
+    var LOGK = log_ceil(k);
+    component line = LineFunctionEqualNoCarry(n, k, 3*n + 2*LOGK + 2); // 6 x 4 x (3k - 2) registers in [0, 2^{3n + 2log(k) + 2})
+    for(var l=0; l<2; l++)for(var idx=0; idx<k; idx++)
+        line.P[l][idx] <== P[l][idx];
+    for(var l=0; l<2; l++)for(var i=0; i<6; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+        line.Q[l][i][j][idx] <== Q[l][i][j][idx];
+
+    var mink;
+    if(kg < 3*k - 2)
+        mink = kg;
+    else
+        mink = 3*k - 2;
+    var logc = log_ceil(12 * (2*k + kg - 2) * mink * k * k);
+    assert( overflowg + 4*n + logc + 2 < 252 );
+    var log2kkg = log_ceil ( 2*k + kg - 2);
+    component mult = Fp12MultiplyNoCarryUnequal(n, kg, 3*k - 2, overflowg + 3*n + logc + 2 - log2kkg); // 3k + kg - 3 registers in [0, 12 * min(kg, 3k - 2) * 2^{overflowg + 3n + 2log(k) + 2} )
+    
+    for(var i=0; i<6; i++)for(var j=0; j<4; j++)for(var idx=0; idx<kg; idx++)
+        mult.a[i][j][idx] <== g[i][j][idx];
+    for(var i=0; i<6; i++)for(var j=0; j<4; j++)for(var idx=0; idx<3*k-2; idx++)
+        mult.b[i][j][idx] <== line.out[i][j][idx];
+    component reduce = Fp12Compress(n, k, 2*k + kg - 3, q, overflowg + 4*n + logc + 2); // k registers in [0, 12 * (2k + kg - 2) * min(kg, 3k - 2) * 2^{overflowg + 4n + 2log(k) + 2} )
+    for(var i=0; i<6; i++)for(var j=0; j<4; j++)for(var idx=0; idx<3*k + kg - 3; idx++)
+        reduce.in[i][j][idx] <== mult.out[i][j][idx];
+
+    component carry = Fp12CarryModP(n, k, overflowg + 4*n + logc + 2, q);
+
+    for(var i=0; i<6; i++)for(var j=0; j<4; j++)for(var idx=0; idx<k; idx++)
+        carry.in[i][j][idx] <== reduce.out[i][j][idx];
+
+    for(var i=0; i<6; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+        out[i][j][idx] <== carry.out[i][j][idx];
+}
+*/
+
+/*
+// version with one less carry per loop that requires 6n + ... overflow 
+// doesn't actually reduce constraints for some reason
+template MillerLoop2(n, k, b, r, q){
+    signal input P[2][k]; 
+    signal input Q[2][6][2][k];
+    signal output out[6][2][k];
+
+    var rBits[500]; // length is k * n
+    var rBitLength;
+    var rSigBits=0;
+    for (var i = 0; i < k; i++) {
+        for (var j = 0; j < n; j++) {
+            rBits[j + n * i] = (r[i] >> j) & 1;
+            if(rBits[j + n * i] == 1){
+                rSigBits++;
+                rBitLength = j + n * i + 1;
+            }
+        }
+    }
+
+    signal Pintermed[rBitLength][2][k]; 
+    signal f[rBitLength][6][2][k];
+
+    component Pdouble[rBitLength];
+    component Padd[rSigBits];
+    component fdouble[rBitLength];
+    component square[rBitLength];
+    component fadd[rSigBits]; 
+    var curid=0;
+
+    var LOGK = log_ceil(k);
+    assert( 6*n + LOGK + 6 + log_ceil( 12*(4*k-3) * (2*k-1) * k * k ) < 252 );
+    
+    for(var i=rBitLength - 1; i>=0; i--){
+        if( i == rBitLength - 1 ){
+            // f = 1 
+            for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+                if(l==0 && j==0 && idx==0)
+                    f[i][l][j][idx] <== 1;
+                else
+                    f[i][l][j][idx] <== 0;
+            }
+            for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                Pintermed[i][j][idx] <== P[j][idx];
+        }else{
+            // compute fdouble[i] = f[i+1]^2 * l_{Pintermed[i+1], Pintermed[i+1]}(Q) 
+            square[i] = Fp12MultiplyNoCarry(n, k, 2*n + LOGK + 4); // 2k-1 registers in [0, 12 * k * 2^{2n} )
+            for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+                square[i].a[l][j][idx] <== f[i+1][l][j][idx];
+                square[i].a[l][j+2][idx] <== 0;
+                square[i].b[l][j][idx] <== f[i+1][l][j][idx];
+                square[i].b[l][j+2][idx] <== 0;
+            }
+
+            fdouble[i] = Fp12MultiplyWithLineEqual(n, k, 2*k-1, 2*n + LOGK + 4, q);
+            // assert ( 6n + log(k) + 6 + log(12 * (4k-3) * (2k-1) * k * k ) ) < 252
+            for(var l=0; l<6; l++)for(var j=0; j<4; j++)for(var idx=0; idx<2*k-1; idx++)
+                fdouble[i].g[l][j][idx] <== square[i].out[l][j][idx];
+            for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                fdouble[i].P[j][idx] <== Pintermed[i+1][j][idx];            
+            for(var eps=0; eps<2; eps++)for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                fdouble[i].Q[eps][l][j][idx] <== Q[eps][l][j][idx];
+
+            if( i != 0 || (i == 0 && rBits[i] == 1) ){
+                Pdouble[i] = EllipticCurveDouble(n, k, 0, b, q);  
+                for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                    Pdouble[i].in[j][idx] <== Pintermed[i+1][j][idx]; 
+            }
+            
+            if(rBits[i] == 0){
+                for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                    f[i][l][j][idx] <== fdouble[i].out[l][j][idx]; 
+                if( i != 0 ){
+                    for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                        Pintermed[i][j][idx] <== Pdouble[i].out[j][idx];
+                }
+            }else{
+                // fadd[curid] = fdouble * l_{Pdouble[i], P}(Q) 
+                fadd[curid] = Fp12MultiplyWithLineUnequal(n, k, k, n, q); 
+                for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+                    fadd[curid].g[l][j][idx] <== fdouble[i].out[l][j][idx];
+                    fadd[curid].g[l][j+2][idx] <== 0;
+                }
+                for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+                    fadd[curid].P[0][j][idx] <== Pdouble[i].out[j][idx];            
+                    fadd[curid].P[1][j][idx] <== P[j][idx];            
+                }
+                for(var eps=0; eps<2; eps++)for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                    fadd[curid].Q[eps][l][j][idx] <== Q[eps][l][j][idx];
+
+                for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                    f[i][l][j][idx] <== fadd[curid].out[l][j][idx]; 
+
+                if(i != 0){
+                    // Padd[curid] = Pdouble[i] + P 
+                    Padd[curid] = EllipticCurveAddUnequal(n, k, q); 
+                    for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+                        Padd[curid].a[j][idx] <== Pdouble[i].out[j][idx];
+                        Padd[curid].b[j][idx] <== P[j][idx];
+                    }
+
+                    for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                        Pintermed[i][j][idx] <== Padd[curid].out[j][idx];
+                }
+                
+                curid++;
+            }
+        }
+    }
+    for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+        out[l][j][idx] <== f[0][l][j][idx];
+    
+}
+*/
diff --git a/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/extra_field_circuits.circom b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/extra_field_circuits.circom
new file mode 100644
index 0000000..546db18
--- /dev/null
+++ b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/extra_field_circuits.circom
@@ -0,0 +1,722 @@
+pragma circom 2.0.2;
+
+include "bigint.circom";
+include "bigint_func.circom";
+include "fp2.circom";
+include "fp12.circom";
+
+// Extra circuits with different approaches to field operations. 
+// Kept here for reference; less efficient or specialized than the ones in field_elements.circom
+
+
+// a, b are elements of Fp^l
+// a[i] represents a[i][0] + a[i][1] * 2**n + ... + a[i][l-1] * 2**(n*(k-1))
+// compute a+b in Fp^l
+template FieldAdd2D(n, k, l) {
+    signal input a[l][k];
+    signal input b[l][k];
+    signal input p[k];
+    signal output c[l][k];
+
+    component adders[l];
+    for (var i = 0; i < l; i++) {
+        adders[i] = BigAddModP(n, k);
+        for (var j = 0; j < k; j++) {
+            adders[i].a[j] <== a[i][j];
+            adders[i].b[j] <== b[i][j];
+            adders[i].p[j] <== p[j];
+        }   
+        for (var j = 0; j < k; j ++) {
+            c[i][j] <== adders[i].out[j];
+        }
+    }
+}
+
+// take a polynomial expression a[0] + omega^1 a[1] + ... + omega^(2l-2) a[2l-2]
+// reduce it to degree l-1 using omega^l + omega^(l-1) poly[l-1] + ... + poly[0] = 0
+// WARNING: can produce incorrectly handled negative coefficients. only here for reference; do not use
+template PolynomialReduce(l) {
+    signal input a[2*l-1];
+    signal input poly[l];
+    signal output out[l];
+
+    var residue[2*l-1];
+    signal quotient[l-1];
+    for (var i = 0; i < 2*l-1; i++) {
+        residue[i] = a[i];
+    }
+    for (var i = l-2; i >= 0; i --) {
+        for (var j = 0; j < l; j ++) {
+            residue[i + j] = residue[i + j] - residue[i + l] * poly[j];
+        }
+        quotient[i] <-- residue[i+l];
+        residue[i+l] = 0;
+    }
+    component mult = BigMultShortLong(1, l+1);
+    for (var i = 0; i < l-1; i ++) {
+        mult.a[i] <== quotient[i];
+        mult.b[i] <== poly[i];
+    }
+    mult.a[l-1] <== 0;
+    mult.a[l] <== 0;
+    mult.b[l-1] <== poly[l-1];
+    mult.b[l] <== 1;
+    signal a_out[2*l-1];
+    for (var i = 0; i < 2*l-1; i++) {
+        a_out[i] <== mult.out[i];
+    }
+    for (var i = 0; i < l; i ++ ) {
+        out[i] <-- residue[i];
+    }
+    for (var i = 0; i < l; i ++) {
+        a[i] === a_out[i] + out[i];
+    }
+    for (var i = l; i < 2*l-1; i ++) {
+        a[i] === a_out[i];
+    }
+}
+
+template Fp2PolynomialReduce(n, k, p) {
+    var l = 2;
+    signal input a[2*l-1][k];
+    var poly[2] = [1, 0]; // x^2 + 1 = 0
+    signal output out[l][k];
+
+    for (var i = 0; i < k; i ++) {
+        out[1][i] <== a[1][i];
+    }
+    component sub = FpSubtract(n, k, p);
+    for (var i = 0; i < k; i ++) {
+        sub.a[i] <== a[0][i];
+        sub.b[i] <== a[2][i];
+    }
+    for (var i = 0; i < k; i ++) {
+        out[0][i] <== sub.out[i];
+    }
+}
+
+
+// very un-optimized version: 
+
+// outputs a*b in Fp2 
+// (a0 + a1 u)*(b0 + b1 u) = (a0*b0 - a1*b1) + (a0*b1 + a1*b0)u 
+// out[i] has k registers each in [0, 2^n)
+// out[i] in [0, p)
+// A similar circuit can do multiplication in different fields. 
+// The only difference is that Fp2PolynomialReduce (which reduces quadratics by x^2+1) 
+// must be replaced with a different circuit specialized to the minimal polynomial
+template Fp2Multiply1(n, k, p) {
+    // l is always 2. poly is always [1, 0]
+    var l = 2;
+    signal input a[l][k];
+    signal input b[l][k];
+    signal output out[l][k];
+
+    component mult = BigMultShortLong2D(n, k, l);
+    for (var i = 0; i < l; i ++) {
+        for (var j = 0; j < k; j ++) {
+            mult.a[i][j] <== a[i][j];
+            mult.b[i][j] <== b[i][j];
+        }
+    } // out: 2l-1 x 2k-1 array of longs
+    component longshorts[2*l-1];
+    for (var i = 0; i < 2*l-1; i++) {
+        longshorts[i] = LongToShortNoEndCarry(n, 2*k-1);
+        for (var j = 0; j < 2*k-1; j ++) {
+            longshorts[i].in[j] <== mult.out[i][j];
+        }
+    } // out: 2l-1 x 2k array of shorts
+    component bigmods[2*l-1];
+    for (var i = 0; i < 2*l-1; i ++) {
+        bigmods[i] = BigMod(n, k);
+        for (var j = 0; j < 2*k; j ++) {
+            bigmods[i].a[j] <== longshorts[i].out[j];
+        }
+        for (var j = 0; j < k; j ++) {
+            bigmods[i].b[j] <== p[j];
+        }
+    } // out: 2l-1 x k array of shorts
+    component reduce = Fp2PolynomialReduce(n, k, p);
+    for (var i = 0; i < 2*l-1; i ++) {
+        for (var j = 0; j < k; j ++) {
+            reduce.a[i][j] <== bigmods[i].mod[j];
+        }
+    } // out: l x k array of shorts
+    for (var i = 0; i < l; i++) {
+        for (var j = 0; j < k; j++) {
+            out[i][j] <== reduce.out[i][j];
+        }
+    } // out: l x k array of shorts
+}
+
+
+// squaring can be optimized to save 2 multiplication
+// (a**2-b**2) = (a+b)(a-b) 
+// (a+b u)**2 = (a+b)(a-b) + (a*b+a*b)u
+template Fp2Square(n, k){
+    signal input in[2][k];
+    signal input p[k];
+    signal output out[2][k];
+    
+    component sum = BigAdd(n, k);
+    for(var i=0; i<k; i++){
+        sum.a[i] <== in[0][i];
+        sum.b[i] <== in[1][i];
+    }
+    component diff = BigSubModP(n, k);
+    for(var i=0; i<k; i++){
+        diff.a[i] <== in[0][i];
+        diff.b[i] <== in[1][i];
+        diff.p[i] <== p[i];
+    }
+    component prod = BigMult(n, k+1);
+    for(var i=0; i<k; i++){
+        prod.a[i] <== sum.out[i];
+        prod.b[i] <== diff.out[i];
+    }
+    prod.a[k] <== sum.out[k];
+    prod.b[k] <== 0;
+
+    component prod_mod = BigMod2(n, k, 2*k+2);
+    for(var i=0; i<2*k+2; i++){
+        prod_mod.a[i] <== prod.out[i];
+        if(i<k){
+            prod_mod.b[i] <== p[i];
+        }
+    }
+    for(var i=0; i<k; i++){
+        out[0][i] <== prod_mod.mod[i];
+    }
+    
+    component ab = BigMult(n, k);
+    for(var i=0; i<k; i++){
+        ab.a[i] <== in[0][i];
+        ab.b[i] <== in[1][i];
+    }
+    component two_ab = BigAdd(n, 2*k); 
+    for(var i=0; i<2*k; i++){
+        two_ab.a[i] <== ab.out[i];
+        two_ab.b[i] <== ab.out[i];
+    }
+    component two_ab_mod = BigMod2(n, k, 2*k+1);
+    for(var i=0; i<2*k+1; i++){
+        two_ab_mod.a[i] <== two_ab.out[i];
+        if(i < k){
+            two_ab_mod.b[i] <== p[i];
+        }
+    }
+    for(var i=0; i<k; i++){
+        out[1][i] <== two_ab_mod.mod[i];
+    }
+}
+
+// a[2][k] all registers in [0, 2**n)
+// b[2][k] all registers in [0, 2**n)
+// p[k]
+// consider a,b as elements of Fp2 
+// out[2][2][k] solving
+//      a0*b0 + (p-a1)*b1 = p * out[0][0] + out[0][1] with out[0][1] in [0,p) 
+//      a0*b1 + a1*b0 = p * out[1][0] + out[1][1] with out[1][1] in [0,p) 
+// out[i][0] has k+2 registers in short BigInt format [0, 2**n)
+// out[i][1] has k registers in short BigInt format
+// a * b = out[0][1] + out[1][1] * u in Fp2 
+function Fp2prod(n, k, a, b, p){
+    var out[2][2][20];
+    // solve for X and Y such that a0*b0 + (p-a1)*b1 = p*X + Y with Y in [0,p) 
+    // -a1*b1 = (p-a1)*b1 mod p
+    var a0b0_var[20] = prod(n, k, a[0], b[0]);
+    var a1_neg[20] = long_sub(n, k, p, a[1]); 
+    var a1b1_neg[20] = prod(n, k, a1_neg, b[1]);
+    var diff[20] = long_add(n, 2*k, a0b0_var, a1b1_neg); // 2*k+1 registers
+    out[0] = long_div2(n, k, k+1, diff, p); 
+    // X = out[0][0] has k+2 registers, Y = out[0][1] has k registers 
+    
+    // solve for X and Y such that a0*b1 + a1*b0 = p*X + Y with Y in [0,p) 
+    var a0b1_var[20] = prod(n, k, a[0], b[1]);
+    var a1b0_var[20] = prod(n, k, a[1], b[0]);
+    var sum[20] = long_add(n, 2*k, a0b1_var, a1b0_var); // output 2*k+1 registers
+    out[1] = long_div2(n, k, k+1, sum, p); 
+    // X = out[1][0] has k+2 registers, Y = out[1][1] has k registers 
+
+    return out;
+}
+
+// output (a0 + a1 u)*(b0 + b1 u) = (a0*b0 + (p-a1)*b1) + (a0*b1 + a1*b0)u 
+//      where no carries are performed 
+// out[0], out[1] have 2*k-1 registers 
+// out[0][i] in (-(k+1)*2^{2n}, (k+1)*2^{2n+1})
+// out[1][i] in [0, (k+1)*2^{2n+1}) 
+template Fp2multiplyNoCarry(n, k){
+    signal input a[2][k];
+    signal input b[2][k];
+    signal input p[k];
+    signal output out[2][2*k-1];
+    
+    component a0b0 = BigMultShortLong(n, k);
+    component a1b1 = BigMultShortLong(n, k);
+    component pb1 = BigMultShortLong(n, k); 
+    component a0b1 = BigMultShortLong(n, k); 
+    component a1b0 = BigMultShortLong(n, k);
+    
+    for(var i=0; i<k; i++){
+        a0b0.a[i] <== a[0][i];
+        a0b0.b[i] <== b[0][i];
+
+        a1b1.a[i] <== a[1][i];
+        a1b1.b[i] <== b[1][i];
+
+        pb1.a[i] <== p[i];
+        pb1.b[i] <== b[1][i];
+
+        a0b1.a[i] <== a[0][i];
+        a0b1.b[i] <== b[1][i];
+
+        a1b0.a[i] <== a[1][i];
+        a1b0.b[i] <== b[0][i];
+    }
+ 
+    for(var i=0; i<2*k-1; i++){
+        out[0][i] <== a0b0.out[i] + pb1.out[i] - a1b1.out[i];
+        out[1][i] <== a0b1.out[i] + a1b0.out[i];
+    }
+}
+
+// multiplication specialized to Fp^2 
+// (a0 + a1 u)*(b0 + b1 u) = (a0*b0 - a1*b1) + (a0*b1 + a1*b0)u
+template Fp2multiply(n, k){
+    signal input a[2][k];
+    signal input b[2][k];
+    signal input p[k];
+    signal output out[2][k];
+
+    var LOGK = log_ceil(k);
+    assert(2*n + 1 + LOGK<254);
+
+    var Xvar[2][2][20] = Fp2prod(n, k, a, b, p); 
+    component range_checks[2][k];
+    component lt[2];
+    signal X[2][k+2]; 
+    component X_range_checks[2][k+2];
+    
+    for(var eps=0; eps<2; eps++){
+        lt[eps] = BigLessThan(n, k);
+        for(var i=0; i<k; i++){
+            out[eps][i] <-- Xvar[eps][1][i];
+            range_checks[eps][i] = Num2Bits(n);
+            range_checks[eps][i].in <== out[eps][i];
+            
+            lt[eps].a[i] <== out[eps][i];
+            lt[eps].b[i] <== p[i];
+        }
+        lt[eps].out === 1;
+        
+        for(var i=0; i<k+2; i++){
+            X[eps][i] <-- Xvar[eps][0][i];
+            X_range_checks[eps][i] = Num2Bits(n);
+            X_range_checks[eps][i].in <== X[eps][i];
+        }
+        
+    }
+
+    
+    // out[0] constraint: X = X[0], Y = out[0] 
+    // constrain by Carry( a0 *' b0 +' p *' b1 -' a1 *' b1 - p *' X - Y ) = 0 
+    // where all operations are performed without carry 
+    // each register is an overflow representation in the range (-k*2^{2n+1}-2^n, k*2^{2n + 1} )
+    //                                          which is inside (-2^{2n+1+LOGK}, 2^{2n+1+LOGK})
+
+    // out[1] constraint: X = X[1], Y = out[1]
+    // constrain by Carry( a0 *' b1 +' a1 *' b0 -' p *' X - Y) = 0 
+    // each register is an overflow representation in the range (-k*2^{2n}-2^n, k*2^{2n + 1} )
+    //                                          which is inside (-2^{2n+1+LOGK}, 2^{2n+1+LOGK})
+    
+    component ab = Fp2multiplyNoCarry(n, k); 
+    for(var i=0; i<k; i++){
+        ab.p[i] <== p[i];
+        ab.a[0][i] <== a[0][i];
+        ab.a[1][i] <== a[1][i];
+        ab.b[0][i] <== b[0][i];
+        ab.b[1][i] <== b[1][i];
+    }
+    component pX[2];
+    component carry_check[2];
+    for(var eps=0; eps<2; eps++){
+        pX[eps] = BigMultShortLong(n, k+2); // 2*k+3 registers
+        for(var i=0; i<k; i++){
+            pX[eps].a[i] <== p[i];
+            pX[eps].b[i] <== X[eps][i];
+        }
+        for(var i=k; i<k+2; i++){
+            pX[eps].a[i] <== 0;
+            pX[eps].b[i] <== X[eps][i];
+        }
+
+        carry_check[eps] = CheckCarryToZero(n, 2*n+2+LOGK, 2*k+3); 
+        for(var i=0; i<k; i++)
+            carry_check[eps].in[i] <== ab.out[eps][i] - pX[eps].out[i] - out[eps][i]; 
+        for(var i=k; i<2*k-1; i++)
+            carry_check[eps].in[i] <== ab.out[eps][i] - pX[eps].out[i]; 
+        for(var i=2*k-1; i<2*k+3; i++)
+            carry_check[eps].in[i] <== -pX[eps].out[i];
+    }
+
+}
+
+
+// adapted from BigMultShortLong2D and LongToShortNoEndCarry2 witness computation
+function prod3D(n, k, l, a, b, c) {
+    // first compute the intermediate values. taken from BigMulShortLong
+    var prod_val[20][20]; // length is 3l - 2 by 3k - 2
+    for (var i = 0; i < 3 * k; i++) {
+        for (var j = 0; j < 3 * l; j ++) {
+            prod_val[j][i] = 0;
+        }
+    }
+    for (var i1 = 0; i1 < k; i1 ++) {
+        for (var i2 = 0; i2 < k; i2 ++) {
+	    for (var i3 = 0; i3 < k; i3 ++) {
+		for (var j1 = 0; j1 < l; j1 ++) {
+                    for (var j2 = 0; j2 < l; j2 ++) {
+			for (var j3 = 0; j3 < l; j3 ++) {
+			    prod_val[j1 + j2 + j3][i1 + i2 + i3] = prod_val[j1 + j2 + j3][i1 + i2 + i3] + a[j1][i1] * b[j2][i2] * c[j3][i3];
+			}
+		    }
+                }
+            }
+        }
+    }
+
+    // now do a bunch of carrying to make sure registers not overflowed. taken from LongToShortNoEndCarry2
+    var out[20][20]; // length is 3 * l by 3 * k
+
+    var split[20][20][3]; // second dimension has length 3 * k - 1
+    for (var j = 0; j < 3 * l - 1; j ++) {
+        for (var i = 0; i < 3 * k - 1; i++) {
+            split[j][i] = SplitThreeFn(prod_val[j][i], n, n, n);
+        }
+    }
+
+    var carry[20][20]; // length is 3l-1 x 3k
+    var sumAndCarry[20][2];
+    for ( var j = 0; j < 3 * l - 1; j ++) {
+        carry[j][0] = 0;
+        out[j][0] = split[j][0][0];
+        if (3 * k - 1 > 1) {
+            sumAndCarry[j] = SplitFn(split[j][0][1] + split[j][1][0], n, n);
+            out[j][1] = sumAndCarry[j][0];
+            carry[j][1] = sumAndCarry[j][1];
+        }
+        if (3 * k - 1 > 2) {
+            for (var i = 2; i < 3 * k - 1; i++) {
+                sumAndCarry[j] = SplitFn(split[j][i][0] + split[j][i-1][1] + split[j][i-2][2] + carry[j][i-1], n, n);
+                out[j][i] = sumAndCarry[j][0];
+                carry[j][i] = sumAndCarry[j][1];
+            }
+            out[j][3 * k - 1] = split[j][3*k-2][1] + split[j][3*k-3][2] + carry[j][3*k-2];
+        }
+    }
+
+    return out;
+}
+
+
+// a = sum w^i u^j a_ij for w^6=u+1, u^2=-1. similarly for b, c
+// we first write a = A + B u, b = C + D u, c = E + F u and compute 
+// abc = (ACE - BDE - ADF - BCF) + (ADE + BCE + ACF - BCF) u, and then simplify the representation
+// assumes n, k are chosen so that cubic carries are OK
+template Fp12MultiplyThree(n, k, p) {
+    var l = 6;
+    signal input a[l][2][k];
+    signal input b[l][2][k];
+    signal input c[l][2][k];
+    signal output out[l][2][k];
+
+    var LOGK = log_ceil(k);
+    var LOGL = 4;
+    assert(l<15);
+    assert(k<7);
+    assert(2*n + 1 + LOGK + LOGL <254);
+
+    var a0[l][k];
+    var a1[l][k];
+    var b0[l][k];
+    var b1[l][k];
+    var c0[l][k];
+    var c1[l][k];
+    var neg_a0[l][20];
+    var neg_a1[l][20];
+   for (var i = 0; i < l; i ++) { 
+        for ( var j = 0; j < k; j ++) {
+            a0[i][j] = a[i][0][j];
+            a1[i][j] = a[i][1][j];
+            b0[i][j] = b[i][0][j];
+            b1[i][j] = b[i][1][j];
+            c0[i][j] = c[i][0][j];
+            c1[i][j] = c[i][1][j];
+        }
+    }
+    for ( var i = 0; i < l; i ++) {
+        neg_a0[i] = long_sub(n, k, p, a0[i]);
+        neg_a1[i] = long_sub(n, k, p, a1[i]);
+    }
+
+    var real_init[3*l-1][20];
+    var imag_init[3*l-1][20];
+    var imag_init_neg[3*l-1][20];
+    var real[l][2][20];
+    var imag[l][2][20];
+    // each product will be 3l-1 x 3k
+    var a0b0c0_var[20][20] = prod3D(n, k, l, a0, b0, c0);
+    var a1b1c0_neg[20][20] = prod3D(n, k, l, neg_a1, b1, c0);
+    var a1b0c1_neg[20][20] = prod3D(n, k, l, neg_a1, b0, c1);
+    var a0b1c1_neg[20][20] = prod3D(n, k, l, neg_a0, b1, c1);
+
+    var a1b0c0_var[20][20] = prod3D(n, k, l, a1, b0, c0);
+    var a0b1c0_var[20][20] = prod3D(n, k, l, a0, b1, c0);
+    var a0b0c1_var[20][20] = prod3D(n, k, l, a0, b0, c1);
+    var a1b1c1_neg[20][20] = prod3D(n, k, l, neg_a0, b1, c1);
+
+    var a1b0c0_neg[20][20] = prod3D(n, k, l, neg_a1, b0, c0);
+    var a0b1c0_neg[20][20] = prod3D(n, k, l, neg_a0, b1, c0);
+    var a0b0c1_neg[20][20] = prod3D(n, k, l, neg_a0, b0, c1);
+    var a1b1c1_var[20][20] = prod3D(n, k, l, a0, b1, c1);
+
+    for (var i = 0; i < 3 * l - 1; i ++) { // compute initial rep (deg w = 10)
+        real_init[i] = long_add4(n, 3 * k, a0b0c0_var[i], a1b1c0_neg[i], a1b0c1_neg[i], a0b1c1_neg[i]); // 3 * k + 1 registers each
+        imag_init[i] = long_add4(n, 3 * k, a1b0c0_var[i], a0b1c0_var[i], a0b0c1_var[i], a1b1c1_neg[i]);
+	imag_init_neg[i] = long_add4(n, 3 * k, a1b0c0_neg[i], a0b1c0_neg[i], a0b0c1_neg[i], a1b1c1_var[i]);
+    }
+
+    // carries using w^6 = u + 1, w^12 = 2 u
+    var real_carry[l][20];
+    var imag_carry[l][20];
+    var real_final[l][20];
+    var imag_final[l][20];
+    var zeros[20]; // to balance register sizes
+    for (var i = 0; i < 20; i ++) {
+        zeros[i] = 0;
+    }
+    for (var i = 0; i < l; i ++) {
+        if (i == l - 1) {
+            real_carry[i] = long_add4(n, 3*k+1, zeros, zeros, real_init[i + l], imag_init_neg[i + l]);
+            imag_carry[i] = long_add4(n, 3*k+1, zeros, zeros, real_init[i + l], imag_init[i + l]);
+        } else {
+            real_carry[i] = long_add4(n, 3*k+1, real_init[i + l], imag_init_neg[i + l], imag_init_neg[i + 2 * l], imag_init_neg[i + 2 * l]); // now 3*k+2 registers
+            imag_carry[i] = long_add4(n, 3*k+1, imag_init[i + l], real_init[i + l], real_init[i + 2 * l], real_init[i + 2 * l]);
+        }
+    }    
+    for (var i = 0; i < l; i ++) {
+        real_final[i] = long_add_unequal(n, 3*k+2, 3*k+1, real_carry[i], real_init[i]); // now 3*k+3 registers
+        imag_final[i] = long_add_unequal(n, 3*k+2, 3*k+1, imag_carry[i], imag_init[i]);
+    }
+
+    // reduction mod p
+    var prod_real_temp[l][2][20];
+    var prod_imag_temp[l][2][20];
+
+    // prod_real[*][0][2 * k + 4] * p + prod_real[*][1][k] = real_final[*]
+    // prod_imag[*][0][2 * k + 4] * p + prod_imag[*][1][k] = imag_final[*]
+    signal prod_real[l][2][2 * k + 4];
+    signal prod_imag[l][2][2 * k + 4];
+    for (var i = 0; i < l; i ++) {
+        prod_real_temp[i] = long_div2(n, k, 2 * k + 3, real_final[i], p); // 2 * k + 4 register quotient, k register remainder
+        prod_imag_temp[i] = long_div2(n, k, 2 * k + 3, imag_final[i], p);
+    }
+    for (var i = 0; i < l; i ++) {
+        for (var j = 0; j < 2 * k + 4; j ++) {
+            prod_real[i][0][j] <-- prod_real_temp[i][0][j];
+            prod_imag[i][0][j] <-- prod_imag_temp[i][0][j];
+            if (j < k) {
+                prod_real[i][1][j] <-- prod_real_temp[i][1][j];
+                prod_imag[i][1][j] <-- prod_imag_temp[i][1][j];
+            } else {
+                prod_real[i][1][j] <== 0;
+                prod_imag[i][1][j] <== 0;
+            }
+        }
+    }
+    for (var i = 0; i < l; i ++) {
+        for (var j = 0; j < k; j ++) {
+            out[i][0][j] <== prod_real[i][1][j];
+            out[i][1][j] <== prod_imag[i][1][j];
+        }
+    }
+
+    component out_range_checks[l][2][k];
+    for(var i=0; i<l; i++){
+        for (var j = 0; j < 2; j ++) {
+            for (var m = 0; m < k; m ++) {
+                out_range_checks[i][j][m] = Num2Bits(n);
+                out_range_checks[i][j][m].in <== out[i][j][m];
+            }
+        }
+    }
+    component lt[l][2];
+    for (var i = 0; i < l; i ++) {
+        for (var j = 0; j < 2; j ++) {
+            lt[i][j] = BigLessThan(n, k);
+            for (var m = 0; m < k; m ++) {
+                lt[i][j].a[m] <== out[i][j][m];
+                lt[i][j].b[m] <== p[m];
+            }
+            lt[i][j].out === 1;
+        }
+    }
+
+    component div_range_checks[l][2][2 * k + 4];
+    for (var i = 0; i < l; i ++) {
+        for (var j = 0; j < 2 * k + 4; j ++) {
+            div_range_checks[i][0][j] = Num2Bits(n);
+            div_range_checks[i][1][j] = Num2Bits(n);
+            div_range_checks[i][0][j].in <== prod_real[i][0][j];
+            div_range_checks[i][1][j].in <== prod_imag[i][0][j];
+        }
+    }
+
+    // constrain by:
+    // X = a0 *' b0 *' c0 +' (p -' a1) *' b1 *' c0 +' (p -' a1) *' b0 *' c1 +' (p -' a0) *' b1 *' c1
+    // Y = a1 *' b0 *' c0 +' a0 *' b1 *' c0 +' a0 *' b0 *' c1 +' (p -' a1) *' b1 *' c1
+    // Carry( X_0 +' X_1 -' Y_1 -' Y_2 -' Y_2 -' p *' prod_real[0] -' prod_real[1] ) = 0
+    // Carry( Y_0 +' X_1 +' Y_1 +' X_2 +' X_2 -' p *' prod_imag[0] -' prod_imag[1] ) = 0
+    // where all operations are performed without carry 
+    // X_0 is the coeffs of w^0, ..., w^5
+    // X_1 is the coeffs of w^6, ..., w^11
+    // X_2 is the coeffs of w^12, ..., w^17
+    // each register is an overflow representation in the range (-kl*2^{3n+4}, kl*2^{3n + 4} )    
+    component b0c0 = BigMultShortLong2D(n, k, l);
+    component b0c1 = BigMultShortLong2D(n, k, l);
+    component b1c0 = BigMultShortLong2D(n, k, l);
+    component b1c1 = BigMultShortLong2D(n, k, l);
+    for (var i = 0; i < l; i ++) {
+        for (var j = 0; j < k; j ++) {
+            b0c0.a[i][j] <== b[i][0][j];
+            b0c0.b[i][j] <== c[i][0][j];
+            b0c1.a[i][j] <== b[i][0][j];
+            b0c1.b[i][j] <== c[i][1][j];
+            b1c0.a[i][j] <== b[i][1][j];
+            b1c0.b[i][j] <== c[i][0][j];
+            b1c1.a[i][j] <== b[i][1][j];
+            b1c1.b[i][j] <== c[i][1][j];
+	}
+    }
+    
+    component a0b0c0 = BigMultShortLong2DUnequal(n, k, 2 * k - 1, l, 2 * l - 1);
+    component a1b0c0 = BigMultShortLong2DUnequal(n, k, 2 * k - 1, l, 2 * l - 1);
+    component a0b0c1 = BigMultShortLong2DUnequal(n, k, 2 * k - 1, l, 2 * l - 1);
+    component a1b0c1 = BigMultShortLong2DUnequal(n, k, 2 * k - 1, l, 2 * l - 1);
+    component a0b1c0 = BigMultShortLong2DUnequal(n, k, 2 * k - 1, l, 2 * l - 1);
+    component a1b1c0 = BigMultShortLong2DUnequal(n, k, 2 * k - 1, l, 2 * l - 1);
+    component a0b1c1 = BigMultShortLong2DUnequal(n, k, 2 * k - 1, l, 2 * l - 1);
+    component a1b1c1 = BigMultShortLong2DUnequal(n, k, 2 * k - 1, l, 2 * l - 1);
+
+    component pb0c1 = BigMultShortLong2DUnequal(n, k, 2 * k - 1, l, 2 * l - 1);
+    component pb1c0 = BigMultShortLong2DUnequal(n, k, 2 * k - 1, l, 2 * l - 1);
+    component pb1c1 = BigMultShortLong2DUnequal(n, k, 2 * k - 1, l, 2 * l - 1);
+    for (var i = 0; i < l; i ++) {
+        for (var j = 0; j < k; j ++) {
+	    a0b0c0.a[i][j] <== a[i][0][j];
+	    a0b0c1.a[i][j] <== a[i][0][j];
+	    a0b1c0.a[i][j] <== a[i][0][j];
+	    a0b1c1.a[i][j] <== a[i][0][j];
+	    a1b0c0.a[i][j] <== a[i][1][j];
+	    a1b0c1.a[i][j] <== a[i][1][j];
+	    a1b1c0.a[i][j] <== a[i][1][j];
+	    a1b1c1.a[i][j] <== a[i][1][j];
+
+	    pb0c1.a[i][j] <== p[j];
+	    pb1c0.a[i][j] <== p[j];
+	    pb1c1.a[i][j] <== p[j];
+	}
+    }
+    for (var i = 0; i < 2 * l - 1; i++) {
+	for (var j = 0; j < 2 * k - 1; j++) {
+	    a0b0c0.b[i][j] <== b0c0.out[i][j];
+	    a1b0c0.b[i][j] <== b0c0.out[i][j];
+	    a0b0c1.b[i][j] <== b0c1.out[i][j];
+	    a1b0c1.b[i][j] <== b0c1.out[i][j];
+	    a0b1c0.b[i][j] <== b1c0.out[i][j];
+	    a1b1c0.b[i][j] <== b1c0.out[i][j];
+	    a0b1c1.b[i][j] <== b1c1.out[i][j];
+	    a1b1c1.b[i][j] <== b1c1.out[i][j];
+
+	    pb0c1.b[i][j] <== b0c1.out[i][j];
+	    pb1c0.b[i][j] <== b1c0.out[i][j];
+	    pb1c1.b[i][j] <== b1c1.out[i][j];
+	}
+    }
+    
+    component p_prod_real0[l];
+    component p_prod_imag0[l];
+    for (var i = 0; i < l; i ++) {
+        p_prod_real0[i] = BigMultShortLongUnequal(n, k, 2 * k + 4);
+        p_prod_imag0[i] = BigMultShortLongUnequal(n, k, 2 * k + 4);
+
+	for (var j = 0; j < k; j++) {
+	    p_prod_real0[i].a[j] <== p[j];
+	    p_prod_imag0[i].a[j] <== p[j];
+	}
+	for (var j = 0; j < 2 * k + 4; j++) {
+	    p_prod_real0[i].b[j] <== prod_real[i][0][j];
+	    p_prod_imag0[i].b[j] <== prod_imag[i][0][j];
+	}
+    }    
+
+    var X0[l][3 * k - 2];
+    var X1[l][3 * k - 2];
+    var X2[l][3 * k - 2];
+    var Y0[l][3 * k - 2];
+    var Y1[l][3 * k - 2];
+    var Y2[l][3 * k - 2];
+    for (var i = 0; i < l; i++) {
+	for (var j = 0; j < 3 * k - 2; j++) {
+	    X0[i][j] = a0b0c0.out[i][j] + pb1c0.out[i][j] - a1b1c0.out[i][j] + pb0c1.out[i][j] - a1b0c1.out[i][j] + pb1c1.out[i][j] - a0b1c1.out[i][j];
+	    X1[i][j] = a0b0c0.out[i + l][j] + pb1c0.out[i + l][j] - a1b1c0.out[i + l][j] + pb0c1.out[i + l][j] - a1b0c1.out[i + l][j] + pb1c1.out[i + l][j] - a0b1c1.out[i + l][j];
+	    Y0[i][j] = a1b0c0.out[i][j] + a0b1c0.out[i][j] + a0b0c1.out[i][j] + pb1c1.out[i][j] - a1b1c1.out[i][j];
+	    Y1[i][j] = a1b0c0.out[i + l][j] + a0b1c0.out[i + l][j] + a0b0c1.out[i + l][j] + pb1c1.out[i + l][j] - a1b1c1.out[i + l][j];
+	    if (i < l - 2) {
+		X2[i][j] = a0b0c0.out[i + 2 * l][j] + pb1c0.out[i + 2 * l][j] - a1b1c0.out[i + 2 * l][j] + pb0c1.out[i + 2 * l][j] - a1b0c1.out[i + 2 * l][j] + pb1c1.out[i + 2 * l][j] - a0b1c1.out[i + 2 * l][j];	    
+		Y2[i][j] = a1b0c0.out[i + 2 * l][j] + a0b1c0.out[i + 2 * l][j] + a0b0c1.out[i + 2 * l][j] + pb1c1.out[i + 2 * l][j] - a1b1c1.out[i + 2 * l][j];
+	    } else {
+		X2[i][j] = 0;
+		Y2[i][j] = 0;
+	    }    
+	}
+    }
+    
+    component carry_check[l][2];
+    for (var i = 0; i < l; i++) {
+	if (3 * k - 2 < 2 * k + 4) {
+            carry_check[i][0] = CheckCarryToZero(n, 3 * n + 4 + LOGK + LOGL, 2 * k + 4);
+            carry_check[i][1] = CheckCarryToZero(n, 3 * n + 4 + LOGK + LOGL, 2 * k + 4);
+	} else {
+            carry_check[i][0] = CheckCarryToZero(n, 3 * n + 4 + LOGK + LOGL, 3 * k - 2);
+            carry_check[i][1] = CheckCarryToZero(n, 3 * n + 4 + LOGK + LOGL, 3 * k - 2);
+	}
+	    
+        for (var j = 0; j < k; j ++) {
+            carry_check[i][0].in[j] <== X0[i][j] + X1[i][j] - Y1[i][j] - Y2[i][j] - Y2[i][j] - p_prod_real0[i].out[j] - prod_real[i][1][j];
+	    carry_check[i][1].in[j] <== Y0[i][j] + X1[i][j] + Y1[i][j] + X2[i][j] + X2[i][j] - p_prod_imag0[i].out[j] - prod_imag[i][1][j];
+        }
+	if (3 * k - 2 < 2 * k + 4) {
+            for (var j = k; j < 3 * k - 2; j ++) {
+		carry_check[i][0].in[j] <== X0[i][j] + X1[i][j] - Y1[i][j] - Y2[i][j] - Y2[i][j] - p_prod_real0[i].out[j] - prod_real[i][1][j];
+		carry_check[i][1].in[j] <== Y0[i][j] + X1[i][j] + Y1[i][j] + X2[i][j] + X2[i][j] - p_prod_imag0[i].out[j] - prod_imag[i][1][j];
+            }
+            for (var j = 3 * k - 2; j < 2 * k + 4; j++) {
+		carry_check[i][0].in[j] <== - prod_real[i][1][j];
+		carry_check[i][1].in[j] <== - prod_imag[i][1][j];
+	    }
+        } else {
+	    for (var j = k; j < 2 * k + 4; j ++) {
+		carry_check[i][0].in[j] <== X0[i][j] + X1[i][j] - Y1[i][j] - Y2[i][j] - Y2[i][j] - p_prod_real0[i].out[j] - prod_real[i][1][j];
+		carry_check[i][1].in[j] <== Y0[i][j] + X1[i][j] + Y1[i][j] + X2[i][j] + X2[i][j] - p_prod_imag0[i].out[j] - prod_imag[i][1][j];
+            }
+            for (var j = 2 * k + 4; j < 3 * k - 2; j++) {
+		carry_check[i][0].in[j] <== X0[i][j] + X1[i][j] - Y1[i][j] - Y2[i][j] - Y2[i][j] - p_prod_real0[i].out[j];
+		carry_check[i][1].in[j] <== Y0[i][j] + X1[i][j] + Y1[i][j] + X2[i][j] + X2[i][j] - p_prod_imag0[i].out[j];
+	    }
+
+	}
+    }
+}
+
diff --git a/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/field_elements_func.circom b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/field_elements_func.circom
new file mode 100644
index 0000000..511bb72
--- /dev/null
+++ b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/field_elements_func.circom
@@ -0,0 +1,290 @@
+pragma circom 2.0.3;
+
+function get_fp_sgn0(a){
+    return a[0] % 2; 
+}
+
+// n bits per register
+// num has k registers
+// p has k registers
+// k * n <= 500
+// p is a prime
+// if num == 0 mod p, returns 0
+// else computes inv = num^{-1} mod p using extended euclidean algorithm
+// https://brilliant.org/wiki/extended-euclidean-algorithm/
+function find_Fp_inverse(n, k, num, p) {
+    var amodp[2][50] = long_div2(n, k, 0, num, p); 
+    var a[50];
+    var b[50]; 
+    var x[50];
+    var y[50];
+    var u[50];
+    var v[50];
+
+    var ret[50];
+
+    for(var i=0; i<k; i++){
+        a[i] = amodp[1][i];
+        b[i] = p[i];
+        x[i] = 0;
+        y[i] = 0;
+        u[i] = 0;
+        v[i] = 0;
+    }
+    y[0] = 1;
+    u[0] = 1;
+    // euclidean algorithm takes log_phi( min(a, p) ) iterations, where phi is golden ratio
+    // should be less than 1000 for our cases...
+    for(var l=0; l<1000; l++){
+        var ka = 0;
+        for (var i = 0; i < k; i++) {
+            if (a[i] != 0) {
+                ka = i + 1;
+            }
+        }
+        if (ka == 0) {
+            for (var i = 0; i < k; i++) {
+                ret[i] = x[i];
+            }
+            return ret;
+        }
+
+        var r[2][50] = long_div2(n, ka, k - ka, b, a); 
+        var q[50]; 
+        for(var i = 0; i < k - ka + 1; i++)
+            q[i] = r[0][i];
+        for(var i = k - ka + 1; i < k; i++)
+            q[i] = 0;
+        
+        var newu[50] = long_sub_mod(n, k, x, prod_mod(n, k, u, q, p), p); 
+        var newv[50] = long_sub_mod(n, k, y, prod_mod(n, k, v, q, p), p); 
+        
+        for(var i = 0; i < k; i++){
+            b[i] = a[i];
+            if( i < ka )
+                a[i] = r[1][i];
+            else
+                a[i] = 0;
+            x[i] = u[i];
+            y[i] = v[i];
+            u[i] = newu[i];
+            v[i] = newv[i];
+        }
+    }
+    // should never reach here (loop should always return before now)
+    assert(0 == 1);
+    return ret;
+}
+
+// a[k] registers can overflow
+//  assume actual value of a < 2^{n*(k+m)} 
+// p[k] registers in [0, 2^n)
+// out[2][k] solving
+//      a = p * out[0] + out[1] with out[1] in [0,p) 
+// out[0] has m registers in range [-2^n, 2^n)
+// out[1] has k registers in range [0, 2^n)
+function get_signed_Fp_carry_witness(n, k, m, a, p){
+    var out[2][50];
+    var a_short[51] = signed_long_to_short(n, k, a); 
+
+    /* // commenting out to improve speed
+    // let me make sure everything is in <= k+m registers
+    for(var j=k+m; j<50; j++)
+        assert( a_short[j] == 0 );
+    */
+
+    if(a_short[50] == 0){
+        out = long_div2(n, k, m, a_short, p);    
+    }else{
+        var a_pos[50];
+        for(var i=0; i<k+m; i++) 
+            a_pos[i] = -a_short[i];
+
+        var X[2][50] = long_div2(n, k, m, a_pos, p);
+        // what if X[1] is 0? 
+        var Y_is_zero = 1;
+        for(var i=0; i<k; i++){
+            if(X[1][i] != 0)
+                Y_is_zero = 0;
+        }
+        if( Y_is_zero == 1 ){
+            out[1] = X[1];
+        }else{
+            out[1] = long_sub(n, k, p, X[1]); 
+            
+            X[0][0]++;
+            if(X[0][0] >= (1<<n)){
+                for(var i=0; i<m-1; i++){
+                    var carry = X[0][i] \ (1<<n); 
+                    X[0][i+1] += carry;
+                    X[0][i] -= carry * (1<<n);
+                }
+                assert( X[0][m-1] < (1<<n) ); 
+            }
+        }
+        for(var i=0; i<m; i++)
+            out[0][i] = -X[0][i]; 
+    }
+
+    return out;
+}
+
+
+// Implements: 
+//      calls get_signed_Fp_carry_witness twice
+// a[2][k] registers can overflow
+//  assume actual value of each a[i] < (2^n)^{k+m} 
+// p[k] registers in [0, 2^n)
+// out[2][2][k] solving
+//      a[0] = p * out[0][0] + out[0][1] with out[0][1] in [0,p) 
+//      a[1] = p * out[1][0] + out[1][1] with out[1][1] in [0,p) 
+// out[i][0] has m registers in range [-2^n, 2^n)
+// out[i][1] has k registers in range [0, 2^n)
+function get_signed_Fp2_carry_witness(n, k, m, a, p){
+    var out[2][2][50];
+
+    for(var i=0; i<2; i++)
+        out[i] = get_signed_Fp_carry_witness(n, k, m, a[i], p);
+
+    return out;
+}
+
+
+function get_fp2_sgn0(k, a){
+    var z = long_is_zero(k, a[0]);
+    var sgn0 = a[0][0] % 2;
+    var sgn1 = a[1][0] % 2;
+    return sgn0 | (z & sgn1);
+}
+
+// helper function to precompute the product of two elements a, b in Fp2
+// a[2][k], b[2][k] all registers in [0, 2^n) 
+// (a0 + a1 u)*(b0 + b1 u) = (a0*b0 - a1*b1) + (a0*b1 + a1*b0)u 
+// this is a direct computation - totally distinct from the combo of Fp2multiplyNoCarry and get_Fp2_carry_witness
+function find_Fp2_product(n, k, a, b, p){
+    var out[2][50];
+    var ab[2][2][50]; 
+    for(var i=0; i<2; i++)for(var j=0; j<2; j++){
+        ab[i][j] = prod_mod(n,k,a[i],b[j],p);
+    }
+    out[0] = long_sub_mod(n,k,ab[0][0],ab[1][1],p); 
+    out[1] = long_add_mod(n,k,ab[0][1],ab[1][0],p);
+
+    return out;
+}
+
+// helper function to precompute the sum of two elements a, b in Fp2
+// a[2][k], b[2][k] all registers in [0, 2^n) 
+// this is a direct computation
+function find_Fp2_sum(n, k, a, b, p){
+    var out[2][50];
+    out[0] = long_add_mod(n,k,a[0],b[0],p); 
+    out[1] = long_add_mod(n,k,a[1],b[1],p);
+    return out;
+}
+
+// helper function to precompute the difference of two elements a, b in Fp2
+// a[2][k], b[2][k] all registers in [0, 2^n) 
+// this is a direct computation
+function find_Fp2_diff(n, k, a, b, p){
+    var out[2][50];
+    out[0] = long_sub_mod(n,k,a[0],b[0],p); 
+    out[1] = long_sub_mod(n,k,a[1],b[1],p);
+    return out;
+}
+
+
+// n bits per register
+// a has 2 x k registers, elt of Fp2
+// p has k registers
+// e has 2k registers
+// k * n <= 400
+// p is a prime
+// computes a^e in Fp2
+function find_Fp2_exp(n, k, a, p, e){
+    var eBits[800]; // length is (2k-1) * n
+    var bitLength; 
+    for (var i = 0; i < 2*k; i++) {
+        for (var j = 0; j < n; j++) {
+            eBits[j + n * i] = (e[i] >> j) & 1;
+            if(eBits[j + n * i] == 1)
+                bitLength = j + n * i + 1;
+        }
+    }
+
+    var out[2][50]; // length is k
+    for(var i = 0; i < 50; i++) {
+        out[0][i] = 0;
+        out[1][i] = 0;
+    }
+    out[0][0] = 1;
+
+    // repeated squaring
+    for(var i = bitLength-1; i >= 0; i--) {
+        // multiply by a if bit is 0
+        if (eBits[i] == 1)
+            out = find_Fp2_product(n, k, out, a, p);
+        // square, unless we're at the end
+        if (i > 0)
+            out = find_Fp2_product(n, k, out, out, p);
+    }
+    return out;
+}
+
+function is_equal_Fp2(n, k, a, b){
+    for(var i=0; i<2; i++)for(var idx=0; idx<k; idx++){
+        if(a[i][idx] != b[i][idx])
+            return 0;
+    }
+    return 1;
+}
+
+// a[2][k] elt in Fp2 
+// output multiplies by XI0 +u
+// multiplies register bounds by (XI0 + 1)
+function signed_Fp2_mult_w6(k, a, XI0){
+    var out[2][50];
+    for(var i=0; i<k; i++){
+        out[0][i] = a[0][i]*XI0 - a[1][i];
+        out[1][i] = a[0][i] + a[1][i]*XI0;
+    }
+    return out;
+}
+
+
+// a is 2 x k, represents element of Fp^2
+// out is the inverse of a in Fp^2 (2 x k array of shorts)
+
+// Src: https://github.com/paulmillr/noble-bls12-381/blob/23823d664b1767fb20c9c19c5800c66993b576a5/math.ts#L444
+// We wish to find the multiplicative inverse of a nonzero
+// element a + bu in Fp2. We leverage an identity
+//
+// (a + bu)(a - bu) = a² + b²
+//
+// which holds because u² = -1. This can be rewritten as
+//
+// (a + bu)(a - bu)/(a² + b²) = 1
+//
+// because a² + b² = 0 has no nonzero solutions for (a, b).
+// This gives that (a - bu)/(a² + b²) is the inverse
+// of (a + bu). 
+function find_Fp2_inverse(n, k, a, p) {
+    var sq0[50] = prod(n, k, a[0], a[0]);
+    var sq1[50] = prod(n, k, a[1], a[1]);
+    var sq_sum[50] = long_add(n, 2*k, sq0, sq1);
+    var sq_sum_div[2][50] = long_div2(n, k, k+1, sq_sum, p);
+    // lambda = 1/(sq_sum)%p
+    var lambda[50] = mod_inv(n, k, sq_sum_div[1], p);
+    var out0[50] = prod(n, k, lambda, a[0]);
+    var out0_div[2][50] = long_div(n, k, out0, p);
+    var out[2][50];
+    out[0] = out0_div[1];
+    
+    var out1_pre[50] = long_sub(n, k, p, a[1]);
+    var out1[50] = prod(n, k, lambda, out1_pre);
+    var out1_div[2][50] = long_div(n, k, out1, p);
+    out[1] = out1_div[1];
+    return out;
+}
+
+
diff --git a/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/final_exp.circom b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/final_exp.circom
new file mode 100644
index 0000000..2fba651
--- /dev/null
+++ b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/final_exp.circom
@@ -0,0 +1,519 @@
+pragma circom 2.0.3;
+
+include "bigint.circom";
+include "bigint_func.circom";
+include "field_elements_func.circom";
+include "fp2.circom";
+include "fp12.circom";
+
+// assume input is an element of Fp12 in the cyclotomic subgroup GΦ₁₂
+// A cyclotomic group is a subgroup of Fp^n defined by
+//   GΦₙ(p) = {α ∈ Fpⁿ : α^{Φₙ(p)} = 1}
+
+// below we implement compression and decompression for an element  GΦ₁₂ following Theorem 3.1 of https://eprint.iacr.org/2010/542.pdf
+// Fp4 = Fp2(w^3) where (w^3)^2 = 1+u 
+// Fp12 = Fp4(w) where w^3 = w^3 
+
+// in = g0 + g2 w + g4 w^2 + g1 w^3 + g3 w^4 + g5 w^5 where g_i are elements of Fp2
+// out = Compress(in) = [ g2, g3, g4, g5 ] 
+template Fp12CyclotomicCompress(n, k) {
+    signal input in[6][2][k];
+    signal output out[4][2][k]; 
+
+    for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++){
+        out[0][eps][j] <== in[1][eps][j];
+        out[1][eps][j] <== in[4][eps][j];
+        out[2][eps][j] <== in[2][eps][j];
+        out[3][eps][j] <== in[5][eps][j];
+    } 
+}
+
+// in = [g2, g3, g4, g5] where g_i are elements of Fp2
+// out[6][2][k] each register in [0, 2^n)
+// out = Decompress(in) = g0 + g2 w + g4 w^2 + g1 w^3 + g3 w^4 + g5 w^5 where
+// if g2 != 0:
+//      g1 = (g5^2 * (1+u) + 3 g4^2 - 2 g3)/(4g2) 
+//      g0 = (2 g1^2 + g2 * g5 - 3 g3*g4) * (1+u) + 1
+// if g2 = 0:
+//      g1 = (2 g4 * g5)/g3
+//      g0 = (2 g1^2 - 3 g3 * g4) * (1+u)  + 1    NOTE g0 IS QUARTIC IN THE INPUTS, so I don't think it's worth trying to compute a NoCarry version of g0
+// out0 = g0, out1 = g2, out2 = g4, out3 = g1, out4 = g3, out5 = g5
+template Fp12CyclotomicDecompress(n, k, p) {
+    signal input in[4][2][k];
+    signal output out[6][2][k]; 
+
+    var XI0 = 1;
+    var LOGK = log_ceil(k); 
+    var LOGK2 = log_ceil( ((1+XI0)*2*k + 6*k )*k + 1);
+    var LOGK3 = log_ceil( (1+XI0) * 6*k*k + 1 );
+    assert(3*n + LOGK2 < 250);
+
+    var len = 2*k-1; // number of registers in output of Fp2MultiplyNoCarry
+                     // len = k if using Fp2MultiplyNoCarryCompress 
+
+    // g2 = in[0], g3 = in[1], g4 = in[2], g5 = in[3]
+    for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++){
+        out[1][eps][j] <== in[0][eps][j]; 
+        out[2][eps][j] <== in[2][eps][j]; 
+        out[4][eps][j] <== in[1][eps][j]; 
+        out[5][eps][j] <== in[3][eps][j]; 
+    }
+
+    // detect if g2 is 0
+    component g2IsZero = Fp2IsZero(n, k, p);
+    for(var eps=0; eps<2; eps++)for(var i=0; i<k; i++){
+        g2IsZero.in[eps][i] <== in[0][eps][i];
+    }
+
+    // COMPUTATION OF g1 when g2 != 0:
+    component g5sq = SignedFp2MultiplyNoCarry(n, k, 2*n + 1 + LOGK); // overflow < 2k * 2^{2n}
+    for(var i=0; i<k; i++)for(var eps=0; eps<2; eps++){
+        g5sq.a[eps][i] <== in[3][eps][i];
+        g5sq.b[eps][i] <== in[3][eps][i];
+    }
+    // c = XI0 + u
+    // g5^2 * c
+    var g5sqc[4][50] = signed_Fp2_mult_w6(len, g5sq.out, XI0); // overflow < (1+XI0)*2k*2^{2n}
+    // 3 g4^2
+    component g4sq3 = SignedFp2MultiplyNoCarry(n, k, 2*n + 3 + LOGK); // overflow 6k*2^{2n}
+
+    for(var i=0; i<k; i++)for(var eps=0; eps<2; eps++){
+        g4sq3.a[eps][i] <== 3*in[2][eps][i];
+        g4sq3.b[eps][i] <== in[2][eps][i];
+    }
+    signal g1num[2][len];   // g5^2 * (XI0 + u) + 3 g4^2 - 2 g3
+                            // overflow ((1+XI0)*2k + 6k + 2/2^n)*2^{2n}
+    for(var i=0; i<len; i++)for(var eps=0; eps<2; eps++){
+        if(i < k)
+            g1num[eps][i] <== g5sqc[eps][i] + g4sq3.out[eps][i] - 2*in[1][eps][i];
+        else
+            g1num[eps][i] <== g5sqc[eps][i] + g4sq3.out[eps][i];
+    }
+
+    component g1numRed = Fp2Compress(n, k, k-1, p, 3*n + LOGK2);
+    // overflow < ((1+XI0)*2k + 6k + 2/2^n)*k *2^{3n}
+    for(var i=0; i<2; i++)for(var j=0; j<2*k-1; j++)
+        g1numRed.in[i][j] <== g1num[i][j];
+    // compute g1numRed / 4g2
+    component g1_1 = SignedFp2Divide(n, k, 3*n + LOGK2, n+2, p); 
+    for(var j=0; j<k; j++){
+        for(var i=0; i<2; i++) 
+            g1_1.a[i][j] <== g1numRed.out[i][j]; 
+        for(var i=0; i<2; i++){
+            g1_1.b[i][j] <== 4*in[0][i][j]; 
+        }
+    }
+
+    // END OF COMPUTATION OF g1 when g2 != 0:
+
+
+
+    // COMPUTATION OF g1 when g2 = 0:
+    // g1 = 2*g4*g5 / g3
+    component twog4g5 = SignedFp2MultiplyNoCarryCompress(n, k, p, n+1,3*n+2+2*LOGK); // overflow 4k^2 * 2^{3n}
+    for(var i=0; i<k; i++)for(var eps=0; eps<2; eps++){
+        twog4g5.a[eps][i] <== 2*in[2][eps][i];
+        twog4g5.b[eps][i] <== in[3][eps][i];
+    }
+    component g1_0 = SignedFp2Divide(n, k, 3*n+2+2*LOGK, n, p);
+    for(var j=0; j<k; j++){
+        for(var i=0; i<2; i++)
+            g1_0.a[i][j] <== twog4g5.out[i][j]; 
+        for(var i=0; i<2; i++){
+            g1_0.b[i][j] <== in[1][i][j]; 
+        }
+    }
+    // END OF COMPUTATION OF g1 when g2 = 0.
+
+    for(var i=0; i<k; i++)for(var eps=0; eps<2; eps++)
+        out[3][eps][i] <== g1_1.out[eps][i] + g2IsZero.out * (g1_0.out[eps][i] - g1_1.out[eps][i]);
+    
+
+    // COMPUTATION OF g0 when g2 != 0:
+    // g0 = (2 g1^2 + g2 g5 - 3 g3 g4 )(1+u) + 1
+    component twog1sq= SignedFp2MultiplyNoCarry(n, k, 2*n + 2 + LOGK); // overflow 4*k * 2^{2n}
+    for(var i=0; i<k; i++)for(var eps=0; eps<2; eps++){
+        twog1sq.a[eps][i] <== 2*g1_1.out[eps][i];
+        twog1sq.b[eps][i] <== g1_1.out[eps][i];
+    }
+    
+    component g2g5 = SignedFp2MultiplyNoCarry(n, k, 2*n + 1 + LOGK); // overflow 2k * 2^{2n}
+    for(var i=0; i<k; i++)for(var eps=0; eps<2; eps++){
+        g2g5.a[eps][i] <== in[0][eps][i];
+        g2g5.b[eps][i] <== in[3][eps][i];
+    }
+    
+    component threeg3g4 = SignedFp2MultiplyNoCarry(n, k, 2*n + 3 + LOGK); // overflow 6*k * 2^{2n}
+    for(var i=0; i<k; i++)for(var eps=0; eps<2; eps++){
+        threeg3g4.a[eps][i] <== 3*in[1][eps][i];
+        threeg3g4.b[eps][i] <== in[2][eps][i];
+    }
+    // 2 g1^2 + g2 g5 - 3 g3 g4 
+    var temp[2][len]; 
+    for(var i=0; i<2; i++)for(var j=0; j<len; j++)
+        temp[i][j] = twog1sq.out[i][j] + g2g5.out[i][j] - threeg3g4.out[i][j];
+    
+    // (2 g1^2 + g2 g5 - 3 g3 g4)(1+u)
+    var tempc[2][50] = signed_Fp2_mult_w6(len, temp, XI0); // overflow abs val < (1+XI0)*6k * 2^{2n}
+    // (2 g1^2 + g2 g5 - 3 g3 g4)(1+u) + 1 
+    tempc[0][0]++;
+    component compress01 = Fp2Compress(n, k, k-1, p, 3*n + LOGK3); 
+    for(var i=0; i<2; i++)for(var j=0; j<2*k-1; j++)
+        compress01.in[i][j] <== tempc[i][j];
+
+    component carry_mod01 = SignedFp2CarryModP(n, k, 3*n + LOGK3, p);
+    for(var i=0; i<2; i++)for(var j=0; j<k; j++)
+        carry_mod01.in[i][j] <== compress01.out[i][j];
+     
+    signal g0_1[2][k]; 
+    for(var i=0; i<2; i++)for(var j=0; j<k; j++)
+        g0_1[i][j] <== carry_mod01.out[i][j]; 
+    // END OF COMPUTATION OF g0 when g2 != 0. 
+    
+    // COMPUTATION OF g0 when g2 = 0:
+    // g0 = (2g1^2 - 3g3g4)(1+u) + 1
+    component twog1_0sq= SignedFp2MultiplyNoCarry(n, k, 2*n + 2 + LOGK); // overflow 4k * 2^{2n}
+    for(var i=0; i<k; i++)for(var eps=0; eps<2; eps++){
+        twog1_0sq.a[eps][i] <== 2*g1_0.out[eps][i];
+        twog1_0sq.b[eps][i] <== g1_0.out[eps][i];
+    }
+    // can reuse threeg3g4 ! 
+    for(var i=0; i<2; i++)for(var j=0; j<len; j++)
+        temp[i][j] = twog1_0sq.out[i][j] - threeg3g4.out[i][j];
+    // overflow 6*k * 2^{2n}
+    tempc = signed_Fp2_mult_w6(len, temp, XI0);
+    tempc[0][0]++;
+    component compress00 = Fp2Compress(n, k, k-1, p, 3*n + LOGK3); 
+    for(var i=0; i<2; i++)for(var j=0; j<2*k-1; j++)
+        compress00.in[i][j] <== tempc[i][j];
+    component carry_mod00 = SignedFp2CarryModP(n, k, 3*n + LOGK3, p);
+    for(var i=0; i<2; i++)for(var j=0; j<k; j++)
+        carry_mod00.in[i][j] <== compress00.out[i][j];
+    signal g0_0[2][k]; 
+    for(var i=0; i<2; i++)for(var j=0; j<k; j++)
+        g0_0[i][j] <== carry_mod00.out[i][j]; 
+    // END OF COMPUTATION OF g0 when g2 = 0.    
+        
+    for(var i=0; i<k; i++)for(var eps=0; eps<2; eps++)
+        out[0][eps][i] <== g0_1[eps][i] + g2IsZero.out * (g0_0[eps][i] - g0_1[eps][i]);
+
+}
+
+// input is [g2, g3, g4, g5] = C(g) in compressed format of Fp12cyclotomicCompress 
+//  input[i][2] keeps track of positive and negatives 
+//  don't assume anything about overflow in registers in case we want to square twice before carry
+// output is C(g^2) = [h2, h3, h4, h5] computed using Theorem 3.2 of https://eprint.iacr.org/2010/542.pdf 
+//  c = XI0 + u
+//  h2 = 2(g2 + 3*c*B_45) 
+//  h3 = 3(A_45 - (c+1)B_45) - 2g3
+//  h4 = 3(A_23 - (c+1)B_23) - 2g4
+//  h5 = 2(g5 + 3B_23) 
+//  A_ij = (g_i + g_j)(g_i + c g_j)
+//  B_ij = g_i g_j 
+
+// everything computed with no carries 
+// If registers of in[] are in [0, B), then registers of out[] have abs val < (18(XI0 + 2)k + 2/B )* B^2 
+template SignedFp12CyclotomicSquareNoCarry(n, k) {
+    signal input in[4][2][k];
+    signal output out[4][2][2*k-1];
+
+    var XI0 = 1;
+    var LOGK = log_ceil(k);
+
+    component B23 = SignedFp2MultiplyNoCarry(n, k, 2*n + 1 + LOGK); // overflow in 2*k*2^{2N} 
+    component B45 = SignedFp2MultiplyNoCarry(n, k, 2*n + 1 + LOGK); 
+    for(var i=0; i<2; i++)for(var j=0; j<k; j++){
+        B23.a[i][j] <== in[0][i][j];
+        B23.b[i][j] <== in[1][i][j];
+
+        B45.a[i][j] <== in[2][i][j];
+        B45.b[i][j] <== in[3][i][j];
+    }
+
+    component A23 = SignedFp2MultiplyNoCarry(n, k, 2*n + 5 + LOGK); // overflow in 4*(2+XI0)*k *2^{2N}     
+    component A45 = SignedFp2MultiplyNoCarry(n, k, 2*n + 5 + LOGK);
+    // c*g3 = (1+u)*g3
+    var cg3[2][50] = signed_Fp2_mult_w6(k, in[1], XI0); 
+    var cg5[2][50] = signed_Fp2_mult_w6(k, in[3], XI0);
+    for(var i=0; i<2; i++)for(var j=0; j<k; j++){
+        A23.a[i][j] <== in[0][i][j] + in[1][i][j];  // 2*2^{N}
+        A23.b[i][j] <== in[0][i][j] + cg3[i][j];    // (2+XI0)*2^{N}
+
+        A45.a[i][j] <== in[2][i][j] + in[3][i][j];
+        A45.b[i][j] <== in[2][i][j] + cg5[i][j];
+    }
+    
+    var cB45[2][50] = signed_Fp2_mult_w6(2*k-1, B45.out, XI0);  // (1+XI0)*2k*2^{2N}
+    var cB23[2][50] = signed_Fp2_mult_w6(2*k-1, B23.out, XI0); 
+    for(var i=0; i<2; i++)for(var j=0; j<2*k-1; j++){
+        if(j < k){
+            out[0][i][j] <== 2*(in[0][i][j] + 3*cB45[i][j]);    // (2 + 6*(1+XI0)k) * 2^{2N}
+            out[3][i][j] <== 2*(in[3][i][j] + 3*B23.out[i][j]); // (2 + 6*(1+XI0)k) * 2^{2N}
+            out[1][i][j] <== 3*(A45.out[i][j] - cB45[i][j] - B45.out[i][j]) - 2*in[1][i][j]; 
+                                                                // 3*4*(2+XI0)*k * 2^{2N} 
+            out[2][i][j] <== 3*(A23.out[i][j] - cB23[i][j] - B23.out[i][j]) - 2*in[2][i][j]; 
+        }else{
+            out[0][i][j] <== 2*(3*cB45[i][j]);   
+            out[3][i][j] <== 2*(3*B23.out[i][j]); 
+            out[1][i][j] <== 3*(A45.out[i][j] - cB45[i][j] - B45.out[i][j]); 
+            out[2][i][j] <== 3*(A23.out[i][j] - cB23[i][j] - B23.out[i][j]); 
+        }
+    }
+}
+
+// input is [g2, g3, g4, g5] = C(g) is output of Fp12cyclotomicCompress 
+// assume in[4][2][k] has registers in [0, 2^n) with in[i][j] in [0, p)
+// output is C(g^2) 
+// out[4][2][k] has registers in [0, 2^n) with out[i][j] in [0, p) 
+template Fp12CyclotomicSquare(n, k, p) {
+    signal input in[4][2][k]; 
+    signal output out[4][2][k];
+
+    var XI0 = 1;
+    var LOGK2 = log_ceil(18*(2+XI0)*k *k + 1); 
+    assert(3*n + LOGK2 < 251);
+
+    component sq = SignedFp12CyclotomicSquareNoCarry(n, k);
+    for(var i=0; i<4; i++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++){
+        sq.in[i][eps][j] <== in[i][eps][j]; 
+    }
+    component sqRed[4]; 
+    component sqMod[4];
+    for(var i=0; i<4; i++){
+        sqRed[i] = Fp2Compress(n, k, k-1, p, 3*n + LOGK2); 
+        for(var eps=0; eps<2; eps++)for(var j=0; j<2*k-1; j++)
+            sqRed[i].in[eps][j] <== sq.out[i][eps][j]; 
+        sqMod[i] = SignedFp2CarryModP(n, k, 3*n + LOGK2, p);
+        for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++)
+            sqMod[i].in[eps][j] <== sqRed[i].out[eps][j]; 
+    }
+    for(var i=0; i<4; i++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++)
+        out[i][eps][j] <== sqMod[i].out[eps][j];
+}
+
+// assume input is an element of Fp12 in the cyclotomic subgroup GΦ12
+// output is input raised to the e-th power
+// use the square and multiply method
+// assume 0 < e < 2^254
+template Fp12CyclotomicExp(n, k, e, p) {
+    assert( e > 0 );
+
+    signal input in[6][2][k];
+    signal output out[6][2][k];
+
+    var temp = e;
+    // get bitlength of e 
+    var BITLENGTH;
+    for(var i=0; i<254; i++){
+        if( temp != 0 )
+            BITLENGTH = i; 
+        temp = temp>>1;
+    }
+    BITLENGTH++;
+
+    // Compress in[]
+    component Cin = Fp12CyclotomicCompress(n, k);
+    for(var i=0; i<6; i++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++)
+        Cin.in[i][eps][j] <== in[i][eps][j];
+    
+    component pow2[BITLENGTH]; // pow2[i] = C(in^{2^i})
+    component Dpow2[BITLENGTH];
+    component mult[BITLENGTH];
+
+    signal first[6][2][k];
+    var curid = 0; // tracks current index in mult[] 
+
+    for(var i=0; i<BITLENGTH; i++){
+        // compute pow2[i] = pow2[i-1]**2
+        if( i > 0 ){ // pow2[0] is never defined since there is no squaring involved
+            pow2[i] = Fp12CyclotomicSquare(n, k, p);
+            if( i == 1 ){
+                for(var id=0; id<4; id++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++)
+                    pow2[i].in[id][eps][j] <== Cin.out[id][eps][j];
+            }else{
+                for(var id=0; id<4; id++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++)
+                    pow2[i].in[id][eps][j] <== pow2[i-1].out[id][eps][j];
+            }
+        }
+        if( ((e >> i) & 1) == 1 ){
+            // decompress pow2[i] so we can use it 
+            if( i > 0 ){
+                Dpow2[curid] = Fp12CyclotomicDecompress(n, k, p);
+                for(var id=0; id<4; id++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++)
+                    Dpow2[curid].in[id][eps][j] <== pow2[i].out[id][eps][j];
+            }
+            if(curid == 0){ // this is the least significant bit
+                if( i == 0 ){
+                    for(var id=0; id<6; id++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++)
+                        first[id][eps][j] <== in[id][eps][j];
+                }else{
+                    for(var id=0; id<6; id++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++)
+                        first[id][eps][j] <== Dpow2[curid].out[id][eps][j];
+                }
+            }else{
+                // multiply what we already have with pow2[i]
+                mult[curid] = Fp12Multiply(n, k, p); 
+                for(var id=0; id<6; id++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++)
+                    mult[curid].a[id][eps][j] <== Dpow2[curid].out[id][eps][j];
+                if(curid == 1){
+                    for(var id=0; id<6; id++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++)
+                        mult[curid].b[id][eps][j] <== first[id][eps][j];
+                }else{
+                    for(var id=0; id<6; id++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++)
+                        mult[curid].b[id][eps][j] <== mult[curid-1].out[id][eps][j];
+                }
+            } 
+            curid++; 
+        }
+    }
+    curid--;
+    if(curid == 0){
+        for(var id=0; id<6; id++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++)
+            out[id][eps][j] <== first[id][eps][j];
+    }else{
+        for(var id=0; id<6; id++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++)
+            out[id][eps][j] <== mult[curid].out[id][eps][j];
+    }
+}
+
+// hard part of final exponentiation
+// use equation at top of p.14 from https://eprint.iacr.org/2020/875.pdf
+template FinalExpHardPart(n, k, p){
+    signal input in[6][2][k]; 
+    signal output out[6][2][k];
+
+    var x = get_BLS12_381_parameter();  // absolute value of parameter for BLS12-381
+    
+    // in^{(x+1)/3} 
+    component pow1 = Fp12CyclotomicExp(n, k, (x+1)\3, p); 
+    for(var id=0; id<6; id++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++)
+        pow1.in[id][eps][j] <== in[id][eps][j];
+    
+    // in^{(x+1)/3 * (x+1)}
+    component pow2 = Fp12CyclotomicExp(n, k, x+1, p); 
+    for(var id=0; id<6; id++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++)
+        pow2.in[id][eps][j] <== pow1.out[id][eps][j];
+
+    // in^{(x+1)^2/3 * -1} = pow2^-1  inverse = frob(6) in cyclotomic subgroup
+    component pow3 = Fp12FrobeniusMap(n, k, 6);
+    for(var id=0; id<6; id++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++)
+        pow3.in[id][eps][j] <== pow2.out[id][eps][j];
+
+    // in^{(x+1)^2/3 * -x} = pow3^x 
+    component pow4 = Fp12CyclotomicExp(n, k, x, p); 
+    for(var id=0; id<6; id++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++)
+        pow4.in[id][eps][j] <== pow3.out[id][eps][j];
+
+    // in^{(x+1)^2/3 * p} = pow2^p 
+    component pow5 = Fp12FrobeniusMap(n, k, 1);
+    for(var id=0; id<6; id++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++)
+        pow5.in[id][eps][j] <== pow2.out[id][eps][j];
+
+    // in^{(x+1)^2/3 * (-x+p)} = pow4 * pow5
+    component pow6 = Fp12Multiply(n, k, p);
+    for(var id=0; id<6; id++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++){
+        pow6.a[id][eps][j] <== pow4.out[id][eps][j];
+        pow6.b[id][eps][j] <== pow5.out[id][eps][j];
+    }
+
+    // in^{(x+1)^2/3 * (-x+p) * x}  = pow6^x
+    component pow7 = Fp12CyclotomicExp(n, k, x, p);
+    for(var id=0; id<6; id++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++)
+        pow7.in[id][eps][j] <== pow6.out[id][eps][j];
+
+    // in^{(x+1)^2/3 * (-x+p) * x^2}  = pow7^x
+    component pow8 = Fp12CyclotomicExp(n, k, x, p);
+    for(var id=0; id<6; id++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++)
+        pow8.in[id][eps][j] <== pow7.out[id][eps][j];
+
+    // in^{(x+1)^2/3 * (-x+p) * q^2} = pow6^{q^2}
+    component pow9 = Fp12FrobeniusMap(n, k, 2);
+    for(var id=0; id<6; id++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++)
+        pow9.in[id][eps][j] <== pow6.out[id][eps][j];
+    
+    // in^{(x+1)^2/3 * (-x+p) * -1} = pow6^{-1} = pow6^{q^6}
+    component pow10 = Fp12FrobeniusMap(n, k, 6);
+    for(var id=0; id<6; id++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++)
+        pow10.in[id][eps][j] <== pow6.out[id][eps][j];
+    
+    // in^{(x+1)^2/3 * (-x+p) * (x^2 + q^2)} = pow8 * pow9
+    component pow11 = Fp12Multiply(n, k, p);
+    for(var id=0; id<6; id++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++){
+        pow11.a[id][eps][j] <== pow8.out[id][eps][j];
+        pow11.b[id][eps][j] <== pow9.out[id][eps][j];
+    }
+    
+    // in^{(x+1)^2/3 * (-x+p) * (x^2 + q^2 - 1)} = pow10 * pow11
+    component pow12 = Fp12Multiply(n, k, p);
+    for(var id=0; id<6; id++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++){
+        pow12.a[id][eps][j] <== pow10.out[id][eps][j];
+        pow12.b[id][eps][j] <== pow11.out[id][eps][j];
+    }
+    
+    // final answer
+    // in^{(x+1)^2/3 * (-x+p) * (x^2 + q^2 - 1) + 1} = pow12 * in 
+    component pow13 = Fp12Multiply(n, k, p); 
+    for(var id=0; id<6; id++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++){
+        pow13.a[id][eps][j] <== pow12.out[id][eps][j];
+        pow13.b[id][eps][j] <== in[id][eps][j];
+    }
+    
+    for(var id=0; id<6; id++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++)
+        out[id][eps][j] <== pow13.out[id][eps][j];
+}
+
+// easy part of final exponentiation 
+// out = in^{ (q^6 - 1)*(q^2 + 1) }
+template FinalExpEasyPart(n, k, p){
+    signal input in[6][2][k];
+    signal output out[6][2][k];
+    
+    // in^{q^6} 
+    component f1 = Fp12FrobeniusMap(n, k, 6); 
+    for(var id=0; id<6; id++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++)
+        f1.in[id][eps][j] <== in[id][eps][j];
+
+    // in^{-1}
+    component f2 = Fp12Invert(n, k, p);
+    for(var id=0; id<6; id++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++)
+        f2.in[id][eps][j] <== in[id][eps][j];
+
+    // in^{q^6 - 1}
+    component f3 = Fp12Multiply(n, k, p);
+    for(var id=0; id<6; id++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++){
+        f3.a[id][eps][j] <== f1.out[id][eps][j];
+        f3.b[id][eps][j] <== f2.out[id][eps][j];
+    }
+    
+    // in^{(q^6-1)*q^2} = f3^{q^2}
+    component f4 = Fp12FrobeniusMap(n, k, 2); 
+    for(var id=0; id<6; id++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++)
+        f4.in[id][eps][j] <== f3.out[id][eps][j];
+    
+    // in^{(q^6-1)(q^2+1)} = f4 * f3
+    component f5 = Fp12Multiply(n, k, p);
+    for(var id=0; id<6; id++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++){
+        f5.a[id][eps][j] <== f3.out[id][eps][j];
+        f5.b[id][eps][j] <== f4.out[id][eps][j];
+    }
+    
+    for(var id=0; id<6; id++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++)
+        out[id][eps][j] <== f5.out[id][eps][j];
+}
+
+// out = in^{(q^12-1)/r} = FinalExpHardPart( FinalExpEasyPart(in) )
+template FinalExponentiate(n, k, p){
+    signal input in[6][2][k];
+    signal output out[6][2][k];
+
+    component f1 = FinalExpEasyPart(n, k, p);
+    for(var id=0; id<6; id++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++)
+        f1.in[id][eps][j] <== in[id][eps][j];
+    
+    component f = FinalExpHardPart(n, k, p);
+    for(var id=0; id<6; id++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++)
+        f.in[id][eps][j] <== f1.out[id][eps][j];
+    
+    for(var id=0; id<6; id++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++)
+        out[id][eps][j] <== f.out[id][eps][j];
+}
diff --git a/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/fp.circom b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/fp.circom
new file mode 100644
index 0000000..bf2a51e
--- /dev/null
+++ b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/fp.circom
@@ -0,0 +1,293 @@
+pragma circom 2.0.3;
+
+include "bigint.circom";
+include "bigint_func.circom";
+
+// a[i], b[i] in 0... 2**n-1
+// represent a = a[0] + a[1] * 2**n + .. + a[k - 1] * 2**(n * k)
+// calculates (a+b)%p, where 0<= a,b < p 
+template FpAdd(n, k, p){
+    assert(n <= 252);
+    signal input a[k];
+    signal input b[k];
+    signal output out[k];
+
+    component add = BigAdd(n,k);
+    for (var i = 0; i < k; i++) {
+        add.a[i] <== a[i];
+        add.b[i] <== b[i];
+    }
+    component lt = BigLessThan(n, k+1);
+    for (var i = 0; i < k; i++) {
+        lt.a[i] <== add.out[i];
+        lt.b[i] <== p[i];
+    }
+    lt.a[k] <== add.out[k];
+    lt.b[k] <== 0; 
+
+    component sub = BigSub(n,k+1);
+    for (var i = 0; i < k; i++) {
+        sub.a[i] <== add.out[i];
+        sub.b[i] <== p[i] - lt.out * p[i];
+    }
+    sub.a[k] <== add.out[k];
+    sub.b[k] <== 0;
+    
+    sub.out[k] === 0;
+    for (var i = 0; i < k; i++) {
+        out[i] <== sub.out[i];
+    }
+}
+
+// calculates (a - b) % p, where a, b < p
+// note: does not assume a >= b
+template FpSubtract(n, k, p){
+    assert(n <= 252);
+    signal input a[k];
+    signal input b[k];
+    signal output out[k];
+    component sub = BigSub(n, k);
+    for (var i = 0; i < k; i++){
+        sub.a[i] <== a[i];
+        sub.b[i] <== b[i];
+    }
+    signal flag;
+    flag <== sub.underflow;
+    component add = BigAdd(n, k);
+    for (var i = 0; i < k; i++){
+        add.a[i] <== sub.out[i];
+        add.b[i] <== p[i];
+    }
+    signal tmp[k];
+    for (var i = 0; i < k; i++){
+        tmp[i] <== (1 - flag) * sub.out[i];
+        out[i] <== tmp[i] + flag * add.out[i];
+    }
+}
+
+// Input: in <= p
+// Output: -in (mod p) = p - in if in != 0, else 0 
+// Constrains in <= p
+template FpNegate(n, k, p){
+    signal input in[k];
+    signal output out[k];
+
+    component neg = BigSub(n, k); 
+    component is_zero = BigIsZero(k);
+    for(var idx=0; idx<k; idx++){
+        neg.a[idx] <== p[idx];
+        neg.b[idx] <== in[idx];
+        
+        is_zero.in[idx] <== in[idx];
+    }
+    neg.underflow === 0; // constrain in <= p
+    for(var idx=0; idx<k; idx++)
+        out[idx] <== (1-is_zero.out)*neg.out[idx];
+}
+
+template FpMultiply(n, k, p) {
+    assert(n <= 252);
+    signal input a[k];
+    signal input b[k];
+    signal output out[k];
+
+    var LOGK = log_ceil(k);
+
+    component nocarry = BigMultShortLong(n, k, 2*n + LOGK);
+    for (var i = 0; i < k; i++) {
+        nocarry.a[i] <== a[i];
+        nocarry.b[i] <== b[i];
+    }
+    component red = PrimeReduce(n, k, k-1, p, 3*n + 2*LOGK);
+    for(var i=0; i<2*k-1; i++)
+        red.in[i] <== nocarry.out[i];
+
+    component big_mod = SignedFpCarryModP(n, k, 3*n + 2*LOGK, p);
+    for (var i = 0; i < k; i++)
+        big_mod.in[i] <== red.out[i];
+
+    for (var i = 0; i < k; i++)
+        out[i] <== big_mod.out[i];
+}
+
+// constrain in = p * X + Y 
+// in[i] in (-2^overflow, 2^overflow) 
+// assume registers of X have abs value < 2^{overflow - n - log(min(k,m)) - 1} 
+// assume overflow - 1 >= n 
+template CheckCarryModP(n, k, m, overflow, p){
+    signal input in[k]; 
+    signal input X[m];
+    signal input Y[k];
+
+    assert( overflow < 251 );
+    assert( n <= overflow - 1);
+    component pX;
+    component carry_check;
+
+    pX = BigMultShortLongUnequal(n, k, m, overflow); // p has k registers, X has m registers, so output really has k+m-1 registers 
+    // overflow register in  (-2^{overflow-1} , 2^{overflow-1})
+    for(var i=0; i<k; i++)
+        pX.a[i] <== p[i];
+    for(var i=0; i<m; i++)
+        pX.b[i] <== X[i];
+
+    // in - p*X - Y has registers in (-2^{overflow+1}, 2^{overflow+1})
+    carry_check = CheckCarryToZero(n, overflow+1, k+m-1 ); 
+    for(var i=0; i<k; i++){
+        carry_check.in[i] <== in[i] - pX.out[i] - Y[i]; 
+    }
+    for(var i=k; i<k+m-1; i++)
+        carry_check.in[i] <== -pX.out[i];
+}
+
+// solve for in = p * X + out
+// assume in has registers in (-2^overflow, 2^overflow) 
+// X has registers lying in [-2^n, 2^n) 
+// X has at most Ceil( overflow / n ) registers 
+
+// out has registers in [0, 2^n) but don't constrain out < p
+template SignedFpCarryModP(n, k, overflow, p){
+    signal input in[k]; 
+    var m = (overflow + n - 1) \ n; 
+    signal output X[m];
+    signal output out[k];
+
+    assert( overflow < 251 );
+
+    var Xvar[2][50] = get_signed_Fp_carry_witness(n, k, m, in, p); 
+    component X_range_checks[m];
+    component range_checks[k]; 
+    //component lt = BigLessThan(n, k); 
+
+    for(var i=0; i<k; i++){
+        out[i] <-- Xvar[1][i];
+        range_checks[i] = Num2Bits(n); 
+        range_checks[i].in <== out[i];
+        //lt.a[i] <== out[i];
+        //lt.b[i] <== p[i];
+    }
+    //lt.out === 1;
+    
+    for(var i=0; i<m; i++){
+        X[i] <-- Xvar[0][i];
+        X_range_checks[i] = Num2Bits(n+1);
+        X_range_checks[i].in <== X[i] + (1<<n); // X[i] should be between [-2^n, 2^n)
+    }
+    
+    component mod_check = CheckCarryModP(n, k, m, overflow, p);
+    for(var i=0; i<k; i++){
+        mod_check.in[i] <== in[i];
+        mod_check.Y[i] <== out[i];
+    }
+    for(var i=0; i<m; i++){
+        mod_check.X[i] <== X[i];
+    }
+}
+
+
+
+// Constrain in = 0 mod p by solving for in = p * X
+// assume in has registers in (-2^overflow, 2^overflow) 
+// X has registers lying in [-2^n, 2^n) 
+// X has at most Ceil( overflow / n ) registers 
+
+// save range check on Y compared to SignedFpCarryModP
+template SignedCheckCarryModToZero(n, k, overflow, p){
+    signal input in[k]; 
+    var m = (overflow + n - 1) \ n; 
+    signal output X[m];
+
+    assert( overflow < 251 );
+
+    var Xvar[2][50] = get_signed_Fp_carry_witness(n, k, m, in, p); 
+    component X_range_checks[m];
+
+    for(var i=0; i<m; i++){
+        X[i] <-- Xvar[0][i];
+        X_range_checks[i] = Num2Bits(n+1);
+        X_range_checks[i].in <== X[i] + (1<<n); // X[i] should be between [-2^n, 2^n)
+    }
+    
+    component mod_check = CheckCarryModP(n, k, m, overflow, p);
+    for(var i=0; i<k; i++){
+        mod_check.in[i] <== in[i];
+        mod_check.Y[i] <== 0;
+    }
+    for(var i=0; i<m; i++){
+        mod_check.X[i] <== X[i];
+    }
+}
+
+// in has k registers, elt of Fp
+// https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-hash-to-curve-11#section-4.1
+// return in % 2
+// This requires `in` to be the unique element < p. 
+// NOTE: different from Wahby-Boneh paper https://eprint.iacr.org/2019/403.pdf and python reference code: https://github.com/algorand/bls_sigs_ref/blob/master/python-impl/opt_swu_g2.py
+template FpSgn0(n, k, p){
+    signal input in[k];
+    signal output out;
+
+    // constrain in < p
+    component lt = BigLessThan(n, k);
+    for(var i=0; i<k; i++){
+        lt.a[i] <== in[i];
+        lt.b[i] <== p[i];
+    }
+    lt.out === 1;
+    
+    // note we only need in[0] ! 
+    var r = in[0] % 2;
+    var q = (in[0] - r) / 2; 
+    out <-- r;
+    signal div;
+    div <-- q; 
+    out * (1 - out) === 0;
+    in[0] === 2 * div + out;
+}
+
+template FpIsZero(n, k, p){
+    signal input in[k];
+    signal output out;
+
+    // check that in < p 
+    component lt = BigLessThan(n, k);
+    component isZero = BigIsZero(k);
+    for(var i = 0; i < k; i++) {
+        lt.a[i] <== in[i];
+        lt.b[i] <== p[i];
+
+        isZero.in[i] <== in[i];
+    }
+    lt.out === 1;
+    out <== isZero.out;
+}
+
+template FpIsEqual(n, k, p){
+    signal input in[2][k];
+    signal output out;
+
+    // check in[i] < p
+    component lt[2];
+    for(var i = 0; i < 2; i++){
+        lt[i] = BigLessThan(n, k);
+        for(var idx=0; idx<k; idx++){
+            lt[i].a[idx] <== in[i][idx];
+            lt[i].b[idx] <== p[idx];
+        }
+        lt[i].out === 1;
+    }
+
+    component isEqual[k+1];
+    var sum = 0;
+    for(var i = 0; i < k; i++){
+        isEqual[i] = IsEqual();
+        isEqual[i].in[0] <== in[0][i];
+        isEqual[i].in[1] <== in[1][i];
+        sum = sum + isEqual[i].out;
+    }
+
+    isEqual[k] = IsEqual();
+    isEqual[k].in[0] <== sum;
+    isEqual[k].in[1] <== k;
+    out <== isEqual[k].out;
+}
diff --git a/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/fp12.circom b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/fp12.circom
new file mode 100644
index 0000000..daa8a12
--- /dev/null
+++ b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/fp12.circom
@@ -0,0 +1,521 @@
+pragma circom 2.0.3;
+
+include "bigint.circom";
+include "field_elements_func.circom";
+include "fp.circom";
+include "fp2.circom";
+include "fp12_func.circom";
+include "bls12_381_func.circom";
+
+template Fp12FrobeniusMap(n, k, power){
+    signal input in[6][2][k];
+    signal output out[6][2][k];
+
+    var p[50] = get_BLS12_381_prime(n, k);
+    var FP12_FROBENIUS_COEFFICIENTS[12][6][2][20] = get_Fp12_frobenius(n, k);
+    var pow = power % 12;
+ 
+    component in_frob[6]; 
+ 
+    // multiply in_frob[i] by FP12_FROBENIUS_COEFFICIENTS[pow][i] 
+    // if pow is even, then FP12_FROBENIUS_COEFFICIENTS[pow][i] is in Fp instead of Fp2, so can optimize 
+    component mult_odd[6];
+    component mult_even[6][2];
+    if( (pow % 2) == 0 ){
+        for(var j=0; j<k; j++){
+            out[0][0][j] <== in[0][0][j];
+            out[0][1][j] <== in[0][1][j];
+        } 
+        for(var i=1; i<6; i++){
+            mult_even[i][0] = FpMultiply(n, k, p);
+            mult_even[i][1] = FpMultiply(n, k, p);
+            for(var j=0; j<k; j++){
+                mult_even[i][0].a[j] <== in[i][0][j];
+                mult_even[i][1].a[j] <== in[i][1][j];
+
+                mult_even[i][0].b[j] <== FP12_FROBENIUS_COEFFICIENTS[pow][i][0][j];
+                mult_even[i][1].b[j] <== FP12_FROBENIUS_COEFFICIENTS[pow][i][0][j];
+            }
+            for(var j=0; j<k; j++){
+                out[i][0][j] <== mult_even[i][0].out[j];
+                out[i][1][j] <== mult_even[i][1].out[j];
+            }
+        }
+    }else{
+        // apply Frob to coefficients first
+        for(var i=0; i<6; i++){
+            in_frob[i] = Fp2FrobeniusMap(n, k, pow, p); 
+            for(var j=0; j<k; j++){
+                in_frob[i].in[0][j] <== in[i][0][j];
+                in_frob[i].in[1][j] <== in[i][1][j];
+            }
+        }
+        for(var j=0; j<k; j++){
+            out[0][0][j] <== in_frob[0].out[0][j];
+            out[0][1][j] <== in_frob[0].out[1][j];
+        } 
+        for(var i=1; i<6; i++){
+            mult_odd[i] = Fp2Multiply(n, k, p);
+            for(var j=0; j<k; j++){
+                for(var eps=0; eps<2; eps++){
+                    mult_odd[i].a[eps][j] <== in_frob[i].out[eps][j];
+                    mult_odd[i].b[eps][j] <== FP12_FROBENIUS_COEFFICIENTS[pow][i][eps][j];
+                }
+            }
+            for(var j=0; j<k; j++){
+                out[i][0][j] <== mult_odd[i].out[0][j];
+                out[i][1][j] <== mult_odd[i].out[1][j];
+            }
+        }
+    }
+}
+
+template Fp12Add(n, k, p) {
+    signal input a[6][2][k];
+    signal input b[6][2][k];
+    signal output out[6][2][k];
+    component adders[6][2];
+    for (var i = 0; i < 6; i ++) {
+        for (var j = 0; j < 2; j ++) {
+            adders[i][j] = FpAdd(n,k, p);
+            for (var m = 0; m < k; m ++) {
+                adders[i][j].a[m] <== a[i][j][m];
+                adders[i][j].b[m] <== b[i][j][m];
+                adders[i][j].p[m] <== p[m];
+            }
+            for (var m = 0; m < k; m ++) {
+                out[i][j][m] <== adders[i][j].out[m];
+            }
+        }
+    }
+}
+
+// a is k array representing element a of Fp allowing negative registers
+// b is 6 x 2 x k array representing element b0 + b1 u of Fp12 allowing negative registers
+//      where b_i = b[][i][] is 6 x k array
+// out is a*b in Fp12 as 6 x 2 x (2k-1) array
+// m_out is the expected max number of bits in the output registers
+template SignedFp12ScalarMultiplyNoCarry(n, k, m_out){
+    signal input a[k];
+    signal input b[6][2][k];
+    signal output out[6][2][2*k-1];
+
+    component ab[6][2]; 
+    for(var i=0; i<6; i++)for(var j=0; j<2; j++){
+        ab[i][j] = BigMultShortLong(n, k, m_out); // 2k-1 registers 
+
+        for(var idx=0; idx<k; idx++){
+            ab[i][j].a[idx] <== a[idx];
+            ab[i][j].b[idx] <== b[i][j][idx]; 
+        } 
+    }
+    
+    for(var i=0; i<6; i++)for(var j=0; j<2; j++)for(var idx=0; idx<2*k-1; idx++)
+        out[i][j][idx] <== ab[i][j].out[idx];
+}
+
+// m_out is the expected max number of bits in the output registers
+template SignedFp12ScalarMultiplyNoCarryUnequal(n, ka, kb, m_out){
+    signal input a[ka];
+    signal input b[6][2][kb];
+    signal output out[6][2][ka+kb-1];
+
+    component ab[6][2]; 
+    for(var i=0; i<6; i++)for(var j=0; j<2; j++){
+        ab[i][j] = BigMultShortLongUnequal(n, ka, kb, m_out); // 2k-1 registers 
+
+        for(var idx=0; idx<ka; idx++)
+            ab[i][j].a[idx] <== a[idx];
+        for(var idx=0; idx<kb; idx++)
+            ab[i][j].b[idx] <== b[i][j][idx]; 
+    }
+    
+    for(var i=0; i<6; i++)for(var j=0; j<2; j++)for(var idx=0; idx<ka+kb-1; idx++)
+        out[i][j][idx] <== ab[i][j].out[idx];
+}
+
+// a is 2 x k array representing element a of Fp2 allowing negative registers
+// b is 6 x 2 x k array representing element b0 + b1 u of Fp12 allowing negative registers
+//      where b_i = b[][i][] is 6 x k array
+// out is a*b in Fp12 as 6 x 2 x (2k-1) array
+// m_out is the expected max number of bits in the output registers
+template SignedFp12Fp2MultiplyNoCarry(n, k, m_out){
+    signal input a[2][k];
+    signal input b[6][2][k];
+    signal output out[6][2][2*k-1];
+
+    component ab[6][2];
+    component abi[6][2];
+    for(var i=0; i<6; i++)for(var j=0; j<2; j++){
+        ab[i][j] = BigMultShortLong(n, k, m_out); // 2k-1 registers
+        abi[i][j] = BigMultShortLong(n, k, m_out); // 2k-1 registers 
+
+        for(var idx=0; idx<k; idx++){
+            ab[i][j].a[idx] <== a[0][idx];
+            ab[i][j].b[idx] <== b[i][j][idx]; 
+        } 
+        for(var idx=0; idx<k; idx++){
+            abi[i][j].a[idx] <== a[1][idx];
+            abi[i][j].b[idx] <== b[i][j][idx]; 
+        }
+    }
+    
+    for(var i=0; i<6; i++)for(var idx=0; idx<2*k-1; idx++) {
+        out[i][0][idx] <== ab[i][0].out[idx] - abi[i][1].out[idx];
+        out[i][1][idx] <== abi[i][0].out[idx] + ab[i][1].out[idx];
+    }
+}
+
+// m_out is the expected max number of bits in the output registers
+template SignedFp12Fp2MultiplyNoCarryUnequal(n, ka, kb, m_out){
+    signal input a[2][ka];
+    signal input b[6][2][kb];
+    signal output out[6][2][ka+kb-1];
+
+    component ab[6][2];
+    component abi[6][2];
+    for(var i=0; i<6; i++)for(var j=0; j<2; j++){
+        ab[i][j] = BigMultShortLongUnequal(n, ka, kb, m_out); // 2k-1 registers
+        abi[i][j] = BigMultShortLongUnequal(n, ka, kb, m_out); // 2k-1 registers 
+
+        for(var idx=0; idx<ka; idx++){
+            ab[i][j].a[idx] <== a[0][idx];
+            abi[i][j].a[idx] <== a[1][idx];
+        }
+        for(var idx=0; idx<kb; idx++){
+            ab[i][j].b[idx] <== b[i][j][idx];
+            abi[i][j].b[idx] <== b[i][j][idx];
+        }
+    }
+    
+    for(var i=0; i<6; i++)for(var idx=0; idx<ka+kb-1; idx++){
+        out[i][0][idx] <== ab[i][0].out[idx] - abi[i][1].out[idx];
+        out[i][1][idx] <== abi[i][0].out[idx] + ab[i][1].out[idx];
+    }
+}
+
+// we first write a = a0 + a1 u, b = b0 + b1 u for ai, bi being:
+//     * length 6 vectors with ka, kb registers in (-B_a, B_a) and (-B_b, B_b)
+// ab = (a0 b0 - a1 b1 ) + (a0 b1 + a1 b0) u
+// a_i b_j is degree 10 polynomial in w
+// Assume w^6 = XI0 + u and convert ab into degree 5 polynomials in w by substitution
+// The real and imaginary parts are
+//     * length 6 vectors with ka+kb-1 registers abs val < B_a * B_b * 6 * min(ka, kb) * (2+XI0)
+// m_out is the expected max number of bits in the output registers
+template SignedFp12MultiplyNoCarryUnequal(n, ka, kb, m_out){
+    var l = 6;
+    var XI0 = 1;
+    signal input a[l][2][ka];
+    signal input b[l][2][kb];
+    signal output out[l][2][ka + kb -1];
+
+    component a0b0 = BigMultShortLong2DUnequal(n, ka, kb, l, l);
+    component a0b1 = BigMultShortLong2DUnequal(n, ka, kb, l, l);
+    component a1b0 = BigMultShortLong2DUnequal(n, ka, kb, l, l);
+    component a1b1 = BigMultShortLong2DUnequal(n, ka, kb, l, l);
+    
+    for (var i = 0; i < l; i ++) {
+        for (var j = 0; j < ka; j ++) {
+            a0b0.a[i][j] <== a[i][0][j];
+            a0b1.a[i][j] <== a[i][0][j];
+
+            a1b0.a[i][j] <== a[i][1][j];
+            a1b1.a[i][j] <== a[i][1][j];
+        }
+        for (var j = 0; j < kb; j ++) {
+            a0b0.b[i][j] <== b[i][0][j];
+            a1b0.b[i][j] <== b[i][0][j];
+
+            a0b1.b[i][j] <== b[i][1][j];
+            a1b1.b[i][j] <== b[i][1][j];
+        }
+	}
+    
+    // X[][0] = a0 b0 - a1 b1
+    // X[][1] = a0 b1 + a1 b0 
+    // X[][0] = sum_{i=0}^10 X[i][0] * w^i 
+    signal X[2 * l - 1][2][ka + kb - 1];
+    for (var i = 0; i < 2 * l - 1; i++) {
+        for (var j = 0; j < ka + kb - 1; j++) {
+            X[i][0][j] <== a0b0.out[i][j] - a1b1.out[i][j];
+            X[i][1][j] <== a0b1.out[i][j] + a1b0.out[i][j];
+        }
+    }
+
+    // X[i+6][0] w^{i+6} = X[i+6][0] * XI0 * w^i + X[i+6][0] * w^i       * u 
+    // X[i+6][1] w^{i+6} = - X[i+6][1] * w^i       X[i+6][1] * XI0 * w^i * u 
+    for (var i = 0; i < l; i++)for (var j = 0; j < ka + kb - 1; j++) {
+        if (i < l - 1) {
+            out[i][0][j] <== X[i][0][j] + X[l + i][0][j]*XI0 - X[l + i][1][j];
+            out[i][1][j] <== X[i][1][j] + X[l + i][0][j]     + X[l + i][1][j];
+        } else {
+            out[i][0][j] <== X[i][0][j];
+            out[i][1][j] <== X[i][1][j];
+        }
+    }
+}
+
+template SignedFp12MultiplyNoCarry(n, k, m_out){
+    var l = 6;
+    signal input a[l][2][k];
+    signal input b[l][2][k];
+    signal output out[l][2][2*k-1];
+    
+    component mult = SignedFp12MultiplyNoCarryUnequal(n, k, k, m_out);
+    for(var i=0; i<l; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+        mult.a[i][j][idx] <== a[i][j][idx];
+        mult.b[i][j][idx] <== b[i][j][idx];
+    }
+    for(var i=0; i<l; i++)for(var j=0; j<2; j++)for(var idx=0; idx<2*k-1; idx++)
+        out[i][j][idx] <== mult.out[i][j][idx]; 
+}
+
+// m_out is the expected max number of bits in the output registers
+template Fp12Compress(n, k, m, p, m_out){
+    var l = 6;
+    signal input in[l][2][k+m];
+    signal output out[l][2][k];
+
+    component reduce[l][2];
+    for (var i = 0; i < l; i++)for (var j = 0; j < 2; j++){
+        reduce[i][j] = PrimeReduce(n, k, m, p, m_out);
+        for (var idx = 0; idx < k + m; idx++) 
+            reduce[i][j].in[idx] <== in[i][j][idx];
+    }
+
+    for (var i = 0; i < l; i++)for (var j = 0; j < 2; j++)for (var idx = 0; idx < k; idx++) 
+        out[i][j][idx] <== reduce[i][j].out[idx];
+}
+
+// Input is same as for Fp12MultiplyNoCarry
+// Our answer is the prime reduction of output of Fp12MultiplyNoCarry to
+//     * length 6 vectors with k registers in [0, B_a * B_b * 2^n * 6*(2+XI0) * k^2 )
+// p is length k
+// m_in is the expected max number of bits in the input registers (necessary for some intermediate overflow validation)
+// m_out is the expected max number of bits in the output registers
+template SignedFp12MultiplyNoCarryCompress(n, k, p, m_in, m_out) {
+    var l = 6;
+    var XI0 = 1;
+    signal input a[l][2][k];
+    signal input b[l][2][k];
+    signal output out[l][2][k];
+
+    var LOGK1 = log_ceil(6*k*(2+XI0));
+    component nocarry = SignedFp12MultiplyNoCarry(n, k, 2*m_in + LOGK1);
+    for (var i = 0; i < l; i ++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){ 
+        nocarry.a[i][j][idx] <== a[i][j][idx];
+        nocarry.b[i][j][idx] <== b[i][j][idx];
+    }
+
+    component reduce = Fp12Compress(n, k, k-1, p, m_out);
+    for (var i = 0; i < l; i++)for (var j = 0; j < 2; j++)
+        for (var idx = 0; idx < 2 * k - 1; idx++) 
+            reduce.in[i][j][idx] <== nocarry.out[i][j][idx];
+
+    for (var i = 0; i < l; i++)for (var j = 0; j < 2; j++)
+        for (var idx = 0; idx < k; idx++) 
+            out[i][j][idx] <== reduce.out[i][j][idx];
+}
+
+// solve for: in = X * p + out
+// X has Ceil( overflow / n ) registers, lying in [-2^n, 2^n)
+// assume in has registers in [0, 2^overflow)
+template SignedFp12CarryModP(n, k, overflow, p) {
+    var l = 6;
+    var m = (overflow + n - 1) \ n;
+    signal input in[l][2][k];
+    signal output X[l][2][m];
+    signal output out[l][2][k];
+
+    assert( overflow < 251 );
+
+    component carry[l][2];
+    for(var i=0; i<l; i++)for(var j=0; j<2; j++){
+        carry[i][j] = SignedFpCarryModP(n, k, overflow, p);
+        for(var idx=0; idx<k; idx++)
+            carry[i][j].in[idx] <== in[i][j][idx];
+        for(var idx=0; idx<m; idx++)
+            X[i][j][idx] <== carry[i][j].X[idx];
+        for(var idx=0; idx<k; idx++)
+            out[i][j][idx] <== carry[i][j].out[idx];
+    }
+}
+
+
+// version of Fp12Multiply that uses the prime reduction trick
+// takes longer to compile
+// assumes p has k registers with kth register nonzero
+template Fp12Multiply(n, k, p) {
+    var l = 6;
+    var XI0 = 1;
+    signal input a[l][2][k];
+    signal input b[l][2][k];
+    
+    signal output out[l][2][k];
+
+    var LOGK2 = log_ceil(6*k*k*(2+XI0)); 
+    component no_carry = SignedFp12MultiplyNoCarryCompress(n, k, p, n, 3*n + LOGK2);
+    // registers abs val < 2^{3n} * 6*(2 + XI0) * k^2 )
+    for (var i = 0; i < l; i++)for(var j = 0; j < 2; j++){
+        for (var idx = 0; idx < k; idx++) {
+            no_carry.a[i][j][idx] <== a[i][j][idx];
+            no_carry.b[i][j][idx] <== b[i][j][idx];
+        }
+    }
+    component carry_mod;
+    carry_mod = SignedFp12CarryModP(n, k, 3*n + LOGK2, p);
+    for (var i = 0; i < l; i++)for (var j = 0; j < 2; j++)
+        for (var idx = 0; idx < k; idx++)
+		    carry_mod.in[i][j][idx] <== no_carry.out[i][j][idx];
+        
+    
+    for (var i = 0; i < l; i++)for (var j = 0; j < 2; j++)
+        for (var idx = 0; idx < k; idx++)
+            out[i][j][idx] <== carry_mod.out[i][j][idx];
+}
+
+// unoptimized squaring, just takes two elements of Fp12 and multiplies them
+template Fp12Square(n, k, p) {
+    signal input in[6][2][k];
+    signal output out[6][2][k];
+
+    // for now just use plain multiplication, this can be optimized later
+    component square = Fp12Multiply(n, k, p);
+    for(var i=0; i<6; i++)for(var j=0; j<k; j++){
+        square.a[i][0][j] <== in[i][0][j];
+        square.a[i][1][j] <== in[i][1][j];
+    
+        square.b[i][0][j] <== in[i][0][j];
+        square.b[i][1][j] <== in[i][1][j];
+    }
+
+    for(var i=0; i<6; i++)for(var j=0; j<k; j++){
+        out[i][0][j] <== square.out[i][0][j];
+        out[i][1][j] <== square.out[i][1][j];
+    }
+}
+
+
+// not actually a relevant circuit - this only exists to test find_Fp6_inverse
+template Fp6Invert(n, k, p) {
+    signal input a0[2][k];
+    signal input a1[2][k];
+    signal input a2[2][k];
+    var out[6][2][50] = find_Fp6_inverse(n, k, p, a0, a1, a2);
+    signal output real_out[6][2][k];
+    for (var i = 0; i < 6; i++) {
+        for (var j = 0; j < 2; j ++) {
+            for (var idx = 0; idx < k; idx++) {
+                real_out[i][j][idx] <-- out[i][j][idx];
+            }
+        }
+    }
+}
+
+// Call find_Fp12_inverse to compute inverse
+// Then check out * in = 1, out is an array of shorts
+template Fp12Invert(n, k, p){
+    signal input in[6][2][k];
+    signal output out[6][2][k];
+
+    var inverse[6][2][50] = find_Fp12_inverse(n, k, p, in); // 6 x 2 x 50, only 6 x 2 x k relevant
+    for (var i = 0; i < 6; i ++) {
+        for (var j = 0; j < 2; j ++) {
+            for (var m = 0; m < k; m ++) {
+                out[i][j][m] <-- inverse[i][j][m];
+            }
+        }
+    }
+
+    component outRangeChecks[6][2][k];
+    for(var i=0; i<6; i++) for(var j=0; j<2; j++) for(var m=0; m<k; m++) {
+        outRangeChecks[i][j][m] = Num2Bits(n);
+        outRangeChecks[i][j][m].in <== out[i][j][m];
+    }
+
+    component in_out = Fp12Multiply(n, k, p);
+    for(var i=0; i<6; i++) for(var j=0; j<2; j++) for(var m=0; m<k; m++) {
+        in_out.a[i][j][m] <== in[i][j][m];
+        in_out.b[i][j][m] <== out[i][j][m];
+    }
+
+    for(var i=0; i<6; i++)for(var j=0; j<2; j++) for(var m = 0; m < k; m ++) {
+        if(i == 0 && j == 0 && m == 0)
+            in_out.out[i][j][m] === 1;
+        else
+            in_out.out[i][j][m] === 0;
+    }
+}
+
+// input is an element of Fp12 
+// output is input raised to the e-th power
+// use the square and multiply method
+// assume 0 < e < 2^254
+template Fp12Exp(n, k, e, p) {
+    assert( e > 0 );
+
+    signal input in[6][2][k];
+    signal output out[6][2][k];
+
+    var temp = e;
+    var BITLENGTH;
+    for(var i=0; i<254; i++){
+        if( temp != 0 )
+            BITLENGTH = i; 
+        temp = temp>>1;
+    }
+    BITLENGTH++;
+    component pow2[BITLENGTH]; // pow2[i] = in^{2^i} 
+    component mult[BITLENGTH];
+
+    signal first[6][2][k];
+    var curid = 0;
+
+    for(var i=0; i<BITLENGTH; i++){
+        // compute pow2[i] = pow2[i-1]**2
+        if( i > 0 ){ // pow2[0] is never defined since there is no squaring involved
+            pow2[i] = Fp12Square(n, k, p);
+            for(var j=0; j<k; j++) pow2[i].p[j] <== p[j];
+            if( i == 1 ){
+                for(var id=0; id<6; id++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++)
+                    pow2[i].in[id][eps][j] <== in[id][eps][j];
+            }else{
+                for(var id=0; id<6; id++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++)
+                    pow2[i].in[id][eps][j] <== pow2[i-1].out[id][eps][j];
+            }
+        }
+        if( ((e >> i) & 1) == 1 ){
+            if(curid == 0){ // this is the least significant bit
+                if( i == 0 ){
+                    for(var id=0; id<6; id++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++)
+                        first[id][eps][j] <== in[id][eps][j];
+                }else{
+                    for(var id=0; id<6; id++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++)
+                        first[id][eps][j] <== pow2[i].out[id][eps][j];
+                }
+            }else{
+                // multiply what we already have with pow2[i]
+                mult[curid] = Fp12Multiply(n, k, p); 
+                for(var id=0; id<6; id++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++)
+                    mult[curid].a[id][eps][j] <== pow2[i].out[id][eps][j];
+                if(curid == 1){
+                    for(var id=0; id<6; id++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++)
+                        mult[curid].b[id][eps][j] <== first[id][eps][j];
+                }else{
+                    for(var id=0; id<6; id++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++)
+                        mult[curid].b[id][eps][j] <== mult[curid-1].out[id][eps][j];
+                }
+            } 
+            curid++; 
+        }
+    }
+    curid--;
+    if(curid == 0){
+        for(var id=0; id<6; id++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++)
+            out[id][eps][j] <== first[id][eps][j];
+    }else{
+        for(var id=0; id<6; id++)for(var eps=0; eps<2; eps++)for(var j=0; j<k; j++)
+            out[id][eps][j] <== mult[curid].out[id][eps][j];
+    }
+}
+
diff --git a/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/fp12_func.circom b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/fp12_func.circom
new file mode 100644
index 0000000..0585896
--- /dev/null
+++ b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/fp12_func.circom
@@ -0,0 +1,228 @@
+pragma circom 2.0.3;
+
+function find_Fp12_sum(n, k, a, b, p) {
+    var out[6][2][50];
+    for(var i=0; i<6; i++)
+        out[i] = find_Fp2_sum(n, k, a[i], b[i], p);
+    return out;
+}
+
+function find_Fp12_diff(n, k, a, b, p) {
+    var out[6][2][50];
+    for(var i=0; i<6; i++)
+        out[i] = find_Fp2_diff(n, k, a[i], b[i], p);
+    return out;
+}
+
+function find_Fp12_product(n, k, a, b, p) {
+    var l = 6;
+    var a0[l][50];
+    var a1[l][50];
+    var b0[l][50];
+    var b1[l][50];
+    var neg_b0[l][50];
+    var neg_b1[l][50];
+    var out[l][2][50];
+    for (var i = 0; i < l; i ++) { 
+        for ( var j = 0; j < k; j ++) {
+            a0[i][j] = a[i][0][j];
+            a1[i][j] = a[i][1][j];
+            b0[i][j] = b[i][0][j];
+            b1[i][j] = b[i][1][j];
+        }
+    }
+    for ( var i = 0; i < l; i ++) {
+        neg_b0[i] = long_sub(n, k, p, b0[i]);
+        neg_b1[i] = long_sub(n, k, p, b1[i]);
+    }
+
+    var real_init[20][50];
+    var imag_init[20][50];
+    var imag_init_neg[20][50];
+    // var real[l][2][50];
+    // var imag[l][2][50];
+    // each product will be 2l-1 x 2k
+    var a0b0_var[20][50] = prod2D(n, k, l, a0, b0);
+    var a1b1_neg[20][50] = prod2D(n, k, l, a1, neg_b1);
+    var a0b1_var[20][50] = prod2D(n, k, l, a0, b1);
+    var a1b0_var[20][50] = prod2D(n, k, l, a1, b0);
+    var a0b1_neg[20][50] = prod2D(n, k, l, a0, neg_b1);
+    var a1b0_neg[20][50] = prod2D(n, k, l, a1, neg_b0);
+    for (var i = 0; i < 2*l - 1; i ++) { // compute initial rep (deg w = 10)
+        real_init[i] = long_add(n, 2*k, a0b0_var[i], a1b1_neg[i]); // 2*k+1 registers each
+        imag_init[i] = long_add(n, 2*k, a0b1_var[i], a1b0_var[i]);
+        imag_init_neg[i] = long_add(n, 2*k, a0b1_neg[i], a1b0_neg[i]);
+    }
+    var real_carry[l][50];
+    var imag_carry[l][50];
+    var real_final[l][50];
+    var imag_final[l][50];
+    var zeros[50]; // to balance register sizes
+    for (var i = 0; i < 50; i ++) {
+        zeros[i] = 0;
+    }
+    for (var i = 0; i < l; i ++) {
+        if (i == l - 1) {
+            real_carry[i] = long_add(n, 2*k+1, zeros, zeros);
+            imag_carry[i] = long_add(n, 2*k+1, zeros, zeros);
+        } else {
+            real_carry[i] = long_add(n, 2*k+1, real_init[i+l], imag_init_neg[i+l]); // now 2*k+2 registers
+            imag_carry[i] = long_add(n, 2*k+1, imag_init[i+l], real_init[i+l]);
+        }
+    }
+    for (var i = 0; i < l; i ++) {
+        real_final[i] = long_add_unequal(n, 2*k+2, 2*k+1, real_carry[i], real_init[i]); // now 2*k+3 registers
+        imag_final[i] = long_add_unequal(n, 2*k+2, 2*k+1, imag_carry[i], imag_init[i]);
+    }
+    var XYreal_temp[l][2][50];
+    var XYimag_temp[l][2][50];
+    for (var i = 0; i < l; i ++) {
+        XYreal_temp[i] = long_div2(n, k, k+3, real_final[i], p); // k+4 register quotient, k register remainder
+        XYimag_temp[i] = long_div2(n, k, k+3, imag_final[i], p);
+    }
+    for (var i = 0; i < l; i ++) {
+        for (var j = 0; j < k; j ++) {
+            out[i][0][j] = XYreal_temp[i][1][j];
+            out[i][1][j] = XYimag_temp[i][1][j];
+        }
+    }
+    return out;
+}
+
+// a is 6 x 2 x k element of Fp^12
+// compute inverse. first multiply by conjugate a + bw (a,b in Fp^6, w^6=1+u, u^2=-1)
+// then reduce to inverting in Fp^6
+function find_Fp12_inverse(n, k, p, a) {
+    var A[6][2][50];
+    var B[6][2][50];
+    var Bw[6][2][50];
+    for (var i = 0; i < 3; i ++) {
+        for (var j = 0; j < 2; j ++) {
+            for (var m = 0; m < k; m ++) {
+                A[2*i+1][j][m] = 0;
+                B[2*i+1][j][m] = 0;
+                A[2*i][j][m] = a[2*i][j][m];
+                B[2*i][j][m] = a[2*i+1][j][m];
+                Bw[2*i][j][m] = 0;
+                Bw[2*i+1][j][m] = a[2*i+1][j][m];
+            }
+        }
+    }
+    var A2[6][2][50] = find_Fp12_product(n, k, A, A, p);
+    var B2[6][2][50] = find_Fp12_product(n, k, B, B, p);
+    var conj[6][2][50] = find_Fp12_diff(n, k, A, Bw, p);
+    var w2[6][2][50];
+    for (var i = 0; i < 6; i ++) {
+        for (var j = 0; j < 2; j ++) {
+            for (var m = 0; m < k; m ++) {
+                if (i == 2 && j == 0 && m == 0) {
+                    w2[i][j][m] = 1;
+                } else {
+                    w2[i][j][m] = 0;
+                }
+            }
+        }
+    }
+    var B2w2[6][2][50] = find_Fp12_product(n, k, B2, w2, p);
+    var conjProd[6][2][50] = find_Fp12_diff(n, k, A2, B2w2, p);
+    var a0[2][50];
+    var a1[2][50];
+    var a2[2][50];
+    for (var i = 0; i < 2; i ++) {
+        for (var m = 0; m < k; m ++) {
+            a0[i][m] = conjProd[0][i][m];
+            a1[i][m] = conjProd[2][i][m];
+            a2[i][m] = conjProd[4][i][m];
+        }
+    }
+    var conjProdInv[6][2][50] = find_Fp6_inverse(n, k, p, a0, a1, a2);
+    var out[6][2][50] = find_Fp12_product(n, k, conj, conjProdInv, p);
+    return out;
+}
+
+// compute the inverse of a0 + a1v + a2v^2 in Fp6, where 
+// v^3 = 1+u, u^2 = -1, a0 a1 a2 in Fp2 (2 x k)
+// returns an element in standard Fp12 representation (6 x 2 x k)
+function find_Fp6_inverse(n, k, p, a0, a1, a2) {
+    var out[6][2][50];
+
+    var a0_squared[2][50] = find_Fp2_product(n, k, a0, a0, p);
+    var a1_squared[2][50] = find_Fp2_product(n, k, a1, a1, p);
+    var a2_squared[2][50] = find_Fp2_product(n, k, a2, a2, p);
+    var a0a1[2][50] = find_Fp2_product(n, k, a0, a1, p);
+    var a0a2[2][50] = find_Fp2_product(n, k, a0, a2, p);
+    var a1a2[2][50] = find_Fp2_product(n, k, a1, a2, p);
+    var a0a1a2[2][50] = find_Fp2_product(n, k, a0a1, a2, p);
+
+    var v3[2][50]; // v^3 = 1 + u
+    for (var i = 0; i < 2; i ++) {
+        for (var j = 0; j < k; j ++) {
+            if (j == 0) {
+                v3[i][j] = 1;
+            } else {
+                v3[i][j] = 0;
+            }
+        }
+    }
+
+    var three_v3[2][50]; // 3v^3 = 3 + 3u
+    for (var i = 0; i < 2; i ++) {
+        for (var j = 0; j < k; j ++) {
+            if (j == 0) {
+                three_v3[i][j] = 3;
+            } else {
+                three_v3[i][j] = 0;
+            }
+        }
+    }
+
+    var v6[2][50]; // v^6 = 2u
+    for (var i = 0; i < 2; i ++) {
+        for (var j = 0; j < k; j ++) {
+            if (i == 1 && j == 0) {
+                v6[i][j] = 2;
+            } else {
+                v6[i][j] = 0;
+            }
+        }
+    }
+
+    var v0_1[2][50] = find_Fp2_product(n, k, a1a2, v3, p);
+    var v0_temp[2][50] = find_Fp2_diff(n, k, a0_squared, v0_1, p); // a0^2 - a1a2v^3
+    var v1_1[2][50] = find_Fp2_product(n, k, a2_squared, v3, p);
+    var v1_temp[2][50] = find_Fp2_diff(n, k, v1_1, a0a1, p); // v^3a2^2 - a0a1
+    var v2_temp[2][50] = find_Fp2_diff(n, k, a1_squared, a0a2, p); // a1^2 - a0a2
+
+    var a0_cubed[2][50] = find_Fp2_product(n, k, a0, a0_squared, p);
+    var a1_cubed[2][50] = find_Fp2_product(n, k, a1, a1_squared, p);
+    var a2_cubed[2][50] = find_Fp2_product(n, k, a2, a2_squared, p);
+    var a13v3[2][50] = find_Fp2_product(n, k, a1_cubed, v3, p);
+    var a23v6[2][50] = find_Fp2_product(n, k, a2_cubed, v6, p);
+    var a0a1a23v3[2][50] = find_Fp2_product(n, k, a0a1a2, three_v3, p);
+
+    var denom_1[2][50] = find_Fp2_sum(n, k, a0_cubed, a13v3, p);
+    var denom_2[2][50] = find_Fp2_diff(n, k, a23v6, a0a1a23v3, p);
+    var denom[2][50] = find_Fp2_sum(n, k, denom_1, denom_2, p); // a0^3 + a1^3v^3 + a2^3v^6 - 3a0a1a2v^3
+
+    var denom_inv[2][50] = find_Fp2_inverse(n, k, denom, p);
+
+    var v0_final[2][50] = find_Fp2_product(n, k, v0_temp, denom_inv, p);
+    var v1_final[2][50] = find_Fp2_product(n, k, v1_temp, denom_inv, p);
+    var v2_final[2][50] = find_Fp2_product(n, k, v2_temp, denom_inv, p);
+
+    for (var i = 1; i < 6; i = i + 2) {
+        for (var j = 0; j < 2; j ++) {
+            for (var m = 0; m < 50; m ++) {
+                if (i > 1)
+                out[i][j][m] = 0;
+                else 
+                out[i][j][m] = 0;//v3[j][m];
+            }
+        }
+    }
+    out[0] = v0_final;
+    out[2] = v1_final;
+    out[4] = v2_final;
+    return out;
+}
+
diff --git a/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/fp2.circom b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/fp2.circom
new file mode 100644
index 0000000..797acc2
--- /dev/null
+++ b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/fp2.circom
@@ -0,0 +1,540 @@
+pragma circom 2.0.3;
+
+include "bigint.circom";
+include "bigint_func.circom";
+include "field_elements_func.circom";
+include "fp.circom";
+
+// add two elements in Fp2
+template Fp2Add(n, k, p) {
+    signal input a[2][k];
+    signal input b[2][k];
+    signal output out[2][k];
+
+    component adders[2];
+    for (var i = 0; i < 2; i++) {
+        adders[i] = FpAdd(n, k, p);
+        for (var j = 0; j < k; j++) {
+            adders[i].a[j] <== a[i][j];
+            adders[i].b[j] <== b[i][j];
+        }   
+        for (var j = 0; j < k; j ++) {
+            out[i][j] <== adders[i].out[j];
+        }
+    }
+}
+
+
+/*
+p has k registers 
+Inputs: 
+    - a[2][ka] allow signed overflow
+    - b[2][kb] 
+Outputs:
+    - out[2][ka+kb-1] such that 
+        (a0 + a1 u)*(b0 + b1 u) = out[0] + out[1] u  
+Notes:
+    - if each a[i][j], b[i][j] has abs value < B then out[i][j] has abs val < 2*k*B^2 
+    - out[i] has ka+kb-1 registers since that's output of BigMultShortLong
+m_out is the expected max number of bits in the output registers
+*/
+template SignedFp2MultiplyNoCarryUnequal(n, ka, kb, m_out){
+    signal input a[2][ka];
+    signal input b[2][kb];
+    signal output out[2][ka+kb-1];
+
+    component ab[2][2];
+    for(var i=0; i<2; i++)for(var j=0; j<2; j++){
+        ab[i][j] = BigMultShortLongUnequal(n, ka, kb, m_out); // output has ka+kb-1 registers
+        for(var l=0; l<ka; l++)
+            ab[i][j].a[l] <== a[i][l];
+        for(var l=0; l<kb; l++)
+            ab[i][j].b[l] <== b[j][l];
+    }
+    
+    for(var j=0; j<ka+kb-1; j++){
+        out[0][j] <== ab[0][0].out[j] - ab[1][1].out[j];
+        out[1][j] <== ab[0][1].out[j] + ab[1][0].out[j];
+    }
+}
+
+template SignedFp2MultiplyNoCarry(n, k, m_out){
+    signal input a[2][k];
+    signal input b[2][k];
+    signal output out[2][2*k-1];
+
+    component mult = SignedFp2MultiplyNoCarryUnequal(n, k, k, m_out);
+    for(var i=0; i<2; i++)for(var j=0; j<k; j++){
+        mult.a[i][j] <== a[i][j];
+        mult.b[i][j] <== b[i][j];
+    }
+    for(var i=0; i<2; i++)for(var j=0; j<2*k-1; j++)
+        out[i][j] <== mult.out[i][j];
+}
+
+// input is 2 x (k+m) with registers in (-B,B)
+//  in[0] + in[1] u
+// output is congruent to input (mod p) and represented as 2 x k where registers have abs val < (m+1)*2^n*B
+// m_out is the expected max number of bits in the output registers
+template Fp2Compress(n, k, m, p, m_out){
+    signal input in[2][k+m]; 
+    signal output out[2][k];
+    
+    component c[2];
+    for(var i=0; i<2; i++){
+        c[i] = PrimeReduce(n, k, m, p, m_out);
+        for(var j=0; j<k+m; j++)
+            c[i].in[j] <== in[i][j]; 
+    }
+    for(var i=0; i<2; i++)for(var j=0; j<k; j++)
+        out[i][j] <== c[i].out[j];
+}
+// same input as above
+// outputs:
+//  out[2][k] such that 
+//      out[i] has k registers because we use the "prime trick" to compress from 2*k-1 to k registers 
+//      if each a[i][j] is in (-B, B) then out[i][j] has abs val < 2k^2 * 2^n*B^2 
+//          2k*B^2 from SignedFp2MultiplyNoCarry
+//          *k*2^n from prime trick
+// m_in is the expected max number of bits in the input registers (necessary for some intermediate overflow validation)
+// m_out is the expected max number of bits in the output registers
+template SignedFp2MultiplyNoCarryCompress(n, k, p, m_in, m_out){
+    signal input a[2][k];
+    signal input b[2][k];
+    signal output out[2][k];
+    
+    var LOGK1 = log_ceil(2*k);
+    component ab = SignedFp2MultiplyNoCarry(n, k, 2*m_in + LOGK1);
+    for(var i=0; i<2; i++)for(var idx=0; idx<k; idx++){
+        ab.a[i][idx] <== a[i][idx];
+        ab.b[i][idx] <== b[i][idx]; 
+    }
+    
+    var LOGK2 = log_ceil(2*k*k);
+    component compress = Fp2Compress(n, k, k-1, p, 2*m_in + n + LOGK2);
+    for(var i=0; i<2; i++)for(var j=0; j<2*k-1; j++)
+        compress.in[i][j] <== ab.out[i][j]; 
+ 
+    for(var i=0; i<2; i++)for(var j=0; j<k; j++)
+        out[i][j] <== compress.out[i][j];
+}
+
+
+template SignedFp2MultiplyNoCarryCompressThree(n, k, p, m_in, m_out){
+    signal input a[2][k];
+    signal input b[2][k];
+    signal input c[2][k];
+    signal output out[2][k];
+    
+    var LOGK = log_ceil(k);
+    component ab = SignedFp2MultiplyNoCarry(n, k, 2*m_in + LOGK + 1);
+    for(var i=0; i<2; i++)for(var idx=0; idx<k; idx++){
+        ab.a[i][idx] <== a[i][idx];
+        ab.b[i][idx] <== b[i][idx]; 
+    }
+    
+    component abc = SignedFp2MultiplyNoCarryUnequal(n, 2*k-1, k, 3*m_in + 2*LOGK + 2);
+    for(var i=0; i<2; i++){
+        for(var idx=0; idx<2*k-1; idx++)
+            abc.a[i][idx] <== ab.out[i][idx];
+        for(var idx=0; idx<k; idx++)
+            abc.b[i][idx] <== c[i][idx];
+    }
+    
+    component compress = Fp2Compress(n, k, 2*k-2, p, 3*m_in + n + 3*LOGK + 3);
+    for(var i=0; i<2; i++)for(var j=0; j<3*k-2; j++)
+        compress.in[i][j] <== abc.out[i][j]; 
+ 
+    for(var i=0; i<2; i++)for(var j=0; j<k; j++)
+        out[i][j] <== compress.out[i][j];
+}
+
+// check if in[0], in[1] both have k registers in [0,2^n)
+// to save constraints, DO NOT CONSTRAIN in[i] < p
+template RangeCheck2D(n, k){
+    signal input in[2][k];
+    component range_checks[2][k];
+    //component lt[2];
+    
+    for(var eps=0; eps<2; eps++){
+        //lt[eps] = BigLessThan(n, k);
+        for(var i=0; i<k; i++){
+            range_checks[eps][i] = Num2Bits(n);
+            range_checks[eps][i].in <== in[eps][i];
+            //lt[eps].a[i] <== in[eps][i];
+            //lt[eps].b[i] <== p[i];
+        }
+        //lt[eps].out === 1;
+    }
+}
+
+// solve for in = p * X + out
+// X has registers lying in [-2^n, 2^n) 
+// X has at most Ceil( overflow / n ) registers 
+// assume in has registers in (-2^overflow, 2^overflow) 
+template SignedFp2CarryModP(n, k, overflow, p){
+    signal input in[2][k]; 
+    var m = (overflow + n - 1) \ n; 
+    signal output X[2][m];
+    signal output out[2][k];
+
+    assert( overflow < 251 );
+
+    component carry[2];
+    for(var i=0; i<2; i++){
+        carry[i] = SignedFpCarryModP(n, k, overflow, p);
+        for(var idx=0; idx<k; idx++)
+            carry[i].in[idx] <== in[i][idx];
+        for(var idx=0; idx<m; idx++)
+            X[i][idx] <== carry[i].X[idx];
+        for(var idx=0; idx<k; idx++)
+            out[i][idx] <== carry[i].out[idx];
+    }
+}
+
+// input is 2 x (k+m) with registers in (-2^overflow, 2^overflow)
+//  in[0] + in[1] u
+// calls Fp2Compress and SignedFp2CarryModP
+template SignedFp2CompressCarry(n, k, m, overflow, p){
+    signal input in[2][k+m]; 
+    signal output out[2][k];
+    
+    var LOGM = log_ceil(m+1);
+    component compress = Fp2Compress(n, k, m, p, overflow + n + LOGM); 
+    for(var i=0; i<2; i++)for(var idx=0; idx<k+m; idx++)
+        compress.in[i][idx] <== in[i][idx];
+    
+    component carry = SignedFp2CarryModP(n, k, overflow + n + LOGM, p);
+    for(var i=0; i<2; i++)for(var idx=0; idx<k; idx++)
+        carry.in[i][idx] <== compress.out[i][idx];
+
+    for(var i=0; i<2; i++)for(var idx=0; idx<k; idx++)
+        out[i][idx] <== carry.out[i][idx];
+}
+
+// outputs a*b in Fp2 
+// (a0 + a1 u)*(b0 + b1 u) = (a0*b0 - a1*b1) + (a0*b1 + a1*b0)u 
+// out[i] has k registers each in [0, 2^n)
+// out[i] in [0, p)
+template Fp2Multiply(n, k, p){
+    signal input a[2][k];
+    signal input b[2][k];
+    signal output out[2][k];
+
+    var LOGK2 = log_ceil(2*k*k);
+    assert(3*n + LOGK2 < 251);
+
+    component c = SignedFp2MultiplyNoCarryCompress(n, k, p, n, 3*n + LOGK2); 
+    for(var i=0; i<k; i++){
+        c.a[0][i] <== a[0][i];
+        c.a[1][i] <== a[1][i];
+        c.b[0][i] <== b[0][i];
+        c.b[1][i] <== b[1][i];
+    }
+    
+    component carry_mod = SignedFp2CarryModP(n, k, 3*n + LOGK2, p); 
+    for(var i=0; i<2; i++)for(var j=0; j<k; j++)
+        carry_mod.in[i][j] <== c.out[i][j]; 
+    
+    for(var i=0; i<2; i++)for(var j=0; j<k; j++)
+        out[i][j] <== carry_mod.out[i][j]; 
+}
+
+
+template Fp2MultiplyThree(n, k, p){
+    signal input a[2][k];
+    signal input b[2][k];
+    signal input c[2][k];
+    signal output out[2][k];
+
+    var LOGK3 = log_ceil(4*k*k*(2*k-1));
+    assert(4*n + LOGK3 < 251);
+
+    component compress = SignedFp2MultiplyNoCarryCompressThree(n, k, p, n, 4*n + LOGK3); 
+    for(var i=0; i<2; i++)for(var idx=0; idx<k; idx++){
+        compress.a[i][idx] <== a[i][idx];
+        compress.b[i][idx] <== b[i][idx];
+        compress.c[i][idx] <== c[i][idx];
+    }
+    
+    component carry_mod = SignedFp2CarryModP(n, k, 4*n + LOGK3, p); 
+    for(var i=0; i<2; i++)for(var j=0; j<k; j++)
+        carry_mod.in[i][j] <== compress.out[i][j]; 
+    
+    for(var i=0; i<2; i++)for(var j=0; j<k; j++)
+        out[i][j] <== carry_mod.out[i][j]; 
+}
+
+
+// input: in[0] + in[1] u
+// output: (p-in[0]) + (p-in[1]) u
+// assume 0 <= in < p
+template Fp2Negate(n, k, p){
+    signal input in[2][k]; 
+    signal output out[2][k];
+    
+    component neg[2];
+    for(var j=0; j<2; j++){
+        neg[j] = FpNegate(n, k, p);
+        for(var i=0; i<k; i++)
+            neg[j].in[i] <== in[j][i];
+        for(var i=0; i<k; i++)
+            out[j][i] <== neg[j].out[i];
+    }
+}
+
+// input: a0 + a1 u, b0 + b1 u
+// output: (a0-b0) + (a1-b1)u
+template Fp2Subtract(n, k, p){
+    signal input a[2][k];
+    signal input b[2][k];
+    signal output out[2][k];
+    
+    component sub0 = FpSubtract(n, k, p);
+    component sub1 = FpSubtract(n, k, p);
+    for(var i=0; i<k; i++){
+        sub0.a[i] <== a[0][i];
+        sub0.b[i] <== b[0][i];
+        sub1.a[i] <== a[1][i];
+        sub1.b[i] <== b[1][i];
+    }
+    for(var i=0; i<k; i++){
+        out[0][i] <== sub0.out[i];
+        out[1][i] <== sub1.out[i];
+    }
+}
+
+// Call find_Fp2_inverse to compute inverse
+// Then check out * in = 1, out is an array of shorts
+template Fp2Invert(n, k, p){
+    signal input in[2][k];
+    signal output out[2][k];
+
+    var inverse[2][50] = find_Fp2_inverse(n, k, in, p); // 2 x 50, only 2 x k relevant
+    for (var i = 0; i < 2; i ++) {
+        for (var j = 0; j < k; j ++) {
+            out[i][j] <-- inverse[i][j];
+        }
+    }
+
+    //range checks
+    component outRangeChecks[2][k];
+    for(var i=0; i<2; i++) for(var j=0; j<k; j++){
+        outRangeChecks[i][j] = Num2Bits(n);
+        outRangeChecks[i][j].in <== out[i][j];
+    }
+
+    component in_out = Fp2Multiply(n, k, p);
+    for(var i=0; i<2; i++)for(var j=0; j<k; j++){
+        in_out.a[i][j] <== in[i][j];
+        in_out.b[i][j] <== out[i][j];
+    }
+
+    for(var i=0; i<2; i++)for(var j=0; j<k; j++){
+        if(i == 0 && j == 0)
+            in_out.out[i][j] === 1;
+        else
+            in_out.out[i][j] === 0;
+    }
+}
+
+// a, b are two elements of Fp2 where we use the 2 x k format 
+// solve for out * b - a = p * X 
+// assume X has at most m registers, lying in [-2^{n+1}, 2^{n+1} )   NOTE n+1 not n DIFFERENT FROM Fp2CarryModP
+// out has registers in [0, 2^n) 
+template SignedFp2Divide(n, k, overflowa, overflowb, p){
+    signal input a[2][k];
+    signal input b[2][k]; 
+    signal output out[2][k]; 
+     
+    var ma = overflowa \ n; 
+    var mb = overflowb \ n;
+    // first precompute a, b mod p as shorts 
+    var a_mod[2][50]; 
+    var b_mod[2][50]; 
+    for(var eps=0; eps<2; eps++){
+        // 2^{overflow} <= 2^{n*ceil(overflow/n)} 
+        var temp[2][50] = get_signed_Fp_carry_witness(n, k, ma, a[eps], p);
+        a_mod[eps] = temp[1];
+        temp = get_signed_Fp_carry_witness(n, k, mb, b[eps], p);
+        b_mod[eps] = temp[1];
+    }
+
+    // precompute 1/b 
+    var b_inv[2][50] = find_Fp2_inverse(n, k, b_mod, p);
+    // precompute a/b
+    var out_var[2][50] = find_Fp2_product(n, k, a_mod, b_inv, p);
+
+    for(var eps=0; eps<2; eps++)for(var i=0; i<k; i++)
+        out[eps][i] <-- out_var[eps][i]; 
+    
+    component check = RangeCheck2D(n, k);
+    for(var eps=0; eps<2; eps++)for(var i=0; i<k; i++)
+        check.in[eps][i] <== out[eps][i];
+    
+    // constraint is out * b = a + p * X 
+    // precompute out * b = p * X' + Y' and a = p * X'' + Y''
+    //            should have Y' = Y'' so X = X' - X''
+    
+    var LOGK2 = log_ceil(2*k*k);
+    // out * b, registers overflow in 2*k*k * 2^{2n + overflowb}
+    component mult = SignedFp2MultiplyNoCarryCompress(n, k, p, max(n, overflowb), 2*n + overflowb + LOGK2); 
+    for(var eps=0; eps<2; eps++)for(var i=0; i<k; i++){
+        mult.a[eps][i] <== out[eps][i]; 
+        mult.b[eps][i] <== b[eps][i]; 
+    }
+    
+    var m = max( mb + k, ma );
+    // get mult = out * b = p*X' + Y'
+    var XY[2][2][50] = get_signed_Fp2_carry_witness(n, k, m, mult.out, p); // total value is < 2^{nk} * 2^{n*k + overflowb - n + 1}
+    // get a = p*X' + Y'
+    var XY1[2][2][50] = get_signed_Fp2_carry_witness(n, k, m, a, p); // same as above, m extra registers enough
+
+    signal X[2][m];
+    component X_range_checks[2][m];
+    for(var eps=0; eps<2; eps++){    
+        for(var i=0; i<m; i++){
+            // X'' = X-X'
+            X[eps][i] <-- XY[eps][0][i] - XY1[eps][0][i]; // each XY[eps][0] is in [-2^n, 2^n) so difference is in [-2^{n+1}, 2^{n+1})
+            X_range_checks[eps][i] = Num2Bits(n+2);
+            X_range_checks[eps][i].in <== X[eps][i] + (1<<(n+1)); // X[eps][i] should be between [-2^{n+1}, 2^{n+1})
+        }
+    }
+    
+    var overflow = max(2*n + overflowb + LOGK2, overflowa);
+    // finally constrain out * b - a = p * X 
+    // out * b - a has overflow in (-2^{overflow+1}, 2^{overflow +1}) 
+    component mod_check[2];  
+    for(var eps=0; eps<2; eps++){
+        mod_check[eps] = CheckCarryModP(n, k, m, overflow + 1, p);
+        for(var i=0; i<k; i++){
+            mod_check[eps].in[i] <== mult.out[eps][i] - a[eps][i];
+            mod_check[eps].Y[i] <== 0;
+        }
+        for(var i=0; i<m; i++)
+            mod_check[eps].X[i] <== X[eps][i];
+    }
+}
+
+
+// input: a+b u
+// output: a-b u 
+// IF p = 3 mod 4 THEN a - b u = (a+b u)^p <-- Frobenius map 
+// aka Fp2FrobeniusMap(n, k)
+template Fp2Conjugate(n, k, p){
+    signal input in[2][k]; 
+    signal output out[2][k];
+    
+    component neg1 = FpNegate(n, k, p);
+    for(var i=0; i<k; i++){
+        neg1.in[i] <== in[1][i];
+    }
+    for(var i=0; i<k; i++){
+        out[0][i] <== in[0][i];
+        out[1][i] <== neg1.out[i];
+    }
+}
+
+// raises to q^power-th power 
+template Fp2FrobeniusMap(n, k, power, p){
+    signal input in[2][k];
+    signal output out[2][k];
+    
+    var pow = power % 2;
+    component neg1 = FpNegate(n,k,p);
+    if(pow == 0){
+        for(var i=0; i<k; i++){
+            out[0][i] <== in[0][i];
+            out[1][i] <== in[1][i];
+        }
+    }else{
+        for(var i=0; i<k; i++){
+            neg1.in[i] <== in[1][i];
+        }
+        for(var i=0; i<k; i++){
+            out[0][i] <== in[0][i];
+            out[1][i] <== neg1.out[i];
+        }
+    }
+}
+
+// in = in0 + in1 * u, elt of Fp2
+// https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-hash-to-curve-11#section-4.1
+// NOTE: different from Wahby-Boneh paper https://eprint.iacr.org/2019/403.pdf and python reference code: https://github.com/algorand/bls_sigs_ref/blob/master/python-impl/opt_swu_g2.py
+template Fp2Sgn0(n, k, p){
+    signal input in[2][k];
+    signal output out;
+
+    component sgn[2];
+    for(var i=0; i<2; i++){
+        sgn[i] = FpSgn0(n, k, p);
+        for(var idx=0; idx<k; idx++)
+            sgn[i].in[idx] <== in[i][idx];
+    }
+    component isZero = BigIsZero(k);
+    for(var idx=0; idx<k; idx++)
+        isZero.in[idx] <== in[0][idx];
+    
+    signal sgn1; // (in0 == 0) && (sgn[1])
+    sgn1 <== isZero.out * sgn[1].out; 
+    out <== sgn[0].out + sgn1 - sgn[0].out * sgn1; // sgn[0] || ( (in0 == 0 && sgn[1]) )
+}
+
+template Fp2IsZero(n, k, p){
+    signal input in[2][k];
+    signal output out;
+
+    // check that in[i] < p 
+    component lt[2];
+    
+    component isZeros[2][k];
+    var total = 2*k;
+    for(var j=0; j<2; j++){
+        lt[j] = BigLessThan(n, k);
+        for(var i = 0; i < k; i++) {
+            lt[j].a[i] <== in[j][i];
+            lt[j].b[i] <== p[i];
+
+            isZeros[j][i] = IsZero();
+            isZeros[j][i].in <== in[j][i];
+            total -= isZeros[j][i].out;
+        }
+        lt[j].out === 1;
+    }
+    component checkZero = IsZero();
+    checkZero.in <== total;
+    out <== checkZero.out;
+}
+
+template Fp2IsEqual(n, k, p){
+    signal input a[2][k];
+    signal input b[2][k];
+    signal output out;
+
+    // check that a[i], b[i] < p 
+    component lta[2];
+    component ltb[2];
+    component isEquals[2][k];
+    var total = 2*k;
+    for(var j=0; j<2; j++){
+        lta[j] = BigLessThan(n, k);
+        ltb[j] = BigLessThan(n, k);
+        for (var i = 0; i < k; i ++) {
+            lta[j].a[i] <== a[j][i]; 
+            lta[j].b[i] <== p[i]; 
+
+            ltb[j].a[i] <== b[j][i]; 
+            ltb[j].b[i] <== p[i]; 
+
+            isEquals[j][i] = IsEqual();
+            isEquals[j][i].in[0] <== a[j][i];
+            isEquals[j][i].in[1] <== b[j][i];
+            total -= isEquals[j][i].out;
+        }
+        lta[j].out === 1;
+        ltb[j].out === 1;
+    }
+    component checkZero = IsZero();
+    checkZero.in <== total;
+    out <== checkZero.out;
+}
diff --git a/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/pairing.circom b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/pairing.circom
new file mode 100644
index 0000000..ed48605
--- /dev/null
+++ b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/circuits/pairing.circom
@@ -0,0 +1,1215 @@
+pragma circom 2.0.3;
+
+include "curve.circom";
+include "curve_fp2.circom";
+include "fp12.circom";
+include "final_exp.circom";
+include "bls12_381_func.circom";
+
+// Inputs:
+//  P is 2 x 2 x k array where P0 = (x_1, y_1) and P1 = (x_2, y_2) are points in E(Fp)
+//  Q is 2 x 6 x 2 x k array representing point (X, Y) in E(Fp12)
+// Assuming (x_1, y_1) != (x_2, y_2)
+// Output:
+//  out is 6 x 2 x (2k-1) array representing element of Fp12 equal to:
+//  (y_1 - y_2) X + (x_2 - x_1) Y + (x_1 y_2 - x_2 y_1)
+// We evaluate out without carries
+// If all registers of P, Q are in [0, 2^n),
+// Then all registers of out have abs val < 3k * 2^{2n} )
+// m_out is the expected max number of bits in the output registers
+template SignedLineFunctionUnequalNoCarry(n, k, m_out){
+    signal input P[2][2][k];
+    signal input Q[2][6][2][k];
+    signal output out[6][2][2*k-1];
+
+    // (y_1 - y_2) X
+    var LOGK = log_ceil(k);
+    component Xmult = SignedFp12ScalarMultiplyNoCarry(n, k, 2*n + LOGK); // registers in [0, k*2^{2n} )
+    // (x_2 - x_1) Y
+    component Ymult = SignedFp12ScalarMultiplyNoCarry(n, k, 2*n + LOGK);
+    for(var i=0; i<k; i++){
+        Xmult.a[i] <== P[0][1][i] - P[1][1][i];
+        
+        Ymult.a[i] <== P[1][0][i] - P[0][0][i];
+    }
+    for(var i=0; i<6; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+        Xmult.b[i][j][idx] <== Q[0][i][j][idx];
+
+        Ymult.b[i][j][idx] <== Q[1][i][j][idx]; 
+    } 
+    
+    component x1y2 = BigMultShortLong(n, k, 2*n + LOGK); // registers in [0, k*2^{2n}) 
+    component x2y1 = BigMultShortLong(n, k, 2*n + LOGK);
+    for(var i=0; i<k; i++){
+        x1y2.a[i] <== P[0][0][i]; 
+        x1y2.b[i] <== P[1][1][i];
+        
+        x2y1.a[i] <== P[1][0][i]; 
+        x2y1.b[i] <== P[0][1][i];
+    }
+    
+    for(var i=0; i<6; i++)for(var j=0; j<2; j++)for(var idx=0; idx<2*k-1; idx++){
+        if( i==0 && j==0 ){
+            out[i][j][idx] <== Xmult.out[i][j][idx] + Ymult.out[i][j][idx] + x1y2.out[idx] - x2y1.out[idx]; // register < 3k*2^{2n} 
+        }else 
+            out[i][j][idx] <== Xmult.out[i][j][idx] + Ymult.out[i][j][idx]; // register in [0, 2k*2^{2n} )
+    }
+}
+
+// Assuming curve is of form Y^2 = X^3 + b for now (a = 0) for better register bounds 
+// Inputs:
+//  P is 2 x k array where P = (x, y) is a point in E(Fp) 
+//  Q is 2 x 6 x 2 x k array representing point (X, Y) in E(Fp12) 
+// Output: 
+//  out is 6 x 2 x (3k-2) array representing element of Fp12 equal to:
+//  3 x^2 (-X + x) + 2 y (Y - y)
+// We evaluate out without carries, with signs
+// If P, Q have registers in [0, B) 
+// Then out has registers with abs val < 3k^2*B^3 + 2k*B^2 < (3k^2 + 2k/B)*B^3)
+// m_out is the expected max number of bits in the output registers
+template SignedLineFunctionEqualNoCarry(n, k, m_out){
+    signal input P[2][k]; 
+    signal input Q[2][6][2][k];
+    signal output out[6][2][3*k-2];
+    var LOGK = log_ceil(k);
+
+    component x_sq3 = BigMultShortLong(n, k, 2*n + 2 + LOGK); // 2k-1 registers in [0, 3*k*2^{2n} )
+    for(var i=0; i<k; i++){
+        x_sq3.a[i] <== 3*P[0][i];
+        x_sq3.b[i] <== P[0][i];
+    } 
+    
+    // 3 x^2 (-X + x)
+    component Xmult = SignedFp12ScalarMultiplyNoCarryUnequal(n, 2*k-1, k, 3*n + 2*LOGK + 2); // 3k-2 registers < 3 * k^2 * 2^{3n})
+    for(var idx=0; idx<2*k-1; idx++){
+        Xmult.a[idx] <== x_sq3.out[idx];
+    }
+    for(var i=0; i<6; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+        if(i==0 && j==0)
+            Xmult.b[i][j][idx] <== P[0][idx] - Q[0][i][j][idx];
+        else
+            Xmult.b[i][j][idx] <== -Q[0][i][j][idx];
+    }
+
+    // 2 y (Y-y)
+    component Ymult = SignedFp12ScalarMultiplyNoCarry(n, k, 2*n + LOGK + 1); // 2k-1 registers < 2k*2^{2n} 
+    for(var idx=0; idx < k; idx++){
+        Ymult.a[idx] <== 2*P[1][idx];
+    }
+    for(var i=0; i<6; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+        if(i==0 && j==0)
+            Ymult.b[i][j][idx] <== Q[1][i][j][idx] - P[1][idx];
+        else
+            Ymult.b[i][j][idx] <== Q[1][i][j][idx];
+    }
+    
+    for(var i=0; i<6; i++)for(var j=0; j<2; j++)for(var idx=0; idx<3*k-2; idx++){
+        if(idx < 2*k-1)
+            out[i][j][idx] <== Xmult.out[i][j][idx] + Ymult.out[i][j][idx];
+        else
+            out[i][j][idx] <== Xmult.out[i][j][idx];
+    }
+}
+
+// Inputs:
+//  P is 2 x 2 x k array where P0 = (x_1, y_1) and P1 = (x_2, y_2) are points in E(Fp)
+//  Q is 2 x 6 x 2 x k array representing point (X, Y) in E(Fp12)
+// Assuming (x_1, y_1) != (x_2, y_2)
+// Output:
+//  Q is 6 x 2 x k array representing element of Fp12 equal to:
+//  (y_1 - y_2) X + (x_2 - x_1) Y + (x_1 y_2 - x_2 y_1)
+template LineFunctionUnequal(n, k, q) {
+    signal input P[2][2][k];
+    signal input Q[2][6][2][k];
+
+    signal output out[6][2][k];
+    var LOGK1 = log_ceil(3*k);
+    var LOGK2 = log_ceil(3*k*k);
+
+    component nocarry = SignedLineFunctionUnequalNoCarry(n, k, 2 * n + LOGK1);
+    for (var i = 0; i < 2; i++)for(var j = 0; j < 2; j++) {
+	    for (var idx = 0; idx < k; idx++) {
+            nocarry.P[i][j][idx] <== P[i][j][idx];
+	    }
+    }
+
+    for (var i = 0; i < 2; i++)for(var j = 0; j < 6; j++) {
+	    for (var l = 0; l < 2; l++) {
+		for (var idx = 0; idx < k; idx++) {
+		    nocarry.Q[i][j][l][idx] <== Q[i][j][l][idx];
+		}
+	    }
+    }
+    component reduce[6][2];
+    for (var i = 0; i < 6; i++) {
+        for (var j = 0; j < 2; j++) {
+            reduce[i][j] = PrimeReduce(n, k, k - 1, q, 3 * n + LOGK2);
+        }
+
+        for (var j = 0; j < 2; j++) {
+            for (var idx = 0; idx < 2 * k - 1; idx++) {
+                reduce[i][j].in[idx] <== nocarry.out[i][j][idx];
+            }
+        }	
+    }
+
+    // max overflow register size is 3 * k^2 * 2^{3n}
+    component carry = SignedFp12CarryModP(n, k, 3 * n + LOGK2, q);
+    for (var i = 0; i < 6; i++) {
+        for (var j = 0; j < 2; j++) {
+            for (var idx = 0; idx < k; idx++) {
+                carry.in[i][j][idx] <== reduce[i][j].out[idx];
+            }
+        }
+    }
+    
+    for (var i = 0; i < 6; i++) {
+        for (var j = 0; j < 2; j++) {
+            for (var idx = 0; idx < k; idx++) {
+            out[i][j][idx] <== carry.out[i][j][idx];
+            }
+        }
+    }    
+}
+
+
+// Assuming curve is of form Y^2 = X^3 + b for now (a = 0) for better register bounds 
+// Inputs:
+//  P is 2 x k array where P = (x, y) is a point in E(Fp) 
+//  Q is 2 x 6 x 2 x k array representing point (X, Y) in E(Fp12) 
+// Output: 
+//  out is 6 x 2 x k array representing element of Fp12 equal to:
+//  3 x^2 (-X + x) + 2 y (Y - y)
+template LineFunctionEqual(n, k, q) {
+    signal input P[2][k];
+    signal input Q[2][6][2][k];
+
+    signal output out[6][2][k];
+
+    var LOGK2 = log_ceil((3*k+1)*k);
+    component nocarry = SignedLineFunctionEqualNoCarry(n, k, 3*n + LOGK2);
+    for (var i = 0; i < 2; i++) {
+        for (var idx = 0; idx < k; idx++) {
+            nocarry.P[i][idx] <== P[i][idx];
+        }
+    }
+
+    for (var i = 0; i < 2; i++) {
+        for (var j = 0; j < 6; j++) {
+            for (var l = 0; l < 2; l++) {
+                for (var idx = 0; idx < k; idx++) {
+                    nocarry.Q[i][j][l][idx] <== Q[i][j][l][idx];
+                }
+            }
+        }
+    }
+    
+    var LOGK3 = log_ceil((2*k-1)*(3*k*k) + 1);
+    component reduce[6][4]; 
+    for (var i = 0; i < 6; i++) {
+        for (var j = 0; j < 2; j++) {
+            reduce[i][j] = PrimeReduce(n, k, 2 * k - 2, q, 4 * n + LOGK3);
+        }
+
+        for (var j = 0; j < 2; j++) {
+            for (var idx = 0; idx < 3 * k - 2; idx++) {
+                reduce[i][j].in[idx] <== nocarry.out[i][j][idx];
+            }
+        }	
+    }
+
+    // max overflow register size is (2k - 1) * (3k^2+1) * 2^{4n} assuming 2k<=2^n
+    component carry = SignedFp12CarryModP(n, k, 4 * n + LOGK3, q);
+    for (var i = 0; i < 6; i++) {
+        for (var j = 0; j < 2; j++) {
+            for (var idx = 0; idx < k; idx++) {
+                carry.in[i][j][idx] <== reduce[i][j].out[idx];
+            }
+        }
+    }
+    
+    for (var i = 0; i < 6; i++) {
+        for (var j = 0; j < 2; j++) {
+            for (var idx = 0; idx < k; idx++) {
+            out[i][j][idx] <== carry.out[i][j][idx];
+            }
+        }
+    }    
+}
+
+
+// Input:
+//  g is 6 x 2 x kg array representing element of Fp12, allowing overflow and negative
+//  P0, P1, Q are as in inputs of SignedLineFunctionUnequalNoCarry
+// Assume:
+//  all registers of g are in [0, 2^{overflowg}) 
+//  all registers of P, Q are in [0, 2^n) 
+// Output:
+//  out = g * l_{P0, P1}(Q) as element of Fp12 with carry 
+//  out is 6 x 2 x k
+template Fp12MultiplyWithLineUnequal(n, k, kg, overflowg, q){
+    signal input g[6][2][kg];
+    signal input P[2][2][k];
+    signal input Q[2][6][2][k];
+    signal output out[6][2][k];
+
+    var XI0 = 1;
+    var LOGK1 = log_ceil(6*k);
+    var LOGK2 = log_ceil(6*k * min(kg, 2*k-1) * 6 * (2+XI0) );
+    var LOGK3 = log_ceil( 6*k * min(kg, 2*k-1) * 6 * (2+XI0) * (k + kg - 1) );
+    assert( overflowg + 3*n + LOGK3 < 251 );
+
+    component line = SignedLineFunctionUnequalNoCarry(n, k, 2*n + LOGK1); // 6 x 2 x 2k - 1 registers abs val < 3k 2^{2n}
+    for(var l=0; l<2; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+        line.P[l][j][idx] <== P[l][j][idx];
+    for(var l=0; l<2; l++)for(var i=0; i<6; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+        line.Q[l][i][j][idx] <== Q[l][i][j][idx];
+    
+    component mult = SignedFp12MultiplyNoCarryUnequal(n, kg, 2*k - 1, overflowg + 2*n + LOGK2); // 6 x 2 x (2k + kg - 2) registers < 3k * min(kg, 2k - 1) * 6 * (2+XI0)* 2^{overflowg + 2n} )
+    
+    for(var i=0; i<6; i++)for(var j=0; j<2; j++)for(var idx=0; idx<kg; idx++)
+        mult.a[i][j][idx] <== g[i][j][idx];
+    for(var i=0; i<6; i++)for(var j=0; j<2; j++)for(var idx=0; idx<2*k-1; idx++)
+        mult.b[i][j][idx] <== line.out[i][j][idx];
+
+
+    component reduce = Fp12Compress(n, k, k + kg - 2, q, overflowg + 3*n + LOGK3); // 6 x 2 x k registers in [0, 3 k * min(kg, 2k - 1) * 6*(2+XI0) * (k + kg - 1) *  2^{overflowg + 3n} )
+    for(var i=0; i<6; i++)for(var j=0; j<2; j++)for(var idx=0; idx<2*k + kg - 2; idx++)
+        reduce.in[i][j][idx] <== mult.out[i][j][idx];
+    
+    component carry = SignedFp12CarryModP(n, k, overflowg + 3*n + LOGK3, q);
+
+    for(var i=0; i<6; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+        carry.in[i][j][idx] <== reduce.out[i][j][idx];
+
+    for(var i=0; i<6; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+        out[i][j][idx] <== carry.out[i][j][idx];
+}
+
+// Assuming curve is of form Y^2 = X^3 + b for now (a = 0) for better register bounds 
+// Inputs:
+//  in is 6 x 2 x k array representing element in Fq12
+//  P is 2 x k array where P = (x, y) is a point in E[r](Fq) 
+//  Q is 2 x 6 x 2 x k array representing point (X, Y) in E(Fq12) 
+// Output:
+//  out = f_x(P,Q) is 6 x 2 x k, where we start with f_0(P,Q) = in and use Miller's algorithm f_{i+j} = f_i * f_j * l_{i,j}(P,Q)
+//  xP = [x]P is 2 x k array
+// Assume:
+//  r is prime (not a parameter in this template)
+//  x in [0, 2^250) and x < r  (we will use this template when x has few significant bits in base 2)
+//  q has k registers in [0, 2^n)
+//  P != O so the order of P in E(Fq) is r, so [i]P != [j]P for i != j in Z/r 
+template MillerLoop(n, k, b, x, q){
+    signal input in[6][2][k];
+    signal input P[2][k]; 
+    signal input Q[2][6][2][k];
+
+    signal output out[6][2][k];
+    signal output xP[2][k];
+
+    var LOGK = log_ceil(k);
+    var XI0 = 1;
+    var LOGK2 = log_ceil(36*(2+XI0)*(2+XI0) * k*k);
+    var LOGK3 = log_ceil(36*(2+XI0)*(2+XI0) * k*k*(2*k-1));
+    assert( 4*n + LOGK3 < 251 );
+    
+
+    var Bits[250]; // length is k * n
+    var BitLength;
+    var SigBits=0;
+    for (var i = 0; i < 250; i++) {
+        Bits[i] = (x >> i) & 1;
+        if(Bits[i] == 1){
+            SigBits++;
+            BitLength = i + 1;
+        }
+    }
+
+    signal Pintermed[BitLength][2][k]; 
+    signal f[BitLength][6][2][k];
+
+    component Pdouble[BitLength];
+    component fdouble[BitLength];
+    component square[BitLength];
+    component line[BitLength];
+    component compress[BitLength];
+    component nocarry[BitLength];
+    component Padd[SigBits];
+    component fadd[SigBits]; 
+    component fadd_pre[SigBits]; 
+    var curid=0;
+
+    for(var i=BitLength - 1; i>=0; i--){
+        if( i == BitLength - 1 ){
+            // f = 1 
+            for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+                f[i][l][j][idx] <== in[l][j][idx];
+            }
+            for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                Pintermed[i][j][idx] <== P[j][idx];
+        }else{
+            // compute fdouble[i] = f[i+1]^2 * l_{Pintermed[i+1], Pintermed[i+1]}(Q) 
+            square[i] = SignedFp12MultiplyNoCarry(n, k, 2*n + 4 + LOGK); // 6 x 2 x 2k-1 registers in [0, 6 * k * (2+XI0) * 2^{2n} )
+            for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+                square[i].a[l][j][idx] <== f[i+1][l][j][idx];
+                square[i].b[l][j][idx] <== f[i+1][l][j][idx];
+            }
+
+            line[i] = LineFunctionEqual(n, k, q); // 6 x 2 x k registers in [0, 2^n) 
+            for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                line[i].P[j][idx] <== Pintermed[i+1][j][idx];            
+            for(var eps=0; eps<2; eps++)
+                for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                    line[i].Q[eps][l][j][idx] <== Q[eps][l][j][idx];
+
+            nocarry[i] = SignedFp12MultiplyNoCarryUnequal(n, 2*k-1, k, 3*n + LOGK2); // 6 x 2 x 3k-2 registers < (6 * (2+XI0))^2 * k^2 * 2^{3n} ) 
+            for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<2*k-1; idx++)
+                nocarry[i].a[l][j][idx] <== square[i].out[l][j][idx];
+            
+            for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                nocarry[i].b[l][j][idx] <== line[i].out[l][j][idx];
+            
+            compress[i] = Fp12Compress(n, k, 2*k-2, q, 4*n + LOGK3); // 6 x 2 x k registers < (6 * (2+ XI0))^2 * k^2 * (2k-1) * 2^{4n} )
+            for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<3*k-2; idx++)
+                compress[i].in[l][j][idx] <== nocarry[i].out[l][j][idx];
+
+            fdouble[i] = SignedFp12CarryModP(n, k, 4*n + LOGK3, q);
+            for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                fdouble[i].in[l][j][idx] <== compress[i].out[l][j][idx]; 
+
+            Pdouble[i] = EllipticCurveDouble(n, k, 0, b, q);  
+            for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                Pdouble[i].in[j][idx] <== Pintermed[i+1][j][idx]; 
+            
+            if(Bits[i] == 0){
+                for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                    f[i][l][j][idx] <== fdouble[i].out[l][j][idx]; 
+                for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                    Pintermed[i][j][idx] <== Pdouble[i].out[j][idx];
+            }else{
+                // fadd[curid] = fdouble * in * l_{Pdouble[i], P}(Q) 
+                fadd_pre[curid] = Fp12Multiply(n, k, q); 
+                for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+                    fadd_pre[curid].a[l][j][idx] <== fdouble[i].out[l][j][idx];
+                    fadd_pre[curid].b[l][j][idx] <== in[l][j][idx]; 
+                }
+
+                fadd[curid] = Fp12MultiplyWithLineUnequal(n, k, k, n, q); 
+                for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                    fadd[curid].g[l][j][idx] <== fadd_pre[curid].out[l][j][idx];
+                
+                for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+                    fadd[curid].P[0][j][idx] <== Pdouble[i].out[j][idx];            
+                    fadd[curid].P[1][j][idx] <== P[j][idx];            
+                }
+                for(var eps=0; eps<2; eps++)for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                    fadd[curid].Q[eps][l][j][idx] <== Q[eps][l][j][idx];
+
+                for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                    f[i][l][j][idx] <== fadd[curid].out[l][j][idx]; 
+
+                // Padd[curid] = Pdouble[i] + P 
+                Padd[curid] = EllipticCurveAddUnequal(n, k, q); 
+                for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+                    Padd[curid].a[j][idx] <== Pdouble[i].out[j][idx];
+                    Padd[curid].b[j][idx] <== P[j][idx];
+                }
+
+                for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                    Pintermed[i][j][idx] <== Padd[curid].out[j][idx];
+                
+                curid++;
+            }
+        }
+    }
+    for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+        out[l][j][idx] <== f[0][l][j][idx];
+    for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+        xP[j][idx] <== Pintermed[0][j][idx]; 
+    
+}
+
+
+// Assuming curve is of form Y^2 = X^3 + b for now (a = 0) for better register bounds 
+// Inputs:
+//  P is 2 x k array where P = (x, y) is a point in E[r](Fq) 
+//  Q is 2 x 6 x 2 x k array representing point (X, Y) in E(Fq12) 
+// Output:
+// f_r(Q) where <f_r> = [r]P - [r]O is computed using Miller's algorithm
+// Assume:
+//  r  = x^4 - x^2 + 1 where x is the parameter of the curve
+//  q has k registers in [0, 2^n)
+//  r is prime
+//  P != O so the order of P in E(Fq) is r, so [i]P != [j]P for i != j in Z/r 
+template BLSMillerLoop(n, k, q){
+    signal input P[2][k]; 
+    signal input Q[2][6][2][k];
+    signal output out[6][2][k];
+
+    var XI0 = 1;
+    var b = 4; // Y^2 = X^3 + 4
+    var x = get_BLS12_381_parameter();
+
+    // fx[i] = f_{x^{i+1}} 
+    component fx[4]; 
+    for(var e=0; e<4; e++){
+        fx[e] = MillerLoop(n, k, b, x, q);
+        if( e == 0 ){
+            for(var i=0; i<6; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+                if(i == 0 && j == 0 && idx == 0)
+                    fx[e].in[i][j][idx] <== 1;
+                else    
+                    fx[e].in[i][j][idx] <== 0;
+            }
+            for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                fx[e].P[j][idx] <== P[j][idx];
+        }else{
+            for(var i=0; i<6; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                fx[e].in[i][j][idx] <== fx[e - 1].out[i][j][idx];
+            for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                fx[e].P[j][idx] <== fx[e - 1].xP[j][idx];            
+        }
+        for(var l=0; l<2; l++)for(var i=0; i<6; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+            fx[e].Q[l][i][j][idx] <== Q[l][i][j][idx];
+    }
+    
+    // f_{x^4} * l_{x^4, 1}(P,Q) 
+    component fx4l = Fp12MultiplyWithLineUnequal(n, k, k, n, q); 
+    // assert( 4*n + log_ceil(12 * (2*k-1) *k * k) + 2 < 252 );  // need this to run MillerLoop anyways
+    for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+        fx4l.g[l][j][idx] <== fx[3].out[l][j][idx];
+    }
+    for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+        fx4l.P[0][j][idx] <== fx[3].xP[j][idx];            
+        fx4l.P[1][j][idx] <== P[j][idx];            
+    }
+    for(var l=0; l<2; l++)for(var i=0; i<6; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+        fx4l.Q[l][i][j][idx] <== Q[l][i][j][idx];
+    
+    /* Don't need this, vertical lines can be omitted due to final exponentiation:
+    // f_{x^2} * l_{r,x^2}(P,Q) where l_{r,x^2}(P,Q) = Q.x - ([x^2]P).x 
+    var LOGK2 = log_ceil(6*(2+XI0)*k*k);
+    component fx2l = SignedFp12MultiplyNoCarryCompress(n, k, q, n, 3*n + LOGK2); // registers in [0, 6*(2+XI0)*k^2*2^{3n} )
+    for(var i=0; i<6; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+        fx2l.a[i][j][idx] <== fx[1].out[i][j][idx];
+        
+        if(i == 0 && j == 0)
+            fx2l.b[i][j][idx] <== Q[0][i][j][idx] - fx[1].xP[0][idx];
+        else
+            fx2l.b[i][j][idx] <== Q[0][i][j][idx];
+    }
+
+    component carry = SignedFp12CarryModP(n, k, 3*n + LOGK2, q);
+    for(var i=0; i<6; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+        carry.in[i][j][idx] <== fx2l.out[i][j][idx];
+    */
+
+    // find fx2^{-1}. Not going to optimize this for now since it's just one call
+    component inv = Fp12Invert(n, k, q);
+    for(var i=0; i<6; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+        inv.in[i][j][idx] <== fx[1].out[i][j][idx];
+
+    component fr = Fp12Multiply(n, k, q);
+    for(var i=0; i<6; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+        fr.a[i][j][idx] <== fx4l.out[i][j][idx];
+        fr.b[i][j][idx] <== inv.out[i][j][idx];
+    }
+    
+    for(var i=0; i<6; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+        out[i][j][idx] <== fr.out[i][j][idx];
+}
+
+template TatePairing(n, k, q){
+    signal input P[2][k]; 
+    signal input Q[2][6][2][k];
+    signal output out[6][2][k];
+
+    component miller = BLSMillerLoop(n, k, q);
+    for(var i=0; i<2; i++)for(var idx=0; idx<k; idx++)
+        miller.P[i][idx] <== P[i][idx];
+    for(var i=0; i<2; i++)for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+        miller.Q[i][l][j][idx] <== Q[i][l][j][idx];
+    
+    component finalexp = FinalExponentiate(n, k, q);
+    for(var i=0; i<6; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+        finalexp.in[i][j][idx] <== miller.out[i][j][idx];
+
+    for(var i=0; i<6; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+        out[i][j][idx] <== finalexp.out[i][j][idx]; 
+
+    /*
+    // check out[i][j] < p since we never did that previously
+    component lt[6][2];
+    for(var i=0; i<6; i++)for(var j=0; j<2; j++){
+        lt[i][j] = BigLessThan(n, k);
+        for(var idx=0; idx<k; idx++){
+            lt[i][j].a[idx] <== out[i][j][idx];
+            lt[i][j].b[idx] <== q[idx];
+        }
+        lt[i][j].out === 1;
+    }*/
+}
+
+// Inputs:
+//  P is 2 x 2 x 2 x k array where P0 = (x_1, y_1) and P1 = (x_2, y_2) are points in E(Fp2)
+//  Q is 2 x k array representing point (X, Y) in E(Fp)
+// Assuming (x_1, y_1) != (x_2, y_2)
+// Output:
+//  out is 6 x 2 x (2k-1) array representing element of Fp12 equal to:
+//  w^3 (y_1 - y_2) X + w^4 (x_2 - x_1) Y + w (x_1 y_2 - x_2 y_1)
+// We evaluate out without carries
+// If all registers of P, Q are in [0, B),
+// Then all registers of out have abs val < 2k * B^2 )
+// m_out is the expected max number of bits in the output registers
+template SignedLineFunctionUnequalNoCarryFp2(n, k, m_out){
+    signal input P[2][2][2][k];
+    signal input Q[2][k];
+    signal output out[6][2][2*k-1];
+
+    // (y_1 - y_2) X
+    var LOGK = log_ceil(k);
+    component Xmult = SignedFp2MultiplyNoCarry(n, k, 2*n + LOGK+1); // registers abs val < 2k*B^2
+    // (x_2 - x_1) Y
+    component Ymult = SignedFp2MultiplyNoCarry(n, k, 2*n + LOGK+1);
+    for(var i = 0; i < 2; i ++) {
+        for(var j=0; j<k; j++){
+            Xmult.a[i][j] <== P[0][1][i][j] - P[1][1][i][j];
+            
+            Ymult.a[i][j] <== P[1][0][i][j] - P[0][0][i][j];
+        }
+    }
+    for(var idx=0; idx<k; idx++){
+        Xmult.b[0][idx] <== Q[0][idx];
+        Xmult.b[1][idx] <== 0;
+
+        Ymult.b[0][idx] <== Q[1][idx]; 
+        Ymult.b[1][idx] <== 0;
+    } 
+    
+    component x1y2 = BigMultShortLong2D(n, k, 2); // 2k-1 registers in [0, 2k*B^2) 
+    component x2y1 = BigMultShortLong2D(n, k, 2);
+    for(var i = 0; i < 2; i ++) {
+        for(var j=0; j<k; j++){
+            x1y2.a[i][j] <== P[0][0][i][j]; 
+            x1y2.b[i][j] <== P[1][1][i][j];
+            
+            x2y1.a[i][j] <== P[1][0][i][j]; 
+            x2y1.b[i][j] <== P[0][1][i][j];
+        }
+    }
+    
+    for(var idx=0; idx<2*k-1; idx++){
+        out[0][0][idx] <== 0;
+        out[0][1][idx] <== 0;
+        out[2][0][idx] <== 0;
+        out[2][1][idx] <== 0;
+        out[5][0][idx] <== 0;
+        out[5][1][idx] <== 0;
+
+        out[1][0][idx] <== x1y2.out[0][idx] - x2y1.out[0][idx] - x1y2.out[2][idx] + x2y1.out[2][idx];
+        out[1][1][idx] <== x1y2.out[1][idx] - x2y1.out[1][idx];
+        out[3][0][idx] <== Xmult.out[0][idx];
+        out[3][1][idx] <== Xmult.out[1][idx];
+        out[4][0][idx] <== Ymult.out[0][idx];
+        out[4][1][idx] <== Ymult.out[1][idx];
+    }
+}
+
+
+// Assuming curve is of form Y^2 = X^3 + b for now (a = 0) for better register bounds 
+// Inputs:
+//  P is 2 x 2 x k array where P = (x, y) is a point in E(Fp2) 
+//  Q is 2 x 6 x 2 x k array representing point (X, Y) in E(Fp12) 
+// Output: 
+//  out is 6 x 2 x (3k-2) array representing element of Fp12 equal to:
+//  (3x^3 - 2y^2) + w^2 (-3 x^2 X) + w^3 (2 y Y)
+// We evaluate out without carries, with signs
+// If P, Q have registers in [0, B) 
+// Then out has registers abs val < 12k^2*B^3
+// m_out is the expected max number of bits in the output registers
+template SignedLineFunctionEqualNoCarryFp2(n, k, m_out){
+    signal input P[2][2][k]; 
+    signal input Q[2][k];
+    signal output out[6][2][3*k-2];
+    var LOGK = log_ceil(k);
+
+    component x_sq3 = BigMultShortLong2D(n, k, 2); // 2k-1 registers in [0, 6*k*2^{2n} )
+    for(var i=0; i<2; i++){
+        for(var j = 0; j < k; j ++) {
+            x_sq3.a[i][j] <== 3*P[0][i][j];
+            x_sq3.b[i][j] <== P[0][i][j];
+        }
+    }
+
+    component x_cu3 = BigMultShortLong2DUnequal(n, 2*k-1, k, 2, 2);
+    for (var i = 0; i < 2*k-1; i ++) {
+        if (i < k) {
+            x_cu3.b[0][i] <== P[0][0][i];
+            x_cu3.b[1][i] <== P[0][1][i];
+        }
+        x_cu3.a[0][i] <== x_sq3.out[0][i] - x_sq3.out[2][i];
+        x_cu3.a[1][i] <== x_sq3.out[1][i];
+    }
+
+    component y_sq2 = BigMultShortLong2D(n, k, 2); // 2k-1 registers in [0, 6*k*2^{2n} )
+    for(var i=0; i<2; i++){
+        for(var j = 0; j < k; j ++) {
+            y_sq2.a[i][j] <== 2*P[1][i][j];
+            y_sq2.b[i][j] <== P[1][i][j];
+        }
+    } 
+    
+    component Xmult = SignedFp2MultiplyNoCarryUnequal(n, 2*k-1, k, 3*n + 2*LOGK + 3); // 3k-2 registers abs val < 12 * k^2 * 2^{3n})
+    for(var idx=0; idx<2*k-1; idx++){
+        Xmult.a[0][idx] <== x_sq3.out[0][idx] - x_sq3.out[2][idx];
+        Xmult.a[1][idx] <== x_sq3.out[1][idx];
+    }
+    for(var idx=0; idx<k; idx++){
+        Xmult.b[0][idx] <== - Q[0][idx];
+        Xmult.b[1][idx] <== 0;
+    }
+
+    component Ymult = SignedFp2MultiplyNoCarryUnequal(n, k, k, 2*n + LOGK + 2); // 2k-1 registers abs val < 4k*2^{2n} 
+    for(var idx=0; idx < k; idx++){
+        Ymult.a[0][idx] <== 2*P[1][0][idx];
+        Ymult.a[1][idx] <== 2*P[1][1][idx];
+    }
+    for(var idx=0; idx<k; idx++){
+        Ymult.b[0][idx] <== Q[1][idx];
+        Ymult.b[1][idx] <== 0;
+    }
+    
+    for(var idx=0; idx<3*k-2; idx++){
+        out[1][0][idx] <== 0;
+        out[1][1][idx] <== 0;
+        out[4][0][idx] <== 0;
+        out[4][1][idx] <== 0;
+        out[5][0][idx] <== 0;
+        out[5][1][idx] <== 0;
+
+        if (idx < 2*k-1) {
+            out[0][0][idx] <== x_cu3.out[0][idx] - x_cu3.out[2][idx] - y_sq2.out[0][idx] + y_sq2.out[2][idx];
+            out[0][1][idx] <== x_cu3.out[1][idx] - y_sq2.out[1][idx];
+            out[3][0][idx] <== Ymult.out[0][idx];
+            out[3][1][idx] <== Ymult.out[1][idx];
+        }
+        else {
+            out[0][0][idx] <== x_cu3.out[0][idx] - x_cu3.out[2][idx];
+            out[0][1][idx] <== x_cu3.out[1][idx];
+            out[3][0][idx] <== 0;
+            out[3][1][idx] <== 0;
+        }
+        out[2][0][idx] <== Xmult.out[0][idx];
+        out[2][1][idx] <== Xmult.out[1][idx];
+    }
+}
+
+// Inputs:
+//  P is 2 x 2 x k array where P0 = (x_1, y_1) and P1 = (x_2, y_2) are points in E(Fp2)
+//  Q is 2 x 6 x 2 x k array representing point (X, Y) in E(Fp12)
+// Assuming (x_1, y_1) != (x_2, y_2)
+// Output:
+//  Q is 6 x 2 x k array representing element of Fp12 equal to:
+//  w^3 (y_1 - y_2) X + w^4 (x_2 - x_1) Y + w (x_1 y_2 - x_2 y_1)
+template LineFunctionUnequalFp2(n, k, q) {
+    signal input P[2][2][2][k];
+    signal input Q[2][k];
+
+    signal output out[6][2][k];
+    var LOGK1 = log_ceil(2*k);
+    var LOGK2 = log_ceil(2*k*k);
+
+    component nocarry = SignedLineFunctionUnequalNoCarryFp2(n, k, 2 * n + LOGK1);
+    for (var i = 0; i < 2; i++)for(var j = 0; j < 2; j++) {
+	    for (var idx = 0; idx < k; idx++) {
+            nocarry.P[i][j][0][idx] <== P[i][j][0][idx];
+            nocarry.P[i][j][1][idx] <== P[i][j][1][idx];
+	    }
+    }
+
+    for (var i = 0; i < 2; i++) {
+        for (var idx = 0; idx < k; idx++) {
+            nocarry.Q[i][idx] <== Q[i][idx];
+        }
+    }
+    component reduce[6][2];
+    for (var i = 0; i < 6; i++) {
+        for (var j = 0; j < 2; j++) {
+            reduce[i][j] = PrimeReduce(n, k, k - 1, q, 3 * n + LOGK2);
+        }
+
+        for (var j = 0; j < 2; j++) {
+            for (var idx = 0; idx < 2 * k - 1; idx++) {
+                reduce[i][j].in[idx] <== nocarry.out[i][j][idx];
+            }
+        }	
+    }
+
+    // max overflow register size is 2k^2 * 2^{3n}
+    component carry = SignedFp12CarryModP(n, k, 3 * n + LOGK2, q);
+    for (var i = 0; i < 6; i++) {
+        for (var j = 0; j < 2; j++) {
+            for (var idx = 0; idx < k; idx++) {
+                carry.in[i][j][idx] <== reduce[i][j].out[idx];
+            }
+        }
+    }
+    
+    for (var i = 0; i < 6; i++) {
+        for (var j = 0; j < 2; j++) {
+            for (var idx = 0; idx < k; idx++) {
+            out[i][j][idx] <== carry.out[i][j][idx];
+            }
+        }
+    }    
+}
+
+// Assuming curve is of form Y^2 = X^3 + b for now (a = 0) for better register bounds 
+// Inputs:
+//  P is 2 x 2 x k array where P = (x, y) is a point in E(Fp2) 
+//  Q is 2 x 6 x 2 x k array representing point (X, Y) in E(Fp12) 
+// Output: 
+//  out is 6 x 2 x k array representing element of Fp12 equal to:
+//  (3x^3 - 2y^2) + w^2 (-3 x^2 X) + w^3 (2 y Y)
+template LineFunctionEqualFp2(n, k, q) {
+    signal input P[2][2][k];
+    signal input Q[2][k];
+
+    signal output out[6][2][k];
+
+    var LOGK2 = log_ceil(12*k*k + 1);
+    component nocarry = SignedLineFunctionEqualNoCarryFp2(n, k, 3*n + LOGK2);
+    for (var i = 0; i < 2; i++) {
+        for (var j = 0; j < 2; j ++) {
+            for (var idx = 0; idx < k; idx++) {
+                nocarry.P[i][j][idx] <== P[i][j][idx];
+            }
+        }
+    }
+
+    for (var i = 0; i < 2; i++) {
+        for (var idx = 0; idx < k; idx++) {
+            nocarry.Q[i][idx] <== Q[i][idx];
+        }
+    }
+    
+    var LOGK3 = log_ceil((2*k-1)*12*k*k + 1);
+    component reduce[6][4]; 
+    for (var i = 0; i < 6; i++) {
+        for (var j = 0; j < 2; j++) {
+            reduce[i][j] = PrimeReduce(n, k, 2 * k - 2, q, 4 * n + LOGK3);
+        }
+
+        for (var j = 0; j < 2; j++) {
+            for (var idx = 0; idx < 3 * k - 2; idx++) {
+                reduce[i][j].in[idx] <== nocarry.out[i][j][idx];
+            }
+        }	
+    }
+
+    // max overflow register size is (2k - 1) * 12k^2 * 2^{4n}
+    component carry = SignedFp12CarryModP(n, k, 4 * n + LOGK3, q);
+    for (var i = 0; i < 6; i++) {
+        for (var j = 0; j < 2; j++) {
+            for (var idx = 0; idx < k; idx++) {
+                carry.in[i][j][idx] <== reduce[i][j].out[idx];
+            }
+        }
+    }
+    
+    for (var i = 0; i < 6; i++) {
+        for (var j = 0; j < 2; j++) {
+            for (var idx = 0; idx < k; idx++) {
+            out[i][j][idx] <== carry.out[i][j][idx];
+            }
+        }
+    }    
+}
+
+
+// Input:
+//  g is 6 x 2 x kg array representing element of Fp12, allowing overflow and negative
+//  P0, P1, Q are as in inputs of SignedLineFunctionUnequalNoCarryFp2
+// Assume:
+//  all registers of g are in [0, 2^{overflowg}) 
+//  all registers of P, Q are in [0, 2^n) 
+// Output:
+//  out = g * l_{P0, P1}(Q) as element of Fp12 with carry 
+//  out is 6 x 2 x k
+template Fp12MultiplyWithLineUnequalFp2(n, k, kg, overflowg, q){
+    signal input g[6][2][kg];
+    signal input P[2][2][2][k];
+    signal input Q[2][k];
+    signal output out[6][2][k];
+
+    var XI0 = 1;
+    var LOGK1 = log_ceil(12*k);
+    var LOGK2 = log_ceil(12*k * min(kg, 2*k-1) * 6 * (2+XI0) );
+    var LOGK3 = log_ceil( 12*k * min(kg, 2*k-1) * 6 * (2+XI0) * (k + kg - 1) );
+    assert( overflowg + 3*n + LOGK3 < 251 );
+
+    component line = SignedLineFunctionUnequalNoCarryFp2(n, k, 2*n + LOGK1); // 6 x 2 x 2k - 1 registers in [0, 12k 2^{2n})
+    for(var i=0; i<2; i++)for(var j=0; j<2; j++)for(var l=0; l<2; l++)for(var idx=0; idx<k; idx++)
+        line.P[i][j][l][idx] <== P[i][j][l][idx];
+    for(var l=0; l<2; l++)for(var idx=0; idx<k; idx++)
+        line.Q[l][idx] <== Q[l][idx];
+    
+    component mult = SignedFp12MultiplyNoCarryUnequal(n, kg, 2*k - 1, overflowg + 2*n + LOGK2); // 6 x 2 x (2k + kg - 2) registers abs val < 12k * min(kg, 2k - 1) * 6 * (2+XI0)* 2^{overflowg + 2n} 
+    
+    for(var i=0; i<6; i++)for(var j=0; j<2; j++)for(var idx=0; idx<kg; idx++)
+        mult.a[i][j][idx] <== g[i][j][idx];
+    for(var i=0; i<6; i++)for(var j=0; j<2; j++)for(var idx=0; idx<2*k-1; idx++)
+        mult.b[i][j][idx] <== line.out[i][j][idx];
+
+
+    component reduce = Fp12Compress(n, k, k + kg - 2, q, overflowg + 3*n + LOGK3); // 6 x 2 x k registers abs val < 12 k * min(kg, 2k - 1) * 6*(2+XI0) * (k + kg - 1) *  2^{overflowg + 3n} 
+    for(var i=0; i<6; i++)for(var j=0; j<2; j++)for(var idx=0; idx<2*k + kg - 2; idx++)
+        reduce.in[i][j][idx] <== mult.out[i][j][idx];
+    
+    component carry = SignedFp12CarryModP(n, k, overflowg + 3*n + LOGK3, q);
+
+    for(var i=0; i<6; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+        carry.in[i][j][idx] <== reduce.out[i][j][idx];
+
+    for(var i=0; i<6; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+        out[i][j][idx] <== carry.out[i][j][idx];
+}
+
+// Assuming curve is of form Y^2 = X^3 + b for now (a = 0) for better register bounds 
+// b is complex
+// Inputs:
+//  P is 2 x 2 x k array where P = (x, y) is a point in E[r](Fq2) 
+//  Q is 2 x k array representing point (X, Y) in E(Fq) 
+// Output:
+//  out = f_x(P,Q) is 6 x 2 x k, where we start with f_0(P,Q) = in and use Miller's algorithm f_{i+j} = f_i * f_j * l_{i,j}(P,Q)
+//  xP = [x]P is 2 x 2 x k array
+// Assume:
+//  r is prime (not a parameter in this template)
+//  x in [0, 2^250) and x < r  (we will use this template when x has few significant bits in base 2)
+//  q has k registers in [0, 2^n)
+//  P != O so the order of P in E(Fq) is r, so [i]P != [j]P for i != j in Z/r 
+//  X^3 + b = 0 has no solution in Fq2, i.e., the y-coordinate of P cannot be 0.
+template MillerLoopFp2(n, k, b, x, q){
+    signal input P[2][2][k]; 
+    signal input Q[2][k];
+
+    signal output out[6][2][k];
+    signal output xP[2][2][k];
+
+    var LOGK = log_ceil(k);
+    var XI0 = 1;
+    var LOGK2 = log_ceil(36*(2+XI0)*(2+XI0) * k*k);
+    var LOGK3 = log_ceil(36*(2+XI0)*(2+XI0) * k*k*(2*k-1));
+    assert( 4*n + LOGK3 < 251 );
+    
+    var Bits[250]; 
+    var BitLength;
+    var SigBits=0;
+    for (var i = 0; i < 250; i++) {
+        Bits[i] = (x >> i) & 1;
+        if(Bits[i] == 1){
+            SigBits++;
+            BitLength = i + 1;
+        }
+    }
+
+    signal R[BitLength][2][2][k]; 
+    signal f[BitLength][6][2][k];
+
+    component Pdouble[BitLength];
+    component fdouble[BitLength];
+    component square[BitLength];
+    component line[BitLength];
+    component compress[BitLength];
+    component nocarry[BitLength];
+    component Padd[SigBits];
+    component fadd[SigBits]; 
+    var curid=0;
+
+    for(var i=BitLength - 1; i>=0; i--){
+        if( i == BitLength - 1 ){
+            // f = 1 
+            for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+                if(l==0 && j==0 && idx==0)
+                    f[i][l][j][idx] <== 1;
+                else    
+                    f[i][l][j][idx] <== 0;
+            }
+            for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)for(var l=0; l<2; l++)
+                R[i][j][l][idx] <== P[j][l][idx];
+        }else{
+            // compute fdouble[i] = f[i+1]^2 * l_{R[i+1], R[i+1]}(Q) 
+            square[i] = SignedFp12MultiplyNoCarry(n, k, 2*n + 4 + LOGK); // 6 x 2 x 2k-1 registers in [0, 6 * k * (2+XI0) * 2^{2n} )
+            for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+                square[i].a[l][j][idx] <== f[i+1][l][j][idx];
+                square[i].b[l][j][idx] <== f[i+1][l][j][idx];
+            }
+            
+            line[i] = LineFunctionEqualFp2(n, k, q); // 6 x 2 x k registers in [0, 2^n) 
+            for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)for(var l=0; l<2; l++)
+                line[i].P[j][l][idx] <== R[i+1][j][l][idx];            
+            for(var eps=0; eps<2; eps++)
+                for(var idx=0; idx<k; idx++)
+                    line[i].Q[eps][idx] <== Q[eps][idx];
+            
+            nocarry[i] = SignedFp12MultiplyNoCarryUnequal(n, 2*k-1, k, 3*n + LOGK2); // 6 x 2 x 3k-2 registers < (6 * (2+XI0))^2 * k^2 * 2^{3n} ) 
+            for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<2*k-1; idx++)
+                nocarry[i].a[l][j][idx] <== square[i].out[l][j][idx];
+            
+            for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                nocarry[i].b[l][j][idx] <== line[i].out[l][j][idx];
+            
+            compress[i] = Fp12Compress(n, k, 2*k-2, q, 4*n + LOGK3); // 6 x 2 x k registers < (6 * (2+ XI0))^2 * k^2 * (2k-1) * 2^{4n} )
+            for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<3*k-2; idx++)
+                compress[i].in[l][j][idx] <== nocarry[i].out[l][j][idx];
+            
+            fdouble[i] = SignedFp12CarryModP(n, k, 4*n + LOGK3, q);
+            for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                fdouble[i].in[l][j][idx] <== compress[i].out[l][j][idx]; 
+            
+            Pdouble[i] = EllipticCurveDoubleFp2(n, k, [0,0], b, q);  
+            for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)for(var l=0; l<2; l++)
+                Pdouble[i].in[j][l][idx] <== R[i+1][j][l][idx]; 
+            
+            if(Bits[i] == 0){
+                for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                    f[i][l][j][idx] <== fdouble[i].out[l][j][idx]; 
+                for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)for(var l=0; l<2; l++)
+                    R[i][j][l][idx] <== Pdouble[i].out[j][l][idx];
+            }else{
+                fadd[curid] = Fp12MultiplyWithLineUnequalFp2(n, k, k, n, q); 
+                for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                    fadd[curid].g[l][j][idx] <== fdouble[i].out[l][j][idx];
+                
+                for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)for(var l=0; l<2; l++){
+                    fadd[curid].P[0][j][l][idx] <== Pdouble[i].out[j][l][idx];            
+                    fadd[curid].P[1][j][l][idx] <== P[j][l][idx];            
+                }
+                for(var eps=0; eps<2; eps++)for(var idx=0; idx<k; idx++)
+                    fadd[curid].Q[eps][idx] <== Q[eps][idx];
+
+                for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                    f[i][l][j][idx] <== fadd[curid].out[l][j][idx]; 
+
+                // Padd[curid] = Pdouble[i] + P 
+                Padd[curid] = EllipticCurveAddUnequalFp2(n, k, q); 
+                for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)for(var l=0; l<2; l++){
+                    Padd[curid].a[j][l][idx] <== Pdouble[i].out[j][l][idx];
+                    Padd[curid].b[j][l][idx] <== P[j][l][idx];
+                }
+
+                for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)for(var l=0; l<2; l++)
+                    R[i][j][l][idx] <== Padd[curid].out[j][l][idx];
+                
+                curid++;
+            }
+        }
+    }
+    for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+        out[l][j][idx] <== f[0][l][j][idx];
+    for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)for(var l=0; l<2; l++)
+        xP[j][l][idx] <== R[0][j][l][idx]; 
+}
+
+
+// Assuming curve is of form Y^2 = X^3 + b for now (a = 0) for better register bounds 
+// b is complex
+// Inputs:
+//  P is 2 x 2 x 2 x k array where P[i] = (x_i, y_i) is a point in E[r](Fq2) 
+//  Q is 2 x 2 x k array representing point (X_i, Y_i) in E(Fq) 
+// Output:
+//  out = f_x(P_0,Q_0) f_x(P_1, Q_1) is 6 x 2 x k, where we start with f_0(P,Q) = in and use Miller's algorithm f_{i+j} = f_i * f_j * l_{i,j}(P,Q)
+// Assume:
+//  r is prime (not a parameter in this template)
+//  x in [0, 2^250) and x < r  (we will use this template when x has few significant bits in base 2)
+//  q has k registers in [0, 2^n)
+//  P != O so the order of P in E(Fq) is r, so [i]P != [j]P for i != j in Z/r 
+//  X^3 + b = 0 has no solution in Fq2, i.e., the y-coordinate of P cannot be 0.
+template MillerLoopFp2Two(n, k, b, x, q){
+    signal input P[2][2][2][k]; 
+    signal input Q[2][2][k];
+
+    signal output out[6][2][k];
+
+    var LOGK = log_ceil(k);
+    var XI0 = 1;
+    var LOGK2 = log_ceil(36*(2+XI0)*(2+XI0) * k*k);
+    var LOGK3 = log_ceil(36*(2+XI0)*(2+XI0) * k*k*(2*k-1));
+    assert( 4*n + LOGK3 < 251 );
+    
+    var Bits[250]; // length is k * n
+    var BitLength;
+    var SigBits=0;
+    for (var i = 0; i < 250; i++) {
+        Bits[i] = (x >> i) & 1;
+        if(Bits[i] == 1){
+            SigBits++;
+            BitLength = i + 1;
+        }
+    }
+
+    signal R[BitLength][2][2][2][k]; 
+    signal f[BitLength][6][2][k];
+
+    component Pdouble[BitLength][2];
+    component fdouble_0[BitLength];
+    component fdouble[BitLength];
+    component square[BitLength];
+    component line[BitLength][2];
+    component compress[BitLength];
+    component nocarry[BitLength];
+    component Padd[SigBits][2];
+    component fadd[SigBits][2]; 
+    var curid=0;
+
+    for(var i=BitLength - 1; i>=0; i--){
+        if( i == BitLength - 1 ){
+            // f = 1 
+            for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+                if(l==0 && j==0 && idx==0)
+                    f[i][l][j][idx] <== 1;
+                else    
+                    f[i][l][j][idx] <== 0;
+            }
+            for(var idP=0; idP<2; idP++)
+                for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)for(var l=0; l<2; l++)
+                    R[i][idP][j][l][idx] <== P[idP][j][l][idx];
+        }else{
+            // compute fdouble[i] = (f[i+1]^2 * l_{R[i+1][0], R[i+1][0]}(Q[0])) * l_{R[i+1][1], R[i+1][1]}(Q[1])
+            square[i] = SignedFp12MultiplyNoCarry(n, k, 2*n + 4 + LOGK); // 6 x 2 x 2k-1 registers in [0, 6 * k * (2+XI0) * 2^{2n} )
+            for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+                square[i].a[l][j][idx] <== f[i+1][l][j][idx];
+                square[i].b[l][j][idx] <== f[i+1][l][j][idx];
+            }
+            for(var idP=0; idP<2; idP++){
+                line[i][idP] = LineFunctionEqualFp2(n, k, q); // 6 x 2 x k registers in [0, 2^n) 
+                for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)for(var l=0; l<2; l++)
+                    line[i][idP].P[j][l][idx] <== R[i+1][idP][j][l][idx];            
+                for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                    line[i][idP].Q[j][idx] <== Q[idP][j][idx];
+
+                Pdouble[i][idP] = EllipticCurveDoubleFp2(n, k, [0,0], b, q);  
+                for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)for(var l=0; l<2; l++)
+                    Pdouble[i][idP].in[j][l][idx] <== R[i+1][idP][j][l][idx]; 
+            }
+            
+            nocarry[i] = SignedFp12MultiplyNoCarryUnequal(n, 2*k-1, k, 3*n + LOGK2); // 6 x 2 x 3k-2 registers < (6 * (2+XI0))^2 * k^2 * 2^{3n} ) 
+            for(var l=0; l<6; l++)for(var j=0; j<2; j++){
+                for(var idx=0; idx<2*k-1; idx++)
+                    nocarry[i].a[l][j][idx] <== square[i].out[l][j][idx];
+                for(var idx=0; idx<k; idx++)
+                    nocarry[i].b[l][j][idx] <== line[i][0].out[l][j][idx];
+            }
+            
+            compress[i] = Fp12Compress(n, k, 2*k-2, q, 4*n + LOGK3); // 6 x 2 x k registers < (6 * (2+ XI0))^2 * k^2 * (2k-1) * 2^{4n} )
+            for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<3*k-2; idx++)
+                compress[i].in[l][j][idx] <== nocarry[i].out[l][j][idx];
+            
+            fdouble_0[i] = SignedFp12CarryModP(n, k, 4*n + LOGK3, q);
+            for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                fdouble_0[i].in[l][j][idx] <== compress[i].out[l][j][idx]; 
+            
+            fdouble[i] = Fp12Multiply(n, k, q);
+            for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+                fdouble[i].a[l][j][idx] <== fdouble_0[i].out[l][j][idx];
+                fdouble[i].b[l][j][idx] <== line[i][1].out[l][j][idx];
+            }
+
+            if(Bits[i] == 0){
+                for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                    f[i][l][j][idx] <== fdouble[i].out[l][j][idx]; 
+                for(var idP=0; idP<2; idP++)
+                    for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)for(var l=0; l<2; l++)
+                        R[i][idP][j][l][idx] <== Pdouble[i][idP].out[j][l][idx];
+            }else{
+                for(var idP=0; idP<2; idP++){
+                    fadd[curid][idP] = Fp12MultiplyWithLineUnequalFp2(n, k, k, n, q); 
+                    for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++){
+                        if(idP == 0)
+                            fadd[curid][idP].g[l][j][idx] <== fdouble[i].out[l][j][idx];
+                        else
+                            fadd[curid][idP].g[l][j][idx] <== fadd[curid][idP-1].out[l][j][idx];
+                    }
+                
+                    for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)for(var l=0; l<2; l++){
+                        fadd[curid][idP].P[0][j][l][idx] <== Pdouble[i][idP].out[j][l][idx]; 
+                        fadd[curid][idP].P[1][j][l][idx] <== P[idP][j][l][idx];            
+                    }
+                    for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                        fadd[curid][idP].Q[j][idx] <== Q[idP][j][idx];
+
+                    // Padd[curid][idP] = Pdouble[i][idP] + P[idP] 
+                    Padd[curid][idP] = EllipticCurveAddUnequalFp2(n, k, q); 
+                    for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)for(var l=0; l<2; l++){
+                        Padd[curid][idP].a[j][l][idx] <== Pdouble[i][idP].out[j][l][idx];
+                        Padd[curid][idP].b[j][l][idx] <== P[idP][j][l][idx];
+                    }
+
+                    for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)for(var l=0; l<2; l++)
+                        R[i][idP][j][l][idx] <== Padd[curid][idP].out[j][l][idx];
+                
+                }
+                for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+                    f[i][l][j][idx] <== fadd[curid][1].out[l][j][idx]; 
+
+                curid++;
+            }
+        }
+    }
+    for(var l=0; l<6; l++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+        out[l][j][idx] <== f[0][l][j][idx];
+}
+
+template OptimalAtePairing(n, k, q){
+    signal input P[2][2][k]; 
+    signal input Q[2][k];
+    signal output out[6][2][k];
+
+    var x = get_BLS12_381_parameter();
+
+    signal negP[2][2][k]; // (x, -y) mod q
+    // currently EllipticCurveDoubleFp2 relies on 0 <= in < p so we cannot pass a negative number for negP
+    component neg[2];
+    for(var j=0; j<2; j++){
+        neg[j] = FpNegate(n, k, q); 
+        for(var idx=0; idx<k; idx++)
+            neg[j].in[idx] <== P[1][j][idx];
+        for(var idx=0; idx<k; idx++){
+            negP[0][j][idx] <== P[0][j][idx];
+            negP[1][j][idx] <== neg[j].out[idx];
+        }
+    }
+    component miller = MillerLoopFp2(n, k, [4,4], x, q);
+    for(var i=0; i<2; i++)for(var j=0; j <2; j++)for(var idx=0; idx<k; idx++)
+        miller.P[i][j][idx] <== negP[i][j][idx];
+    for(var i=0; i<2; i++)for(var idx=0; idx<k; idx++)
+        miller.Q[i][idx] <== Q[i][idx];
+    /*for(var i = 0; i <6; i ++)for(var j = 0; j < 2; j++)for(var l = 0; l < k; l++) {
+        if (i==0 && j == 0 && l == 0) {
+            miller.in[i][j][l] <== 1;
+        }
+        else {
+            miller.in[i][j][l] <== 0;
+        }
+    }*/
+    
+    component finalexp = FinalExponentiate(n, k, q);
+    for(var i=0; i<6; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+        finalexp.in[i][j][idx] <== miller.out[i][j][idx];
+
+    for(var i=0; i<6; i++)for(var j=0; j<2; j++)for(var idx=0; idx<k; idx++)
+        out[i][j][idx] <== finalexp.out[i][j][idx]; 
+
+    /*
+    // check out[i][j] < p since we never did that previously
+    component lt[6][2];
+    for(var i=0; i<6; i++)for(var j=0; j<2; j++){
+        lt[i][j] = BigLessThan(n, k);
+        for(var idx=0; idx<k; idx++){
+            lt[i][j].a[idx] <== out[i][j][idx];
+            lt[i][j].b[idx] <== q[idx];
+        }
+        lt[i][j].out === 1;
+    }*/
+}
+
diff --git a/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/detect.sage b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/detect.sage
new file mode 100644
index 0000000..d3b69dc
--- /dev/null
+++ b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/detect.sage
@@ -0,0 +1,149 @@
+import json
+
+# input was taken from https://github.com/yi-sun/circom-pairing/blob/c686f0011f8d18e0c11bd87e0a109e9478eb9e61/scripts/signature/input_signature.json
+valid_input = {
+  "pubkey": [["2009822906594717","20442509737585892","19998406545305169","3257293002446733","9524330011591718","22878868367690592","556175690519393"],["5482847202149361","4456548308632729","21161498208540270","18926196016982932","18046733294100249","18607721477678504","984728513755546"]],
+  "signature": [[["1487298433264780","21541914032228149","73299277954222","20592869769470411","32212248507196091","17554646455239324","1400739176536426"],["27905525805850593","18587761296700115","8576740118892489","11542896562448560","7356486269846127","23099198775676489","1749349290976783"]],[["31664845608474726","21511101585070684","7988459814562914","21965083449674839","34785620406298652","8737667885256512","1239676855703922"],["21168837382994750","18380311182872957","1550072237479276","25163299916141397","15976128696107164","19450465035445157","1263320772306782"]]],
+  "hash": [[["8670705751816379","27916718246162202","6395341560288320","5071828068778565","884362211036596","13355992922842281","1162842904818986"],["14717501328985393","31614581546810189","9166577628201389","7197046436844177","34297293075691057","30988820664340476","955223845761836"]],[["26176120477808773","17848253405193635","10200691223057045","30698812458808988","35170596397378464","16950994534356644","1023288348312740"],["626986936810458","13104768905936102","12195987525789509","7065968987246367","12036339442865628","7744881743405338","1545199030663080"]]]
+}
+
+# Convert all string entries to integers in valid_input
+valid_input = {
+    "pubkey": [[int(x) for x in row] for row in valid_input["pubkey"]],
+    "signature": [[[int(x) for x in subrow] for subrow in row] for row in valid_input["signature"]],
+    "hash": [[[int(x) for x in subrow] for subrow in row] for row in valid_input["hash"]]
+}
+
+# defined in bls12_381_func.get_BLS12_381_prime()
+p = [35747322042231467, 36025922209447795, 1084959616957103, 7925923977987733, 16551456537884751, 23443114579904617, 1829881462546425]
+
+def array_to_number(arr):
+    """
+    Convert a 7-part array representation of a number to a single integer.
+    Each part represents 64 bits of the number.
+    """
+    result = 0
+    for i, part in enumerate(reversed(arr)):
+        result += part << (64 * i)
+    return result
+
+def number_to_array(num):
+    """
+    Convert a single integer to a 7-part array representation.
+    Each part represents 64 bits of the number.
+    """
+    result = []
+    mask = (1 << 64) - 1  # 64-bit mask
+    for _ in range(7):
+        result.append(num & mask)
+        num >>= 64
+    return list(reversed(result))
+
+# Convert array to number
+p_num = array_to_number(p)
+print(f"p as a number: {p_num}")
+
+# Convert number back to array
+p_array = number_to_array(p_num)
+print(f"p as an array: {p_array}")
+
+# Verify that the conversion is correct
+print(f"Original p and converted p_array are equal: {p == p_array}")
+
+
+# Function to create a delta that causes overflow but doesn't exceed 2^55 - 1
+def create_overflow_delta(original, p):
+    delta = [0] * 7
+    max_value = 2**55 - 1
+    for i in range(7):
+        if original[i] <= p[i]:
+            delta[i] = min(p[i] - original[i] + 1, max_value - original[i])
+        else:
+            delta[i] = 0
+    return delta
+
+# Convert delta array to number
+def delta_to_number(delta):
+    return sum(d << (64 * i) for i, d in enumerate(reversed(delta)))
+
+# Calculate deltas for each component
+pubkey0_delta = create_overflow_delta(valid_input["pubkey"][0], p)
+pubkey1_delta = create_overflow_delta(valid_input["pubkey"][1], p)
+signature00_delta = create_overflow_delta(valid_input["signature"][0][0], p)
+signature01_delta = create_overflow_delta(valid_input["signature"][0][1], p)
+signature10_delta = create_overflow_delta(valid_input["signature"][1][0], p)
+signature11_delta = create_overflow_delta(valid_input["signature"][1][1], p)
+hash00_delta = create_overflow_delta(valid_input["hash"][0][0], p)
+hash01_delta = create_overflow_delta(valid_input["hash"][0][1], p)
+hash10_delta = create_overflow_delta(valid_input["hash"][1][0], p)
+hash11_delta = create_overflow_delta(valid_input["hash"][1][1], p)
+
+# Calculate modified values
+pubkey0 = number_to_array(array_to_number(valid_input["pubkey"][0]) + delta_to_number(pubkey0_delta))
+pubkey1 = number_to_array(array_to_number(valid_input["pubkey"][1]) + delta_to_number(pubkey1_delta))
+signature00 = number_to_array(array_to_number(valid_input["signature"][0][0]) + delta_to_number(signature00_delta))
+signature01 = number_to_array(array_to_number(valid_input["signature"][0][1]) + delta_to_number(signature01_delta))
+signature10 = number_to_array(array_to_number(valid_input["signature"][1][0]) + delta_to_number(signature10_delta))
+signature11 = number_to_array(array_to_number(valid_input["signature"][1][1]) + delta_to_number(signature11_delta))
+hash00 = number_to_array(array_to_number(valid_input["hash"][0][0]) + delta_to_number(hash00_delta))
+hash01 = number_to_array(array_to_number(valid_input["hash"][0][1]) + delta_to_number(hash01_delta))
+hash10 = number_to_array(array_to_number(valid_input["hash"][1][0]) + delta_to_number(hash10_delta))
+hash11 = number_to_array(array_to_number(valid_input["hash"][1][1]) + delta_to_number(hash11_delta))
+
+# Prepare the output dictionary
+output = {
+    "pubkey": [
+        [str(x) for x in pubkey0],
+        [str(x) for x in pubkey1]
+    ],
+    "signature": [
+        [
+            [str(x) for x in signature00],
+            [str(x) for x in signature01]
+        ],
+        [
+            [str(x) for x in signature10],
+            [str(x) for x in signature11]
+        ]
+    ],
+    "hash": [
+        [
+            [str(x) for x in hash00],
+            [str(x) for x in hash01]
+        ],
+        [
+            [str(x) for x in hash10],
+            [str(x) for x in hash11]
+        ]
+    ]
+}
+
+# Print the output in JSON format
+print(json.dumps(output, indent=2))
+
+# Verify overflow and range check
+def verify_overflow_and_range(original, modified, p):
+    overflow = False
+    range_check_pass = True
+    for o, m, p_val in zip(original, modified, p):
+        if m > p_val:
+            overflow = True
+        if m > 2**55 - 1:
+            range_check_pass = False
+    return overflow, range_check_pass
+
+print("\nOverflow and Range Check verification:")
+for name, orig, mod in [
+    ("pubkey[0]", valid_input['pubkey'][0], pubkey0),
+    ("pubkey[1]", valid_input['pubkey'][1], pubkey1),
+    ("signature[0][0]", valid_input['signature'][0][0], signature00),
+    ("signature[0][1]", valid_input['signature'][0][1], signature01),
+    ("signature[1][0]", valid_input['signature'][1][0], signature10),
+    ("signature[1][1]", valid_input['signature'][1][1], signature11),
+    ("hash[0][0]", valid_input['hash'][0][0], hash00),
+    ("hash[0][1]", valid_input['hash'][0][1], hash01),
+    ("hash[1][0]", valid_input['hash'][1][0], hash10),
+    ("hash[1][1]", valid_input['hash'][1][1], hash11)
+]:
+    overflow, range_check = verify_overflow_and_range(orig, mod, p)
+    print(f"{name}: Overflow: {overflow}, Range Check Pass: {range_check}")
\ No newline at end of file
diff --git a/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/exploitable_witness.json b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/exploitable_witness.json
new file mode 100644
index 0000000..11a58a6
--- /dev/null
+++ b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/exploitable_witness.json
@@ -0,0 +1,5384 @@
+[
+  "1",
+  "0",
+  "35747322042231468",
+  "36025922209447796",
+  "19998406545305169",
+  "7925923977987734",
+  "16551456537884752",
+  "23443114579904618",
+  "1829881462546426",
+  "35747322042231468",
+  "36025922209447796",
+  "21161498208540270",
+  "18926196016982932",
+  "18046733294100249",
+  "23443114579904618",
+  "1829881462546426",
+  "35747322042231468",
+  "36025922209447796",
+  "1084959616957104",
+  "20592869769470411",
+  "32212248507196091",
+  "23443114579904618",
+  "1829881462546426",
+  "35747322042231468",
+  "36025922209447796",
+  "8576740118892489",
+  "11542896562448560",
+  "16551456537884752",
+  "23443114579904618",
+  "1829881462546426",
+  "35747322042231468",
+  "36025922209447796",
+  "7988459814562914",
+  "21965083449674839",
+  "34785620406298652",
+  "23443114579904618",
+  "1829881462546426",
+  "35747322042231468",
+  "36025922209447796",
+  "1550072237479276",
+  "25163299916141397",
+  "16551456537884752",
+  "23443114579904618",
+  "1829881462546426",
+  "35747322042231468",
+  "36025922209447796",
+  "6395341560288320",
+  "7925923977987734",
+  "16551456537884752",
+  "23443114579904618",
+  "1829881462546426",
+  "35747322042231468",
+  "36025922209447796",
+  "9166577628201389",
+  "7925923977987734",
+  "34297293075691057",
+  "30988820664340476",
+  "1829881462546426",
+  "35747322042231468",
+  "36025922209447796",
+  "10200691223057045",
+  "30698812458808988",
+  "35170596397378464",
+  "23443114579904618",
+  "1829881462546426",
+  "35747322042231468",
+  "36025922209447796",
+  "12195987525789509",
+  "7925923977987734",
+  "16551456537884752",
+  "23443114579904618",
+  "1829881462546426",
+  "0",
+  "35747322042231468",
+  "36025922209447796",
+  "19998406545305169",
+  "7925923977987734",
+  "16551456537884752",
+  "23443114579904618",
+  "1829881462546426",
+  "35747322042231467",
+  "36025922209447795",
+  "1084959616957103",
+  "7925923977987733",
+  "16551456537884751",
+  "23443114579904617",
+  "1829881462546425",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "35747322042231468",
+  "35747322042231467",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "36025922209447796",
+  "36025922209447795",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "19998406545305169",
+  "1084959616957103",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698185273128880147551",
+  "16520788812845429032235950627030886889699386256410977867434853674377329072339",
+  "0",
+  "7925923977987734",
+  "7925923977987733",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "16551456537884752",
+  "16551456537884751",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "23443114579904618",
+  "23443114579904617",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "1829881462546426",
+  "1829881462546425",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "35747322042231468",
+  "35747322042231467",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "36025922209447796",
+  "36025922209447795",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "19998406545305169",
+  "1084959616957103",
+  "0",
+  "1",
+  "0",
+  "0",
+  "0",
+  "1",
+  "0",
+  "1",
+  "1",
+  "1",
+  "0",
+  "0",
+  "1",
+  "1",
+  "1",
+  "0",
+  "0",
+  "0",
+  "1",
+  "0",
+  "0",
+  "1",
+  "0",
+  "1",
+  "1",
+  "0",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "1",
+  "1",
+  "0",
+  "1",
+  "0",
+  "1",
+  "1",
+  "0",
+  "0",
+  "0",
+  "1",
+  "1",
+  "0",
+  "0",
+  "1",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "1",
+  "54942243947312034",
+  "0",
+  "7925923977987734",
+  "7925923977987733",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "16551456537884752",
+  "16551456537884751",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "23443114579904618",
+  "23443114579904617",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "1829881462546426",
+  "1829881462546425",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "35747322042231468",
+  "36025922209447796",
+  "21161498208540270",
+  "18926196016982932",
+  "18046733294100249",
+  "23443114579904618",
+  "1829881462546426",
+  "35747322042231467",
+  "36025922209447795",
+  "1084959616957103",
+  "7925923977987733",
+  "16551456537884751",
+  "23443114579904617",
+  "1829881462546425",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "35747322042231468",
+  "35747322042231467",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "36025922209447796",
+  "36025922209447795",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "21161498208540270",
+  "1084959616957103",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698184110037216912450",
+  "6488557114232293078595353579087145833199287004409292759198246499940658832332",
+  "0",
+  "18926196016982932",
+  "7925923977987733",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698193186303769500418",
+  "16945135252984555788352814838481825172650093920524874724792817889509888317698",
+  "0",
+  "18046733294100249",
+  "16551456537884751",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698202691299052280119",
+  "4890169191046987992003874053369267051937095441254263105395177553142500076245",
+  "0",
+  "23443114579904618",
+  "23443114579904617",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "1829881462546426",
+  "1829881462546425",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "35747322042231468",
+  "35747322042231467",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "36025922209447796",
+  "36025922209447795",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "21161498208540270",
+  "1084959616957103",
+  "1",
+  "1",
+  "1",
+  "1",
+  "1",
+  "1",
+  "0",
+  "1",
+  "1",
+  "1",
+  "0",
+  "1",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "0",
+  "0",
+  "1",
+  "0",
+  "0",
+  "0",
+  "1",
+  "1",
+  "1",
+  "0",
+  "0",
+  "1",
+  "1",
+  "0",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "1",
+  "1",
+  "0",
+  "0",
+  "1",
+  "0",
+  "1",
+  "0",
+  "1",
+  "1",
+  "1",
+  "0",
+  "0",
+  "0",
+  "1",
+  "1",
+  "56105335610547135",
+  "0",
+  "18926196016982932",
+  "7925923977987733",
+  "1",
+  "1",
+  "1",
+  "1",
+  "1",
+  "1",
+  "1",
+  "1",
+  "0",
+  "0",
+  "1",
+  "0",
+  "0",
+  "1",
+  "0",
+  "0",
+  "1",
+  "0",
+  "0",
+  "0",
+  "1",
+  "0",
+  "1",
+  "0",
+  "1",
+  "1",
+  "0",
+  "1",
+  "0",
+  "1",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "1",
+  "0",
+  "1",
+  "0",
+  "0",
+  "1",
+  "0",
+  "1",
+  "0",
+  "0",
+  "0",
+  "1",
+  "1",
+  "1",
+  "0",
+  "0",
+  "1",
+  "0",
+  "1",
+  "47029069057959167",
+  "0",
+  "18046733294100249",
+  "16551456537884751",
+  "0",
+  "1",
+  "0",
+  "1",
+  "0",
+  "0",
+  "1",
+  "1",
+  "0",
+  "1",
+  "1",
+  "0",
+  "0",
+  "1",
+  "0",
+  "0",
+  "1",
+  "0",
+  "1",
+  "0",
+  "0",
+  "1",
+  "1",
+  "1",
+  "1",
+  "1",
+  "1",
+  "1",
+  "1",
+  "1",
+  "0",
+  "0",
+  "0",
+  "1",
+  "0",
+  "0",
+  "1",
+  "1",
+  "1",
+  "1",
+  "1",
+  "1",
+  "1",
+  "1",
+  "0",
+  "0",
+  "1",
+  "0",
+  "1",
+  "0",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "37524073775179466",
+  "0",
+  "23443114579904618",
+  "23443114579904617",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "1829881462546426",
+  "1829881462546425",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "35747322042231468",
+  "36025922209447796",
+  "1084959616957104",
+  "20592869769470411",
+  "32212248507196091",
+  "23443114579904618",
+  "1829881462546426",
+  "35747322042231467",
+  "36025922209447795",
+  "1084959616957103",
+  "7925923977987733",
+  "16551456537884751",
+  "23443114579904617",
+  "1829881462546425",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "35747322042231468",
+  "35747322042231467",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "36025922209447796",
+  "36025922209447795",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "1084959616957104",
+  "1084959616957103",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "20592869769470411",
+  "7925923977987733",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698191519630017012939",
+  "19985984210725198804253141309924435795463765463353705078260143127272739957268",
+  "0",
+  "32212248507196091",
+  "16551456537884751",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698188525783839184277",
+  "5778141431974268658089061185479077583321867475738024177594002965731349082725",
+  "0",
+  "23443114579904618",
+  "23443114579904617",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "1829881462546426",
+  "1829881462546425",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "35747322042231468",
+  "35747322042231467",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "36025922209447796",
+  "36025922209447795",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "1084959616957104",
+  "1084959616957103",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "20592869769470411",
+  "7925923977987733",
+  "0",
+  "1",
+  "1",
+  "0",
+  "1",
+  "1",
+  "0",
+  "0",
+  "1",
+  "1",
+  "0",
+  "1",
+  "1",
+  "0",
+  "1",
+  "0",
+  "0",
+  "1",
+  "0",
+  "1",
+  "0",
+  "0",
+  "1",
+  "0",
+  "0",
+  "0",
+  "1",
+  "0",
+  "0",
+  "1",
+  "0",
+  "0",
+  "1",
+  "0",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "0",
+  "1",
+  "1",
+  "0",
+  "1",
+  "0",
+  "1",
+  "48695742810446646",
+  "0",
+  "32212248507196091",
+  "16551456537884751",
+  "0",
+  "0",
+  "1",
+  "1",
+  "0",
+  "1",
+  "1",
+  "0",
+  "0",
+  "1",
+  "0",
+  "1",
+  "0",
+  "1",
+  "1",
+  "0",
+  "1",
+  "1",
+  "0",
+  "1",
+  "1",
+  "1",
+  "0",
+  "0",
+  "0",
+  "1",
+  "1",
+  "0",
+  "0",
+  "0",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "0",
+  "1",
+  "1",
+  "0",
+  "1",
+  "1",
+  "0",
+  "0",
+  "0",
+  "1",
+  "0",
+  "1",
+  "1",
+  "1",
+  "1",
+  "0",
+  "1",
+  "1",
+  "0",
+  "1",
+  "51689588988275308",
+  "0",
+  "23443114579904618",
+  "23443114579904617",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "1829881462546426",
+  "1829881462546425",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "35747322042231468",
+  "36025922209447796",
+  "8576740118892489",
+  "11542896562448560",
+  "16551456537884752",
+  "23443114579904618",
+  "1829881462546426",
+  "35747322042231467",
+  "36025922209447795",
+  "1084959616957103",
+  "7925923977987733",
+  "16551456537884751",
+  "23443114579904617",
+  "1829881462546425",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "35747322042231468",
+  "35747322042231467",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "36025922209447796",
+  "36025922209447795",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "8576740118892489",
+  "1084959616957103",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698196694795306560231",
+  "208819881617586254036039768789500553669644730468365893097569125945919541310",
+  "0",
+  "11542896562448560",
+  "7925923977987733",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698200569603224034790",
+  "3241991901838845114673107346050696549681677270751501898386555638236624608603",
+  "0",
+  "16551456537884752",
+  "16551456537884751",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "23443114579904618",
+  "23443114579904617",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "1829881462546426",
+  "1829881462546425",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "35747322042231468",
+  "35747322042231467",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "36025922209447796",
+  "36025922209447795",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "8576740118892489",
+  "1084959616957103",
+  "0",
+  "1",
+  "0",
+  "1",
+  "1",
+  "0",
+  "0",
+  "0",
+  "1",
+  "0",
+  "1",
+  "0",
+  "1",
+  "0",
+  "0",
+  "1",
+  "1",
+  "0",
+  "1",
+  "1",
+  "0",
+  "0",
+  "0",
+  "1",
+  "1",
+  "1",
+  "0",
+  "0",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "1",
+  "1",
+  "1",
+  "0",
+  "1",
+  "1",
+  "0",
+  "1",
+  "1",
+  "1",
+  "0",
+  "0",
+  "1",
+  "0",
+  "1",
+  "0",
+  "1",
+  "1",
+  "0",
+  "0",
+  "1",
+  "43520577520899354",
+  "0",
+  "11542896562448560",
+  "7925923977987733",
+  "1",
+  "1",
+  "0",
+  "1",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "0",
+  "0",
+  "0",
+  "1",
+  "0",
+  "0",
+  "1",
+  "1",
+  "1",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "1",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "1",
+  "1",
+  "1",
+  "0",
+  "0",
+  "1",
+  "1",
+  "0",
+  "0",
+  "1",
+  "1",
+  "0",
+  "1",
+  "1",
+  "0",
+  "0",
+  "1",
+  "1",
+  "0",
+  "0",
+  "0",
+  "1",
+  "39645769603424795",
+  "0",
+  "16551456537884752",
+  "16551456537884751",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "23443114579904618",
+  "23443114579904617",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "1829881462546426",
+  "1829881462546425",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "35747322042231468",
+  "36025922209447796",
+  "7988459814562914",
+  "21965083449674839",
+  "34785620406298652",
+  "23443114579904618",
+  "1829881462546426",
+  "35747322042231467",
+  "36025922209447795",
+  "1084959616957103",
+  "7925923977987733",
+  "16551456537884751",
+  "23443114579904617",
+  "1829881462546425",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "35747322042231468",
+  "35747322042231467",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "36025922209447796",
+  "36025922209447795",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "7988459814562914",
+  "1084959616957103",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698197283075610889806",
+  "12979815355392756546673711104581649694970160906255193053464009433921460721138",
+  "0",
+  "21965083449674839",
+  "7925923977987733",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698190147416336808511",
+  "13899821287551822815266267483886503442766475306109950708337534545610930833702",
+  "0",
+  "34785620406298652",
+  "16551456537884751",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698185952411940081716",
+  "828444493769929996644733936852419401751282313098016664703515388789877267866",
+  "0",
+  "23443114579904618",
+  "23443114579904617",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "1829881462546426",
+  "1829881462546425",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "35747322042231468",
+  "35747322042231467",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "36025922209447796",
+  "36025922209447795",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "7988459814562914",
+  "1084959616957103",
+  "1",
+  "1",
+  "0",
+  "0",
+  "1",
+  "1",
+  "0",
+  "1",
+  "1",
+  "0",
+  "0",
+  "0",
+  "1",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "1",
+  "1",
+  "1",
+  "1",
+  "1",
+  "0",
+  "0",
+  "1",
+  "0",
+  "0",
+  "1",
+  "1",
+  "0",
+  "0",
+  "1",
+  "0",
+  "0",
+  "1",
+  "1",
+  "0",
+  "1",
+  "0",
+  "1",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "0",
+  "0",
+  "0",
+  "1",
+  "1",
+  "0",
+  "0",
+  "1",
+  "42932297216569779",
+  "0",
+  "21965083449674839",
+  "7925923977987733",
+  "0",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "1",
+  "1",
+  "0",
+  "1",
+  "0",
+  "0",
+  "0",
+  "1",
+  "0",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "0",
+  "1",
+  "0",
+  "0",
+  "1",
+  "0",
+  "0",
+  "0",
+  "1",
+  "0",
+  "1",
+  "0",
+  "1",
+  "0",
+  "0",
+  "0",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "1",
+  "1",
+  "1",
+  "0",
+  "0",
+  "0",
+  "1",
+  "1",
+  "0",
+  "1",
+  "50067956490651074",
+  "0",
+  "34785620406298652",
+  "16551456537884751",
+  "1",
+  "0",
+  "1",
+  "1",
+  "0",
+  "0",
+  "1",
+  "1",
+  "1",
+  "1",
+  "1",
+  "1",
+  "0",
+  "1",
+  "0",
+  "0",
+  "1",
+  "1",
+  "1",
+  "0",
+  "0",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "1",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "1",
+  "1",
+  "1",
+  "1",
+  "1",
+  "0",
+  "0",
+  "0",
+  "1",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "1",
+  "54262960887377869",
+  "0",
+  "23443114579904618",
+  "23443114579904617",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "1829881462546426",
+  "1829881462546425",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "35747322042231468",
+  "36025922209447796",
+  "1550072237479276",
+  "25163299916141397",
+  "16551456537884752",
+  "23443114579904618",
+  "1829881462546426",
+  "35747322042231467",
+  "36025922209447795",
+  "1084959616957103",
+  "7925923977987733",
+  "16551456537884751",
+  "23443114579904617",
+  "1829881462546425",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "35747322042231468",
+  "35747322042231467",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "36025922209447796",
+  "36025922209447795",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "1550072237479276",
+  "1084959616957103",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698203721463187973444",
+  "20157493906088655933013727174709483555979150143989472671779323480418737379070",
+  "0",
+  "25163299916141397",
+  "7925923977987733",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698186949199870341953",
+  "10281520796381386760604212247478733941633207222128954966736411823433537474695",
+  "0",
+  "16551456537884752",
+  "16551456537884751",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "23443114579904618",
+  "23443114579904617",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "1829881462546426",
+  "1829881462546425",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "35747322042231468",
+  "35747322042231467",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "36025922209447796",
+  "36025922209447795",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "1550072237479276",
+  "1084959616957103",
+  "1",
+  "0",
+  "1",
+  "1",
+  "1",
+  "1",
+  "0",
+  "1",
+  "0",
+  "1",
+  "0",
+  "1",
+  "1",
+  "0",
+  "1",
+  "1",
+  "0",
+  "1",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "0",
+  "0",
+  "0",
+  "1",
+  "1",
+  "1",
+  "1",
+  "0",
+  "0",
+  "0",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "1",
+  "1",
+  "0",
+  "0",
+  "1",
+  "0",
+  "1",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36493909639486141",
+  "0",
+  "25163299916141397",
+  "7925923977987733",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "1",
+  "0",
+  "0",
+  "1",
+  "1",
+  "0",
+  "0",
+  "1",
+  "0",
+  "1",
+  "1",
+  "1",
+  "0",
+  "0",
+  "1",
+  "0",
+  "1",
+  "1",
+  "0",
+  "1",
+  "0",
+  "1",
+  "0",
+  "1",
+  "0",
+  "1",
+  "0",
+  "1",
+  "1",
+  "0",
+  "0",
+  "1",
+  "0",
+  "1",
+  "0",
+  "1",
+  "1",
+  "1",
+  "1",
+  "0",
+  "0",
+  "1",
+  "0",
+  "1",
+  "1",
+  "1",
+  "1",
+  "0",
+  "1",
+  "53266172957117632",
+  "0",
+  "16551456537884752",
+  "16551456537884751",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "23443114579904618",
+  "23443114579904617",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "1829881462546426",
+  "1829881462546425",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "35747322042231468",
+  "36025922209447796",
+  "6395341560288320",
+  "7925923977987734",
+  "16551456537884752",
+  "23443114579904618",
+  "1829881462546426",
+  "35747322042231467",
+  "36025922209447795",
+  "1084959616957103",
+  "7925923977987733",
+  "16551456537884751",
+  "23443114579904617",
+  "1829881462546425",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "35747322042231468",
+  "35747322042231467",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "36025922209447796",
+  "36025922209447795",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "6395341560288320",
+  "1084959616957103",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698198876193865164400",
+  "7215719450100762043190880201539238573897727258277246424856368174425868728816",
+  "0",
+  "7925923977987734",
+  "7925923977987733",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "16551456537884752",
+  "16551456537884751",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "23443114579904618",
+  "23443114579904617",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "1829881462546426",
+  "1829881462546425",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "35747322042231468",
+  "35747322042231467",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "36025922209447796",
+  "36025922209447795",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "6395341560288320",
+  "1084959616957103",
+  "1",
+  "0",
+  "0",
+  "0",
+  "1",
+  "0",
+  "0",
+  "1",
+  "1",
+  "0",
+  "0",
+  "1",
+  "1",
+  "0",
+  "0",
+  "1",
+  "0",
+  "1",
+  "0",
+  "1",
+  "1",
+  "0",
+  "1",
+  "0",
+  "1",
+  "0",
+  "1",
+  "0",
+  "0",
+  "1",
+  "0",
+  "1",
+  "1",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "1",
+  "1",
+  "0",
+  "1",
+  "1",
+  "1",
+  "0",
+  "1",
+  "1",
+  "0",
+  "1",
+  "0",
+  "0",
+  "1",
+  "0",
+  "0",
+  "1",
+  "41339178962295185",
+  "0",
+  "7925923977987734",
+  "7925923977987733",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "16551456537884752",
+  "16551456537884751",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "23443114579904618",
+  "23443114579904617",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "1829881462546426",
+  "1829881462546425",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "35747322042231468",
+  "36025922209447796",
+  "9166577628201389",
+  "7925923977987734",
+  "34297293075691057",
+  "30988820664340476",
+  "1829881462546426",
+  "35747322042231467",
+  "36025922209447795",
+  "1084959616957103",
+  "7925923977987733",
+  "16551456537884751",
+  "23443114579904617",
+  "1829881462546425",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "35747322042231468",
+  "35747322042231467",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "36025922209447796",
+  "36025922209447795",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "9166577628201389",
+  "1084959616957103",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698196104957797251331",
+  "15974043596773785231530221636012875200337517092897163182135700218422342725119",
+  "0",
+  "7925923977987734",
+  "7925923977987733",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "34297293075691057",
+  "16551456537884751",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698186440739270689311",
+  "21810317087749038893144242477217639833599314740970744832595548992883272044760",
+  "0",
+  "30988820664340476",
+  "23443114579904617",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698196640869724059758",
+  "13278077414891367582982143550146232467192302940109820833597467153533861807476",
+  "0",
+  "1829881462546426",
+  "1829881462546425",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "35747322042231468",
+  "35747322042231467",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "36025922209447796",
+  "36025922209447795",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "9166577628201389",
+  "1084959616957103",
+  "0",
+  "1",
+  "1",
+  "1",
+  "1",
+  "1",
+  "1",
+  "1",
+  "0",
+  "1",
+  "1",
+  "0",
+  "0",
+  "0",
+  "1",
+  "0",
+  "1",
+  "0",
+  "1",
+  "0",
+  "0",
+  "0",
+  "1",
+  "1",
+  "0",
+  "1",
+  "0",
+  "0",
+  "1",
+  "0",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "1",
+  "0",
+  "0",
+  "0",
+  "1",
+  "1",
+  "0",
+  "1",
+  "1",
+  "0",
+  "1",
+  "0",
+  "0",
+  "1",
+  "1",
+  "1",
+  "0",
+  "0",
+  "1",
+  "44110415030208254",
+  "0",
+  "7925923977987734",
+  "7925923977987733",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "34297293075691057",
+  "16551456537884751",
+  "0",
+  "1",
+  "0",
+  "0",
+  "0",
+  "1",
+  "1",
+  "1",
+  "1",
+  "0",
+  "1",
+  "1",
+  "1",
+  "1",
+  "1",
+  "1",
+  "1",
+  "1",
+  "0",
+  "0",
+  "1",
+  "0",
+  "0",
+  "0",
+  "1",
+  "1",
+  "0",
+  "1",
+  "0",
+  "0",
+  "0",
+  "1",
+  "0",
+  "1",
+  "1",
+  "1",
+  "1",
+  "1",
+  "0",
+  "1",
+  "1",
+  "1",
+  "0",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "1",
+  "1",
+  "1",
+  "1",
+  "1",
+  "0",
+  "1",
+  "53774633556770274",
+  "0",
+  "30988820664340476",
+  "23443114579904617",
+  "1",
+  "1",
+  "0",
+  "0",
+  "1",
+  "0",
+  "0",
+  "1",
+  "1",
+  "1",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "1",
+  "1",
+  "1",
+  "1",
+  "0",
+  "1",
+  "0",
+  "1",
+  "0",
+  "1",
+  "1",
+  "0",
+  "0",
+  "1",
+  "1",
+  "1",
+  "1",
+  "0",
+  "0",
+  "0",
+  "1",
+  "1",
+  "0",
+  "1",
+  "1",
+  "1",
+  "0",
+  "0",
+  "1",
+  "1",
+  "0",
+  "1",
+  "0",
+  "1",
+  "1",
+  "0",
+  "0",
+  "1",
+  "43574503103399827",
+  "0",
+  "1829881462546426",
+  "1829881462546425",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "35747322042231468",
+  "36025922209447796",
+  "10200691223057045",
+  "30698812458808988",
+  "35170596397378464",
+  "23443114579904618",
+  "1829881462546426",
+  "35747322042231467",
+  "36025922209447795",
+  "1084959616957103",
+  "7925923977987733",
+  "16551456537884751",
+  "23443114579904617",
+  "1829881462546425",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "35747322042231468",
+  "35747322042231467",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "36025922209447796",
+  "36025922209447795",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "10200691223057045",
+  "1084959616957103",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698195070844202395675",
+  "4862374403137229224276224674963193250633460957214309765946456252636148996902",
+  "0",
+  "30698812458808988",
+  "7925923977987733",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698181413687327674362",
+  "10515241221951499826000312577185558876494437010110015499394598987226762252115",
+  "0",
+  "35170596397378464",
+  "16551456537884751",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698185567435949001904",
+  "472718225366416750889462589013864436498222954594521298256032725138322286115",
+  "0",
+  "23443114579904618",
+  "23443114579904617",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "1829881462546426",
+  "1829881462546425",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "35747322042231468",
+  "35747322042231467",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "36025922209447796",
+  "36025922209447795",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "10200691223057045",
+  "1084959616957103",
+  "0",
+  "1",
+  "1",
+  "0",
+  "0",
+  "1",
+  "1",
+  "1",
+  "1",
+  "1",
+  "1",
+  "0",
+  "1",
+  "0",
+  "1",
+  "1",
+  "1",
+  "1",
+  "1",
+  "1",
+  "1",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "0",
+  "1",
+  "0",
+  "1",
+  "1",
+  "0",
+  "1",
+  "0",
+  "1",
+  "1",
+  "0",
+  "1",
+  "0",
+  "1",
+  "0",
+  "0",
+  "0",
+  "1",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "0",
+  "1",
+  "45144528625063910",
+  "0",
+  "30698812458808988",
+  "7925923977987733",
+  "1",
+  "1",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "1",
+  "0",
+  "1",
+  "0",
+  "0",
+  "0",
+  "1",
+  "0",
+  "1",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "0",
+  "0",
+  "1",
+  "0",
+  "0",
+  "1",
+  "0",
+  "0",
+  "1",
+  "0",
+  "1",
+  "1",
+  "1",
+  "1",
+  "1",
+  "0",
+  "0",
+  "1",
+  "1",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "0",
+  "1",
+  "1",
+  "58801685499785223",
+  "0",
+  "35170596397378464",
+  "16551456537884751",
+  "1",
+  "0",
+  "0",
+  "0",
+  "1",
+  "0",
+  "1",
+  "0",
+  "1",
+  "1",
+  "0",
+  "0",
+  "1",
+  "1",
+  "0",
+  "0",
+  "1",
+  "0",
+  "0",
+  "1",
+  "1",
+  "0",
+  "1",
+  "0",
+  "1",
+  "0",
+  "0",
+  "0",
+  "1",
+  "0",
+  "1",
+  "0",
+  "0",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "1",
+  "0",
+  "0",
+  "1",
+  "0",
+  "0",
+  "0",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "1",
+  "54647936878457681",
+  "0",
+  "23443114579904618",
+  "23443114579904617",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "1829881462546426",
+  "1829881462546425",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "35747322042231468",
+  "36025922209447796",
+  "12195987525789509",
+  "7925923977987734",
+  "16551456537884752",
+  "23443114579904618",
+  "1829881462546426",
+  "35747322042231467",
+  "36025922209447795",
+  "1084959616957103",
+  "7925923977987733",
+  "16551456537884751",
+  "23443114579904617",
+  "1829881462546425",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "35747322042231468",
+  "35747322042231467",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "36025922209447796",
+  "36025922209447795",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "12195987525789509",
+  "1084959616957103",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698193075547899663211",
+  "11908078605498015048766704561858369961067595076592969295042120993749762395859",
+  "0",
+  "7925923977987734",
+  "7925923977987733",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "16551456537884752",
+  "16551456537884751",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "23443114579904618",
+  "23443114579904617",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "1829881462546426",
+  "1829881462546425",
+  "0",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "21888242871839275222246405745257275088548364400416034343698204186575808495616",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "35747322042231468",
+  "35747322042231467",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "36025922209447796",
+  "36025922209447795",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "12195987525789509",
+  "1084959616957103",
+  "0",
+  "1",
+  "1",
+  "0",
+  "1",
+  "0",
+  "0",
+  "1",
+  "0",
+  "0",
+  "1",
+  "1",
+  "0",
+  "1",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "1",
+  "0",
+  "0",
+  "1",
+  "1",
+  "1",
+  "1",
+  "0",
+  "0",
+  "0",
+  "1",
+  "1",
+  "1",
+  "1",
+  "0",
+  "1",
+  "0",
+  "1",
+  "1",
+  "0",
+  "1",
+  "0",
+  "0",
+  "1",
+  "1",
+  "1",
+  "1",
+  "0",
+  "1",
+  "1",
+  "1",
+  "0",
+  "0",
+  "1",
+  "0",
+  "1",
+  "47139824927796374",
+  "0",
+  "7925923977987734",
+  "7925923977987733",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "16551456537884752",
+  "16551456537884751",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "23443114579904618",
+  "23443114579904617",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "1829881462546426",
+  "1829881462546425",
+  "1",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "1",
+  "36028797018963969",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0",
+  "0"
+ ]
\ No newline at end of file
diff --git a/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/input.json b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/input.json
new file mode 100644
index 0000000..58dd2b8
--- /dev/null
+++ b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/input.json
@@ -0,0 +1,106 @@
+{
+    "pubkey": [
+      [
+        "35747322042231468",
+        "36025922209447796",
+        "19998406545305169",
+        "7925923977987734",
+        "16551456537884752",
+        "23443114579904618",
+        "1829881462546426"
+      ],
+      [
+        "35747322042231468",
+        "36025922209447796",
+        "21161498208540270",
+        "18926196016982932",
+        "18046733294100249",
+        "23443114579904618",
+        "1829881462546426"
+      ]
+    ],
+    "signature": [
+      [
+        [
+          "35747322042231468",
+          "36025922209447796",
+          "1084959616957104",
+          "20592869769470411",
+          "32212248507196091",
+          "23443114579904618",
+          "1829881462546426"
+        ],
+        [
+          "35747322042231468",
+          "36025922209447796",
+          "8576740118892489",
+          "11542896562448560",
+          "16551456537884752",
+          "23443114579904618",
+          "1829881462546426"
+        ]
+      ],
+      [
+        [
+          "35747322042231468",
+          "36025922209447796",
+          "7988459814562914",
+          "21965083449674839",
+          "34785620406298652",
+          "23443114579904618",
+          "1829881462546426"
+        ],
+        [
+          "35747322042231468",
+          "36025922209447796",
+          "1550072237479276",
+          "25163299916141397",
+          "16551456537884752",
+          "23443114579904618",
+          "1829881462546426"
+        ]
+      ]
+    ],
+    "hash": [
+      [
+        [
+          "35747322042231468",
+          "36025922209447796",
+          "6395341560288320",
+          "7925923977987734",
+          "16551456537884752",
+          "23443114579904618",
+          "1829881462546426"
+        ],
+        [
+          "35747322042231468",
+          "36025922209447796",
+          "9166577628201389",
+          "7925923977987734",
+          "34297293075691057",
+          "30988820664340476",
+          "1829881462546426"
+        ]
+      ],
+      [
+        [
+          "35747322042231468",
+          "36025922209447796",
+          "10200691223057045",
+          "30698812458808988",
+          "35170596397378464",
+          "23443114579904618",
+          "1829881462546426"
+        ],
+        [
+          "35747322042231468",
+          "36025922209447796",
+          "12195987525789509",
+          "7925923977987734",
+          "16551456537884752",
+          "23443114579904618",
+          "1829881462546426"
+        ]
+      ]
+    ]
+  }
\ No newline at end of file
diff --git a/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/zkbugs_clean.sh b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/zkbugs_clean.sh
new file mode 100755
index 0000000..1552cfc
--- /dev/null
+++ b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/zkbugs_clean.sh
@@ -0,0 +1,6 @@
+#!/bin/bash
+source zkbugs_vars.sh
+
+rm -rf ${TARGET}.sym ${TARGET}_0001.zkey ${TARGET}.r1cs ${TARGET}_0000.zkey ${TARGET}_js \
+    final.ptau proof.json verification_key.json detect.sage.py witness.json \
+    ${TARGET}.json public.json
diff --git a/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/zkbugs_compile_setup.sh b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/zkbugs_compile_setup.sh
new file mode 100755
index 0000000..8ad037e
--- /dev/null
+++ b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/zkbugs_compile_setup.sh
@@ -0,0 +1,36 @@
+#!/bin/bash
+source zkbugs_vars.sh
+
+# Check if circom, snarkjs, and the ptau file exist
+MISSING_TOOLS=()
+if ! command -v circom &> /dev/null; then
+    MISSING_TOOLS+=("circom")
+fi
+if ! command -v snarkjs &> /dev/null; then
+    MISSING_TOOLS+=("snarkjs")
+fi
+if [ ! -f "$PTAU_FILE" ]; then
+    MISSING_TOOLS+=("PTAU file")
+fi
+
+if [ ${#MISSING_TOOLS[@]} -ne 0 ]; then
+    echo "The following are missing: ${MISSING_TOOLS[*]}"
+    echo "Please ensure they are installed and available."
+    exit 1
+else
+    echo "circom, snarkjs, and the PTAU file are already installed."
+fi
+
+# Print the message to compile the target and then compile it
+echo "Compiling the target circuit: $CIRCOM_CIRCUIT"
+circom $CIRCOM_CIRCUIT --O0 --r1cs --wasm --sym
+
+# Print message and then perform phase 2 of the ceremony.
+echo "Phase 2 of the ceremony producing zkey and verifiaction key: ${ZKEY_FINAL}" 
+snarkjs powersoftau prepare phase2 ${PTAU_FILE} ${PTAU_FINAL} -v
+snarkjs groth16 setup $R1CS ${PTAU_FINAL} ${ZKEY_INIT}
+snarkjs zkey contribute ${ZKEY_INIT} ${ZKEY_FINAL} --name="1st Contributor Name" -v
+snarkjs zkey export verificationkey ${ZKEY_FINAL} $VKEY
+
+# Exit
+exit 0
diff --git a/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/zkbugs_config.json b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/zkbugs_config.json
new file mode 100644
index 0000000..a3ff8d8
--- /dev/null
+++ b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/zkbugs_config.json
@@ -0,0 +1,33 @@
+{
+    "Template CoreVerifyPubkeyG1 does not perform input validation (Simplified)": {
+      "Id": "succinctlabs/telepathy-circuits/veridise-V-SUC-VUL-002-simplified",
+      "Project": "https://github.com/succinctlabs/telepathy-circuits",
+      "Commit": "9c84fb0f38531718296d9b611f8bd6107f61a9b8",
+      "Fix Commit": "b0c839cef30c3c25ef41d1ad3000081784766934",
+      "DSL": "Circom",
+      "Vulnerability": "Under-Constrained",
+      "Location": {
+        "Path": "circuits/bls_signature.circom",
+        "Function": "CoreVerifyPubkeyG1ToyExample",
+        "Line": "77-95"
+      },
+      "Source": {
+        "Audit Report": {
+          "Source Link": "https://veridise.com/wp-content/uploads/2023/04/VAR-Succinct.pdf",
+          "Bug ID": "V-SUC-VUL-002: Template CoreVerifyPubkeyG1 does not perform input validation"
+        }
+      },
+      "Commands": {
+        "Setup Environment": "./zkbugs_setup.sh",
+        "Reproduce": "./zkbugs_exploit.sh",
+        "Compile and Preprocess": "./zkbugs_compile_setup.sh",
+        "Positive Test": "./zkbugs_positive_test.sh",
+        "Find Exploit": "./zkbugs_find_exploit.sh",
+        "Clean": "./zkbugs_clean.sh"
+      },
+      "Short Description of the Vulnerability": "This bug is in the circom-pairing BLS signature verification logic. pubkey, signature and hash are divided into 7-entry chunks of 55-bit data, and each entry is checked against according entry in `p`. When calling `BigLessThan()`, the output isn't verified therefore attacker can manipulate the input so that it overflows p.",
+      "Short Description of the Exploit": "The circuit had been simplified to demonstrate the bug, the attack idea is calculating a `delta` such that it makes the input overflow but still bounded by 2**55 - 1 to pass the range check inside `BigLessThan()`. In reality, attacker would bruteforce a special set of inputs satisfying a list of constraints. The details are explained in the PR comment.",
+      "Proposed Mitigation": "In each iteration of the for loop, add a constraint `lt[idx].out === 1` to make sure the input is indeed bounded by `p`."
+    }
+  }
+  
diff --git a/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/zkbugs_exploit.sh b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/zkbugs_exploit.sh
new file mode 100755
index 0000000..9451142
--- /dev/null
+++ b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/zkbugs_exploit.sh
@@ -0,0 +1,30 @@
+#!/bin/bash
+source zkbugs_vars.sh
+
+# Run the following scripts
+./zkbugs_clean.sh
+./zkbugs_compile_setup.sh
+./zkbugs_positive_test.sh
+
+# Copy extra circom runtime scripts to convert JSON to wtns
+echo "Copy extra circom runtime scripts to convert JSON to wtns"
+cp ${CIRCOM_RUNTIME}/* $CIRCUITJS
+
+# Replace the witness
+echo "Replace the witness"
+node $CIRCUITJS/export_witness.js $CIRCUITWASM $EXPLOITABLE_WTNS $WTNS
+
+# Print message for producing proof
+echo "Producing proof"
+
+# Run the command to produce the proof
+snarkjs groth16 prove $ZKEY_FINAL $WTNS proof.json public.json
+
+# Print message for verifying proof
+echo "Verifying proof"
+
+# Run the command to verify the proof
+snarkjs groth16 verify $VKEY public.json proof.json
+
+# Exit
+exit 0
diff --git a/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/zkbugs_find_exploit.sh b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/zkbugs_find_exploit.sh
new file mode 100755
index 0000000..115413c
--- /dev/null
+++ b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/zkbugs_find_exploit.sh
@@ -0,0 +1,18 @@
+#!/bin/bash
+
+# TODO:
+# This script is a wrapper of an underlying poc-generating script
+# By default it is sagemath, but for some bugs it will be SMT solver script or JS script.
+# Update this script to accordingly.
+
+# Check if SageMath is installed
+if ! command -v sage &> /dev/null; then
+    echo "SageMath is not installed. Please install SageMath and try again."
+    exit 1
+fi
+
+# Run the SageMath script
+sage detect.sage
+
+# Exit
+exit 0
diff --git a/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/zkbugs_positive_test.sh b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/zkbugs_positive_test.sh
new file mode 100755
index 0000000..5bdba26
--- /dev/null
+++ b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/zkbugs_positive_test.sh
@@ -0,0 +1,23 @@
+#!/bin/bash
+source zkbugs_vars.sh
+
+# Print message for computing witness
+echo "Computing witness"
+
+# Run the command to compute the witness
+node $CIRCUITJS/generate_witness.js $CIRCUITWASM $INPUTJSON $WTNS
+
+# Print message for producing proof
+echo "Producing proof"
+
+# Run the command to produce the proof
+snarkjs groth16 prove $ZKEY_FINAL $WTNS proof.json public.json
+
+# Print message for verifying proof
+echo "Verifying proof"
+
+# Run the command to verify the proof
+snarkjs groth16 verify $VKEY public.json proof.json
+
+# Exit
+exit 0
diff --git a/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/zkbugs_setup.sh b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/zkbugs_setup.sh
new file mode 100755
index 0000000..75af9e7
--- /dev/null
+++ b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/zkbugs_setup.sh
@@ -0,0 +1,32 @@
+#!/bin/bash
+source zkbugs_vars.sh
+
+echo "Root path: $ROOT_PATH"
+
+# Check if circom and snarkjs are installed
+MISSING_TOOLS=()
+if ! command -v circom &> /dev/null; then
+    MISSING_TOOLS+=("circom")
+fi
+if ! command -v snarkjs &> /dev/null; then
+    MISSING_TOOLS+=("snarkjs")
+fi
+
+if [ ${#MISSING_TOOLS[@]} -ne 0 ]; then
+    echo "The following tools are missing: ${MISSING_TOOLS[*]}"
+    echo "Please install them using the script: $ROOT_PATH/scripts/install_circom.sh"
+    exit 1
+else
+    echo "circom and snarkjs are already installed."
+fi
+
+# Check if initial ptau file exists
+if [ -f "$PTAU_FILE" ]; then
+    echo "The PTAU file exists at: $PTAU_FILE"
+else
+    echo "The PTAU file does not exist."
+    echo "Please generate it using the script: $ROOT_PATH/scripts/generate_ptau_snarkjs.sh bn128 12"
+fi
+
+# 6. Print that setup is completed
+echo "Setup is completed."
diff --git a/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/zkbugs_vars.sh b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/zkbugs_vars.sh
new file mode 100755
index 0000000..69a587d
--- /dev/null
+++ b/dataset/circom/succinctlabs_telepathy-circuits/veridise_template_CoreVerifyPubkeyG1_does_not_perform_input_validation_simplified_original/zkbugs_vars.sh
@@ -0,0 +1,18 @@
+#!/bin/bash
+SCRIPT_PATH=$(realpath "$0")
+ROOT_PATH=$(dirname "$(dirname "$(dirname "$(dirname "$(dirname "$SCRIPT_PATH")")")")")
+PTAU_TARGET=bn128_pot16_0001.ptau
+PTAU_FILE="$ROOT_PATH/misc/circom/$PTAU_TARGET"
+PTAU_FINAL="final.ptau"
+TARGET=circuit
+R1CS="$TARGET.r1cs"
+ZKEY_INIT=${TARGET}_0000.zkey
+ZKEY_FINAL=${TARGET}_0001.zkey
+VKEY=verification_key.json
+CIRCOM_CIRCUIT="circuits/$TARGET.circom"
+CIRCUITJS=${TARGET}_js
+CIRCUITWASM=${CIRCUITJS}/${TARGET}.wasm
+INPUTJSON=input.json
+WTNS=$CIRCUITJS/witness.wtns
+EXPLOITABLE_WTNS=exploitable_witness.json
+CIRCOM_RUNTIME=${ROOT_PATH}/misc/circom_runtime