ci: update version string in docs

chore: optimized release builds by default (#844 )
fix: remove console import from index.ts in in-browser-evm-verifier package (#841 )
2026-01-13 00:08:12 -05:00 · 2024-09-05 13:52:21 +00:00 · 2024-09-05 15:52:03 +02:00 · 2024-08-30 18:47:59 +01:00 · 2024-08-27 09:45:40 -04:00 · 2024-08-19 00:24:53 -04:00
47 changed files with 1942 additions and 1657 deletions
--- a/.github/workflows/engine.yml
+++ b/.github/workflows/engine.yml
@@ -22,15 +22,18 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
          override: true
          components: rustfmt, clippy
      - uses: jetli/wasm-pack-action@v0.4.0
+        with:
+          # Pin to version 0.12.1
+          version: 'v0.12.1'
      - name: Add wasm32-unknown-unknown target
        run: rustup target add wasm32-unknown-unknown

      - name: Add rust-src
-        run: rustup component add rust-src --toolchain nightly-2024-02-06-x86_64-unknown-linux-gnu
+        run: rustup component add rust-src --toolchain nightly-2024-07-18-x86_64-unknown-linux-gnu
      - name: Install binaryen
        run: |
          set -e
--- a/.github/workflows/large-tests.yml
+++ b/.github/workflows/large-tests.yml
@@ -11,7 +11,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
          override: true
          components: rustfmt, clippy
      - name: nanoGPT Mock
--- a/.github/workflows/pypi.yml
+++ b/.github/workflows/pypi.yml
@@ -40,7 +40,7 @@ jobs:

      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
          override: true
          components: rustfmt, clippy

@@ -86,7 +86,7 @@ jobs:

      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
          override: true
          components: rustfmt, clippy

--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -45,7 +45,7 @@ jobs:
    steps:
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
          override: true
          components: rustfmt, clippy
      - name: Checkout repo
@@ -106,27 +106,27 @@ jobs:
        include:
          - build: windows-msvc
            os: windows-latest
-            rust: nightly-2024-02-06
+            rust: nightly-2024-07-18
            target: x86_64-pc-windows-msvc
          - build: macos
            os: macos-13
-            rust: nightly-2024-02-06
+            rust: nightly-2024-07-18
            target: x86_64-apple-darwin
          - build: macos-aarch64
            os: macos-13
-            rust: nightly-2024-02-06
+            rust: nightly-2024-07-18
            target: aarch64-apple-darwin
          - build: linux-musl
            os: ubuntu-22.04
-            rust: nightly-2024-02-06
+            rust: nightly-2024-07-18
            target: x86_64-unknown-linux-musl
          - build: linux-gnu
            os: ubuntu-22.04
-            rust: nightly-2024-02-06
+            rust: nightly-2024-07-18
            target: x86_64-unknown-linux-gnu
          - build: linux-aarch64
            os: ubuntu-22.04
-            rust: nightly-2024-02-06
+            rust: nightly-2024-07-18
            target: aarch64-unknown-linux-gnu

    steps:
@@ -181,9 +181,14 @@ jobs:
          echo "target flag is: ${{ env.TARGET_FLAGS }}"
          echo "target dir is: ${{ env.TARGET_DIR }}"

-      - name: Build release binary
+      - name: Build release binary (no asm)
+        if: matrix.build != 'linux-gnu'
        run: ${{ env.CARGO }} build --release ${{ env.TARGET_FLAGS }} -Z sparse-registry

+      - name: Build release binary (asm)
+        if: matrix.build == 'linux-gnu'
+        run: ${{ env.CARGO }} build --release ${{ env.TARGET_FLAGS }} -Z sparse-registry --features asm
+
      - name: Strip release binary
        if: matrix.build != 'windows-msvc' && matrix.build != 'linux-aarch64'
        run: strip "target/${{ matrix.target }}/release/ezkl"
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -26,7 +26,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
          override: true
          components: rustfmt, clippy
      - name: Build
@@ -38,7 +38,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
          override: true
          components: rustfmt, clippy
      - name: Docs
@@ -50,7 +50,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
@@ -73,7 +73,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
@@ -92,13 +92,13 @@ jobs:
      # - name: Conv overflow (wasi)
      #   run: cargo wasi test conv_col_ultra_overflow -- --include-ignored --nocapture
      - name: lookup overflow
-        run: cargo nextest run  --release lookup_ultra_overflow --no-capture --features icicle -- --include-ignored
+        run: cargo nextest run lookup_ultra_overflow --no-capture --features icicle -- --include-ignored
      - name: Matmul overflow
        run: RUST_LOG=debug cargo nextest run matmul_col_ultra_overflow --no-capture --features icicle -- --include-ignored
      - name: Conv overflow
        run: RUST_LOG=debug cargo nextest run conv_col_ultra_overflow --no-capture --features icicle -- --include-ignored
      - name: Conv + relu overflow
-        run: cargo nextest run  --release conv_relu_col_ultra_overflow --no-capture --features icicle -- --include-ignored
+        run: cargo nextest run conv_relu_col_ultra_overflow --no-capture --features icicle -- --include-ignored

  ultra-overflow-tests_og-lookup:
    runs-on: non-gpu
@@ -106,7 +106,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
@@ -139,7 +139,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
@@ -172,7 +172,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
@@ -189,17 +189,20 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
          override: true
          components: rustfmt, clippy
      - uses: jetli/wasm-pack-action@v0.4.0
+        with:
+          # Pin to version 0.12.1
+          version: 'v0.12.1'
      - uses: nanasess/setup-chromedriver@v2
        # with:
        #   chromedriver-version: "115.0.5790.102"
      - name: Install wasm32-unknown-unknown
        run: rustup target add wasm32-unknown-unknown
      - name: Add rust-src
-        run: rustup component add rust-src --toolchain nightly-2024-02-06-x86_64-unknown-linux-gnu
+        run: rustup component add rust-src --toolchain nightly-2024-07-18-x86_64-unknown-linux-gnu
      - name: Run wasm verifier tests
        # on mac:
        #   AR=/opt/homebrew/opt/llvm/bin/llvm-ar CC=/opt/homebrew/opt/llvm/bin/clang wasm-pack test --firefox --headless -- -Z build-std="panic_abort,std" --features web
@@ -212,7 +215,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
@@ -229,7 +232,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
@@ -260,6 +263,8 @@ jobs:
        run: cargo nextest run --release --verbose tests::mock_hashed_input_::t  --test-threads 32
      - name: hashed params
        run: cargo nextest run --release --verbose tests::mock_hashed_params_::t  --test-threads 32
+      - name: hashed params public inputs
+        run: cargo nextest run --release --verbose tests::mock_hashed_params_public_inputs_::t  --test-threads 32
      - name: hashed outputs
        run: cargo nextest run --release --verbose tests::mock_hashed_output_::t  --test-threads 32
      - name: hashed inputs + params + outputs
@@ -288,7 +293,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
@@ -306,7 +311,7 @@ jobs:
          node-version: "18.12.1"
          cache: "pnpm"
      - name: "Add rust-src"
-        run: rustup component add rust-src --toolchain nightly-2024-02-06-x86_64-unknown-linux-gnu
+        run: rustup component add rust-src --toolchain nightly-2024-07-18-x86_64-unknown-linux-gnu
      - name: Install dependencies for js tests and in-browser-evm-verifier package
        run: |
          pnpm install --frozen-lockfile
@@ -325,10 +330,10 @@ jobs:
          cd in-browser-evm-verifier
          pnpm build:commonjs
          cd ..
-      - name: Install solc
-        run: (hash svm 2>/dev/null || cargo install svm-rs) && svm install 0.8.20 && solc --version
+      # - name: Install solc
+      #   run: (hash svm 2>/dev/null || cargo install svm-rs) && svm install 0.8.20 && solc --version
      - name: Install Anvil
-        run: cargo install --git https://github.com/foundry-rs/foundry --rev c2233ec9fe61e0920c61c6d779bc707252852037 --profile local --locked anvil --force
+        run: cargo install --git https://github.com/foundry-rs/foundry --rev 62cdea8ff9e6efef011f77e295823b5f2dbeb3a1 --locked anvil --force
      - name: KZG prove and verify tests (EVM + VK rendered seperately)
        run: cargo nextest run --release --verbose tests_evm::kzg_evm_prove_and_verify_render_seperately_ --test-threads 1
      - name: KZG prove and verify tests (EVM + kzg all)
@@ -367,15 +372,18 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
          override: true
          components: rustfmt, clippy
      - uses: jetli/wasm-pack-action@v0.4.0
+        with:
+          # Pin to version 0.12.1
+          version: 'v0.12.1'
      - name: Add wasm32-unknown-unknown target
        run: rustup target add wasm32-unknown-unknown

      - name: Add rust-src
-        run: rustup component add rust-src --toolchain nightly-2024-02-06-x86_64-unknown-linux-gnu
+        run: rustup component add rust-src --toolchain nightly-2024-07-18-x86_64-unknown-linux-gnu
      - uses: actions/checkout@v3
      - name: Use pnpm 8
        uses: pnpm/action-setup@v2
@@ -433,40 +441,40 @@ jobs:
      - name: KZG prove and verify tests (hashed outputs)
        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_hashed

-  prove-and-verify-tests-gpu:
-    runs-on: GPU
-    env:
-      ENABLE_ICICLE_GPU: true
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions-rs/toolchain@v1
-        with:
-          toolchain: nightly-2024-02-06
-          override: true
-          components: rustfmt, clippy
-      - name: Add rust-src
-        run: rustup component add rust-src --toolchain nightly-2024-02-06-x86_64-unknown-linux-gnu
-      - uses: actions/checkout@v3
-      - uses: baptiste0928/cargo-install@v1
-        with:
-          crate: cargo-nextest
-          locked: true
-      - name: KZG prove and verify tests (kzg outputs)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_kzg_output --features icicle --test-threads 1
-      - name: KZG prove and verify tests (public outputs + column overflow)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_with_overflow_::w --features icicle  --test-threads 1
-      - name: KZG prove and verify tests (public outputs + fixed params + column overflow)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_with_overflow_fixed_params_ --features icicle  --test-threads 1
-      - name: KZG prove and verify tests (public outputs)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_::t --features icicle  --test-threads 1
-      - name: KZG prove and verify tests (public outputs + column overflow)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_::t --features icicle  --test-threads 1
-      - name: KZG prove and verify tests (public inputs)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_public_input --features icicle  --test-threads 1
-      - name: KZG prove and verify tests (fixed params)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_fixed_params --features icicle  --test-threads 1
-      - name: KZG prove and verify tests (hashed outputs)
-        run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_hashed --features icicle  --test-threads 1
+  # prove-and-verify-tests-gpu:
+  #   runs-on: GPU
+  #   env:
+  #     ENABLE_ICICLE_GPU: true
+  #   steps:
+  #     - uses: actions/checkout@v4
+  #     - uses: actions-rs/toolchain@v1
+  #       with:
+  #         toolchain: nightly-2024-07-18
+  #         override: true
+  #         components: rustfmt, clippy
+  #     - name: Add rust-src
+  #       run: rustup component add rust-src --toolchain nightly-2024-07-18-x86_64-unknown-linux-gnu
+  #     - uses: actions/checkout@v3
+  #     - uses: baptiste0928/cargo-install@v1
+  #       with:
+  #         crate: cargo-nextest
+  #         locked: true
+  #     - name: KZG prove and verify tests (kzg outputs)
+  #       run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_kzg_output --features icicle --test-threads 1
+  #     - name: KZG prove and verify tests (public outputs + column overflow)
+  #       run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_with_overflow_::w --features icicle  --test-threads 1
+  #     - name: KZG prove and verify tests (public outputs + fixed params + column overflow)
+  #       run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_with_overflow_fixed_params_ --features icicle  --test-threads 1
+  #     - name: KZG prove and verify tests (public outputs)
+  #       run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_::t --features icicle  --test-threads 1
+  #     - name: KZG prove and verify tests (public outputs + column overflow)
+  #       run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_::t --features icicle  --test-threads 1
+  #     - name: KZG prove and verify tests (public inputs)
+  #       run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_public_input --features icicle  --test-threads 1
+  #     - name: KZG prove and verify tests (fixed params)
+  #       run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_fixed_params --features icicle  --test-threads 1
+  #     - name: KZG prove and verify tests (hashed outputs)
+  #       run: cargo nextest run --release --verbose tests::kzg_prove_and_verify_hashed --features icicle  --test-threads 1

  prove-and-verify-mock-aggr-tests:
    runs-on: self-hosted
@@ -475,7 +483,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
@@ -493,7 +501,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
@@ -501,7 +509,7 @@ jobs:
          crate: cargo-nextest
          locked: true
      - name: KZG )tests
-        run: cargo nextest run --release --verbose tests_aggr::kzg_aggr_prove_and_verify_  --features icicle --test-threads 1 -- --include-ignored
+        run: cargo nextest run --verbose tests_aggr::kzg_aggr_prove_and_verify_  --features icicle --test-threads 1 -- --include-ignored

  prove-and-verify-aggr-tests:
    runs-on: large-self-hosted
@@ -510,7 +518,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
@@ -527,17 +535,17 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
        with:
          crate: cargo-nextest
          locked: true
-      - name: Install solc
-        run: (hash svm 2>/dev/null || cargo install svm-rs) && svm install 0.8.20 && solc --version
+      # - name: Install solc
+      #   run: (hash svm 2>/dev/null || cargo install svm-rs) && svm install 0.8.20 && solc --version
      - name: Install Anvil
-        run: cargo install --git https://github.com/foundry-rs/foundry --rev c2233ec9fe61e0920c61c6d779bc707252852037 --profile local --locked anvil --force
+        run: cargo install --git https://github.com/foundry-rs/foundry --rev 62cdea8ff9e6efef011f77e295823b5f2dbeb3a1 --locked anvil --force
      - name: KZG prove and verify aggr tests
        run: cargo nextest run  --release --verbose tests_evm::kzg_evm_aggr_prove_and_verify_::t --test-threads 4 -- --include-ignored

@@ -548,7 +556,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
@@ -568,17 +576,17 @@ jobs:
          python-version: "3.12"
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
          override: true
          components: rustfmt, clippy
      - name: Install cmake
        run: sudo apt-get install -y cmake
-      - name: Install solc
-        run: (hash svm 2>/dev/null || cargo install svm-rs) && svm install 0.8.20 && solc --version
+      # - name: Install solc
+      #   run: (hash svm 2>/dev/null || cargo install svm-rs) && svm install 0.8.20 && solc --version
      - name: Setup Virtual Env and Install python dependencies
        run: python -m venv .env --clear; source .env/bin/activate; pip install -r requirements.txt;
      - name: Install Anvil
-        run: cargo install --git https://github.com/foundry-rs/foundry --rev c2233ec9fe61e0920c61c6d779bc707252852037 --profile local --locked anvil --force
+        run: cargo install --git https://github.com/foundry-rs/foundry --rev 62cdea8ff9e6efef011f77e295823b5f2dbeb3a1 --locked anvil --force
      - name: Build python ezkl
        run: source .env/bin/activate; unset CONDA_PREFIX; maturin develop --features python-bindings --release
      - name: Run pytest
@@ -594,7 +602,7 @@ jobs:
          python-version: "3.12"
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
@@ -643,17 +651,17 @@ jobs:
          python-version: "3.11"
      - uses: actions-rs/toolchain@v1
        with:
-          toolchain: nightly-2024-02-06
+          toolchain: nightly-2024-07-18
          override: true
          components: rustfmt, clippy
      - uses: baptiste0928/cargo-install@v1
        with:
          crate: cargo-nextest
          locked: true
-      - name: Install solc
-        run: (hash svm 2>/dev/null || cargo install svm-rs) && svm install 0.8.20 && solc --version
+      # - name: Install solc
+      #   run: (hash svm 2>/dev/null || cargo install svm-rs) && svm install 0.8.20 && solc --version
      - name: Install Anvil
-        run: cargo install --git https://github.com/foundry-rs/foundry --rev c2233ec9fe61e0920c61c6d779bc707252852037 --profile local --locked anvil --force
+        run: cargo install --git https://github.com/foundry-rs/foundry --rev 62cdea8ff9e6efef011f77e295823b5f2dbeb3a1 --locked anvil --force
      - name: Install pip
        run: python -m ensurepip --upgrade
      - name: Setup Virtual Env and Install python dependencies
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1042,6 +1042,15 @@ dependencies = [
 "wyz",
 ]

+[[package]]
+name = "blake2"
+version = "0.10.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46502ad458c9a52b69d4d4d32775c788b7a1b85e8bc9d482d92250fc0e3f8efe"
+dependencies = [
+ "digest 0.10.7",
+]
+
 [[package]]
 name = "blake2b_simd"
 version = "1.0.2"
@@ -1086,9 +1095,9 @@ checksum = "8d696c370c750c948ada61c69a0ee2cbbb9c50b1019ddb86d9317157a99c2cae"

 [[package]]
 name = "blst"
-version = "0.3.12"
+version = "0.3.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62dc83a094a71d43eeadd254b1ec2d24cb6a0bb6cadce00df51f0db594711a32"
+checksum = "4378725facc195f1a538864863f6de233b500a8862747e7f165078a419d5e874"
 dependencies = [
 "cc",
 "glob",
@@ -1182,7 +1191,7 @@ dependencies = [
 "js-sys",
 "num-traits",
 "wasm-bindgen",
- "windows-targets 0.52.4",
+ "windows-targets 0.52.6",
 ]

 [[package]]
@@ -1536,6 +1545,15 @@ dependencies = [
 "zeroize",
 ]

+[[package]]
+name = "deranged"
+version = "0.3.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b42b6fa04a440b495c8b04d0e71b707c585f83cb9cb28cf8cd0d976c315e31b4"
+dependencies = [
+ "powerfmt",
+]
+
 [[package]]
 name = "derivative"
 version = "2.2.0"
@@ -1859,7 +1877,7 @@ dependencies = [
 "halo2_gadgets",
 "halo2_proofs",
 "halo2_solidity_verifier",
- "halo2curves 0.6.1 (git+https://github.com/privacy-scaling-explorations/halo2curves?rev=9fff22c)",
+ "halo2curves 0.7.0",
 "hex",
 "indicatif",
 "instant",
@@ -1868,6 +1886,7 @@ dependencies = [
 "log",
 "maybe-rayon",
 "metal",
+ "mimalloc",
 "mnist",
 "num",
 "objc",
@@ -2088,9 +2107,9 @@ dependencies = [

 [[package]]
 name = "fs4"
-version = "0.8.4"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7e180ac76c23b45e767bd7ae9579bc0bb458618c4bc71835926e098e61d15f8"
+checksum = "e8c6b3bd49c37d2aa3f3f2220233b29a7cd23f79d1fe70e5337d25fb390793de"
 dependencies = [
 "rustix",
 "windows-sys 0.52.0",
@@ -2297,19 +2316,24 @@ dependencies = [
 [[package]]
 name = "halo2_proofs"
 version = "0.3.0"
-source = "git+https://github.com/zkonduit/halo2#8cfca221f53069a0374687654882b99e729041d7#8cfca221f53069a0374687654882b99e729041d7"
+source = "git+https://github.com/zkonduit/halo2?branch=ac/cache-lookup-commitments#8b13a0d2a7a34d8daab010dadb2c47dfa47d37d0?branch=ac/cache-lookup-commitments#8b13a0d2a7a34d8daab010dadb2c47dfa47d37d0"
 dependencies = [
+ "bincode",
 "blake2b_simd",
 "env_logger",
 "ff",
 "group",
- "halo2curves 0.6.1 (git+https://github.com/privacy-scaling-explorations/halo2curves?rev=9fff22c)",
+ "halo2curves 0.7.0",
 "icicle",
+ "instant",
+ "lazy_static",
 "log",
 "maybe-rayon",
 "rand_chacha",
 "rand_core 0.6.4",
 "rustacuda",
+ "rustc-hash",
+ "serde",
 "sha3 0.9.1",
 "tracing",
 ]
@@ -2317,7 +2341,7 @@ dependencies = [
 [[package]]
 name = "halo2_solidity_verifier"
 version = "0.1.0"
-source = "git+https://github.com/alexander-camuto/halo2-solidity-verifier?branch=main#eb04be1f7d005e5b9dd3ff41efa30aeb5e0c34a3"
+source = "git+https://github.com/alexander-camuto/halo2-solidity-verifier?branch=ac/update-h2-curves#3082fda94151fc6760a3cb2be4741ddbeef04c03"
 dependencies = [
 "askama",
 "blake2b_simd",
@@ -2393,15 +2417,18 @@ dependencies = [

 [[package]]
 name = "halo2curves"
-version = "0.6.1"
-source = "git+https://github.com/privacy-scaling-explorations/halo2curves?rev=9fff22c#9fff22c5f72cc54fac1ef3a844e1072b08cfecdf"
+version = "0.7.0"
+source = "git+https://github.com/privacy-scaling-explorations/halo2curves?rev=b753a832e92d5c86c5c997327a9cf9de86a18851#b753a832e92d5c86c5c997327a9cf9de86a18851"
 dependencies = [
- "blake2b_simd",
+ "blake2",
+ "digest 0.10.7",
 "ff",
 "group",
+ "halo2derive",
 "hex",
 "lazy_static",
 "num-bigint",
+ "num-integer",
 "num-traits",
 "pairing",
 "pasta_curves",
@@ -2411,11 +2438,25 @@ dependencies = [
 "rayon",
 "serde",
 "serde_arrays",
+ "sha2",
 "static_assertions",
 "subtle",
 "unroll",
 ]

+[[package]]
+name = "halo2derive"
+version = "0.1.0"
+source = "git+https://github.com/privacy-scaling-explorations/halo2curves?rev=b753a832e92d5c86c5c997327a9cf9de86a18851#b753a832e92d5c86c5c997327a9cf9de86a18851"
+dependencies = [
+ "num-bigint",
+ "num-integer",
+ "num-traits",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
 [[package]]
 name = "halo2wrong"
 version = "0.1.0"
@@ -2510,9 +2551,9 @@ dependencies = [

 [[package]]
 name = "http-body"
-version = "1.0.0"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1cac85db508abc24a2e48553ba12a996e87244a0395ce011e62b37158745d643"
+checksum = "1efedce1fb8e6913f23e0c92de8e62cd5b772a67e7b3946df930a62566c93184"
 dependencies = [
 "bytes",
 "http",
@@ -2599,9 +2640,9 @@ dependencies = [

 [[package]]
 name = "hyper-util"
-version = "0.1.6"
+version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ab92f4f49ee4fb4f997c784b7a2e0fa70050211e0b6a287f898c3c9785ca956"
+checksum = "cde7055719c54e36e95e8719f95883f22072a48ede39db7fc17a4e1d5281e9b9"
 dependencies = [
 "bytes",
 "futures-channel",
@@ -2859,9 +2900,9 @@ dependencies = [

 [[package]]
 name = "keccak-asm"
-version = "0.1.1"
+version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "47a3633291834c4fbebf8673acbc1b04ec9d151418ff9b8e26dcd79129928758"
+checksum = "422fbc7ff2f2f5bdffeb07718e5a5324dca72b0c9293d50df4026652385e3314"
 dependencies = [
 "digest 0.10.7",
 "sha3-asm",
@@ -2928,6 +2969,16 @@ version = "0.2.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4ec2a862134d2a7d32d7983ddcdd1c4923530833c9f2ea1a44fc5fa473989058"

+[[package]]
+name = "libmimalloc-sys"
+version = "0.1.39"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23aa6811d3bd4deb8a84dde645f943476d13b248d818edcf8ce0b2f37f036b44"
+dependencies = [
+ "cc",
+ "libc",
+]
+
 [[package]]
 name = "libredox"
 version = "0.0.1"
@@ -3026,9 +3077,9 @@ checksum = "90ed8c1e510134f979dbc4f070f87d4313098b704861a105fe34231c70a3901c"

 [[package]]
 name = "lru"
-version = "0.12.3"
+version = "0.12.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3262e75e648fce39813cb56ac41f3c3e3f65217ebf3844d818d1f9398cfb0dc"
+checksum = "37ee39891760e7d94734f6f63fedc29a2e4a152f836120753a72503f09fcf904"
 dependencies = [
 "hashbrown 0.14.3",
 ]
@@ -3117,8 +3168,8 @@ dependencies = [

 [[package]]
 name = "metal"
-version = "0.27.0"
-source = "git+https://github.com/gfx-rs/metal-rs#ff8fd3d6dc7792852f8a015458d7e6d42d7fb352"
+version = "0.29.0"
+source = "git+https://github.com/gfx-rs/metal-rs#0e1918b34689c4b8cd13a43372f9898680547ee9"
 dependencies = [
 "bitflags 2.5.0",
 "block",
@@ -3129,6 +3180,15 @@ dependencies = [
 "paste",
 ]

+[[package]]
+name = "mimalloc"
+version = "0.1.43"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68914350ae34959d83f732418d51e2427a794055d0b9529f48259ac07af65633"
+dependencies = [
+ "libmimalloc-sys",
+]
+
 [[package]]
 name = "mime"
 version = "0.3.17"
@@ -3262,6 +3322,12 @@ dependencies = [
 "num-traits",
 ]

+[[package]]
+name = "num-conv"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
+
 [[package]]
 name = "num-integer"
 version = "0.1.46"
@@ -3775,6 +3841,12 @@ dependencies = [
 "postgres-protocol",
 ]

+[[package]]
+name = "powerfmt"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
+
 [[package]]
 name = "ppv-lite86"
 version = "0.2.17"
@@ -3999,9 +4071,9 @@ checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"

 [[package]]
 name = "quinn"
-version = "0.11.2"
+version = "0.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e4ceeeeabace7857413798eb1ffa1e9c905a9946a57d81fb69b4b71c4d8eb3ad"
+checksum = "b22d8e7369034b9a7132bc2008cac12f2013c8132b45e0554e6e20e2617f2156"
 dependencies = [
 "bytes",
 "pin-project-lite",
@@ -4009,6 +4081,7 @@ dependencies = [
 "quinn-udp",
 "rustc-hash",
 "rustls",
+ "socket2",
 "thiserror",
 "tokio",
 "tracing",
@@ -4016,9 +4089,9 @@ dependencies = [

 [[package]]
 name = "quinn-proto"
-version = "0.11.3"
+version = "0.11.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ddf517c03a109db8100448a4be38d498df8a210a99fe0e1b9eaf39e78c640efe"
+checksum = "ba92fb39ec7ad06ca2582c0ca834dfeadcaf06ddfc8e635c80aa7e1c05315fdd"
 dependencies = [
 "bytes",
 "rand 0.8.5",
@@ -4033,9 +4106,9 @@ dependencies = [

 [[package]]
 name = "quinn-udp"
-version = "0.5.2"
+version = "0.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9096629c45860fc7fb143e125eb826b5e721e10be3263160c7d60ca832cf8c46"
+checksum = "8bffec3605b73c6f1754535084a85229fa8a30f86014e6c81aeec4abb68b0285"
 dependencies = [
 "libc",
 "once_cell",
@@ -4233,9 +4306,9 @@ dependencies = [

 [[package]]
 name = "reqwest"
-version = "0.12.5"
+version = "0.12.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7d6d2a27d57148378eb5e111173f4276ad26340ecc5c49a4a2152167a2d6a37"
+checksum = "f8f4955649ef5c38cc7f9e8aa41761d48fb9677197daea9984dc54f56aad5e63"
 dependencies = [
 "base64 0.22.1",
 "bytes",
@@ -4270,6 +4343,7 @@ dependencies = [
 "tokio",
 "tokio-native-tls",
 "tokio-rustls",
+ "tokio-socks",
 "tokio-util",
 "tower-service",
 "url",
@@ -4278,7 +4352,7 @@ dependencies = [
 "wasm-streams",
 "web-sys",
 "webpki-roots",
- "winreg",
+ "windows-registry",
 ]

 [[package]]
@@ -4443,9 +4517,9 @@ checksum = "d626bb9dae77e28219937af045c257c28bfd3f69333c512553507f5f9798cb76"

 [[package]]
 name = "rustc-hash"
-version = "1.1.0"
+version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
+checksum = "583034fd73374156e66797ed8e5b0d5690409c9226b22d87cb7f19821c05d152"

 [[package]]
 name = "rustc-hex"
@@ -4501,9 +4575,9 @@ dependencies = [

 [[package]]
 name = "rustls"
-version = "0.23.11"
+version = "0.23.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4828ea528154ae444e5a642dbb7d5623354030dc9822b83fd9bb79683c7399d0"
+checksum = "c58f8c84392efc0a126acce10fa59ff7b3d2ac06ab451a33f2741989b806b044"
 dependencies = [
 "once_cell",
 "ring",
@@ -4515,9 +4589,9 @@ dependencies = [

 [[package]]
 name = "rustls-native-certs"
-version = "0.7.1"
+version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a88d6d420651b496bdd98684116959239430022a115c1240e6c3993be0b15fba"
+checksum = "04182dffc9091a404e0fc069ea5cd60e5b866c3adf881eff99a32d048242dffa"
 dependencies = [
 "openssl-probe",
 "rustls-pemfile",
@@ -4528,9 +4602,9 @@ dependencies = [

 [[package]]
 name = "rustls-pemfile"
-version = "2.1.2"
+version = "2.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29993a25686778eb88d4189742cd713c9bce943bc54251a33509dc63cbacf73d"
+checksum = "196fe16b00e106300d3e45ecfcb764fa292a535d7326a29a5875c579c7417425"
 dependencies = [
 "base64 0.22.1",
 "rustls-pki-types",
@@ -4538,15 +4612,15 @@ dependencies = [

 [[package]]
 name = "rustls-pki-types"
-version = "1.7.0"
+version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "976295e77ce332211c0d24d92c0e83e50f5c5f046d11082cea19f3df13a3562d"
+checksum = "fc0a2ce646f8655401bb81e7927b812614bd5d91dbc968696be50603510fcaf0"

 [[package]]
 name = "rustls-webpki"
-version = "0.102.5"
+version = "0.102.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f9a6fccd794a42c2c105b513a2f62bc3fd8f3ba57a4593677ceb0bd035164d78"
+checksum = "8e6b52d4fda176fd835fdc55a835d4a89b8499cad995885a21149d5ad62f852e"
 dependencies = [
 "ring",
 "rustls-pki-types",
@@ -4807,9 +4881,9 @@ dependencies = [

 [[package]]
 name = "sha3-asm"
-version = "0.1.1"
+version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9b57fd861253bff08bb1919e995f90ba8f4889de2726091c8876f3a4e823b40"
+checksum = "57d79b758b7cb2085612b11a235055e485605a5103faccdd633f35bd7aee69dd"
 dependencies = [
 "cc",
 "cfg-if",
@@ -4864,11 +4938,11 @@ checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
 [[package]]
 name = "snark-verifier"
 version = "0.1.1"
-source = "git+https://github.com/zkonduit/snark-verifier?branch=ac/chunked-mv-lookup#574b65ea6b4d43eebac5565146519a95b435815c"
+source = "git+https://github.com/zkonduit/snark-verifier?branch=ac/chunked-mv-lookup#8762701ab8fa04e7d243a346030afd85633ec970"
 dependencies = [
 "ecc",
 "halo2_proofs",
- "halo2curves 0.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "halo2curves 0.6.1",
 "hex",
 "itertools 0.10.5",
 "lazy_static",
@@ -5002,14 +5076,13 @@ checksum = "81cdd64d312baedb58e21336b31bc043b77e01cc99033ce76ef539f78e965ebc"

 [[package]]
 name = "svm-rs"
-version = "0.5.4"
+version = "0.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af5910befd515534a92e9424f250d952fe6f6dba6a92bd001dfeba1fb4a2f87c"
+checksum = "7b638fb4b6a74ef632a18935d240596b2618c8eb5c888e9cbf3c689af9a4aded"
 dependencies = [
 "const-hex",
 "dirs",
 "fs4",
- "once_cell",
 "reqwest",
 "semver 1.0.22",
 "serde",
@@ -5022,9 +5095,9 @@ dependencies = [

 [[package]]
 name = "svm-rs-builds"
-version = "0.5.4"
+version = "0.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d5ea000fdbeab0b2739315f9093c75ea63030e5c44f92daa72401d11b48adda"
+checksum = "813b21b9858cc493134b899c96e73c60f2e6043f050a17020e98ad8c2d9c9912"
 dependencies = [
 "build_const",
 "const-hex",
@@ -5072,6 +5145,9 @@ name = "sync_wrapper"
 version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a7065abeca94b6a8a577f9bd45aa0867a2238b74e8eb67cf10d492bc39351394"
+dependencies = [
+ "futures-core",
+]

 [[package]]
 name = "tabled"
@@ -5217,11 +5293,14 @@ dependencies = [

 [[package]]
 name = "time"
-version = "0.3.23"
+version = "0.3.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59e399c068f43a5d116fedaf73b203fa4f9c519f17e2b34f63221d3792f81446"
+checksum = "5dfd88e563464686c916c7e46e623e520ddc6d79fa6641390f2e3fa86e83e885"
 dependencies = [
+ "deranged",
 "itoa",
+ "num-conv",
+ "powerfmt",
 "serde",
 "time-core",
 "time-macros",
@@ -5229,16 +5308,17 @@ dependencies = [

 [[package]]
 name = "time-core"
-version = "0.1.1"
+version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7300fbefb4dadc1af235a9cef3737cea692a9d97e1b9cbcd4ebdae6f8868e6fb"
+checksum = "ef927ca75afb808a4d64dd374f00a2adf8d0fcff8e7b184af886c3c87ec4a3f3"

 [[package]]
 name = "time-macros"
-version = "0.2.10"
+version = "0.2.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96ba15a897f3c86766b757e5ac7221554c6750054d74d5b28844fce5fb36a6c4"
+checksum = "3f252a68540fde3a3877aeea552b832b40ab9a69e318efd078774a01ddee1ccf"
 dependencies = [
+ "num-conv",
 "time-core",
 ]

@@ -5351,6 +5431,18 @@ dependencies = [
 "tokio",
 ]

+[[package]]
+name = "tokio-socks"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d4770b8024672c1101b3f6733eab95b18007dbe0847a8afe341fcf79e06043f"
+dependencies = [
+ "either",
+ "futures-util",
+ "thiserror",
+ "tokio",
+]
+
 [[package]]
 name = "tokio-stream"
 version = "0.1.15"
@@ -5430,9 +5522,9 @@ dependencies = [

 [[package]]
 name = "tower-layer"
-version = "0.3.2"
+version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c20c8dbed6283a09604c3e69b4b7eeb54e298b8a600d4d5ecb5ad39de609f1d0"
+checksum = "121c2a6cda46980bb0fcd1647ffaf6cd3fc79a013de288782836f6df9c48780e"

 [[package]]
 name = "tower-service"
@@ -6028,7 +6120,37 @@ version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
 dependencies = [
- "windows-targets 0.52.4",
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-registry"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e400001bb720a623c1c69032f8e3e4cf09984deec740f007dd2b03ec864804b0"
+dependencies = [
+ "windows-result",
+ "windows-strings",
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-result"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d1043d8214f791817bab27572aaa8af63732e11bf84aa21a45a78d6c317ae0e"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-strings"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4cd9b125c486025df0eabcb585e62173c6c9eddcec5d117d3b6e8c30e2ee4d10"
+dependencies = [
+ "windows-result",
+ "windows-targets 0.52.6",
 ]

 [[package]]
@@ -6046,7 +6168,7 @@ version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
 dependencies = [
- "windows-targets 0.52.4",
+ "windows-targets 0.52.6",
 ]

 [[package]]
@@ -6066,17 +6188,18 @@ dependencies = [

 [[package]]
 name = "windows-targets"
-version = "0.52.4"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7dd37b7e5ab9018759f893a1952c9420d060016fc19a472b4bb20d1bdd694d1b"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
 dependencies = [
- "windows_aarch64_gnullvm 0.52.4",
- "windows_aarch64_msvc 0.52.4",
- "windows_i686_gnu 0.52.4",
- "windows_i686_msvc 0.52.4",
- "windows_x86_64_gnu 0.52.4",
- "windows_x86_64_gnullvm 0.52.4",
- "windows_x86_64_msvc 0.52.4",
+ "windows_aarch64_gnullvm 0.52.6",
+ "windows_aarch64_msvc 0.52.6",
+ "windows_i686_gnu 0.52.6",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc 0.52.6",
+ "windows_x86_64_gnu 0.52.6",
+ "windows_x86_64_gnullvm 0.52.6",
+ "windows_x86_64_msvc 0.52.6",
 ]

 [[package]]
@@ -6087,9 +6210,9 @@ checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"

 [[package]]
 name = "windows_aarch64_gnullvm"
-version = "0.52.4"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bcf46cf4c365c6f2d1cc93ce535f2c8b244591df96ceee75d8e83deb70a9cac9"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"

 [[package]]
 name = "windows_aarch64_msvc"
@@ -6099,9 +6222,9 @@ checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"

 [[package]]
 name = "windows_aarch64_msvc"
-version = "0.52.4"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da9f259dd3bcf6990b55bffd094c4f7235817ba4ceebde8e6d11cd0c5633b675"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"

 [[package]]
 name = "windows_i686_gnu"
@@ -6111,9 +6234,15 @@ checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"

 [[package]]
 name = "windows_i686_gnu"
-version = "0.52.4"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b474d8268f99e0995f25b9f095bc7434632601028cf86590aea5c8a5cb7801d3"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"

 [[package]]
 name = "windows_i686_msvc"
@@ -6123,9 +6252,9 @@ checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"

 [[package]]
 name = "windows_i686_msvc"
-version = "0.52.4"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1515e9a29e5bed743cb4415a9ecf5dfca648ce85ee42e15873c3cd8610ff8e02"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"

 [[package]]
 name = "windows_x86_64_gnu"
@@ -6135,9 +6264,9 @@ checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"

 [[package]]
 name = "windows_x86_64_gnu"
-version = "0.52.4"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5eee091590e89cc02ad514ffe3ead9eb6b660aedca2183455434b93546371a03"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"

 [[package]]
 name = "windows_x86_64_gnullvm"
@@ -6147,9 +6276,9 @@ checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"

 [[package]]
 name = "windows_x86_64_gnullvm"
-version = "0.52.4"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77ca79f2451b49fa9e2af39f0747fe999fcda4f5e241b2898624dca97a1f2177"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"

 [[package]]
 name = "windows_x86_64_msvc"
@@ -6159,9 +6288,9 @@ checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"

 [[package]]
 name = "windows_x86_64_msvc"
-version = "0.52.4"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32b752e52a2da0ddfbdbcc6fceadfeede4c939ed16d13e648833a61dfb611ed8"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"

 [[package]]
 name = "winnow"
@@ -6181,16 +6310,6 @@ dependencies = [
 "memchr",
 ]

-[[package]]
-name = "winreg"
-version = "0.52.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a277a57398d4bfa075df44f501a17cfdf8542d224f0d36095a2adc7aee4ef0a5"
-dependencies = [
- "cfg-if",
- "windows-sys 0.48.0",
-]
-
 [[package]]
 name = "wyz"
 version = "0.5.1"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -16,34 +16,33 @@ crate-type = ["cdylib", "rlib"]

 [dependencies]
 halo2_gadgets = { git = "https://github.com/zkonduit/halo2", branch = "ac/optional-selector-poly" }
-halo2_proofs = { git = "https://github.com/zkonduit/halo2", branch = "ac/optional-selector-poly" }
-halo2curves = { git = "https://github.com/privacy-scaling-explorations/halo2curves", rev = "9fff22c", features = [
-    "derive_serde",
+halo2curves = { git = "https://github.com/privacy-scaling-explorations/halo2curves", rev = "b753a832e92d5c86c5c997327a9cf9de86a18851", features = [
+    "derive_serde"
 ] }
+halo2_proofs = { git = "https://github.com/zkonduit/halo2?branch=ac/cache-lookup-commitments#8b13a0d2a7a34d8daab010dadb2c47dfa47d37d0", package = "halo2_proofs", branch = "ac/cache-lookup-commitments" }
 rand = { version = "0.8", default_features = false }
 itertools = { version = "0.10.3", default_features = false }
 clap = { version = "4.5.3", features = ["derive"] }
-clap_complete = "4.5.2"
 serde = { version = "1.0.126", features = ["derive"], optional = true }
 serde_json = { version = "1.0.97", default_features = false, features = [
    "float_roundtrip",
    "raw_value",
 ], optional = true }
+clap_complete = "4.5.2"
 log = { version = "0.4.17", default_features = false, optional = true }
 thiserror = { version = "1.0.38", default_features = false }
 hex = { version = "0.4.3", default_features = false }
 halo2_wrong_ecc = { git = "https://github.com/zkonduit/halo2wrong", branch = "ac/chunked-mv-lookup", package = "ecc" }
-snark-verifier = { git = "https://github.com/zkonduit/snark-verifier", branch = "ac/chunked-mv-lookup", features = [
+snark-verifier = { git = "https://github.com/zkonduit/snark-verifier", branch = "ac/chunked-mv-lookup",  features = [
    "derive_serde",
 ] }
-halo2_solidity_verifier = { git = "https://github.com/alexander-camuto/halo2-solidity-verifier", branch = "main" }
+halo2_solidity_verifier = { git = "https://github.com/alexander-camuto/halo2-solidity-verifier", branch = "ac/update-h2-curves" }
 maybe-rayon = { version = "0.1.1", default_features = false }
 bincode = { version = "1.3.3", default_features = false }
 unzip-n = "0.1.2"
 num = "0.4.1"
 portable-atomic = "1.6.0"
 tosubcommand = { git = "https://github.com/zkonduit/enum_to_subcommand", package = "tosubcommand" }
-metal = { git = "https://github.com/gfx-rs/metal-rs", optional = true }
 semver = "1.0.22"

 # evm related deps
@@ -65,9 +64,9 @@ pg_bigdecimal = "0.1.5"
 lazy_static = "1.4.0"
 colored_json = { version = "3.0.1", default_features = false, optional = true }
 regex = { version = "1", default_features = false }
-tokio = { version = "1.35", default_features = false, features = [
+tokio = { version = "1.35.0", default_features = false, features = [
    "macros",
-    "rt-multi-thread"
+    "rt-multi-thread",
 ] }
 pyo3 = { version = "0.21.2", features = [
    "extension-module",
@@ -75,14 +74,16 @@ pyo3 = { version = "0.21.2", features = [
    "macros",
 ], default_features = false, optional = true }
 pyo3-asyncio = { git = "https://github.com/jopemachine/pyo3-asyncio/", branch="migration-pyo3-0.21", features = [
-    "attributes",
+  "attributes",
    "tokio-runtime",
 ], default_features = false, optional = true }
+
 pyo3-log = { version = "0.10.0", default_features = false, optional = true }
 tract-onnx = { git = "https://github.com/sonos/tract/", rev = "40c64319291184814d9fea5fdf4fa16f5a4f7116", default_features = false, optional = true }
 tabled = { version = "0.12.0", optional = true }
+metal = { git = "https://github.com/gfx-rs/metal-rs", optional = true }
 objc = { version = "0.2.4", optional = true }
-
+mimalloc = "0.1"

 [target.'cfg(not(all(target_arch = "wasm32", target_os = "unknown")))'.dependencies]
 colored = { version = "2.0.0", default_features = false, optional = true }
@@ -90,6 +91,7 @@ env_logger = { version = "0.10.0", default_features = false, optional = true }
 chrono = "0.4.31"
 sha256 = "1.4.0"

+
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 getrandom = { version = "0.2.8", features = ["js"] }
 instant = { version = "0.1", features = ["wasm-bindgen", "inaccurate"] }
@@ -177,7 +179,7 @@ required-features = ["ezkl"]

 [features]
 web = ["wasm-bindgen-rayon"]
-default = ["ezkl", "mv-lookup", "no-banner", "parallel-poly-read"]
+default = ["ezkl", "mv-lookup", "precompute-coset", "no-banner", "parallel-poly-read"]
 onnx = ["dep:tract-onnx"]
 python-bindings = ["pyo3", "pyo3-log", "pyo3-asyncio"]
 ezkl = [
@@ -197,20 +199,25 @@ mv-lookup = [
    "snark-verifier/mv-lookup",
    "halo2_solidity_verifier/mv-lookup",
 ]
+asm = ["halo2curves/asm", "halo2_proofs/asm"]
+precompute-coset = ["halo2_proofs/precompute-coset"]
 det-prove = []
 icicle = ["halo2_proofs/icicle_gpu"]
 empty-cmd = []
 no-banner = []
 no-update = []
-metal = ["dep:metal", "dep:objc"]
+

 # icicle patch to 0.1.0 if feature icicle is enabled
 [patch.'https://github.com/ingonyama-zk/icicle']
 icicle = { git = "https://github.com/ingonyama-zk/icicle?rev=45b00fb", package = "icicle", branch = "fix/vhnat/ezkl-build-fix" }

 [patch.'https://github.com/zkonduit/halo2']
-halo2_proofs = { git = "https://github.com/zkonduit/halo2#8cfca221f53069a0374687654882b99e729041d7", package = "halo2_proofs" }
-
+halo2_proofs = { git = "https://github.com/zkonduit/halo2?branch=ac/cache-lookup-commitments#8b13a0d2a7a34d8daab010dadb2c47dfa47d37d0", package = "halo2_proofs", branch = "ac/cache-lookup-commitments" }

 [profile.release]
 rustflags = ["-C", "relocation-model=pic"]
+lto = "fat"
+codegen-units = 1
+# panic = "abort"
+
--- a/benches/accum_conv.rs
+++ b/benches/accum_conv.rs
@@ -72,6 +72,7 @@ impl Circuit<Fr> for MyCircuit {
                        Box::new(PolyOp::Conv {
                            padding: vec![(0, 0)],
                            stride: vec![1; 2],
+                            group: 1,
                        }),
                    )
                    .unwrap();
--- a/benches/relu.rs
+++ b/benches/relu.rs
@@ -2,6 +2,7 @@ use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Through
 use ezkl::circuit::region::RegionCtx;
 use ezkl::circuit::table::Range;
 use ezkl::circuit::{ops::lookup::LookupOp, BaseConfig as Config, CheckMode};
+use ezkl::fieldutils::IntegerRep;
 use ezkl::pfsys::create_proof_circuit;
 use ezkl::pfsys::TranscriptType;
 use ezkl::pfsys::{create_keys, srs::gen_srs};
@@ -84,7 +85,7 @@ fn runrelu(c: &mut Criterion) {
        };

        let input: Tensor<Value<Fr>> =
-            Tensor::<i32>::from((0..len).map(|_| rng.gen_range(0..10))).into();
+            Tensor::<IntegerRep>::from((0..len).map(|_| rng.gen_range(0..10))).into();

        let circuit = NLCircuit {
            input: ValTensor::from(input.clone()),
--- a/docs/python/requirements-docs.txt
+++ b/docs/python/requirements-docs.txt
@@ -1,4 +1,4 @@
-ezkl==0.0.0
+ezkl==13.0.2
 sphinx
 sphinx-rtd-theme
 sphinxcontrib-napoleon
--- a/docs/python/src/conf.py
+++ b/docs/python/src/conf.py
@@ -1,7 +1,7 @@
 import ezkl

 project = 'ezkl'
-release = '0.0.0'
+release = '13.0.2'
 version = release


--- a/examples/conv2d_mnist/main.rs
+++ b/examples/conv2d_mnist/main.rs
@@ -2,8 +2,7 @@ use ezkl::circuit::region::RegionCtx;
 use ezkl::circuit::{
    ops::lookup::LookupOp, ops::poly::PolyOp, BaseConfig as PolyConfig, CheckMode,
 };
-use ezkl::fieldutils;
-use ezkl::fieldutils::i32_to_felt;
+use ezkl::fieldutils::{self, integer_rep_to_felt, IntegerRep};
 use ezkl::tensor::*;
 use halo2_proofs::dev::MockProver;
 use halo2_proofs::poly::commitment::Params;
@@ -42,8 +41,8 @@ const NUM_INNER_COLS: usize = 1;
 struct Config<
    const LEN: usize, //LEN = CHOUT x OH x OW flattened //not supported yet in rust stable
    const CLASSES: usize,
-    const LOOKUP_MIN: i64,
-    const LOOKUP_MAX: i64,
+    const LOOKUP_MIN: IntegerRep,
+    const LOOKUP_MAX: IntegerRep,
    // Convolution
    const KERNEL_HEIGHT: usize,
    const KERNEL_WIDTH: usize,
@@ -66,8 +65,8 @@ struct Config<
 struct MyCircuit<
    const LEN: usize, //LEN = CHOUT x OH x OW flattened
    const CLASSES: usize,
-    const LOOKUP_MIN: i64,
-    const LOOKUP_MAX: i64,
+    const LOOKUP_MIN: IntegerRep,
+    const LOOKUP_MAX: IntegerRep,
    // Convolution
    const KERNEL_HEIGHT: usize,
    const KERNEL_WIDTH: usize,
@@ -90,8 +89,8 @@ struct MyCircuit<
 impl<
        const LEN: usize,
        const CLASSES: usize,
-        const LOOKUP_MIN: i64,
-        const LOOKUP_MAX: i64,
+        const LOOKUP_MIN: IntegerRep,
+        const LOOKUP_MAX: IntegerRep,
        // Convolution
        const KERNEL_HEIGHT: usize,
        const KERNEL_WIDTH: usize,
@@ -205,6 +204,7 @@ where
                    let op = PolyOp::Conv {
                        padding: vec![(PADDING, PADDING); 2],
                        stride: vec![STRIDE; 2],
+                        group: 1,
                    };
                    let x = config
                        .layer_config
@@ -315,7 +315,11 @@ pub fn runconv() {
        .test_set_length(10_000)
        .finalize();

-    let mut train_data = Tensor::from(trn_img.iter().map(|x| i32_to_felt::<F>(*x as i32 / 16)));
+    let mut train_data = Tensor::from(
+        trn_img
+            .iter()
+            .map(|x| integer_rep_to_felt::<F>(*x as IntegerRep / 16)),
+    );
    train_data.reshape(&[50_000, 28, 28]).unwrap();

    let mut train_labels = Tensor::from(trn_lbl.iter().map(|x| *x as f32));
@@ -343,8 +347,8 @@ pub fn runconv() {
            .map(|fl| {
                let dx = fl * 32_f32;
                let rounded = dx.round();
-                let integral: i32 = unsafe { rounded.to_int_unchecked() };
-                fieldutils::i32_to_felt(integral)
+                let integral: IntegerRep = unsafe { rounded.to_int_unchecked() };
+                fieldutils::integer_rep_to_felt(integral)
            }),
    );

@@ -355,7 +359,8 @@ pub fn runconv() {

    let l0_kernels = l0_kernels.try_into().unwrap();

-    let mut l0_bias = Tensor::<F>::from((0..OUT_CHANNELS).map(|_| fieldutils::i32_to_felt(0)));
+    let mut l0_bias =
+        Tensor::<F>::from((0..OUT_CHANNELS).map(|_| fieldutils::integer_rep_to_felt(0)));
    l0_bias.set_visibility(&ezkl::graph::Visibility::Private);

    let l0_bias = l0_bias.try_into().unwrap();
@@ -363,8 +368,8 @@ pub fn runconv() {
    let mut l2_biases = Tensor::<F>::from(myparams.biases.into_iter().map(|fl| {
        let dx = fl * 32_f32;
        let rounded = dx.round();
-        let integral: i32 = unsafe { rounded.to_int_unchecked() };
-        fieldutils::i32_to_felt(integral)
+        let integral: IntegerRep = unsafe { rounded.to_int_unchecked() };
+        fieldutils::integer_rep_to_felt(integral)
    }));
    l2_biases.set_visibility(&ezkl::graph::Visibility::Private);
    l2_biases.reshape(&[l2_biases.len(), 1]).unwrap();
@@ -374,8 +379,8 @@ pub fn runconv() {
    let mut l2_weights = Tensor::<F>::from(myparams.weights.into_iter().flatten().map(|fl| {
        let dx = fl * 32_f32;
        let rounded = dx.round();
-        let integral: i32 = unsafe { rounded.to_int_unchecked() };
-        fieldutils::i32_to_felt(integral)
+        let integral: IntegerRep = unsafe { rounded.to_int_unchecked() };
+        fieldutils::integer_rep_to_felt(integral)
    }));
    l2_weights.set_visibility(&ezkl::graph::Visibility::Private);
    l2_weights.reshape(&[CLASSES, LEN]).unwrap();
@@ -401,13 +406,13 @@ pub fn runconv() {
        l2_params: [l2_weights, l2_biases],
    };

-    let public_input: Tensor<i32> = vec![
-        -25124i32, -19304, -16668, -4399, -6209, -4548, -2317, -8349, -6117, -23461,
+    let public_input: Tensor<IntegerRep> = vec![
+        -25124, -19304, -16668, -4399, -6209, -4548, -2317, -8349, -6117, -23461,
    ]
    .into_iter()
    .into();

-    let pi_inner: Tensor<F> = public_input.map(i32_to_felt::<F>);
+    let pi_inner: Tensor<F> = public_input.map(integer_rep_to_felt::<F>);

    println!("MOCK PROVING");
    let now = Instant::now();
--- a/examples/mlp_4d_einsum.rs
+++ b/examples/mlp_4d_einsum.rs
@@ -2,7 +2,7 @@ use ezkl::circuit::region::RegionCtx;
 use ezkl::circuit::{
    ops::lookup::LookupOp, ops::poly::PolyOp, BaseConfig as PolyConfig, CheckMode,
 };
-use ezkl::fieldutils::i32_to_felt;
+use ezkl::fieldutils::{integer_rep_to_felt, IntegerRep};
 use ezkl::tensor::*;
 use halo2_proofs::dev::MockProver;
 use halo2_proofs::{
@@ -23,8 +23,8 @@ struct MyConfig {
 #[derive(Clone)]
 struct MyCircuit<
    const LEN: usize, //LEN = CHOUT x OH x OW flattened
-    const LOOKUP_MIN: i64,
-    const LOOKUP_MAX: i64,
+    const LOOKUP_MIN: IntegerRep,
+    const LOOKUP_MAX: IntegerRep,
 > {
    // Given the stateless MyConfig type information, a DNN trace is determined by its input and the parameters of its layers.
    // Computing the trace still requires a forward pass. The intermediate activations are stored only by the layouter.
@@ -34,7 +34,7 @@ struct MyCircuit<
    _marker: PhantomData<F>,
 }

-impl<const LEN: usize, const LOOKUP_MIN: i64, const LOOKUP_MAX: i64> Circuit<F>
+impl<const LEN: usize, const LOOKUP_MIN: IntegerRep, const LOOKUP_MAX: IntegerRep> Circuit<F>
    for MyCircuit<LEN, LOOKUP_MIN, LOOKUP_MAX>
 {
    type Config = MyConfig;
@@ -215,33 +215,33 @@ pub fn runmlp() {
    #[cfg(not(target_arch = "wasm32"))]
    env_logger::init();
    // parameters
-    let mut l0_kernel: Tensor<F> = Tensor::<i32>::new(
+    let mut l0_kernel: Tensor<F> = Tensor::<IntegerRep>::new(
        Some(&[10, 0, 0, -1, 0, 10, 1, 0, 0, 1, 10, 0, 1, 0, 0, 10]),
        &[4, 4],
    )
    .unwrap()
-    .map(i32_to_felt);
+    .map(integer_rep_to_felt);
    l0_kernel.set_visibility(&ezkl::graph::Visibility::Private);

-    let mut l0_bias: Tensor<F> = Tensor::<i32>::new(Some(&[0, 0, 0, 1]), &[4, 1])
+    let mut l0_bias: Tensor<F> = Tensor::<IntegerRep>::new(Some(&[0, 0, 0, 1]), &[4, 1])
        .unwrap()
-        .map(i32_to_felt);
+        .map(integer_rep_to_felt);
    l0_bias.set_visibility(&ezkl::graph::Visibility::Private);

-    let mut l2_kernel: Tensor<F> = Tensor::<i32>::new(
+    let mut l2_kernel: Tensor<F> = Tensor::<IntegerRep>::new(
        Some(&[0, 3, 10, -1, 0, 10, 1, 0, 0, 1, 0, 12, 1, -2, 32, 0]),
        &[4, 4],
    )
    .unwrap()
-    .map(i32_to_felt);
+    .map(integer_rep_to_felt);
    l2_kernel.set_visibility(&ezkl::graph::Visibility::Private);
    // input data, with 1 padding to allow for bias
-    let input: Tensor<Value<F>> = Tensor::<i32>::new(Some(&[-30, -21, 11, 40]), &[4, 1])
+    let input: Tensor<Value<F>> = Tensor::<IntegerRep>::new(Some(&[-30, -21, 11, 40]), &[4, 1])
        .unwrap()
        .into();
-    let mut l2_bias: Tensor<F> = Tensor::<i32>::new(Some(&[0, 0, 0, 1]), &[4, 1])
+    let mut l2_bias: Tensor<F> = Tensor::<IntegerRep>::new(Some(&[0, 0, 0, 1]), &[4, 1])
        .unwrap()
-        .map(i32_to_felt);
+        .map(integer_rep_to_felt);
    l2_bias.set_visibility(&ezkl::graph::Visibility::Private);

    let circuit = MyCircuit::<4, -8192, 8192> {
@@ -251,12 +251,12 @@ pub fn runmlp() {
        _marker: PhantomData,
    };

-    let public_input: Vec<i32> = unsafe {
+    let public_input: Vec<IntegerRep> = unsafe {
        vec![
-            (531f32 / 128f32).round().to_int_unchecked::<i32>(),
-            (103f32 / 128f32).round().to_int_unchecked::<i32>(),
-            (4469f32 / 128f32).round().to_int_unchecked::<i32>(),
-            (2849f32 / 128f32).to_int_unchecked::<i32>(),
+            (531f32 / 128f32).round().to_int_unchecked::<IntegerRep>(),
+            (103f32 / 128f32).round().to_int_unchecked::<IntegerRep>(),
+            (4469f32 / 128f32).round().to_int_unchecked::<IntegerRep>(),
+            (2849f32 / 128f32).to_int_unchecked::<IntegerRep>(),
        ]
    };

@@ -265,7 +265,10 @@ pub fn runmlp() {
    let prover = MockProver::run(
        K as u32,
        &circuit,
-        vec![public_input.iter().map(|x| i32_to_felt::<F>(*x)).collect()],
+        vec![public_input
+            .iter()
+            .map(|x| integer_rep_to_felt::<F>(*x))
+            .collect()],
    )
    .unwrap();
    prover.assert_satisfied();
--- a/in-browser-evm-verifier/src/index.ts
+++ b/in-browser-evm-verifier/src/index.ts
@@ -9,7 +9,6 @@ import { EVM } from '@ethereumjs/evm'
 import { buildTransaction, encodeDeployment } from './utils/tx-builder'
 import { getAccountNonce, insertAccount } from './utils/account-utils'
 import { encodeVerifierCalldata } from '../nodejs/ezkl';
-import { error } from 'console'

 async function deployContract(
  vm: VM,
@@ -66,7 +65,7 @@ async function verify(
    vkAddress = new Uint8Array(uint8Array.buffer);

    // convert uitn8array of length
-    error('vkAddress', vkAddress)
+    console.error('vkAddress', vkAddress)
  }
  const data = encodeVerifierCalldata(proof, vkAddress)

--- a/2
+++ b/2
@@ -1,3 +1,3 @@
 [toolchain]
-channel = "nightly-2024-02-06"
+channel = "nightly-2024-07-18"
 components = ["rustfmt", "clippy"]
--- a/src/bin/ezkl.rs
+++ b/src/bin/ezkl.rs
@@ -1,4 +1,7 @@
 // ignore file if compiling for wasm
+#[global_allocator]
+#[cfg(not(target_arch = "wasm32"))]
+static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;

 #[cfg(not(target_arch = "wasm32"))]
 use clap::{CommandFactory, Parser};
--- a/src/circuit/ops/chip.rs
+++ b/src/circuit/ops/chip.rs
@@ -22,7 +22,7 @@ use crate::{
        table::{Range, RangeCheck, Table},
        utils,
    },
-    tensor::{IntoI64, Tensor, TensorType, ValTensor, VarTensor},
+    tensor::{Tensor, TensorType, ValTensor, VarTensor},
 };
 use std::{collections::BTreeMap, marker::PhantomData};

@@ -327,7 +327,7 @@ pub struct BaseConfig<F: PrimeField + TensorType + PartialOrd> {
    _marker: PhantomData<F>,
 }

-impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> BaseConfig<F> {
+impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> BaseConfig<F> {
    /// Returns a new [BaseConfig] with no inputs, no selectors, and no tables.
    pub fn dummy(col_size: usize, num_inner_cols: usize) -> Self {
        Self {
--- a/src/circuit/ops/errors.rs
+++ b/src/circuit/ops/errors.rs
@@ -1,6 +1,6 @@
 use std::convert::Infallible;

-use crate::tensor::TensorError;
+use crate::{fieldutils::IntegerRep, tensor::TensorError};
 use halo2_proofs::plonk::Error as PlonkError;
 use thiserror::Error;

@@ -57,7 +57,7 @@ pub enum CircuitError {
    InvalidConversion(#[from] Infallible),
    /// Invalid min/max lookup range
    #[error("invalid min/max lookup range: min: {0}, max: {1}")]
-    InvalidMinMaxRange(i64, i64),
+    InvalidMinMaxRange(IntegerRep, IntegerRep),
    /// Missing product in einsum
    #[error("missing product in einsum")]
    MissingEinsumProduct,
@@ -81,7 +81,7 @@ pub enum CircuitError {
    MissingSelectors(String),
    /// Table lookup error
    #[error("value ({0}) out of range: ({1}, {2})")]
-    TableOOR(i64, i64, i64),
+    TableOOR(IntegerRep, IntegerRep, IntegerRep),
    /// Loookup not configured
    #[error("lookup not configured: {0}")]
    LookupNotConfigured(String),
@@ -91,4 +91,7 @@ pub enum CircuitError {
    /// Missing layout
    #[error("missing layout for op: {0}")]
    MissingLayout(String),
+    #[error("[io] {0}")]
+    /// IO error
+    IoError(#[from] std::io::Error),
 }
--- a/src/circuit/ops/hybrid.rs
+++ b/src/circuit/ops/hybrid.rs
@@ -1,7 +1,7 @@
 use super::*;
 use crate::{
    circuit::{layouts, utils, Tolerance},
-    fieldutils::i64_to_felt,
+    fieldutils::integer_rep_to_felt,
    graph::multiplier_to_scale,
    tensor::{self, Tensor, TensorType, ValTensor},
 };
@@ -71,7 +71,7 @@ pub enum HybridOp {
    },
 }

-impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Op<F> for HybridOp {
+impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash > Op<F> for HybridOp {
    ///
    fn requires_homogenous_input_scales(&self) -> Vec<usize> {
        match self {
@@ -184,8 +184,8 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Op<F>
                        config,
                        region,
                        values[..].try_into()?,
-                        i64_to_felt(input_scale.0 as i64),
-                        i64_to_felt(output_scale.0 as i64),
+                        integer_rep_to_felt(input_scale.0 as i128),
+                        integer_rep_to_felt(output_scale.0 as i128),
                    )?
                } else {
                    layouts::nonlinearity(
@@ -209,7 +209,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Op<F>
                        config,
                        region,
                        values[..].try_into()?,
-                        i64_to_felt(denom.0 as i64),
+                        integer_rep_to_felt(denom.0 as i128),
                    )?
                } else {
                    layouts::nonlinearity(
--- a/src/circuit/ops/layouts.rs
+++ b/src/circuit/ops/layouts.rs
--- a/src/circuit/ops/lookup.rs
+++ b/src/circuit/ops/lookup.rs
@@ -3,9 +3,9 @@ use serde::{Deserialize, Serialize};

 use crate::{
    circuit::{layouts, table::Range, utils},
-    fieldutils::{felt_to_i64, i64_to_felt},
+    fieldutils::{felt_to_integer_rep, integer_rep_to_felt, IntegerRep},
    graph::multiplier_to_scale,
-    tensor::{self, IntoI64, Tensor, TensorError, TensorType},
+    tensor::{self, Tensor, TensorError, TensorType},
 };

 use super::Op;
@@ -131,16 +131,63 @@ impl LookupOp {
    /// Returns the range of values that can be represented by the table
    pub fn bit_range(max_len: usize) -> Range {
        let range = (max_len - 1) as f64 / 2_f64;
-        let range = range as i64;
+        let range = range as IntegerRep;
        (-range, range)
    }

+    /// as path
+    pub fn as_path(&self) -> String {
+        match self {
+            LookupOp::Abs => "abs".into(),
+            LookupOp::Ceil { scale } => format!("ceil_{}", scale),
+            LookupOp::Floor { scale } => format!("floor_{}", scale),
+            LookupOp::Round { scale } => format!("round_{}", scale),
+            LookupOp::RoundHalfToEven { scale } => format!("round_half_to_even_{}", scale),
+            LookupOp::Pow { scale, a } => format!("pow_{}_{}", scale, a),
+            LookupOp::KroneckerDelta => "kronecker_delta".into(),
+            LookupOp::Max { scale, a } => format!("max_{}_{}", scale, a),
+            LookupOp::Min { scale, a } => format!("min_{}_{}", scale, a),
+            LookupOp::Sign => "sign".into(),
+            LookupOp::LessThan { a } => format!("less_than_{}", a),
+            LookupOp::LessThanEqual { a } => format!("less_than_equal_{}", a),
+            LookupOp::GreaterThan { a } => format!("greater_than_{}", a),
+            LookupOp::GreaterThanEqual { a } => format!("greater_than_equal_{}", a),
+            LookupOp::Div { denom } => format!("div_{}", denom),
+            LookupOp::Cast { scale } => format!("cast_{}", scale),
+            LookupOp::Recip {
+                input_scale,
+                output_scale,
+            } => format!("recip_{}_{}", input_scale, output_scale),
+            LookupOp::ReLU => "relu".to_string(),
+            LookupOp::LeakyReLU { slope: a } => format!("leaky_relu_{}", a),
+            LookupOp::Sigmoid { scale } => format!("sigmoid_{}", scale),
+            LookupOp::Sqrt { scale } => format!("sqrt_{}", scale),
+            LookupOp::Rsqrt { scale } => format!("rsqrt_{}", scale),
+            LookupOp::Erf { scale } => format!("erf_{}", scale),
+            LookupOp::Exp { scale } => format!("exp_{}", scale),
+            LookupOp::Ln { scale } => format!("ln_{}", scale),
+            LookupOp::Cos { scale } => format!("cos_{}", scale),
+            LookupOp::ACos { scale } => format!("acos_{}", scale),
+            LookupOp::Cosh { scale } => format!("cosh_{}", scale),
+            LookupOp::ACosh { scale } => format!("acosh_{}", scale),
+            LookupOp::Sin { scale } => format!("sin_{}", scale),
+            LookupOp::ASin { scale } => format!("asin_{}", scale),
+            LookupOp::Sinh { scale } => format!("sinh_{}", scale),
+            LookupOp::ASinh { scale } => format!("asinh_{}", scale),
+            LookupOp::Tan { scale } => format!("tan_{}", scale),
+            LookupOp::ATan { scale } => format!("atan_{}", scale),
+            LookupOp::ATanh { scale } => format!("atanh_{}", scale),
+            LookupOp::Tanh { scale } => format!("tanh_{}", scale),
+            LookupOp::HardSwish { scale } => format!("hardswish_{}", scale),
+        }
+    }
+
    /// Matches a [Op] to an operation in the `tensor::ops` module.
-    pub(crate) fn f<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64>(
+    pub(crate) fn f<F: PrimeField + TensorType + PartialOrd + std::hash::Hash>(
        &self,
        x: &[Tensor<F>],
    ) -> Result<ForwardResult<F>, TensorError> {
-        let x = x[0].clone().map(|x| felt_to_i64(x));
+        let x = x[0].clone().map(|x| felt_to_integer_rep(x));
        let res = match &self {
            LookupOp::Abs => Ok(tensor::ops::abs(&x)?),
            LookupOp::Ceil { scale } => Ok(tensor::ops::nonlinearities::ceil(&x, scale.into())),
@@ -227,13 +274,13 @@ impl LookupOp {
            }
        }?;

-        let output = res.map(|x| i64_to_felt(x));
+        let output = res.map(|x| integer_rep_to_felt(x));

        Ok(ForwardResult { output })
    }
 }

-impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Op<F> for LookupOp {
+impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for LookupOp {
    /// Returns a reference to the Any trait.
    fn as_any(&self) -> &dyn Any {
        self
--- a/src/circuit/ops/mod.rs
+++ b/src/circuit/ops/mod.rs
@@ -4,7 +4,7 @@ use serde::{Deserialize, Serialize};

 use crate::{
    graph::quantize_tensor,
-    tensor::{self, IntoI64, Tensor, TensorType, ValTensor},
+    tensor::{self, Tensor, TensorType, ValTensor},
 };
 use halo2curves::ff::PrimeField;

@@ -31,12 +31,12 @@ pub use errors::CircuitError;

 /// A struct representing the result of a forward pass.
 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
-pub struct ForwardResult<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> {
+pub struct ForwardResult<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> {
    pub(crate) output: Tensor<F>,
 }

 /// A trait representing operations that can be represented as constraints in a circuit.
-pub trait Op<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64>:
+pub trait Op<F: PrimeField + TensorType + PartialOrd + std::hash::Hash>:
    std::fmt::Debug + Send + Sync + Any
 {
    /// Returns a string representation of the operation.
@@ -75,7 +75,7 @@ pub trait Op<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64
    fn as_any(&self) -> &dyn Any;
 }

-impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Clone for Box<dyn Op<F>> {
+impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Clone for Box<dyn Op<F>> {
    fn clone(&self) -> Self {
        self.clone_dyn()
    }
@@ -142,7 +142,7 @@ pub struct Input {
    pub datum_type: InputType,
 }

-impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Op<F> for Input {
+impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Input {
    fn out_scale(&self, _: Vec<crate::Scale>) -> Result<crate::Scale, CircuitError> {
        Ok(self.scale)
    }
@@ -197,7 +197,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Op<F>
 #[derive(Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
 pub struct Unknown;

-impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Op<F> for Unknown {
+impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Op<F> for Unknown {
    fn out_scale(&self, _: Vec<crate::Scale>) -> Result<crate::Scale, CircuitError> {
        Ok(0)
    }
@@ -224,7 +224,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Op<F>

 ///
 #[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct Constant<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> {
+pub struct Constant<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> {
    ///
    pub quantized_values: Tensor<F>,
    ///
@@ -234,7 +234,7 @@ pub struct Constant<F: PrimeField + TensorType + PartialOrd + std::hash::Hash +
    pub pre_assigned_val: Option<ValTensor<F>>,
 }

-impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Constant<F> {
+impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Constant<F> {
    ///
    pub fn new(quantized_values: Tensor<F>, raw_values: Tensor<f32>) -> Self {
        Self {
@@ -267,8 +267,7 @@ impl<
            + PartialOrd
            + std::hash::Hash
            + Serialize
-            + for<'de> Deserialize<'de>
-            + IntoI64,
+            + for<'de> Deserialize<'de>,
    > Op<F> for Constant<F>
 {
    fn as_any(&self) -> &dyn Any {
--- a/src/circuit/ops/poly.rs
+++ b/src/circuit/ops/poly.rs
@@ -33,6 +33,7 @@ pub enum PolyOp {
    Conv {
        padding: Vec<(usize, usize)>,
        stride: Vec<usize>,
+        group: usize,
    },
    Downsample {
        axis: usize,
@@ -43,6 +44,7 @@ pub enum PolyOp {
        padding: Vec<(usize, usize)>,
        output_padding: Vec<usize>,
        stride: Vec<usize>,
+        group: usize,
    },
    Add,
    Sub,
@@ -98,7 +100,7 @@ impl<
            + std::hash::Hash
            + Serialize
            + for<'de> Deserialize<'de>
-            + IntoI64,
+            ,
    > Op<F> for PolyOp
 {
    /// Returns a reference to the Any trait.
@@ -148,17 +150,25 @@ impl<
            PolyOp::Sum { axes } => format!("SUM (axes={:?})", axes),
            PolyOp::Prod { .. } => "PROD".into(),
            PolyOp::Pow(_) => "POW".into(),
-            PolyOp::Conv { stride, padding } => {
-                format!("CONV (stride={:?}, padding={:?})", stride, padding)
+            PolyOp::Conv {
+                stride,
+                padding,
+                group,
+            } => {
+                format!(
+                    "CONV (stride={:?}, padding={:?}, group={})",
+                    stride, padding, group
+                )
            }
            PolyOp::DeConv {
                stride,
                padding,
                output_padding,
+                group,
            } => {
                format!(
-                    "DECONV (stride={:?}, padding={:?}, output_padding={:?})",
-                    stride, padding, output_padding
+                    "DECONV (stride={:?}, padding={:?}, output_padding={:?}, group={})",
+                    stride, padding, output_padding, group
                )
            }
            PolyOp::Concat { axis } => format!("CONCAT (axis={})", axis),
@@ -212,9 +222,18 @@ impl<
            PolyOp::Prod { axes, .. } => {
                layouts::prod_axes(config, region, values[..].try_into()?, axes)?
            }
-            PolyOp::Conv { padding, stride } => {
-                layouts::conv(config, region, values[..].try_into()?, padding, stride)?
-            }
+            PolyOp::Conv {
+                padding,
+                stride,
+                group,
+            } => layouts::conv(
+                config,
+                region,
+                values[..].try_into()?,
+                padding,
+                stride,
+                *group,
+            )?,
            PolyOp::GatherElements { dim, constant_idx } => {
                if let Some(idx) = constant_idx {
                    tensor::ops::gather_elements(values[0].get_inner_tensor()?, idx, *dim)?.into()
@@ -261,6 +280,7 @@ impl<
                padding,
                output_padding,
                stride,
+                group,
            } => layouts::deconv(
                config,
                region,
@@ -268,6 +288,7 @@ impl<
                padding,
                output_padding,
                stride,
+                *group,
            )?,
            PolyOp::Add => layouts::pairwise(config, region, values[..].try_into()?, BaseOp::Add)?,
            PolyOp::Sub => layouts::pairwise(config, region, values[..].try_into()?, BaseOp::Sub)?,
--- a/src/circuit/ops/region.rs
+++ b/src/circuit/ops/region.rs
@@ -1,5 +1,6 @@
 use crate::{
    circuit::table::Range,
+    fieldutils::IntegerRep,
    tensor::{Tensor, TensorType, ValTensor, ValType, VarTensor},
 };
 #[cfg(not(target_arch = "wasm32"))]
@@ -11,7 +12,6 @@ use halo2_proofs::{
 use halo2curves::ff::PrimeField;
 use itertools::Itertools;
 use maybe_rayon::iter::ParallelExtend;
-use portable_atomic::AtomicI64 as AtomicInt;
 use std::{
    cell::RefCell,
    collections::{HashMap, HashSet},
@@ -86,6 +86,78 @@ impl ShuffleIndex {
    }
 }

+#[derive(Debug, Clone)]
+/// Some settings for a region to differentiate it across the different phases of proof generation
+pub struct RegionSettings {
+    /// whether we are in witness generation mode
+    pub witness_gen: bool,
+    /// whether we should check range checks for validity
+    pub check_range: bool,
+}
+
+#[allow(unsafe_code)]
+unsafe impl Sync for RegionSettings {}
+#[allow(unsafe_code)]
+unsafe impl Send for RegionSettings {}
+
+impl RegionSettings {
+    /// Create a new region settings
+    pub fn new(witness_gen: bool, check_range: bool) -> RegionSettings {
+        RegionSettings {
+            witness_gen,
+            check_range,
+        }
+    }
+
+    /// Create a new region settings with all true
+    pub fn all_true() -> RegionSettings {
+        RegionSettings {
+            witness_gen: true,
+            check_range: true,
+        }
+    }
+
+    /// Create a new region settings with all false
+    pub fn all_false() -> RegionSettings {
+        RegionSettings {
+            witness_gen: false,
+            check_range: false,
+        }
+    }
+}
+
+#[derive(Debug, Default, Clone)]
+/// Region statistics
+pub struct RegionStatistics {
+    /// the current maximum value of the lookup inputs
+    pub max_lookup_inputs: IntegerRep,
+    /// the current minimum value of the lookup inputs
+    pub min_lookup_inputs: IntegerRep,
+    /// the current maximum value of the range size
+    pub max_range_size: IntegerRep,
+    /// the current set of used lookups
+    pub used_lookups: HashSet<LookupOp>,
+    /// the current set of used range checks
+    pub used_range_checks: HashSet<Range>,
+}
+
+impl RegionStatistics {
+    /// update the statistics with another set of statistics
+    pub fn update(&mut self, other: &RegionStatistics) {
+        self.max_lookup_inputs = self.max_lookup_inputs.max(other.max_lookup_inputs);
+        self.min_lookup_inputs = self.min_lookup_inputs.min(other.min_lookup_inputs);
+        self.max_range_size = self.max_range_size.max(other.max_range_size);
+        self.used_lookups.extend(other.used_lookups.clone());
+        self.used_range_checks
+            .extend(other.used_range_checks.clone());
+    }
+}
+
+#[allow(unsafe_code)]
+unsafe impl Sync for RegionStatistics {}
+#[allow(unsafe_code)]
+unsafe impl Send for RegionStatistics {}
+
 #[derive(Debug)]
 /// A context for a region
 pub struct RegionCtx<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> {
@@ -95,13 +167,8 @@ pub struct RegionCtx<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Ha
    num_inner_cols: usize,
    dynamic_lookup_index: DynamicLookupIndex,
    shuffle_index: ShuffleIndex,
-    used_lookups: HashSet<LookupOp>,
-    used_range_checks: HashSet<Range>,
-    max_lookup_inputs: i64,
-    min_lookup_inputs: i64,
-    max_range_size: i64,
-    witness_gen: bool,
-    check_lookup_range: bool,
+    statistics: RegionStatistics,
+    settings: RegionSettings,
    assigned_constants: ConstantsMap<F>,
 }

@@ -153,12 +220,17 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a

    ///
    pub fn witness_gen(&self) -> bool {
-        self.witness_gen
+        self.settings.witness_gen
    }

    ///
-    pub fn check_lookup_range(&self) -> bool {
-        self.check_lookup_range
+    pub fn check_range(&self) -> bool {
+        self.settings.check_range
+    }
+
+    ///
+    pub fn statistics(&self) -> &RegionStatistics {
+        &self.statistics
    }

    /// Create a new region context
@@ -173,13 +245,8 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
            linear_coord,
            dynamic_lookup_index: DynamicLookupIndex::default(),
            shuffle_index: ShuffleIndex::default(),
-            used_lookups: HashSet::new(),
-            used_range_checks: HashSet::new(),
-            max_lookup_inputs: 0,
-            min_lookup_inputs: 0,
-            max_range_size: 0,
-            witness_gen: true,
-            check_lookup_range: true,
+            statistics: RegionStatistics::default(),
+            settings: RegionSettings::all_true(),
            assigned_constants: HashMap::new(),
        }
    }
@@ -195,39 +262,12 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
        new_self.assigned_constants = constants;
        new_self
    }
-    /// Create a new region context from a wrapped region
-    pub fn from_wrapped_region(
-        region: Option<RefCell<Region<'a, F>>>,
-        row: usize,
-        num_inner_cols: usize,
-        dynamic_lookup_index: DynamicLookupIndex,
-        shuffle_index: ShuffleIndex,
-    ) -> RegionCtx<'a, F> {
-        let linear_coord = row * num_inner_cols;
-        RegionCtx {
-            region,
-            num_inner_cols,
-            linear_coord,
-            row,
-            dynamic_lookup_index,
-            shuffle_index,
-            used_lookups: HashSet::new(),
-            used_range_checks: HashSet::new(),
-            max_lookup_inputs: 0,
-            min_lookup_inputs: 0,
-            max_range_size: 0,
-            witness_gen: false,
-            check_lookup_range: false,
-            assigned_constants: HashMap::new(),
-        }
-    }

    /// Create a new region context
    pub fn new_dummy(
        row: usize,
        num_inner_cols: usize,
-        witness_gen: bool,
-        check_lookup_range: bool,
+        settings: RegionSettings,
    ) -> RegionCtx<'a, F> {
        let region = None;
        let linear_coord = row * num_inner_cols;
@@ -239,13 +279,8 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
            row,
            dynamic_lookup_index: DynamicLookupIndex::default(),
            shuffle_index: ShuffleIndex::default(),
-            used_lookups: HashSet::new(),
-            used_range_checks: HashSet::new(),
-            max_lookup_inputs: 0,
-            min_lookup_inputs: 0,
-            max_range_size: 0,
-            witness_gen,
-            check_lookup_range,
+            statistics: RegionStatistics::default(),
+            settings,
            assigned_constants: HashMap::new(),
        }
    }
@@ -255,8 +290,7 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
        row: usize,
        linear_coord: usize,
        num_inner_cols: usize,
-        witness_gen: bool,
-        check_lookup_range: bool,
+        settings: RegionSettings,
    ) -> RegionCtx<'a, F> {
        let region = None;
        RegionCtx {
@@ -266,13 +300,8 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
            row,
            dynamic_lookup_index: DynamicLookupIndex::default(),
            shuffle_index: ShuffleIndex::default(),
-            used_lookups: HashSet::new(),
-            used_range_checks: HashSet::new(),
-            max_lookup_inputs: 0,
-            min_lookup_inputs: 0,
-            max_range_size: 0,
-            witness_gen,
-            check_lookup_range,
+            statistics: RegionStatistics::default(),
+            settings,
            assigned_constants: HashMap::new(),
        }
    }
@@ -323,12 +352,9 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
    ) -> Result<(), CircuitError> {
        let row = AtomicUsize::new(self.row());
        let linear_coord = AtomicUsize::new(self.linear_coord());
-        let max_lookup_inputs = AtomicInt::new(self.max_lookup_inputs());
-        let min_lookup_inputs = AtomicInt::new(self.min_lookup_inputs());
-        let lookups = Arc::new(Mutex::new(self.used_lookups.clone()));
-        let range_checks = Arc::new(Mutex::new(self.used_range_checks.clone()));
-        let dynamic_lookup_index = Arc::new(Mutex::new(self.dynamic_lookup_index.clone()));
+        let statistics = Arc::new(Mutex::new(self.statistics.clone()));
        let shuffle_index = Arc::new(Mutex::new(self.shuffle_index.clone()));
+        let dynamic_lookup_index = Arc::new(Mutex::new(self.dynamic_lookup_index.clone()));
        let constants = Arc::new(Mutex::new(self.assigned_constants.clone()));

        *output = output.par_enum_map(|idx, _| {
@@ -342,8 +368,7 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
                starting_offset,
                starting_linear_coord,
                self.num_inner_cols,
-                self.witness_gen,
-                self.check_lookup_range,
+                self.settings.clone(),
            );
            let res = inner_loop_function(idx, &mut local_reg);
            // we update the offset and constants
@@ -353,14 +378,9 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
                Ordering::SeqCst,
            );

-            max_lookup_inputs.fetch_max(local_reg.max_lookup_inputs(), Ordering::SeqCst);
-            min_lookup_inputs.fetch_min(local_reg.min_lookup_inputs(), Ordering::SeqCst);
            // update the lookups
-            let mut lookups = lookups.lock().unwrap();
-            lookups.extend(local_reg.used_lookups());
-            // update the range checks
-            let mut range_checks = range_checks.lock().unwrap();
-            range_checks.extend(local_reg.used_range_checks());
+            let mut statistics = statistics.lock().unwrap();
+            statistics.update(local_reg.statistics());
            // update the dynamic lookup index
            let mut dynamic_lookup_index = dynamic_lookup_index.lock().unwrap();
            dynamic_lookup_index.update(&local_reg.dynamic_lookup_index);
@@ -374,20 +394,11 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
            res
        })?;
        self.linear_coord = linear_coord.into_inner();
-        #[allow(trivial_numeric_casts)]
-        {
-            self.max_lookup_inputs = max_lookup_inputs.into_inner();
-            self.min_lookup_inputs = min_lookup_inputs.into_inner();
-        }
        self.row = row.into_inner();
-        self.used_lookups = Arc::try_unwrap(lookups)
+        self.statistics = Arc::try_unwrap(statistics)
            .map_err(|e| CircuitError::GetLookupsError(format!("{:?}", e)))?
            .into_inner()
            .map_err(|e| CircuitError::GetLookupsError(format!("{:?}", e)))?;
-        self.used_range_checks = Arc::try_unwrap(range_checks)
-            .map_err(|e| CircuitError::GetRangeChecksError(format!("{:?}", e)))?
-            .into_inner()
-            .map_err(|e| CircuitError::GetRangeChecksError(format!("{:?}", e)))?;
        self.dynamic_lookup_index = Arc::try_unwrap(dynamic_lookup_index)
            .map_err(|e| CircuitError::GetDynamicLookupError(format!("{:?}", e)))?
            .into_inner()
@@ -411,11 +422,11 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
    ) -> Result<(), CircuitError> {
        let (mut min, mut max) = (0, 0);
        for i in inputs {
-            max = max.max(i.get_int_evals()?.into_iter().max().unwrap_or_default());
-            min = min.min(i.get_int_evals()?.into_iter().min().unwrap_or_default());
+            max = max.max(i.int_evals()?.into_iter().max().unwrap_or_default());
+            min = min.min(i.int_evals()?.into_iter().min().unwrap_or_default());
        }
-        self.max_lookup_inputs = self.max_lookup_inputs.max(max);
-        self.min_lookup_inputs = self.min_lookup_inputs.min(min);
+        self.statistics.max_lookup_inputs = self.statistics.max_lookup_inputs.max(max);
+        self.statistics.min_lookup_inputs = self.statistics.min_lookup_inputs.min(min);
        Ok(())
    }

@@ -427,7 +438,7 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a

        let range_size = (range.1 - range.0).abs();

-        self.max_range_size = self.max_range_size.max(range_size);
+        self.statistics.max_range_size = self.statistics.max_range_size.max(range_size);
        Ok(())
    }

@@ -442,13 +453,13 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a
        lookup: LookupOp,
        inputs: &[ValTensor<F>],
    ) -> Result<(), CircuitError> {
-        self.used_lookups.insert(lookup);
+        self.statistics.used_lookups.insert(lookup);
        self.update_max_min_lookup_inputs(inputs)
    }

    /// add used range check
    pub fn add_used_range_check(&mut self, range: Range) -> Result<(), CircuitError> {
-        self.used_range_checks.insert(range);
+        self.statistics.used_range_checks.insert(range);
        self.update_max_min_lookup_range(range)
    }

@@ -489,27 +500,27 @@ impl<'a, F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RegionCtx<'a

    /// get used lookups
    pub fn used_lookups(&self) -> HashSet<LookupOp> {
-        self.used_lookups.clone()
+        self.statistics.used_lookups.clone()
    }

    /// get used range checks
    pub fn used_range_checks(&self) -> HashSet<Range> {
-        self.used_range_checks.clone()
+        self.statistics.used_range_checks.clone()
    }

    /// max lookup inputs
-    pub fn max_lookup_inputs(&self) -> i64 {
-        self.max_lookup_inputs
+    pub fn max_lookup_inputs(&self) -> IntegerRep {
+        self.statistics.max_lookup_inputs
    }

    /// min lookup inputs
-    pub fn min_lookup_inputs(&self) -> i64 {
-        self.min_lookup_inputs
+    pub fn min_lookup_inputs(&self) -> IntegerRep {
+        self.statistics.min_lookup_inputs
    }

    /// max range check
-    pub fn max_range_size(&self) -> i64 {
-        self.max_range_size
+    pub fn max_range_size(&self) -> IntegerRep {
+        self.statistics.max_range_size
    }

    /// Assign a valtensor to a vartensor
--- a/src/circuit/table.rs
+++ b/src/circuit/table.rs
@@ -11,20 +11,33 @@ use maybe_rayon::prelude::{IntoParallelIterator, ParallelIterator};

 use crate::{
    circuit::CircuitError,
-    fieldutils::i64_to_felt,
-    tensor::{IntoI64, Tensor, TensorType},
+    fieldutils::{integer_rep_to_felt, IntegerRep},
+    tensor::{Tensor, TensorType},
 };

+#[cfg(not(target_arch = "wasm32"))]
+use crate::execute::EZKL_REPO_PATH;
+
 use crate::circuit::lookup::LookupOp;

 /// The range of the lookup table.
-pub type Range = (i64, i64);
+pub type Range = (IntegerRep, IntegerRep);

 /// The safety factor for the range of the lookup table.
-pub const RANGE_MULTIPLIER: i64 = 2;
+pub const RANGE_MULTIPLIER: IntegerRep = 2;
 /// The safety factor offset for the number of rows in the lookup table.
 pub const RESERVED_BLINDING_ROWS_PAD: usize = 3;

+#[cfg(not(target_arch = "wasm32"))]
+lazy_static::lazy_static! {
+    /// an optional directory to read and write the lookup table cache
+    pub static ref LOOKUP_CACHE: String = format!("{}/cache", *EZKL_REPO_PATH);
+}
+
+/// The lookup table cache is disabled on wasm32 target.
+#[cfg(target_arch = "wasm32")]
+pub const LOOKUP_CACHE: &str = "";
+
 #[derive(Debug, Clone)]
 ///
 pub struct SelectorConstructor<F: PrimeField> {
@@ -96,21 +109,22 @@ pub struct Table<F: PrimeField> {
    _marker: PhantomData<F>,
 }

-impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Table<F> {
+impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Table<F> {
    /// get column index given input
    pub fn get_col_index(&self, input: F) -> F {
        //    range is split up into chunks of size col_size, find the chunk that input is in
-        let chunk =
-            (crate::fieldutils::felt_to_i64(input) - self.range.0).abs() / (self.col_size as i64);
+        let chunk = (crate::fieldutils::felt_to_integer_rep(input) - self.range.0).abs()
+            / (self.col_size as IntegerRep);

-        i64_to_felt(chunk)
+        integer_rep_to_felt(chunk)
    }

    /// get first_element of column
    pub fn get_first_element(&self, chunk: usize) -> (F, F) {
-        let chunk = chunk as i64;
+        let chunk = chunk as IntegerRep;
        // we index from 1 to prevent soundness issues
-        let first_element = i64_to_felt(chunk * (self.col_size as i64) + self.range.0);
+        let first_element =
+            integer_rep_to_felt(chunk * (self.col_size as IntegerRep) + self.range.0);
        let op_f = self
            .nonlinearity
            .f(&[Tensor::from(vec![first_element].into_iter())])
@@ -130,12 +144,20 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Table<
 }

 ///
-pub fn num_cols_required(range_len: i64, col_size: usize) -> usize {
+pub fn num_cols_required(range_len: IntegerRep, col_size: usize) -> usize {
    // number of cols needed to store the range
-    (range_len / (col_size as i64)) as usize + 1
+    (range_len / (col_size as IntegerRep)) as usize + 1
 }

-impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Table<F> {
+impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> Table<F> {
+    fn name(&self) -> String {
+        format!(
+            "{}_{}_{}",
+            self.nonlinearity.as_path(),
+            self.range.0,
+            self.range.1
+        )
+    }
    /// Configures the table.
    pub fn configure(
        cs: &mut ConstraintSystem<F>,
@@ -202,8 +224,51 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Table<
        let smallest = self.range.0;
        let largest = self.range.1;

-        let inputs: Tensor<F> = Tensor::from(smallest..=largest).map(|x| i64_to_felt(x));
-        let evals = self.nonlinearity.f(&[inputs.clone()])?;
+        let gen_table = || -> Result<(Tensor<F>, Tensor<F>), crate::tensor::TensorError> {
+            let inputs = Tensor::from(smallest..=largest)
+                .par_enum_map(|_, x| Ok::<_, crate::tensor::TensorError>(integer_rep_to_felt(x)))?;
+            let evals = self.nonlinearity.f(&[inputs.clone()])?;
+            Ok((inputs, evals.output))
+        };
+
+        let (inputs, evals) = if !LOOKUP_CACHE.is_empty() {
+            let cache = std::path::Path::new(&*LOOKUP_CACHE);
+            let cache_path = cache.join(self.name());
+            let input_path = cache_path.join("inputs");
+            let output_path = cache_path.join("outputs");
+            if cache_path.exists() {
+                log::info!("Loading lookup table from cache: {:?}", cache_path);
+                let (input_cache, output_cache) =
+                    (Tensor::load(&input_path)?, Tensor::load(&output_path)?);
+                (input_cache, output_cache)
+            } else {
+                log::info!(
+                    "Generating lookup table and saving to cache: {:?}",
+                    cache_path
+                );
+
+                // mkdir -p cache_path
+                std::fs::create_dir_all(&cache_path).map_err(|e| {
+                    CircuitError::TensorError(crate::tensor::TensorError::FileSaveError(
+                        e.to_string(),
+                    ))
+                })?;
+
+                let (inputs, evals) = gen_table()?;
+                inputs.save(&input_path)?;
+                evals.save(&output_path)?;
+
+                (inputs, evals)
+            }
+        } else {
+            log::info!(
+                "Generating lookup table {} without cache",
+                self.nonlinearity.as_path()
+            );
+
+            gen_table()?
+        };
+
        let chunked_inputs = inputs.chunks(self.col_size);

        self.is_assigned = true;
@@ -235,7 +300,7 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> Table<
                                    )?;
                                }

-                                let output = evals.output[row_offset];
+                                let output = evals[row_offset];

                                table.assign_cell(
                                    || format!("nl_o_col row {}", row_offset),
@@ -272,12 +337,17 @@ pub struct RangeCheck<F: PrimeField> {
    _marker: PhantomData<F>,
 }

-impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> RangeCheck<F> {
+impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RangeCheck<F> {
+    /// as path
+    pub fn as_path(&self) -> String {
+        format!("rangecheck_{}_{}", self.range.0, self.range.1)
+    }
+
    /// get first_element of column
    pub fn get_first_element(&self, chunk: usize) -> F {
-        let chunk = chunk as i64;
+        let chunk = chunk as IntegerRep;
        // we index from 1 to prevent soundness issues
-        i64_to_felt(chunk * (self.col_size as i64) + self.range.0)
+        integer_rep_to_felt(chunk * (self.col_size as IntegerRep) + self.range.0)
    }

    ///
@@ -293,14 +363,14 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> RangeC
    /// get column index given input
    pub fn get_col_index(&self, input: F) -> F {
        //    range is split up into chunks of size col_size, find the chunk that input is in
-        let chunk =
-            (crate::fieldutils::felt_to_i64(input) - self.range.0).abs() / (self.col_size as i64);
+        let chunk = (crate::fieldutils::felt_to_integer_rep(input) - self.range.0).abs()
+            / (self.col_size as IntegerRep);

-        i64_to_felt(chunk)
+        integer_rep_to_felt(chunk)
    }
 }

-impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> RangeCheck<F> {
+impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> RangeCheck<F> {
    /// Configures the table.
    pub fn configure(cs: &mut ConstraintSystem<F>, range: Range, logrows: usize) -> RangeCheck<F> {
        log::debug!("range check range: {:?}", range);
@@ -350,7 +420,32 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash + IntoI64> RangeC
        let smallest = self.range.0;
        let largest = self.range.1;

-        let inputs: Tensor<F> = Tensor::from(smallest..=largest).map(|x| i64_to_felt(x));
+        let inputs: Tensor<F> = if !LOOKUP_CACHE.is_empty() {
+            let cache = std::path::Path::new(&*LOOKUP_CACHE);
+            let cache_path = cache.join(self.as_path());
+            let input_path = cache_path.join("inputs");
+            if cache_path.exists() {
+                log::info!("Loading range check table from cache: {:?}", cache_path);
+                Tensor::load(&input_path)?
+            } else {
+                log::info!(
+                    "Generating range check table and saving to cache: {:?}",
+                    cache_path
+                );
+
+                // mkdir -p cache_path
+                std::fs::create_dir_all(&cache_path)?;
+
+                let inputs = Tensor::from(smallest..=largest).map(|x| integer_rep_to_felt(x));
+                inputs.save(&input_path)?;
+                inputs
+            }
+        } else {
+            log::info!("Generating range check {} without cache", self.as_path());
+
+            Tensor::from(smallest..=largest).map(|x| integer_rep_to_felt(x))
+        };
+
        let chunked_inputs = inputs.chunks(self.col_size);

        self.is_assigned = true;
--- a/src/circuit/tests.rs
+++ b/src/circuit/tests.rs
@@ -256,7 +256,7 @@ mod matmul_col_ultra_overflow_double_col {
    use super::*;

    const K: usize = 4;
-    const LEN: usize = 20;
+    const LEN: usize = 10;
    const NUM_INNER_COLS: usize = 2;

    #[derive(Clone)]
@@ -374,7 +374,7 @@ mod matmul_col_ultra_overflow {
    use super::*;

    const K: usize = 4;
-    const LEN: usize = 20;
+    const LEN: usize = 10;

    #[derive(Clone)]
    struct MatmulCircuit<F: PrimeField + TensorType + PartialOrd> {
@@ -1050,6 +1050,7 @@ mod conv {
                                Box::new(PolyOp::Conv {
                                    padding: vec![(1, 1); 2],
                                    stride: vec![2; 2],
+                                    group: 1,
                                }),
                            )
                            .map_err(|_| Error::Synthesis)
@@ -1158,7 +1159,7 @@ mod conv_col_ultra_overflow {
    use super::*;

    const K: usize = 4;
-    const LEN: usize = 28;
+    const LEN: usize = 10;

    #[derive(Clone)]
    struct ConvCircuit<F: PrimeField + TensorType + PartialOrd> {
@@ -1200,6 +1201,7 @@ mod conv_col_ultra_overflow {
                                Box::new(PolyOp::Conv {
                                    padding: vec![(1, 1); 2],
                                    stride: vec![2; 2],
+                                    group: 1,
                                }),
                            )
                            .map_err(|_| Error::Synthesis)
@@ -1296,7 +1298,7 @@ mod conv_relu_col_ultra_overflow {
    use super::*;

    const K: usize = 4;
-    const LEN: usize = 28;
+    const LEN: usize = 15;

    #[derive(Clone)]
    struct ConvCircuit<F: PrimeField + TensorType + PartialOrd> {
@@ -1345,6 +1347,7 @@ mod conv_relu_col_ultra_overflow {
                                Box::new(PolyOp::Conv {
                                    padding: vec![(1, 1); 2],
                                    stride: vec![2; 2],
+                                    group: 1,
                                }),
                            )
                            .map_err(|_| Error::Synthesis);
--- a/src/eth.rs
+++ b/src/eth.rs
@@ -731,7 +731,7 @@ pub async fn verify_proof_with_data_attestation(

    for val in flattened_instances.clone() {
        let bytes = val.to_repr();
-        let u = U256::from_le_slice(bytes.as_slice());
+        let u = U256::from_le_slice(bytes.inner().as_slice());
        public_inputs.push(u);
    }

--- a/src/execute.rs
+++ b/src/execute.rs
@@ -1,3 +1,4 @@
+use crate::circuit::region::RegionSettings;
 use crate::circuit::CheckMode;
 #[cfg(not(target_arch = "wasm32"))]
 use crate::commands::CalibrationTarget;
@@ -785,6 +786,8 @@ pub(crate) async fn gen_witness(

    let commitment: Commitments = settings.run_args.commitment.into();

+    let region_settings = RegionSettings::all_true();
+
    let start_time = Instant::now();
    let witness = if settings.module_requires_polycommit() {
        if get_srs_path(settings.run_args.logrows, srs_path.clone(), commitment).exists() {
@@ -799,8 +802,7 @@ pub(crate) async fn gen_witness(
                        &mut input,
                        vk.as_ref(),
                        Some(&srs),
-                        true,
-                        true,
+                        region_settings,
                    )?
                }
                Commitments::IPA => {
@@ -814,8 +816,7 @@ pub(crate) async fn gen_witness(
                        &mut input,
                        vk.as_ref(),
                        Some(&srs),
-                        true,
-                        true,
+                        region_settings,
                    )?
                }
            }
@@ -825,12 +826,16 @@ pub(crate) async fn gen_witness(
                &mut input,
                vk.as_ref(),
                None,
-                true,
-                true,
+                region_settings,
            )?
        }
    } else {
-        circuit.forward::<KZGCommitmentScheme<Bn256>>(&mut input, vk.as_ref(), None, true, true)?
+        circuit.forward::<KZGCommitmentScheme<Bn256>>(
+            &mut input,
+            vk.as_ref(),
+            None,
+            region_settings,
+        )?
    };

    // print each variable tuple (symbol, value) as symbol=value
@@ -1023,6 +1028,8 @@ pub(crate) async fn calibrate(
    use std::collections::HashMap;
    use tabled::Table;

+    use crate::fieldutils::IntegerRep;
+
    let data = GraphData::from_path(data)?;
    // load the pre-generated settings
    let settings = GraphSettings::load(&settings_path)?;
@@ -1131,7 +1138,7 @@ pub(crate) async fn calibrate(
            param_scale,
            scale_rebase_multiplier,
            div_rebasing,
-            lookup_range: (i64::MIN, i64::MAX),
+            lookup_range: (IntegerRep::MIN, IntegerRep::MAX),
            ..settings.run_args.clone()
        };

@@ -1171,8 +1178,7 @@ pub(crate) async fn calibrate(
                        &mut data.clone(),
                        None,
                        None,
-                        true,
-                        false,
+                        RegionSettings::all_true(),
                    )
                    .map_err(|e| format!("failed to forward: {}", e))?;

--- a/src/fieldutils.rs
+++ b/src/fieldutils.rs
@@ -2,17 +2,11 @@ use halo2_proofs::arithmetic::Field;
 /// Utilities for converting from Halo2 PrimeField types to integers (and vice-versa).
 use halo2curves::ff::PrimeField;

-/// Converts an i32 to a PrimeField element.
-pub fn i32_to_felt<F: PrimeField>(x: i32) -> F {
-    if x >= 0 {
-        F::from(x as u64)
-    } else {
-        -F::from(x.unsigned_abs() as u64)
-    }
-}
+/// Integer representation of a PrimeField element.
+pub type IntegerRep = i128;

 /// Converts an i64 to a PrimeField element.
-pub fn i64_to_felt<F: PrimeField>(x: i64) -> F {
+pub fn integer_rep_to_felt<F: PrimeField>(x: IntegerRep) -> F {
    if x >= 0 {
        F::from_u128(x as u128)
    } else {
@@ -20,24 +14,9 @@ pub fn i64_to_felt<F: PrimeField>(x: i64) -> F {
    }
 }

-/// Converts a PrimeField element to an i32.
-pub fn felt_to_i32<F: PrimeField + PartialOrd + Field>(x: F) -> i32 {
-    if x > F::from(i32::MAX as u64) {
-        let rep = (-x).to_repr();
-        let negtmp: &[u8] = rep.as_ref();
-        let lower_32 = u32::from_le_bytes(negtmp[..4].try_into().unwrap());
-        -(lower_32 as i32)
-    } else {
-        let rep = (x).to_repr();
-        let tmp: &[u8] = rep.as_ref();
-        let lower_32 = u32::from_le_bytes(tmp[..4].try_into().unwrap());
-        lower_32 as i32
-    }
-}
-
 /// Converts a PrimeField element to an f64.
 pub fn felt_to_f64<F: PrimeField + PartialOrd + Field>(x: F) -> f64 {
-    if x > F::from_u128(i64::MAX as u128) {
+    if x > F::from_u128(IntegerRep::MAX as u128) {
        let rep = (-x).to_repr();
        let negtmp: &[u8] = rep.as_ref();
        let lower_128: u128 = u128::from_le_bytes(negtmp[..16].try_into().unwrap());
@@ -51,17 +30,17 @@ pub fn felt_to_f64<F: PrimeField + PartialOrd + Field>(x: F) -> f64 {
 }

 /// Converts a PrimeField element to an i64.
-pub fn felt_to_i64<F: PrimeField + PartialOrd + Field>(x: F) -> i64 {
-    if x > F::from_u128(i64::MAX as u128) {
+pub fn felt_to_integer_rep<F: PrimeField + PartialOrd + Field>(x: F) -> IntegerRep {
+    if x > F::from_u128(IntegerRep::MAX as u128) {
        let rep = (-x).to_repr();
        let negtmp: &[u8] = rep.as_ref();
        let lower_128: u128 = u128::from_le_bytes(negtmp[..16].try_into().unwrap());
-        -(lower_128 as i64)
+        -(lower_128 as IntegerRep)
    } else {
        let rep = (x).to_repr();
        let tmp: &[u8] = rep.as_ref();
        let lower_128: u128 = u128::from_le_bytes(tmp[..16].try_into().unwrap());
-        lower_128 as i64
+        lower_128 as IntegerRep
    }
 }

@@ -73,33 +52,24 @@ mod test {

    #[test]
    fn test_conv() {
-        let res: F = i32_to_felt(-15i32);
+        let res: F = integer_rep_to_felt(-15);
        assert_eq!(res, -F::from(15));

-        let res: F = i32_to_felt(2_i32.pow(17));
+        let res: F = integer_rep_to_felt(2_i128.pow(17));
        assert_eq!(res, F::from(131072));

-        let res: F = i64_to_felt(-15i64);
+        let res: F = integer_rep_to_felt(-15);
        assert_eq!(res, -F::from(15));

-        let res: F = i64_to_felt(2_i64.pow(17));
+        let res: F = integer_rep_to_felt(2_i128.pow(17));
        assert_eq!(res, F::from(131072));
    }

    #[test]
-    fn felttoi32() {
-        for x in -(2i32.pow(16))..(2i32.pow(16)) {
-            let fieldx: F = i32_to_felt::<F>(x);
-            let xf: i32 = felt_to_i32::<F>(fieldx);
-            assert_eq!(x, xf);
-        }
-    }
-
-    #[test]
-    fn felttoi64() {
-        for x in -(2i64.pow(20))..(2i64.pow(20)) {
-            let fieldx: F = i64_to_felt::<F>(x);
-            let xf: i64 = felt_to_i64::<F>(fieldx);
+    fn felttointegerrep() {
+        for x in -(2_i128.pow(16))..(2_i128.pow(16)) {
+            let fieldx: F = integer_rep_to_felt::<F>(x);
+            let xf: i128 = felt_to_integer_rep::<F>(fieldx);
            assert_eq!(x, xf);
        }
    }
--- a/src/graph/input.rs
+++ b/src/graph/input.rs
@@ -1,7 +1,7 @@
 use super::errors::GraphError;
 use super::quantize_float;
 use crate::circuit::InputType;
-use crate::fieldutils::i64_to_felt;
+use crate::fieldutils::integer_rep_to_felt;
 #[cfg(not(target_arch = "wasm32"))]
 use crate::graph::postgres::Client;
 #[cfg(not(target_arch = "wasm32"))]
@@ -128,7 +128,7 @@ impl FileSourceInner {
    /// Convert to a field element
    pub fn to_field(&self, scale: crate::Scale) -> Fp {
        match self {
-            FileSourceInner::Float(f) => i64_to_felt(quantize_float(f, 0.0, scale).unwrap()),
+            FileSourceInner::Float(f) => integer_rep_to_felt(quantize_float(f, 0.0, scale).unwrap()),
            FileSourceInner::Bool(f) => {
                if *f {
                    Fp::one()
@@ -150,7 +150,7 @@ impl FileSourceInner {
                    0.0
                }
            }
-            FileSourceInner::Field(f) => crate::fieldutils::felt_to_i64(*f) as f64,
+            FileSourceInner::Field(f) => crate::fieldutils::felt_to_integer_rep(*f) as f64,
        }
    }
 }
--- a/src/graph/mod.rs
+++ b/src/graph/mod.rs
@@ -34,10 +34,10 @@ use self::input::{FileSource, GraphData};
 use self::modules::{GraphModules, ModuleConfigs, ModuleForwardResult, ModuleSizes};
 use crate::circuit::lookup::LookupOp;
 use crate::circuit::modules::ModulePlanner;
-use crate::circuit::region::ConstantsMap;
+use crate::circuit::region::{ConstantsMap, RegionSettings};
 use crate::circuit::table::{num_cols_required, Range, Table, RESERVED_BLINDING_ROWS_PAD};
 use crate::circuit::{CheckMode, InputType};
-use crate::fieldutils::felt_to_f64;
+use crate::fieldutils::{felt_to_f64, IntegerRep};
 use crate::pfsys::PrettyElements;
 use crate::tensor::{Tensor, ValTensor};
 use crate::{RunArgs, EZKL_BUF_CAPACITY};
@@ -69,13 +69,14 @@ pub use vars::*;
 use crate::pfsys::field_to_string;

 /// The safety factor for the range of the lookup table.
-pub const RANGE_MULTIPLIER: i64 = 2;
+pub const RANGE_MULTIPLIER: IntegerRep = 2;

 /// The maximum number of columns in a lookup table.
 pub const MAX_NUM_LOOKUP_COLS: usize = 12;

 /// Max representation of a lookup table input
-pub const MAX_LOOKUP_ABS: i64 = (MAX_NUM_LOOKUP_COLS as i64) * 2_i64.pow(MAX_PUBLIC_SRS);
+pub const MAX_LOOKUP_ABS: IntegerRep =
+    (MAX_NUM_LOOKUP_COLS as IntegerRep) * 2_i128.pow(MAX_PUBLIC_SRS);

 #[cfg(not(target_arch = "wasm32"))]
 lazy_static! {
@@ -126,11 +127,11 @@ pub struct GraphWitness {
    /// Any hashes of outputs generated during the forward pass
    pub processed_outputs: Option<ModuleForwardResult>,
    /// max lookup input
-    pub max_lookup_inputs: i64,
+    pub max_lookup_inputs: IntegerRep,
    /// max lookup input
-    pub min_lookup_inputs: i64,
+    pub min_lookup_inputs: IntegerRep,
    /// max range check size
-    pub max_range_size: i64,
+    pub max_range_size: IntegerRep,
 }

 impl GraphWitness {
@@ -804,18 +805,26 @@ impl GraphCircuit {
        // the ordering here is important, we want the inputs to come before the outputs
        // as they are configured in that order as Column<Instances>
        let mut public_inputs: Vec<Fp> = vec![];
-        if self.settings().run_args.input_visibility.is_public() {
-            public_inputs.extend(self.graph_witness.inputs.clone().into_iter().flatten())
-        } else if let Some(processed_inputs) = &data.processed_inputs {
+
+        // we first process the inputs
+        if let Some(processed_inputs) = &data.processed_inputs {
            public_inputs.extend(processed_inputs.get_instances().into_iter().flatten());
        }

+        // we then process the params
        if let Some(processed_params) = &data.processed_params {
            public_inputs.extend(processed_params.get_instances().into_iter().flatten());
        }

+        // if the inputs are public, we add them to the public inputs AFTER the processed params as they are configured in that order as Column<Instances>
+        if self.settings().run_args.input_visibility.is_public() {
+            public_inputs.extend(self.graph_witness.inputs.clone().into_iter().flatten())
+        }
+
+        // if the outputs are public, we add them to the public inputs
        if self.settings().run_args.output_visibility.is_public() {
            public_inputs.extend(self.graph_witness.outputs.clone().into_iter().flatten());
+        // if the outputs are processed, we add the processed outputs to the public inputs
        } else if let Some(processed_outputs) = &data.processed_outputs {
            public_inputs.extend(processed_outputs.get_instances().into_iter().flatten());
        }
@@ -1036,12 +1045,12 @@ impl GraphCircuit {

    fn calc_safe_lookup_range(min_max_lookup: Range, lookup_safety_margin: f64) -> Range {
        (
-            (lookup_safety_margin * min_max_lookup.0 as f64).floor() as i64,
-            (lookup_safety_margin * min_max_lookup.1 as f64).ceil() as i64,
+            (lookup_safety_margin * min_max_lookup.0 as f64).floor() as IntegerRep,
+            (lookup_safety_margin * min_max_lookup.1 as f64).ceil() as IntegerRep,
        )
    }

-    fn calc_num_cols(range_len: i64, max_logrows: u32) -> usize {
+    fn calc_num_cols(range_len: IntegerRep, max_logrows: u32) -> usize {
        let max_col_size = Table::<Fp>::cal_col_size(max_logrows as usize, RESERVED_BLINDING_ROWS);
        num_cols_required(range_len, max_col_size)
    }
@@ -1049,7 +1058,7 @@ impl GraphCircuit {
    fn table_size_logrows(
        &self,
        safe_lookup_range: Range,
-        max_range_size: i64,
+        max_range_size: IntegerRep,
    ) -> Result<u32, GraphError> {
        // pick the range with the largest absolute size safe_lookup_range or max_range_size
        let safe_range = std::cmp::max(
@@ -1068,7 +1077,7 @@ impl GraphCircuit {
    pub fn calc_min_logrows(
        &mut self,
        min_max_lookup: Range,
-        max_range_size: i64,
+        max_range_size: IntegerRep,
        max_logrows: Option<u32>,
        lookup_safety_margin: f64,
    ) -> Result<(), GraphError> {
@@ -1086,7 +1095,7 @@ impl GraphCircuit {
            (safe_lookup_range.1.saturating_sub(safe_lookup_range.0)).saturating_abs();
        // check if has overflowed max lookup input

-        if lookup_size > (MAX_LOOKUP_ABS as f64 / lookup_safety_margin).floor() as i64 {
+        if lookup_size > (MAX_LOOKUP_ABS as f64 / lookup_safety_margin).floor() as IntegerRep {
            return Err(GraphError::LookupRangeTooLarge(
                lookup_size.unsigned_abs() as usize
            ));
@@ -1166,7 +1175,7 @@ impl GraphCircuit {
        &self,
        k: u32,
        safe_lookup_range: Range,
-        max_range_size: i64,
+        max_range_size: IntegerRep,
    ) -> bool {
        // if num cols is too large then the extended k is too large
        if Self::calc_num_cols(safe_lookup_range.1 - safe_lookup_range.0, k) > MAX_NUM_LOOKUP_COLS
@@ -1224,8 +1233,7 @@ impl GraphCircuit {
        inputs: &mut [Tensor<Fp>],
        vk: Option<&VerifyingKey<G1Affine>>,
        srs: Option<&Scheme::ParamsProver>,
-        witness_gen: bool,
-        check_lookup: bool,
+        region_settings: RegionSettings,
    ) -> Result<GraphWitness, GraphError> {
        let original_inputs = inputs.to_vec();

@@ -1274,7 +1282,7 @@ impl GraphCircuit {

        let mut model_results =
            self.model()
-                .forward(inputs, &self.settings().run_args, witness_gen, check_lookup)?;
+                .forward(inputs, &self.settings().run_args, region_settings)?;

        if visibility.output.requires_processing() {
            let module_outlets = visibility.output.overwrites_inputs();
--- a/src/graph/model.rs
+++ b/src/graph/model.rs
@@ -7,10 +7,12 @@ use super::GraphSettings;
 use crate::circuit::hybrid::HybridOp;
 use crate::circuit::region::ConstantsMap;
 use crate::circuit::region::RegionCtx;
+use crate::circuit::region::RegionSettings;
 use crate::circuit::table::Range;
 use crate::circuit::Input;
 use crate::circuit::InputType;
 use crate::circuit::Unknown;
+use crate::fieldutils::IntegerRep;
 use crate::tensor::ValType;
 use crate::{
    circuit::{lookup::LookupOp, BaseConfig as PolyConfig, CheckMode, Op},
@@ -64,11 +66,11 @@ pub struct ForwardResult {
    /// The outputs of the forward pass.
    pub outputs: Vec<Tensor<Fp>>,
    /// The maximum value of any input to a lookup operation.
-    pub max_lookup_inputs: i64,
+    pub max_lookup_inputs: IntegerRep,
    /// The minimum value of any input to a lookup operation.
-    pub min_lookup_inputs: i64,
+    pub min_lookup_inputs: IntegerRep,
    /// The max range check size
-    pub max_range_size: i64,
+    pub max_range_size: IntegerRep,
 }

 impl From<DummyPassRes> for ForwardResult {
@@ -116,11 +118,11 @@ pub struct DummyPassRes {
    /// range checks
    pub range_checks: HashSet<Range>,
    /// max lookup inputs
-    pub max_lookup_inputs: i64,
+    pub max_lookup_inputs: IntegerRep,
    /// min lookup inputs
-    pub min_lookup_inputs: i64,
+    pub min_lookup_inputs: IntegerRep,
    /// min range check
-    pub max_range_size: i64,
+    pub max_range_size: IntegerRep,
    /// outputs
    pub outputs: Vec<Tensor<Fp>>,
 }
@@ -545,7 +547,7 @@ impl Model {
            })
            .collect::<Result<Vec<_>, GraphError>>()?;

-        let res = self.dummy_layout(run_args, &inputs, false, false)?;
+        let res = self.dummy_layout(run_args, &inputs, RegionSettings::all_false())?;

        // if we're using percentage tolerance, we need to add the necessary range check ops for it.

@@ -588,14 +590,13 @@ impl Model {
        &self,
        model_inputs: &[Tensor<Fp>],
        run_args: &RunArgs,
-        witness_gen: bool,
-        check_lookup: bool,
+        region_settings: RegionSettings,
    ) -> Result<ForwardResult, GraphError> {
        let valtensor_inputs: Vec<ValTensor<Fp>> = model_inputs
            .iter()
            .map(|x| x.map(|elem| ValType::Value(Value::known(elem))).into())
            .collect();
-        let res = self.dummy_layout(run_args, &valtensor_inputs, witness_gen, check_lookup)?;
+        let res = self.dummy_layout(run_args, &valtensor_inputs, region_settings)?;
        Ok(res.into())
    }

@@ -1390,8 +1391,7 @@ impl Model {
        &self,
        run_args: &RunArgs,
        inputs: &[ValTensor<Fp>],
-        witness_gen: bool,
-        check_lookup: bool,
+        region_settings: RegionSettings,
    ) -> Result<DummyPassRes, GraphError> {
        debug!("calculating num of constraints using dummy model layout...");

@@ -1410,8 +1410,7 @@ impl Model {
            vars: ModelVars::new_dummy(),
        };

-        let mut region =
-            RegionCtx::new_dummy(0, run_args.num_inner_cols, witness_gen, check_lookup);
+        let mut region = RegionCtx::new_dummy(0, run_args.num_inner_cols, region_settings);

        let outputs = self.layout_nodes(&mut model_config, &mut region, &mut results)?;

--- a/src/graph/utilities.rs
+++ b/src/graph/utilities.rs
@@ -9,6 +9,7 @@ use crate::circuit::lookup::LookupOp;
 #[cfg(not(target_arch = "wasm32"))]
 use crate::circuit::poly::PolyOp;
 use crate::circuit::Op;
+use crate::fieldutils::IntegerRep;
 use crate::tensor::{Tensor, TensorError, TensorType};
 use halo2curves::bn256::Fr as Fp;
 use halo2curves::ff::PrimeField;
@@ -50,16 +51,20 @@ use tract_onnx::tract_hir::{
 /// * `dims` - the dimensionality of the resulting [Tensor].
 /// * `shift` - offset used in the fixed point representation.
 /// * `scale` - `2^scale` used in the fixed point representation.
-pub fn quantize_float(elem: &f64, shift: f64, scale: crate::Scale) -> Result<i64, TensorError> {
+pub fn quantize_float(
+    elem: &f64,
+    shift: f64,
+    scale: crate::Scale,
+) -> Result<IntegerRep, TensorError> {
    let mult = scale_to_multiplier(scale);
-    let max_value = ((i64::MAX as f64 - shift) / mult).round(); // the maximum value that can be represented w/o sig bit truncation
+    let max_value = ((IntegerRep::MAX as f64 - shift) / mult).round(); // the maximum value that can be represented w/o sig bit truncation

    if *elem > max_value {
        return Err(TensorError::SigBitTruncationError);
    }

    // we parallelize the quantization process as it seems to be quite slow at times
-    let scaled = (mult * *elem + shift).round() as i64;
+    let scaled = (mult * *elem + shift).round() as IntegerRep;

    Ok(scaled)
 }
@@ -70,7 +75,7 @@ pub fn quantize_float(elem: &f64, shift: f64, scale: crate::Scale) -> Result<i64
 /// * `scale` - `2^scale` used in the fixed point representation.
 /// * `shift` - offset used in the fixed point representation.
 pub fn dequantize(felt: Fp, scale: crate::Scale, shift: f64) -> f64 {
-    let int_rep = crate::fieldutils::felt_to_i64(felt);
+    let int_rep = crate::fieldutils::felt_to_integer_rep(felt);
    let multiplier = scale_to_multiplier(scale);
    int_rep as f64 / multiplier - shift
 }
@@ -283,10 +288,7 @@ pub fn new_op_from_onnx(
        .flat_map(|x| x.out_scales())
        .collect::<Vec<_>>();

-    let input_dims = inputs
-        .iter()
-        .flat_map(|x| x.out_dims())
-        .collect::<Vec<_>>();
+    let input_dims = inputs.iter().flat_map(|x| x.out_dims()).collect::<Vec<_>>();

    let mut replace_const = |scale: crate::Scale,
                             index: usize,
@@ -1192,7 +1194,13 @@ pub fn new_op_from_onnx(
                }
            }

-            SupportedOp::Linear(PolyOp::Conv { padding, stride })
+            let group = conv_node.group;
+
+            SupportedOp::Linear(PolyOp::Conv {
+                padding,
+                stride,
+                group,
+            })
        }
        "Not" => SupportedOp::Linear(PolyOp::Not),
        "And" => SupportedOp::Linear(PolyOp::And),
@@ -1247,6 +1255,7 @@ pub fn new_op_from_onnx(
                padding,
                output_padding: deconv_node.adjustments.to_vec(),
                stride,
+                group: deconv_node.group,
            })
        }
        "Downsample" => {
@@ -1420,7 +1429,7 @@ pub fn quantize_tensor<F: PrimeField + TensorType + PartialOrd>(
    visibility: &Visibility,
 ) -> Result<Tensor<F>, TensorError> {
    let mut value: Tensor<F> = const_value.par_enum_map(|_, x| {
-        Ok::<_, TensorError>(crate::fieldutils::i64_to_felt::<F>(quantize_float(
+        Ok::<_, TensorError>(crate::fieldutils::integer_rep_to_felt::<F>(quantize_float(
            &(x).into(),
            0.0,
            scale,
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -23,6 +23,7 @@
 )]
 // we allow this for our dynamic range based indexing scheme
 #![allow(clippy::single_range_in_vec_init)]
+#![feature(buf_read_has_data_left)]
 #![feature(stmt_expr_attributes)]

 //! A library for turning computational graphs, such as neural networks, into ZK-circuits.
@@ -85,6 +86,7 @@ use std::str::FromStr;

 use circuit::{table::Range, CheckMode, Tolerance};
 use clap::Args;
+use fieldutils::IntegerRep;
 use graph::Visibility;
 use halo2_proofs::poly::{
    ipa::commitment::IPACommitmentScheme, kzg::commitment::KZGCommitmentScheme,
@@ -243,7 +245,7 @@ pub struct RunArgs {
    #[arg(long, default_value = "1",  value_hint = clap::ValueHint::Other)]
    pub scale_rebase_multiplier: u32,
    /// The min and max elements in the lookup table input column
-    #[arg(short = 'B', long, value_parser = parse_key_val::<i64, i64>, default_value = "-32768->32768")]
+    #[arg(short = 'B', long, value_parser = parse_key_val::<IntegerRep, IntegerRep>, default_value = "-32768->32768")]
    pub lookup_range: Range,
    /// The log_2 number of rows
    #[arg(short = 'K', long, default_value = "17", value_hint = clap::ValueHint::Other)]
--- a/src/logger.rs
+++ b/src/logger.rs
@@ -76,7 +76,7 @@ pub fn init_logger() {
            prefix_token(&record.level()),
            //    pretty print UTC time
            chrono::Utc::now()
-                .format("%Y-%m-%d %H:%M:%S")
+                .format("%Y-%m-%d %H:%M:%S:%3f")
                .to_string()
                .bright_magenta(),
            record.metadata().target(),
--- a/src/pfsys/mod.rs
+++ b/src/pfsys/mod.rs
@@ -558,7 +558,8 @@ where
        + PrimeField
        + FromUniformBytes<64>
        + WithSmallOrderMulGroup<3>,
-    Scheme::Curve: Serialize + DeserializeOwned,
+    Scheme::Curve: Serialize + DeserializeOwned + SerdeObject,
+    Scheme::ParamsProver: Send + Sync,
 {
    let strategy = Strategy::new(params.verifier_params());
    let mut transcript = TranscriptWriterBuffer::<_, Scheme::Curve, _>::init(vec![]);
--- a/src/python.rs
+++ b/src/python.rs
@@ -6,7 +6,7 @@ use crate::circuit::modules::poseidon::{
 use crate::circuit::modules::Module;
 use crate::circuit::{CheckMode, Tolerance};
 use crate::commands::*;
-use crate::fieldutils::{felt_to_i64, i64_to_felt};
+use crate::fieldutils::{felt_to_integer_rep, integer_rep_to_felt, IntegerRep};
 use crate::graph::modules::POSEIDON_LEN_GRAPH;
 use crate::graph::TestDataSource;
 use crate::graph::{
@@ -331,9 +331,9 @@ fn felt_to_big_endian(felt: PyFelt) -> PyResult<String> {
 #[pyfunction(signature = (
    felt,
 ))]
-fn felt_to_int(felt: PyFelt) -> PyResult<i64> {
+fn felt_to_int(felt: PyFelt) -> PyResult<IntegerRep> {
    let felt = crate::pfsys::string_to_field::<Fr>(&felt);
-    let int_rep = felt_to_i64(felt);
+    let int_rep = felt_to_integer_rep(felt);
    Ok(int_rep)
 }

@@ -357,7 +357,7 @@ fn felt_to_int(felt: PyFelt) -> PyResult<i64> {
 ))]
 fn felt_to_float(felt: PyFelt, scale: crate::Scale) -> PyResult<f64> {
    let felt = crate::pfsys::string_to_field::<Fr>(&felt);
-    let int_rep = felt_to_i64(felt);
+    let int_rep = felt_to_integer_rep(felt);
    let multiplier = scale_to_multiplier(scale);
    let float_rep = int_rep as f64 / multiplier;
    Ok(float_rep)
@@ -385,7 +385,7 @@ fn felt_to_float(felt: PyFelt, scale: crate::Scale) -> PyResult<f64> {
 fn float_to_felt(input: f64, scale: crate::Scale) -> PyResult<PyFelt> {
    let int_rep = quantize_float(&input, 0.0, scale)
        .map_err(|_| PyIOError::new_err("Failed to quantize input"))?;
-    let felt = i64_to_felt(int_rep);
+    let felt = integer_rep_to_felt(int_rep);
    Ok(crate::pfsys::field_to_string::<Fr>(&felt))
 }

--- a/src/tensor/errors.rs
+++ b/src/tensor/errors.rs
@@ -27,4 +27,10 @@ pub enum TensorError {
    /// Unset visibility
    #[error("unset visibility")]
    UnsetVisibility,
+    /// File save error
+    #[error("save error: {0}")]
+    FileSaveError(String),
+    /// File load error
+    #[error("load error: {0}")]
+    FileLoadError(String),
 }
--- a/src/tensor/mod.rs
+++ b/src/tensor/mod.rs
@@ -9,7 +9,7 @@ pub mod var;

 pub use errors::TensorError;

-use halo2curves::{bn256::Fr, ff::PrimeField};
+use halo2curves::ff::PrimeField;
 use maybe_rayon::{
    prelude::{
        IndexedParallelIterator, IntoParallelRefIterator, IntoParallelRefMutIterator,
@@ -18,6 +18,9 @@ use maybe_rayon::{
    slice::ParallelSliceMut,
 };
 use serde::{Deserialize, Serialize};
+use std::io::BufRead;
+use std::io::Write;
+use std::path::PathBuf;
 pub use val::*;
 pub use var::*;

@@ -26,7 +29,7 @@ use instant::Instant;

 use crate::{
    circuit::utils,
-    fieldutils::{felt_to_i32, felt_to_i64, i32_to_felt, i64_to_felt},
+    fieldutils::{integer_rep_to_felt, IntegerRep},
    graph::Visibility,
 };

@@ -41,6 +44,7 @@ use itertools::Itertools;
 use metal::{Device, MTLResourceOptions, MTLSize};
 use std::error::Error;
 use std::fmt::Debug;
+use std::io::Read;
 use std::iter::Iterator;
 use std::ops::{Add, Deref, DerefMut, Div, Mul, Neg, Range, Sub};
 use std::{cmp::max, ops::Rem};
@@ -108,7 +112,7 @@ impl TensorType for f32 {
        Some(0.0)
    }

-    // f32 doesnt impl Ord so we cant just use max like we can for i32, usize.
+    // f32 doesnt impl Ord so we cant just use max like we can for IntegerRep, usize.
    // A comparison between f32s needs to handle NAN values.
    fn tmax(&self, other: &Self) -> Option<Self> {
        match (self.is_nan(), other.is_nan()) {
@@ -131,7 +135,7 @@ impl TensorType for f64 {
        Some(0.0)
    }

-    // f32 doesnt impl Ord so we cant just use max like we can for i32, usize.
+    // f32 doesnt impl Ord so we cant just use max like we can for IntegerRep, usize.
    // A comparison between f32s needs to handle NAN values.
    fn tmax(&self, other: &Self) -> Option<Self> {
        match (self.is_nan(), other.is_nan()) {
@@ -150,8 +154,7 @@ impl TensorType for f64 {
 }

 tensor_type!(bool, Bool, false, true);
-tensor_type!(i64, Int64, 0, 1);
-tensor_type!(i32, Int32, 0, 1);
+tensor_type!(IntegerRep, IntegerRep, 0, 1);
 tensor_type!(usize, USize, 0, 1);
 tensor_type!((), Empty, (), ());
 tensor_type!(utils::F32, F32, utils::F32(0.0), utils::F32(1.0));
@@ -316,92 +319,6 @@ impl<T: TensorType> DerefMut for Tensor<T> {
        self.inner.deref_mut()
    }
 }
-/// Convert to i64 trait
-pub trait IntoI64 {
-    /// Convert to i64
-    fn into_i64(self) -> i64;
-
-    /// From i64
-    fn from_i64(i: i64) -> Self;
-}
-
-impl IntoI64 for i64 {
-    fn into_i64(self) -> i64 {
-        self
-    }
-    fn from_i64(i: i64) -> i64 {
-        i
-    }
-}
-
-impl IntoI64 for i32 {
-    fn into_i64(self) -> i64 {
-        self as i64
-    }
-    fn from_i64(i: i64) -> Self {
-        i as i32
-    }
-}
-
-impl IntoI64 for usize {
-    fn into_i64(self) -> i64 {
-        self as i64
-    }
-    fn from_i64(i: i64) -> Self {
-        i as usize
-    }
-}
-
-impl IntoI64 for f32 {
-    fn into_i64(self) -> i64 {
-        self as i64
-    }
-    fn from_i64(i: i64) -> Self {
-        i as f32
-    }
-}
-
-impl IntoI64 for f64 {
-    fn into_i64(self) -> i64 {
-        self as i64
-    }
-    fn from_i64(i: i64) -> Self {
-        i as f64
-    }
-}
-
-impl IntoI64 for () {
-    fn into_i64(self) -> i64 {
-        0
-    }
-    fn from_i64(_: i64) -> Self {}
-}
-
-impl IntoI64 for Fr {
-    fn into_i64(self) -> i64 {
-        felt_to_i64(self)
-    }
-    fn from_i64(i: i64) -> Self {
-        i64_to_felt::<Fr>(i)
-    }
-}
-
-impl<F: PrimeField + IntoI64> IntoI64 for Value<F> {
-    fn into_i64(self) -> i64 {
-        let mut res = vec![];
-        self.map(|x| res.push(x.into_i64()));
-
-        if res.is_empty() {
-            0
-        } else {
-            res[0]
-        }
-    }
-
-    fn from_i64(i: i64) -> Self {
-        Value::known(F::from_i64(i))
-    }
-}

 impl<T: PartialEq + TensorType> PartialEq for Tensor<T> {
    fn eq(&self, other: &Tensor<T>) -> bool {
@@ -431,42 +348,6 @@ where
    }
 }

-impl<F: PrimeField + Clone + TensorType + PartialOrd> From<Tensor<AssignedCell<Assigned<F>, F>>>
-    for Tensor<i32>
-{
-    fn from(value: Tensor<AssignedCell<Assigned<F>, F>>) -> Tensor<i32> {
-        let mut output = Vec::new();
-        value.map(|x| {
-            x.evaluate().value().map(|y| {
-                let e = felt_to_i32(*y);
-                output.push(e);
-                e
-            })
-        });
-        Tensor::new(Some(&output), value.dims()).unwrap()
-    }
-}
-
-impl<F: PrimeField + Clone + TensorType + PartialOrd> From<Tensor<AssignedCell<F, F>>>
-    for Tensor<i32>
-{
-    fn from(value: Tensor<AssignedCell<F, F>>) -> Tensor<i32> {
-        let mut output = Vec::new();
-        value.map(|x| {
-            let mut i = 0;
-            x.value().map(|y| {
-                let e = felt_to_i32(*y);
-                output.push(e);
-                i += 1;
-            });
-            if i == 0 {
-                output.push(0);
-            }
-        });
-        Tensor::new(Some(&output), value.dims()).unwrap()
-    }
-}
-
 impl<F: PrimeField + Clone + TensorType + PartialOrd> From<Tensor<AssignedCell<Assigned<F>, F>>>
    for Tensor<Value<F>>
 {
@@ -479,24 +360,6 @@ impl<F: PrimeField + Clone + TensorType + PartialOrd> From<Tensor<AssignedCell<A
    }
 }

-impl<F: PrimeField + TensorType + Clone + PartialOrd> From<Tensor<Value<F>>> for Tensor<i32> {
-    fn from(t: Tensor<Value<F>>) -> Tensor<i32> {
-        let mut output = Vec::new();
-        t.map(|x| {
-            let mut i = 0;
-            x.map(|y| {
-                let e = felt_to_i32(y);
-                output.push(e);
-                i += 1;
-            });
-            if i == 0 {
-                output.push(0);
-            }
-        });
-        Tensor::new(Some(&output), t.dims()).unwrap()
-    }
-}
-
 impl<F: PrimeField + TensorType + Clone + PartialOrd> From<Tensor<Value<F>>>
    for Tensor<Value<Assigned<F>>>
 {
@@ -508,20 +371,10 @@ impl<F: PrimeField + TensorType + Clone + PartialOrd> From<Tensor<Value<F>>>
    }
 }

-impl<F: PrimeField + TensorType + Clone> From<Tensor<i32>> for Tensor<Value<F>> {
-    fn from(t: Tensor<i32>) -> Tensor<Value<F>> {
+impl<F: PrimeField + TensorType + Clone> From<Tensor<IntegerRep>> for Tensor<Value<F>> {
+    fn from(t: Tensor<IntegerRep>) -> Tensor<Value<F>> {
        let mut ta: Tensor<Value<F>> =
-            Tensor::from((0..t.len()).map(|i| Value::known(i32_to_felt::<F>(t[i]))));
-        // safe to unwrap as we know the dims are correct
-        ta.reshape(t.dims()).unwrap();
-        ta
-    }
-}
-
-impl<F: PrimeField + TensorType + Clone> From<Tensor<i64>> for Tensor<Value<F>> {
-    fn from(t: Tensor<i64>) -> Tensor<Value<F>> {
-        let mut ta: Tensor<Value<F>> =
-            Tensor::from((0..t.len()).map(|i| Value::known(i64_to_felt::<F>(t[i]))));
+            Tensor::from((0..t.len()).map(|i| Value::known(integer_rep_to_felt::<F>(t[i]))));
        // safe to unwrap as we know the dims are correct
        ta.reshape(t.dims()).unwrap();
        ta
@@ -560,6 +413,45 @@ impl<'data, T: Clone + TensorType + std::marker::Send + std::marker::Sync>
    }
 }

+impl<T: Clone + TensorType + PrimeField> Tensor<T> {
+    /// save to a file
+    pub fn save(&self, path: &PathBuf) -> Result<(), TensorError> {
+        let writer =
+            std::fs::File::create(path).map_err(|e| TensorError::FileSaveError(e.to_string()))?;
+        let mut buf_writer = std::io::BufWriter::new(writer);
+
+        self.inner.iter().map(|x| x.clone()).for_each(|x| {
+            let x = x.to_repr();
+            buf_writer.write_all(x.as_ref()).unwrap();
+        });
+
+        Ok(())
+    }
+
+    /// load from a file
+    pub fn load(path: &PathBuf) -> Result<Self, TensorError> {
+        let reader =
+            std::fs::File::open(path).map_err(|e| TensorError::FileLoadError(e.to_string()))?;
+        let mut buf_reader = std::io::BufReader::new(reader);
+
+        let mut inner = Vec::new();
+        while let Ok(true) = buf_reader.has_data_left() {
+            let mut repr = T::Repr::default();
+            match buf_reader.read_exact(repr.as_mut()) {
+                Ok(_) => {
+                    inner.push(T::from_repr(repr).unwrap());
+                }
+                Err(_) => {
+                    return Err(TensorError::FileLoadError(
+                        "Failed to read tensor".to_string(),
+                    ))
+                }
+            }
+        }
+        Ok(Tensor::new(Some(&inner), &[inner.len()]).unwrap())
+    }
+}
+
 impl<T: Clone + TensorType> Tensor<T> {
    /// Sets (copies) the tensor values to the provided ones.
    pub fn new(values: Option<&[T]>, dims: &[usize]) -> Result<Self, TensorError> {
@@ -633,7 +525,8 @@ impl<T: Clone + TensorType> Tensor<T> {
    ///
    /// ```
    /// use ezkl::tensor::Tensor;
-    /// let mut a = Tensor::<i32>::new(None, &[3, 3, 3]).unwrap();
+    /// use ezkl::fieldutils::IntegerRep;
+    /// let mut a = Tensor::<IntegerRep>::new(None, &[3, 3, 3]).unwrap();
    ///
    /// a.set(&[0, 0, 1], 10);
    /// assert_eq!(a[0 + 0 + 1], 10);
@@ -650,7 +543,8 @@ impl<T: Clone + TensorType> Tensor<T> {
    ///
    /// ```
    /// use ezkl::tensor::Tensor;
-    /// let mut a = Tensor::<i32>::new(None, &[2, 3, 5]).unwrap();
+    /// use ezkl::fieldutils::IntegerRep;
+    /// let mut a = Tensor::<IntegerRep>::new(None, &[2, 3, 5]).unwrap();
    ///
    /// a[1*15 + 1*5 + 1] = 5;
    /// assert_eq!(a.get(&[1, 1, 1]), 5);
@@ -664,7 +558,8 @@ impl<T: Clone + TensorType> Tensor<T> {
    ///
    /// ```
    /// use ezkl::tensor::Tensor;
-    /// let mut a = Tensor::<i32>::new(None, &[2, 3, 5]).unwrap();
+    /// use ezkl::fieldutils::IntegerRep;
+    /// let mut a = Tensor::<IntegerRep>::new(None, &[2, 3, 5]).unwrap();
    ///
    /// a[1*15 + 1*5 + 1] = 5;
    /// assert_eq!(a.get(&[1, 1, 1]), 5);
@@ -684,11 +579,12 @@ impl<T: Clone + TensorType> Tensor<T> {
    /// Pad to a length that is divisible by n
    /// ```
    /// use ezkl::tensor::Tensor;
-    /// let mut a = Tensor::<i32>::new(Some(&[1,2,3,4,5,6]), &[2, 3]).unwrap();
-    /// let expected = Tensor::<i32>::new(Some(&[1, 2, 3, 4, 5, 6, 0, 0]), &[8]).unwrap();
+    /// use ezkl::fieldutils::IntegerRep;
+    /// let mut a = Tensor::<IntegerRep>::new(Some(&[1,2,3,4,5,6]), &[2, 3]).unwrap();
+    /// let expected = Tensor::<IntegerRep>::new(Some(&[1, 2, 3, 4, 5, 6, 0, 0]), &[8]).unwrap();
    /// assert_eq!(a.pad_to_zero_rem(4, 0).unwrap(), expected);
    ///
-    /// let expected = Tensor::<i32>::new(Some(&[1, 2, 3, 4, 5, 6, 0, 0, 0]), &[9]).unwrap();
+    /// let expected = Tensor::<IntegerRep>::new(Some(&[1, 2, 3, 4, 5, 6, 0, 0, 0]), &[9]).unwrap();
    /// assert_eq!(a.pad_to_zero_rem(9, 0).unwrap(), expected);
    /// ```
    pub fn pad_to_zero_rem(&self, n: usize, pad: T) -> Result<Tensor<T>, TensorError> {
@@ -704,7 +600,8 @@ impl<T: Clone + TensorType> Tensor<T> {
    ///
    /// ```
    /// use ezkl::tensor::Tensor;
-    /// let mut a = Tensor::<i32>::new(None, &[2, 3, 5]).unwrap();
+    /// use ezkl::fieldutils::IntegerRep;
+    /// let mut a = Tensor::<IntegerRep>::new(None, &[2, 3, 5]).unwrap();
    ///
    /// let flat_index = 1*15 + 1*5 + 1;
    /// a[1*15 + 1*5 + 1] = 5;
@@ -731,8 +628,9 @@ impl<T: Clone + TensorType> Tensor<T> {
    /// Get a slice from the Tensor.
    /// ```
    /// use ezkl::tensor::Tensor;
-    /// let mut a = Tensor::<i32>::new(Some(&[1, 2, 3]), &[3]).unwrap();
-    /// let mut b = Tensor::<i32>::new(Some(&[1, 2]), &[2]).unwrap();
+    /// use ezkl::fieldutils::IntegerRep;
+    /// let mut a = Tensor::<IntegerRep>::new(Some(&[1, 2, 3]), &[3]).unwrap();
+    /// let mut b = Tensor::<IntegerRep>::new(Some(&[1, 2]), &[2]).unwrap();
    ///
    /// assert_eq!(a.get_slice(&[0..2]).unwrap(), b);
    /// ```
@@ -782,9 +680,10 @@ impl<T: Clone + TensorType> Tensor<T> {
    /// Set a slice of the Tensor.
    /// ```
    /// use ezkl::tensor::Tensor;
-    /// let mut a = Tensor::<i32>::new(Some(&[1, 2, 3, 4, 5, 6]), &[2, 3]).unwrap();
-    /// let b = Tensor::<i32>::new(Some(&[1, 2, 3, 1, 2, 3]), &[2, 3]).unwrap();
-    /// a.set_slice(&[1..2], &Tensor::<i32>::new(Some(&[1, 2, 3]), &[1, 3]).unwrap()).unwrap();
+    /// use ezkl::fieldutils::IntegerRep;
+    /// let mut a = Tensor::<IntegerRep>::new(Some(&[1, 2, 3, 4, 5, 6]), &[2, 3]).unwrap();
+    /// let b = Tensor::<IntegerRep>::new(Some(&[1, 2, 3, 1, 2, 3]), &[2, 3]).unwrap();
+    /// a.set_slice(&[1..2], &Tensor::<IntegerRep>::new(Some(&[1, 2, 3]), &[1, 3]).unwrap()).unwrap();
    /// assert_eq!(a, b);
    /// ```
    pub fn set_slice(
@@ -845,6 +744,7 @@ impl<T: Clone + TensorType> Tensor<T> {
    ///
    /// ```
    /// use ezkl::tensor::Tensor;
+    /// use ezkl::fieldutils::IntegerRep;
    /// let a = Tensor::<f32>::new(None, &[3, 3, 3]).unwrap();
    ///
    /// assert_eq!(a.get_index(&[2, 2, 2]), 26);
@@ -868,12 +768,13 @@ impl<T: Clone + TensorType> Tensor<T> {
    ///
    /// ```
    /// use ezkl::tensor::Tensor;
-    /// let a = Tensor::<i32>::new(Some(&[1, 2, 3, 4, 5, 6]), &[6]).unwrap();
-    /// let expected = Tensor::<i32>::new(Some(&[1, 2, 3, 3, 4, 5, 5, 6]), &[8]).unwrap();
+    /// use ezkl::fieldutils::IntegerRep;
+    /// let a = Tensor::<IntegerRep>::new(Some(&[1, 2, 3, 4, 5, 6]), &[6]).unwrap();
+    /// let expected = Tensor::<IntegerRep>::new(Some(&[1, 2, 3, 3, 4, 5, 5, 6]), &[8]).unwrap();
    /// assert_eq!(a.duplicate_every_n(3, 1, 0).unwrap(), expected);
    /// assert_eq!(a.duplicate_every_n(7, 1, 0).unwrap(), a);
    ///
-    /// let expected = Tensor::<i32>::new(Some(&[1, 1, 2, 3, 3, 4, 5, 5, 6]), &[9]).unwrap();
+    /// let expected = Tensor::<IntegerRep>::new(Some(&[1, 1, 2, 3, 3, 4, 5, 5, 6]), &[9]).unwrap();
    /// assert_eq!(a.duplicate_every_n(3, 1, 2).unwrap(), expected);
    ///
    /// ```
@@ -900,8 +801,9 @@ impl<T: Clone + TensorType> Tensor<T> {
    ///
    /// ```
    /// use ezkl::tensor::Tensor;
-    /// let a = Tensor::<i32>::new(Some(&[1, 2, 3, 3, 4, 5, 6, 6]), &[8]).unwrap();
-    /// let expected = Tensor::<i32>::new(Some(&[1, 2, 3, 3, 5, 6, 6]), &[7]).unwrap();
+    /// use ezkl::fieldutils::IntegerRep;
+    /// let a = Tensor::<IntegerRep>::new(Some(&[1, 2, 3, 3, 4, 5, 6, 6]), &[8]).unwrap();
+    /// let expected = Tensor::<IntegerRep>::new(Some(&[1, 2, 3, 3, 5, 6, 6]), &[7]).unwrap();
    /// assert_eq!(a.remove_every_n(4, 1, 0).unwrap(), expected);
    ///
    ///
@@ -935,14 +837,15 @@ impl<T: Clone + TensorType> Tensor<T> {
    /// WARN: assumes indices are in ascending order for speed
    /// ```
    /// use ezkl::tensor::Tensor;
-    /// let a = Tensor::<i32>::new(Some(&[1, 2, 3, 4, 5, 6]), &[6]).unwrap();
-    /// let expected = Tensor::<i32>::new(Some(&[1, 2, 3, 6]), &[4]).unwrap();
+    /// use ezkl::fieldutils::IntegerRep;
+    /// let a = Tensor::<IntegerRep>::new(Some(&[1, 2, 3, 4, 5, 6]), &[6]).unwrap();
+    /// let expected = Tensor::<IntegerRep>::new(Some(&[1, 2, 3, 6]), &[4]).unwrap();
    /// let mut indices = vec![3, 4];
    /// assert_eq!(a.remove_indices(&mut indices, true).unwrap(), expected);
    ///
    ///
-    /// let a = Tensor::<i32>::new(Some(&[52, -245, 153, 13, -4, -56, -163, 249, -128, -172, 396, 143, 2, -96, 504, -44, -158, -393, 61, 95, 191, 74, 64, -219, 553, 104, 235, 222, 44, -216, 63, -251, 40, -140, 112, -355, 60, 123, 26, -116, -89, -200, -109, 168, 135, -34, -99, -54, 5, -81, 322, 87, 4, -139, 420, 92, -295, -12, 262, -1, 26, -48, 231, 1, -335, 244, 188, -4, 5, -362, 57, -198, -184, -117, 40, 305, 49, 30, -59, -26, -37, 96]), &[82]).unwrap();
-    /// let b = Tensor::<i32>::new(Some(&[52, -245, 153, 13, -4, -56, -163, 249, -128, -172, 396, 143, 2, -96, 504, -44, -158, -393, 61, 95, 191, 74, 64, -219, 553, 104, 235, 222, 44, -216, 63, -251, 40, -140, 112, -355, 60, 123, 26, -116, -89, -200, -109, 168, 135, -34, -99, -54, 5, -81, 322, 87, 4, -139, 420, 92, -295, -12, 262, -1, 26, -48, 231, -335, 244, 188, 5, -362, 57, -198, -184, -117, 40, 305, 49, 30, -59, -26, -37, 96]), &[80]).unwrap();
+    /// let a = Tensor::<IntegerRep>::new(Some(&[52, -245, 153, 13, -4, -56, -163, 249, -128, -172, 396, 143, 2, -96, 504, -44, -158, -393, 61, 95, 191, 74, 64, -219, 553, 104, 235, 222, 44, -216, 63, -251, 40, -140, 112, -355, 60, 123, 26, -116, -89, -200, -109, 168, 135, -34, -99, -54, 5, -81, 322, 87, 4, -139, 420, 92, -295, -12, 262, -1, 26, -48, 231, 1, -335, 244, 188, -4, 5, -362, 57, -198, -184, -117, 40, 305, 49, 30, -59, -26, -37, 96]), &[82]).unwrap();
+    /// let b = Tensor::<IntegerRep>::new(Some(&[52, -245, 153, 13, -4, -56, -163, 249, -128, -172, 396, 143, 2, -96, 504, -44, -158, -393, 61, 95, 191, 74, 64, -219, 553, 104, 235, 222, 44, -216, 63, -251, 40, -140, 112, -355, 60, 123, 26, -116, -89, -200, -109, 168, 135, -34, -99, -54, 5, -81, 322, 87, 4, -139, 420, 92, -295, -12, 262, -1, 26, -48, 231, -335, 244, 188, 5, -362, 57, -198, -184, -117, 40, 305, 49, 30, -59, -26, -37, 96]), &[80]).unwrap();
    /// let mut indices = vec![63, 67];
    /// assert_eq!(a.remove_indices(&mut indices, true).unwrap(), b);
    /// ```
@@ -972,6 +875,7 @@ impl<T: Clone + TensorType> Tensor<T> {
    ///Reshape the tensor
    /// ```
    /// use ezkl::tensor::Tensor;
+    /// use ezkl::fieldutils::IntegerRep;
    /// let mut a = Tensor::<f32>::new(None, &[3, 3, 3]).unwrap();
    /// a.reshape(&[9, 3]);
    /// assert_eq!(a.dims(), &[9, 3]);
@@ -1006,22 +910,23 @@ impl<T: Clone + TensorType> Tensor<T> {
    /// Move axis of the tensor
    /// ```
    /// use ezkl::tensor::Tensor;
+    /// use ezkl::fieldutils::IntegerRep;
    /// let mut a = Tensor::<f32>::new(None, &[3, 3, 3]).unwrap();
    /// let b = a.move_axis(0, 2).unwrap();
    /// assert_eq!(b.dims(), &[3, 3, 3]);
    ///
-    /// let mut a = Tensor::<i32>::new(Some(&[1, 2, 3, 4, 5, 6]), &[3, 1, 2]).unwrap();
-    /// let mut expected = Tensor::<i32>::new(Some(&[1, 3, 5, 2, 4, 6]), &[1, 2, 3]).unwrap();
+    /// let mut a = Tensor::<IntegerRep>::new(Some(&[1, 2, 3, 4, 5, 6]), &[3, 1, 2]).unwrap();
+    /// let mut expected = Tensor::<IntegerRep>::new(Some(&[1, 3, 5, 2, 4, 6]), &[1, 2, 3]).unwrap();
    /// let b = a.move_axis(0, 2).unwrap();
    /// assert_eq!(b, expected);
    ///
-    /// let mut a = Tensor::<i32>::new(Some(&[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]), &[2, 3, 2]).unwrap();
-    /// let mut expected = Tensor::<i32>::new(Some(&[1, 3, 5, 2, 4, 6, 7, 9, 11, 8, 10, 12]), &[2, 2, 3]).unwrap();
+    /// let mut a = Tensor::<IntegerRep>::new(Some(&[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]), &[2, 3, 2]).unwrap();
+    /// let mut expected = Tensor::<IntegerRep>::new(Some(&[1, 3, 5, 2, 4, 6, 7, 9, 11, 8, 10, 12]), &[2, 2, 3]).unwrap();
    /// let b = a.move_axis(1, 2).unwrap();
    /// assert_eq!(b, expected);
    ///
-    /// let mut a = Tensor::<i32>::new(Some(&[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]), &[2, 3, 2]).unwrap();
-    /// let mut expected = Tensor::<i32>::new(Some(&[1, 3, 5, 2, 4, 6, 7, 9, 11, 8, 10, 12]), &[2, 2, 3]).unwrap();
+    /// let mut a = Tensor::<IntegerRep>::new(Some(&[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]), &[2, 3, 2]).unwrap();
+    /// let mut expected = Tensor::<IntegerRep>::new(Some(&[1, 3, 5, 2, 4, 6, 7, 9, 11, 8, 10, 12]), &[2, 2, 3]).unwrap();
    /// let b = a.move_axis(2, 1).unwrap();
    /// assert_eq!(b, expected);
    /// ```
@@ -1086,22 +991,23 @@ impl<T: Clone + TensorType> Tensor<T> {
    /// Swap axes of the tensor
    /// ```
    /// use ezkl::tensor::Tensor;
+    /// use ezkl::fieldutils::IntegerRep;
    /// let mut a = Tensor::<f32>::new(None, &[3, 3, 3]).unwrap();
    /// let b = a.swap_axes(0, 2).unwrap();
    /// assert_eq!(b.dims(), &[3, 3, 3]);
    ///
-    /// let mut a = Tensor::<i32>::new(Some(&[1, 2, 3, 4, 5, 6]), &[3, 1, 2]).unwrap();
-    /// let mut expected = Tensor::<i32>::new(Some(&[1, 3, 5, 2, 4, 6]), &[2, 1, 3]).unwrap();
+    /// let mut a = Tensor::<IntegerRep>::new(Some(&[1, 2, 3, 4, 5, 6]), &[3, 1, 2]).unwrap();
+    /// let mut expected = Tensor::<IntegerRep>::new(Some(&[1, 3, 5, 2, 4, 6]), &[2, 1, 3]).unwrap();
    /// let b = a.swap_axes(0, 2).unwrap();
    /// assert_eq!(b, expected);
    ///
-    /// let mut a = Tensor::<i32>::new(Some(&[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]), &[2, 3, 2]).unwrap();
-    /// let mut expected = Tensor::<i32>::new(Some(&[1, 3, 5, 2, 4, 6, 7, 9, 11, 8, 10, 12]), &[2, 2, 3]).unwrap();
+    /// let mut a = Tensor::<IntegerRep>::new(Some(&[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]), &[2, 3, 2]).unwrap();
+    /// let mut expected = Tensor::<IntegerRep>::new(Some(&[1, 3, 5, 2, 4, 6, 7, 9, 11, 8, 10, 12]), &[2, 2, 3]).unwrap();
    /// let b = a.swap_axes(1, 2).unwrap();
    /// assert_eq!(b, expected);
    ///
-    /// let mut a = Tensor::<i32>::new(Some(&[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]), &[2, 3, 2]).unwrap();
-    /// let mut expected = Tensor::<i32>::new(Some(&[1, 3, 5, 2, 4, 6, 7, 9, 11, 8, 10, 12]), &[2, 2, 3]).unwrap();
+    /// let mut a = Tensor::<IntegerRep>::new(Some(&[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]), &[2, 3, 2]).unwrap();
+    /// let mut expected = Tensor::<IntegerRep>::new(Some(&[1, 3, 5, 2, 4, 6, 7, 9, 11, 8, 10, 12]), &[2, 2, 3]).unwrap();
    /// let b = a.swap_axes(2, 1).unwrap();
    /// assert_eq!(b, expected);
    /// ```
@@ -1148,9 +1054,10 @@ impl<T: Clone + TensorType> Tensor<T> {
    /// Broadcasts the tensor to a given shape
    /// ```
    /// use ezkl::tensor::Tensor;
-    /// let mut a = Tensor::<i32>::new(Some(&[1, 2, 3]), &[3, 1]).unwrap();
+    /// use ezkl::fieldutils::IntegerRep;
+    /// let mut a = Tensor::<IntegerRep>::new(Some(&[1, 2, 3]), &[3, 1]).unwrap();
    ///
-    /// let mut expected = Tensor::<i32>::new(Some(&[1, 1, 1, 2, 2, 2, 3, 3, 3]), &[3, 3]).unwrap();
+    /// let mut expected = Tensor::<IntegerRep>::new(Some(&[1, 1, 1, 2, 2, 2, 3, 3, 3]), &[3, 3]).unwrap();
    /// assert_eq!(a.expand(&[3, 3]).unwrap(), expected);
    ///
    /// ```
@@ -1204,6 +1111,7 @@ impl<T: Clone + TensorType> Tensor<T> {
    ///Flatten the tensor shape
    /// ```
    /// use ezkl::tensor::Tensor;
+    /// use ezkl::fieldutils::IntegerRep;
    /// let mut a = Tensor::<f32>::new(None, &[3, 3, 3]).unwrap();
    /// a.flatten();
    /// assert_eq!(a.dims(), &[27]);
@@ -1217,8 +1125,9 @@ impl<T: Clone + TensorType> Tensor<T> {
    /// Maps a function to tensors
    /// ```
    /// use ezkl::tensor::Tensor;
-    /// let mut a = Tensor::<i32>::new(Some(&[1, 4]), &[2]).unwrap();
-    /// let mut c = a.map(|x| i32::pow(x,2));
+    /// use ezkl::fieldutils::IntegerRep;
+    /// let mut a = Tensor::<IntegerRep>::new(Some(&[1, 4]), &[2]).unwrap();
+    /// let mut c = a.map(|x| IntegerRep::pow(x,2));
    /// assert_eq!(c, Tensor::from([1, 16].into_iter()))
    /// ```
    pub fn map<F: FnMut(T) -> G, G: TensorType>(&self, mut f: F) -> Tensor<G> {
@@ -1231,8 +1140,9 @@ impl<T: Clone + TensorType> Tensor<T> {
    /// Maps a function to tensors and enumerates
    /// ```
    /// use ezkl::tensor::{Tensor, TensorError};
-    /// let mut a = Tensor::<i32>::new(Some(&[1, 4]), &[2]).unwrap();
-    /// let mut c = a.enum_map::<_,_,TensorError>(|i, x| Ok(i32::pow(x + i as i32, 2))).unwrap();
+    /// use ezkl::fieldutils::IntegerRep;
+    /// let mut a = Tensor::<IntegerRep>::new(Some(&[1, 4]), &[2]).unwrap();
+    /// let mut c = a.enum_map::<_,_,TensorError>(|i, x| Ok(IntegerRep::pow(x + i as IntegerRep, 2))).unwrap();
    /// assert_eq!(c, Tensor::from([1, 25].into_iter()));
    /// ```
    pub fn enum_map<F: FnMut(usize, T) -> Result<G, E>, G: TensorType, E: Error>(
@@ -1254,8 +1164,9 @@ impl<T: Clone + TensorType> Tensor<T> {
    /// Maps a function to tensors and enumerates in parallel
    /// ```
    /// use ezkl::tensor::{Tensor, TensorError};
-    /// let mut a = Tensor::<i32>::new(Some(&[1, 4]), &[2]).unwrap();
-    /// let mut c = a.par_enum_map::<_,_,TensorError>(|i, x| Ok(i32::pow(x + i as i32, 2))).unwrap();
+    /// use ezkl::fieldutils::IntegerRep;
+    /// let mut a = Tensor::<IntegerRep>::new(Some(&[1, 4]), &[2]).unwrap();
+    /// let mut c = a.par_enum_map::<_,_,TensorError>(|i, x| Ok(IntegerRep::pow(x + i as IntegerRep, 2))).unwrap();
    /// assert_eq!(c, Tensor::from([1, 25].into_iter()));
    /// ```
    pub fn par_enum_map<
@@ -1284,8 +1195,9 @@ impl<T: Clone + TensorType> Tensor<T> {
    /// Get last elem from Tensor
    /// ```
    /// use ezkl::tensor::Tensor;
-    /// let mut a = Tensor::<i32>::new(Some(&[1, 2, 3]), &[3]).unwrap();
-    /// let mut b = Tensor::<i32>::new(Some(&[3]), &[1]).unwrap();
+    /// use ezkl::fieldutils::IntegerRep;
+    /// let mut a = Tensor::<IntegerRep>::new(Some(&[1, 2, 3]), &[3]).unwrap();
+    /// let mut b = Tensor::<IntegerRep>::new(Some(&[3]), &[1]).unwrap();
    ///
    /// assert_eq!(a.last().unwrap(), b);
    /// ```
@@ -1308,8 +1220,9 @@ impl<T: Clone + TensorType> Tensor<T> {
    /// Maps a function to tensors and enumerates in parallel
    /// ```
    /// use ezkl::tensor::{Tensor, TensorError};
-    /// let mut a = Tensor::<i32>::new(Some(&[1, 4]), &[2]).unwrap();
-    /// let mut c = a.par_enum_map::<_,_,TensorError>(|i, x| Ok(i32::pow(x + i as i32, 2))).unwrap();
+    /// use ezkl::fieldutils::IntegerRep;
+    /// let mut a = Tensor::<IntegerRep>::new(Some(&[1, 4]), &[2]).unwrap();
+    /// let mut c = a.par_enum_map::<_,_,TensorError>(|i, x| Ok(IntegerRep::pow(x + i as IntegerRep, 2))).unwrap();
    /// assert_eq!(c, Tensor::from([1, 25].into_iter()));
    /// ```
    pub fn par_enum_map_mut_filtered<
@@ -1332,103 +1245,13 @@ impl<T: Clone + TensorType> Tensor<T> {
    }
 }

-#[cfg(feature = "metal")]
-#[allow(unsafe_code)]
-/// Perform a tensor operation on the GPU using Metal.
-pub fn metal_tensor_op<T: Clone + TensorType + IntoI64 + Send + Sync>(
-    v: &Tensor<T>,
-    w: &Tensor<T>,
-    op: &str,
-) -> Tensor<T> {
-    assert_eq!(v.dims(), w.dims());
-
-    log::trace!("------------------------------------------------");
-
-    let start = Instant::now();
-    let v = v
-        .par_enum_map(|_, x| Ok::<_, TensorError>(x.into_i64()))
-        .unwrap();
-    let w = w
-        .par_enum_map(|_, x| Ok::<_, TensorError>(x.into_i64()))
-        .unwrap();
-    log::trace!("Time to map tensors: {:?}", start.elapsed());
-
-    objc::rc::autoreleasepool(|| {
-        // create function pipeline.
-        // this compiles the function, so a pipline can't be created in performance sensitive code.
-
-        let pipeline = &PIPELINES[op];
-
-        let length = v.len() as u64;
-        let size = length * core::mem::size_of::<i64>() as u64;
-        assert_eq!(v.len(), w.len());
-
-        let start = Instant::now();
-
-        let buffer_a = DEVICE.new_buffer_with_data(
-            unsafe { std::mem::transmute(v.as_ptr()) },
-            size,
-            MTLResourceOptions::StorageModeShared,
-        );
-        let buffer_b = DEVICE.new_buffer_with_data(
-            unsafe { std::mem::transmute(w.as_ptr()) },
-            size,
-            MTLResourceOptions::StorageModeShared,
-        );
-        let buffer_result = DEVICE.new_buffer(
-            size, // the operation will return an array with the same size.
-            MTLResourceOptions::StorageModeShared,
-        );
-
-        log::trace!("Time to load buffers: {:?}", start.elapsed());
-
-        // for sending commands, a command buffer is needed.
-        let start = Instant::now();
-        let command_buffer = QUEUE.new_command_buffer();
-        log::trace!("Time to load command buffer: {:?}", start.elapsed());
-        // to write commands into a buffer an encoder is needed, in our case a compute encoder.
-        let start = Instant::now();
-        let compute_encoder = command_buffer.new_compute_command_encoder();
-        compute_encoder.set_compute_pipeline_state(&pipeline);
-        compute_encoder.set_buffers(
-            0,
-            &[Some(&buffer_a), Some(&buffer_b), Some(&buffer_result)],
-            &[0; 3],
-        );
-        log::trace!("Time to load compute encoder: {:?}", start.elapsed());
-
-        // specify thread count and organization
-        let start = Instant::now();
-        let grid_size = MTLSize::new(length, 1, 1);
-        let threadgroup_size = MTLSize::new(length, 1, 1);
-        compute_encoder.dispatch_threads(grid_size, threadgroup_size);
-        log::trace!("Time to dispatch threads: {:?}", start.elapsed());
-
-        // end encoding and execute commands
-        let start = Instant::now();
-        compute_encoder.end_encoding();
-        command_buffer.commit();
-
-        command_buffer.wait_until_completed();
-        log::trace!("Time to commit: {:?}", start.elapsed());
-
-        let start = Instant::now();
-        let ptr = buffer_result.contents() as *const i64;
-        let len = buffer_result.length() as usize / std::mem::size_of::<i64>();
-        let slice = unsafe { core::slice::from_raw_parts(ptr, len) };
-        let res = Tensor::new(Some(&slice.to_vec()), &v.dims()).unwrap();
-        log::trace!("Time to get result: {:?}", start.elapsed());
-
-        res.map(|x| T::from_i64(x))
-    })
-}
-
 impl<T: Clone + TensorType> Tensor<Tensor<T>> {
    /// Flattens a tensor of tensors
    /// ```
    /// use ezkl::tensor::Tensor;
-    /// let mut a = Tensor::<i32>::new(Some(&[1, 2, 3, 4, 5, 6]), &[2, 3]).unwrap();
-    /// let mut b = Tensor::<i32>::new(Some(&[1, 4]), &[2, 1]).unwrap();
+    /// use ezkl::fieldutils::IntegerRep;
+    /// let mut a = Tensor::<IntegerRep>::new(Some(&[1, 2, 3, 4, 5, 6]), &[2, 3]).unwrap();
+    /// let mut b = Tensor::<IntegerRep>::new(Some(&[1, 4]), &[2, 1]).unwrap();
    /// let mut c = Tensor::new(Some(&[a,b]), &[2]).unwrap();
    /// let mut d = c.combine().unwrap();
    /// assert_eq!(d.dims(), &[8]);
@@ -1444,9 +1267,7 @@ impl<T: Clone + TensorType> Tensor<Tensor<T>> {
    }
 }

-impl<T: TensorType + Add<Output = T> + std::marker::Send + std::marker::Sync + IntoI64> Add
-    for Tensor<T>
-{
+impl<T: TensorType + Add<Output = T> + std::marker::Send + std::marker::Sync> Add for Tensor<T> {
    type Output = Result<Tensor<T>, TensorError>;
    /// Adds tensors.
    /// # Arguments
@@ -1456,42 +1277,43 @@ impl<T: TensorType + Add<Output = T> + std::marker::Send + std::marker::Sync + I
    /// # Examples
    /// ```
    /// use ezkl::tensor::Tensor;
+    /// use ezkl::fieldutils::IntegerRep;
    /// use std::ops::Add;
-    /// let x = Tensor::<i32>::new(
+    /// let x = Tensor::<IntegerRep>::new(
    ///     Some(&[2, 1, 2, 1, 1, 1]),
    ///     &[2, 3],
    /// ).unwrap();
-    /// let k = Tensor::<i32>::new(
+    /// let k = Tensor::<IntegerRep>::new(
    ///     Some(&[2, 3, 2, 1, 1, 1]),
    ///     &[2, 3],
    /// ).unwrap();
    /// let result = x.add(k).unwrap();
-    /// let expected = Tensor::<i32>::new(Some(&[4, 4, 4, 2, 2, 2]), &[2, 3]).unwrap();
+    /// let expected = Tensor::<IntegerRep>::new(Some(&[4, 4, 4, 2, 2, 2]), &[2, 3]).unwrap();
    /// assert_eq!(result, expected);
    ///
    /// // Now test 1D casting
-    /// let x = Tensor::<i32>::new(
+    /// let x = Tensor::<IntegerRep>::new(
    ///     Some(&[2, 1, 2, 1, 1, 1]),
    ///     &[2, 3],
    /// ).unwrap();
-    /// let k = Tensor::<i32>::new(
+    /// let k = Tensor::<IntegerRep>::new(
    ///     Some(&[2]),
    ///     &[1]).unwrap();
    /// let result = x.add(k).unwrap();
-    /// let expected = Tensor::<i32>::new(Some(&[4, 3, 4, 3, 3, 3]), &[2, 3]).unwrap();
+    /// let expected = Tensor::<IntegerRep>::new(Some(&[4, 3, 4, 3, 3, 3]), &[2, 3]).unwrap();
    /// assert_eq!(result, expected);
    ///
    ///
    /// // Now test 2D casting
-    /// let x = Tensor::<i32>::new(
+    /// let x = Tensor::<IntegerRep>::new(
    ///     Some(&[2, 1, 2, 1, 1, 1]),
    ///     &[2, 3],
    /// ).unwrap();
-    /// let k = Tensor::<i32>::new(
+    /// let k = Tensor::<IntegerRep>::new(
    ///     Some(&[2, 3]),
    ///     &[2]).unwrap();
    /// let result = x.add(k).unwrap();
-    /// let expected = Tensor::<i32>::new(Some(&[4, 3, 4, 4, 4, 4]), &[2, 3]).unwrap();
+    /// let expected = Tensor::<IntegerRep>::new(Some(&[4, 3, 4, 4, 4, 4]), &[2, 3]).unwrap();
    /// assert_eq!(result, expected);
    /// ```
    fn add(self, rhs: Self) -> Self::Output {
@@ -1525,13 +1347,14 @@ impl<T: TensorType + Neg<Output = T> + std::marker::Send + std::marker::Sync> Ne
    /// # Examples
    /// ```
    /// use ezkl::tensor::Tensor;
+    /// use ezkl::fieldutils::IntegerRep;
    /// use std::ops::Neg;
-    /// let x = Tensor::<i32>::new(
+    /// let x = Tensor::<IntegerRep>::new(
    ///    Some(&[2, 1, 2, 1, 1, 1]),
    ///   &[2, 3],
    /// ).unwrap();
    /// let result = x.neg();
-    /// let expected = Tensor::<i32>::new(Some(&[-2, -1, -2, -1, -1, -1]), &[2, 3]).unwrap();
+    /// let expected = Tensor::<IntegerRep>::new(Some(&[-2, -1, -2, -1, -1, -1]), &[2, 3]).unwrap();
    /// assert_eq!(result, expected);
    /// ```
    fn neg(self) -> Self {
@@ -1544,9 +1367,7 @@ impl<T: TensorType + Neg<Output = T> + std::marker::Send + std::marker::Sync> Ne
    }
 }

-impl<T: TensorType + Sub<Output = T> + std::marker::Send + std::marker::Sync + IntoI64> Sub
-    for Tensor<T>
-{
+impl<T: TensorType + Sub<Output = T> + std::marker::Send + std::marker::Sync> Sub for Tensor<T> {
    type Output = Result<Tensor<T>, TensorError>;
    /// Subtracts tensors.
    /// # Arguments
@@ -1556,43 +1377,44 @@ impl<T: TensorType + Sub<Output = T> + std::marker::Send + std::marker::Sync + I
    /// # Examples
    /// ```
    /// use ezkl::tensor::Tensor;
+    /// use ezkl::fieldutils::IntegerRep;
    /// use std::ops::Sub;
-    /// let x = Tensor::<i32>::new(
+    /// let x = Tensor::<IntegerRep>::new(
    ///     Some(&[2, 1, 2, 1, 1, 1]),
    ///     &[2, 3],
    /// ).unwrap();
-    /// let k = Tensor::<i32>::new(
+    /// let k = Tensor::<IntegerRep>::new(
    ///     Some(&[2, 3, 2, 1, 1, 1]),
    ///     &[2, 3],
    /// ).unwrap();
    /// let result = x.sub(k).unwrap();
-    /// let expected = Tensor::<i32>::new(Some(&[0, -2, 0, 0, 0, 0]), &[2, 3]).unwrap();
+    /// let expected = Tensor::<IntegerRep>::new(Some(&[0, -2, 0, 0, 0, 0]), &[2, 3]).unwrap();
    /// assert_eq!(result, expected);
    ///
    /// // Now test 1D sub
-    /// let x = Tensor::<i32>::new(
+    /// let x = Tensor::<IntegerRep>::new(
    ///     Some(&[2, 1, 2, 1, 1, 1]),
    ///     &[2, 3],
    /// ).unwrap();
-    /// let k = Tensor::<i32>::new(
+    /// let k = Tensor::<IntegerRep>::new(
    ///     Some(&[2]),
    ///     &[1],
    /// ).unwrap();
    /// let result = x.sub(k).unwrap();
-    /// let expected = Tensor::<i32>::new(Some(&[0, -1, 0, -1, -1, -1]), &[2, 3]).unwrap();
+    /// let expected = Tensor::<IntegerRep>::new(Some(&[0, -1, 0, -1, -1, -1]), &[2, 3]).unwrap();
    /// assert_eq!(result, expected);
    ///
    /// // Now test 2D sub
-    /// let x = Tensor::<i32>::new(
+    /// let x = Tensor::<IntegerRep>::new(
    ///     Some(&[2, 1, 2, 1, 1, 1]),
    ///     &[2, 3],
    /// ).unwrap();
-    /// let k = Tensor::<i32>::new(
+    /// let k = Tensor::<IntegerRep>::new(
    ///     Some(&[2, 3]),
    ///     &[2],
    /// ).unwrap();
    /// let result = x.sub(k).unwrap();
-    /// let expected = Tensor::<i32>::new(Some(&[0, -1, 0, -2, -2, -2]), &[2, 3]).unwrap();
+    /// let expected = Tensor::<IntegerRep>::new(Some(&[0, -1, 0, -2, -2, -2]), &[2, 3]).unwrap();
    /// assert_eq!(result, expected);
    /// ```
    fn sub(self, rhs: Self) -> Self::Output {
@@ -1618,9 +1440,7 @@ impl<T: TensorType + Sub<Output = T> + std::marker::Send + std::marker::Sync + I
    }
 }

-impl<T: TensorType + Mul<Output = T> + std::marker::Send + std::marker::Sync + IntoI64> Mul
-    for Tensor<T>
-{
+impl<T: TensorType + Mul<Output = T> + std::marker::Send + std::marker::Sync> Mul for Tensor<T> {
    type Output = Result<Tensor<T>, TensorError>;
    /// Elementwise multiplies tensors.
    /// # Arguments
@@ -1630,41 +1450,42 @@ impl<T: TensorType + Mul<Output = T> + std::marker::Send + std::marker::Sync + I
    /// # Examples
    /// ```
    /// use ezkl::tensor::Tensor;
+    /// use ezkl::fieldutils::IntegerRep;
    /// use std::ops::Mul;
-    /// let x = Tensor::<i32>::new(
+    /// let x = Tensor::<IntegerRep>::new(
    ///     Some(&[2, 1, 2, 1, 1, 1]),
    ///     &[2, 3],
    /// ).unwrap();
-    /// let k = Tensor::<i32>::new(
+    /// let k = Tensor::<IntegerRep>::new(
    ///     Some(&[2, 3, 2, 1, 1, 1]),
    ///     &[2, 3],
    /// ).unwrap();
    /// let result = x.mul(k).unwrap();
-    /// let expected = Tensor::<i32>::new(Some(&[4, 3, 4, 1, 1, 1]), &[2, 3]).unwrap();
+    /// let expected = Tensor::<IntegerRep>::new(Some(&[4, 3, 4, 1, 1, 1]), &[2, 3]).unwrap();
    /// assert_eq!(result, expected);
    ///
    /// // Now test 1D mult
-    /// let x = Tensor::<i32>::new(
+    /// let x = Tensor::<IntegerRep>::new(
    ///     Some(&[2, 1, 2, 1, 1, 1]),
    ///     &[2, 3],
    /// ).unwrap();
-    /// let k = Tensor::<i32>::new(
+    /// let k = Tensor::<IntegerRep>::new(
    ///     Some(&[2]),
    ///     &[1]).unwrap();
    /// let result = x.mul(k).unwrap();
-    /// let expected = Tensor::<i32>::new(Some(&[4, 2, 4, 2, 2, 2]), &[2, 3]).unwrap();
+    /// let expected = Tensor::<IntegerRep>::new(Some(&[4, 2, 4, 2, 2, 2]), &[2, 3]).unwrap();
    /// assert_eq!(result, expected);
    ///
    /// // Now test 2D mult
-    /// let x = Tensor::<i32>::new(
+    /// let x = Tensor::<IntegerRep>::new(
    ///     Some(&[2, 1, 2, 1, 1, 1]),
    ///     &[2, 3],
    /// ).unwrap();
-    /// let k = Tensor::<i32>::new(
+    /// let k = Tensor::<IntegerRep>::new(
    ///     Some(&[2, 2]),
    ///     &[2]).unwrap();
    /// let result = x.mul(k).unwrap();
-    /// let expected = Tensor::<i32>::new(Some(&[4, 2, 4, 2, 2, 2]), &[2, 3]).unwrap();
+    /// let expected = Tensor::<IntegerRep>::new(Some(&[4, 2, 4, 2, 2, 2]), &[2, 3]).unwrap();
    /// assert_eq!(result, expected);
    /// ```
    fn mul(self, rhs: Self) -> Self::Output {
@@ -1690,7 +1511,7 @@ impl<T: TensorType + Mul<Output = T> + std::marker::Send + std::marker::Sync + I
    }
 }

-impl<T: TensorType + Mul<Output = T> + std::marker::Send + std::marker::Sync + IntoI64> Tensor<T> {
+impl<T: TensorType + Mul<Output = T> + std::marker::Send + std::marker::Sync> Tensor<T> {
    /// Elementwise raise a tensor to the nth power.
    /// # Arguments
    ///
@@ -1699,13 +1520,14 @@ impl<T: TensorType + Mul<Output = T> + std::marker::Send + std::marker::Sync + I
    /// # Examples
    /// ```
    /// use ezkl::tensor::Tensor;
+    /// use ezkl::fieldutils::IntegerRep;
    /// use std::ops::Mul;
-    /// let x = Tensor::<i32>::new(
+    /// let x = Tensor::<IntegerRep>::new(
    ///     Some(&[2, 15, 2, 1, 1, 0]),
    ///     &[2, 3],
    /// ).unwrap();
    /// let result = x.pow(3).unwrap();
-    /// let expected = Tensor::<i32>::new(Some(&[8, 3375, 8, 1, 1, 0]), &[2, 3]).unwrap();
+    /// let expected = Tensor::<IntegerRep>::new(Some(&[8, 3375, 8, 1, 1, 0]), &[2, 3]).unwrap();
    /// assert_eq!(result, expected);
    /// ```
    pub fn pow(&self, mut exp: u32) -> Result<Self, TensorError> {
@@ -1739,30 +1561,31 @@ impl<T: TensorType + Div<Output = T> + std::marker::Send + std::marker::Sync> Di
    /// # Examples
    /// ```
    /// use ezkl::tensor::Tensor;
+    /// use ezkl::fieldutils::IntegerRep;
    /// use std::ops::Div;
-    /// let x = Tensor::<i32>::new(
+    /// let x = Tensor::<IntegerRep>::new(
    ///     Some(&[4, 1, 4, 1, 1, 4]),
    ///     &[2, 3],
    /// ).unwrap();
-    /// let y = Tensor::<i32>::new(
+    /// let y = Tensor::<IntegerRep>::new(
    ///     Some(&[2, 1, 2, 1, 1, 1]),
    ///     &[2, 3],
    /// ).unwrap();
    /// let result = x.div(y).unwrap();
-    /// let expected = Tensor::<i32>::new(Some(&[2, 1, 2, 1, 1, 4]), &[2, 3]).unwrap();
+    /// let expected = Tensor::<IntegerRep>::new(Some(&[2, 1, 2, 1, 1, 4]), &[2, 3]).unwrap();
    /// assert_eq!(result, expected);
    ///
    /// // test 1D casting
-    /// let x = Tensor::<i32>::new(
+    /// let x = Tensor::<IntegerRep>::new(
    ///     Some(&[4, 1, 4, 1, 1, 4]),
    ///     &[2, 3],
    /// ).unwrap();
-    /// let y = Tensor::<i32>::new(
+    /// let y = Tensor::<IntegerRep>::new(
    ///     Some(&[2]),
    ///     &[1],
    /// ).unwrap();
    /// let result = x.div(y).unwrap();
-    /// let expected = Tensor::<i32>::new(Some(&[2, 0, 2, 0, 0, 2]), &[2, 3]).unwrap();
+    /// let expected = Tensor::<IntegerRep>::new(Some(&[2, 0, 2, 0, 0, 2]), &[2, 3]).unwrap();
    /// assert_eq!(result, expected);
    /// ```
    fn div(self, rhs: Self) -> Self::Output {
@@ -1789,17 +1612,18 @@ impl<T: TensorType + Rem<Output = T> + std::marker::Send + std::marker::Sync> Re
    /// # Examples
    /// ```
    /// use ezkl::tensor::Tensor;
+    /// use ezkl::fieldutils::IntegerRep;
    /// use std::ops::Rem;
-    /// let x = Tensor::<i32>::new(
+    /// let x = Tensor::<IntegerRep>::new(
    ///    Some(&[4, 1, 4, 1, 1, 4]),
    ///   &[2, 3],
    /// ).unwrap();
-    /// let y = Tensor::<i32>::new(
+    /// let y = Tensor::<IntegerRep>::new(
    ///    Some(&[2, 1, 2, 1, 1, 1]),
    ///  &[2, 3],
    /// ).unwrap();
    /// let result = x.rem(y).unwrap();
-    /// let expected = Tensor::<i32>::new(Some(&[0, 0, 0, 0, 0, 0]), &[2, 3]).unwrap();
+    /// let expected = Tensor::<IntegerRep>::new(Some(&[0, 0, 0, 0, 0, 0]), &[2, 3]).unwrap();
    /// assert_eq!(result, expected);
    /// ```
    fn rem(self, rhs: Self) -> Self::Output {
@@ -1883,25 +1707,25 @@ mod tests {

    #[test]
    fn tensor_clone() {
-        let x = Tensor::<i32>::new(Some(&[1, 2, 3]), &[3]).unwrap();
+        let x = Tensor::<IntegerRep>::new(Some(&[1, 2, 3]), &[3]).unwrap();
        assert_eq!(x, x.clone());
    }

    #[test]
    fn tensor_eq() {
-        let a = Tensor::<i32>::new(Some(&[1, 2, 3]), &[3]).unwrap();
-        let mut b = Tensor::<i32>::new(Some(&[1, 2, 3]), &[3, 1]).unwrap();
+        let a = Tensor::<IntegerRep>::new(Some(&[1, 2, 3]), &[3]).unwrap();
+        let mut b = Tensor::<IntegerRep>::new(Some(&[1, 2, 3]), &[3, 1]).unwrap();
        b.reshape(&[3]).unwrap();
-        let c = Tensor::<i32>::new(Some(&[1, 2, 4]), &[3]).unwrap();
-        let d = Tensor::<i32>::new(Some(&[1, 2, 4]), &[3, 1]).unwrap();
+        let c = Tensor::<IntegerRep>::new(Some(&[1, 2, 4]), &[3]).unwrap();
+        let d = Tensor::<IntegerRep>::new(Some(&[1, 2, 4]), &[3, 1]).unwrap();
        assert_eq!(a, b);
        assert_ne!(a, c);
        assert_ne!(a, d);
    }
    #[test]
    fn tensor_slice() {
-        let a = Tensor::<i32>::new(Some(&[1, 2, 3, 4, 5, 6]), &[2, 3]).unwrap();
-        let b = Tensor::<i32>::new(Some(&[1, 4]), &[2, 1]).unwrap();
+        let a = Tensor::<IntegerRep>::new(Some(&[1, 2, 3, 4, 5, 6]), &[2, 3]).unwrap();
+        let b = Tensor::<IntegerRep>::new(Some(&[1, 4]), &[2, 1]).unwrap();
        assert_eq!(a.get_slice(&[0..2, 0..1]).unwrap(), b);
    }

--- a/src/tensor/ops.rs
+++ b/src/tensor/ops.rs
--- a/src/tensor/val.rs
+++ b/src/tensor/val.rs
@@ -1,4 +1,4 @@
-use crate::circuit::region::ConstantsMap;
+use crate::{circuit::region::ConstantsMap, fieldutils::felt_to_integer_rep};
 use maybe_rayon::slice::Iter;

 use super::{
@@ -54,6 +54,44 @@ pub enum ValType<F: PrimeField + TensorType + std::marker::Send + std::marker::S
    AssignedConstant(AssignedCell<F, F>, F),
 }

+impl<F: PrimeField + TensorType + PartialOrd> From<ValType<F>> for IntegerRep {
+    fn from(val: ValType<F>) -> Self {
+        match val {
+            ValType::Value(v) => {
+                let mut output = 0;
+                let mut i = 0;
+                v.map(|y| {
+                    let e = felt_to_integer_rep(y);
+                    output = e;
+                    i += 1;
+                });
+                output
+            }
+            ValType::AssignedValue(v) => {
+                let mut output = 0;
+                let mut i = 0;
+                v.evaluate().map(|y| {
+                    let e = felt_to_integer_rep(y);
+                    output = e;
+                    i += 1;
+                });
+                output
+            }
+            ValType::PrevAssigned(v) | ValType::AssignedConstant(v, ..) => {
+                let mut output = 0;
+                let mut i = 0;
+                v.value().map(|y| {
+                    let e = felt_to_integer_rep(*y);
+                    output = e;
+                    i += 1;
+                });
+                output
+            }
+            ValType::Constant(v) => felt_to_integer_rep(v),
+        }
+    }
+}
+
 impl<F: PrimeField + TensorType + std::marker::Send + std::marker::Sync + PartialOrd> ValType<F> {
    /// Returns the inner cell of the [ValType].
    pub fn cell(&self) -> Option<Cell> {
@@ -121,44 +159,6 @@ impl<F: PrimeField + TensorType + std::marker::Send + std::marker::Sync + Partia
    }
 }

-impl<F: PrimeField + TensorType + PartialOrd> From<ValType<F>> for i32 {
-    fn from(val: ValType<F>) -> Self {
-        match val {
-            ValType::Value(v) => {
-                let mut output = 0_i32;
-                let mut i = 0;
-                v.map(|y| {
-                    let e = felt_to_i32(y);
-                    output = e;
-                    i += 1;
-                });
-                output
-            }
-            ValType::AssignedValue(v) => {
-                let mut output = 0_i32;
-                let mut i = 0;
-                v.evaluate().map(|y| {
-                    let e = felt_to_i32(y);
-                    output = e;
-                    i += 1;
-                });
-                output
-            }
-            ValType::PrevAssigned(v) | ValType::AssignedConstant(v, ..) => {
-                let mut output = 0_i32;
-                let mut i = 0;
-                v.value().map(|y| {
-                    let e = felt_to_i32(*y);
-                    output = e;
-                    i += 1;
-                });
-                output
-            }
-            ValType::Constant(v) => felt_to_i32(v),
-        }
-    }
-}
-
 impl<F: PrimeField + TensorType + PartialOrd> From<F> for ValType<F> {
    fn from(t: F) -> ValType<F> {
        ValType::Constant(t)
@@ -317,8 +317,8 @@ impl<F: PrimeField + TensorType + PartialOrd> From<Tensor<AssignedCell<F, F>>> f

 impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> ValTensor<F> {
    /// Allocate a new [ValTensor::Value] from the given [Tensor] of [i64].
-    pub fn from_i64_tensor(t: Tensor<i64>) -> ValTensor<F> {
-        let inner = t.map(|x| ValType::Value(Value::known(i64_to_felt(x))));
+    pub fn from_integer_rep_tensor(t: Tensor<IntegerRep>) -> ValTensor<F> {
+        let inner = t.map(|x| ValType::Value(Value::known(integer_rep_to_felt(x))));
        inner.into()
    }

@@ -521,9 +521,9 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> ValTensor<F> {
    }

    /// Calls `int_evals` on the inner tensor.
-    pub fn get_int_evals(&self) -> Result<Tensor<i64>, TensorError> {
+    pub fn int_evals(&self) -> Result<Tensor<IntegerRep>, TensorError> {
        // finally convert to vector of integers
-        let mut integer_evals: Vec<i64> = vec![];
+        let mut integer_evals: Vec<IntegerRep> = vec![];
        match self {
            ValTensor::Value {
                inner: v, dims: _, ..
@@ -531,25 +531,26 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> ValTensor<F> {
                // we have to push to an externally created vector or else vaf.map() returns an evaluation wrapped in Value<> (which we don't want)
                let _ = v.map(|vaf| match vaf {
                    ValType::Value(v) => v.map(|f| {
-                        integer_evals.push(crate::fieldutils::felt_to_i64(f));
+                        integer_evals.push(crate::fieldutils::felt_to_integer_rep(f));
                    }),
                    ValType::AssignedValue(v) => v.map(|f| {
-                        integer_evals.push(crate::fieldutils::felt_to_i64(f.evaluate()));
+                        integer_evals.push(crate::fieldutils::felt_to_integer_rep(f.evaluate()));
                    }),
                    ValType::PrevAssigned(v) | ValType::AssignedConstant(v, ..) => {
                        v.value_field().map(|f| {
-                            integer_evals.push(crate::fieldutils::felt_to_i64(f.evaluate()));
+                            integer_evals
+                                .push(crate::fieldutils::felt_to_integer_rep(f.evaluate()));
                        })
                    }
                    ValType::Constant(v) => {
-                        integer_evals.push(crate::fieldutils::felt_to_i64(v));
+                        integer_evals.push(crate::fieldutils::felt_to_integer_rep(v));
                        Value::unknown()
                    }
                });
            }
            _ => return Err(TensorError::WrongMethod),
        };
-        let mut tensor: Tensor<i64> = integer_evals.into_iter().into();
+        let mut tensor: Tensor<IntegerRep> = integer_evals.into_iter().into();
        match tensor.reshape(self.dims()) {
            _ => {}
        };
@@ -1002,25 +1003,22 @@ impl<F: PrimeField + TensorType + PartialOrd + std::hash::Hash> ValTensor<F> {
    }
    /// A [String] representation of the [ValTensor] for display, for example in showing intermediate values in a computational graph.
    pub fn show(&self) -> String {
-        match self.clone() {
-            ValTensor::Value {
-                inner: v, dims: _, ..
-            } => {
-                let r: Tensor<i32> = v.map(|x| x.into());
-                if r.len() > 10 {
-                    let start = r[..5].to_vec();
-                    let end = r[r.len() - 5..].to_vec();
-                    // print the two split by ... in the middle
-                    format!(
-                        "[{} ... {}]",
-                        start.iter().map(|x| format!("{}", x)).join(", "),
-                        end.iter().map(|x| format!("{}", x)).join(", ")
-                    )
-                } else {
-                    format!("{:?}", r)
-                }
-            }
-            _ => "ValTensor not PrevAssigned".into(),
+        let r = match self.int_evals() {
+            Ok(v) => v,
+            Err(_) => return "ValTensor not PrevAssigned".into(),
+        };
+
+        if r.len() > 10 {
+            let start = r[..5].to_vec();
+            let end = r[r.len() - 5..].to_vec();
+            // print the two split by ... in the middle
+            format!(
+                "[{} ... {}]",
+                start.iter().map(|x| format!("{}", x)).join(", "),
+                end.iter().map(|x| format!("{}", x)).join(", ")
+            )
+        } else {
+            format!("{:?}", r)
        }
    }
 }
--- a/src/tensor/var.rs
+++ b/src/tensor/var.rs
@@ -368,7 +368,7 @@ impl VarTensor {
                            .sum::<usize>();
                    let dims = &dims[*idx];
                    // this should never ever fail
-                    let t: Tensor<i32> = Tensor::new(None, dims).unwrap();
+                    let t: Tensor<IntegerRep> = Tensor::new(None, dims).unwrap();
                    Ok(t.enum_map(|coord, _| {
                        let (x, y, z) = self.cartesian_coord(offset + coord);
                        region.assign_advice_from_instance(
@@ -497,7 +497,7 @@ impl VarTensor {
                    let (x, y, z) = self.cartesian_coord(offset + coord * step);
                    if matches!(check_mode, CheckMode::SAFE) && coord > 0 && z == 0 && y == 0 {
                        // assert that duplication occurred correctly
-                        assert_eq!(Into::<i32>::into(k.clone()), Into::<i32>::into(v[coord - 1].clone()));
+                        assert_eq!(Into::<IntegerRep>::into(k.clone()), Into::<IntegerRep>::into(v[coord - 1].clone()));
                    };

                    let cell = self.assign_value(region, offset, k.clone(), coord * step, constants)?;
@@ -533,13 +533,14 @@ impl VarTensor {
                if matches!(check_mode, CheckMode::SAFE) {
                     // during key generation this will be 0 so we use this as a flag to check
                     // TODO: this isn't very safe and would be better to get the phase directly
-                    let is_assigned = !Into::<Tensor<i32>>::into(res.clone().get_inner().unwrap())
+                    let res_evals = res.int_evals().unwrap();
+                    let is_assigned = res_evals
                    .iter()
                    .all(|&x| x == 0);
-                    if is_assigned {
+                    if !is_assigned {
                        assert_eq!(
-                            Into::<Tensor<i32>>::into(values.get_inner().unwrap()),
-                            Into::<Tensor<i32>>::into(res.get_inner().unwrap())
+                           values.int_evals().unwrap(),
+                           res_evals
                    )};
                }

--- a/src/wasm.rs
+++ b/src/wasm.rs
@@ -1,41 +1,52 @@
-use crate::circuit::modules::polycommit::PolyCommitChip;
-use crate::circuit::modules::poseidon::spec::{PoseidonSpec, POSEIDON_RATE, POSEIDON_WIDTH};
-use crate::circuit::modules::poseidon::PoseidonChip;
-use crate::circuit::modules::Module;
-use crate::fieldutils::felt_to_i64;
-use crate::fieldutils::i64_to_felt;
-use crate::graph::modules::POSEIDON_LEN_GRAPH;
-use crate::graph::quantize_float;
-use crate::graph::scale_to_multiplier;
-use crate::graph::{GraphCircuit, GraphSettings};
-use crate::pfsys::create_proof_circuit;
-use crate::pfsys::evm::aggregation_kzg::AggregationCircuit;
-use crate::pfsys::evm::aggregation_kzg::PoseidonTranscript;
-use crate::pfsys::verify_proof_circuit;
-use crate::pfsys::TranscriptType;
-use crate::tensor::TensorType;
-use crate::CheckMode;
-use crate::Commitments;
+use crate::{
+    circuit::{
+        modules::{
+            polycommit::PolyCommitChip,
+            poseidon::{
+                spec::{PoseidonSpec, POSEIDON_RATE, POSEIDON_WIDTH},
+                PoseidonChip,
+            },
+            Module,
+        },
+        region::RegionSettings,
+    },
+    fieldutils::{felt_to_integer_rep, integer_rep_to_felt},
+    graph::{
+        modules::POSEIDON_LEN_GRAPH, quantize_float, scale_to_multiplier, GraphCircuit,
+        GraphSettings,
+    },
+    pfsys::{
+        create_proof_circuit,
+        evm::aggregation_kzg::{AggregationCircuit, PoseidonTranscript},
+        verify_proof_circuit, TranscriptType,
+    },
+    tensor::TensorType,
+    CheckMode, Commitments,
+};
 use console_error_panic_hook;
-use halo2_proofs::plonk::*;
-use halo2_proofs::poly::commitment::{CommitmentScheme, ParamsProver};
-use halo2_proofs::poly::ipa::multiopen::{ProverIPA, VerifierIPA};
-use halo2_proofs::poly::ipa::{
-    commitment::{IPACommitmentScheme, ParamsIPA},
-    strategy::SingleStrategy as IPASingleStrategy,
+use halo2_proofs::{
+    plonk::*,
+    poly::{
+        commitment::{CommitmentScheme, ParamsProver},
+        ipa::{
+            commitment::{IPACommitmentScheme, ParamsIPA},
+            multiopen::{ProverIPA, VerifierIPA},
+            strategy::SingleStrategy as IPASingleStrategy,
+        },
+        kzg::{
+            commitment::{KZGCommitmentScheme, ParamsKZG},
+            multiopen::{ProverSHPLONK, VerifierSHPLONK},
+            strategy::SingleStrategy as KZGSingleStrategy,
+        },
+        VerificationStrategy,
+    },
 };
-use halo2_proofs::poly::kzg::multiopen::ProverSHPLONK;
-use halo2_proofs::poly::kzg::multiopen::VerifierSHPLONK;
-use halo2_proofs::poly::kzg::{
-    commitment::{KZGCommitmentScheme, ParamsKZG},
-    strategy::SingleStrategy as KZGSingleStrategy,
-};
-use halo2_proofs::poly::VerificationStrategy;
 use halo2_solidity_verifier::encode_calldata;
-use halo2curves::bn256::{Bn256, Fr, G1Affine};
-use halo2curves::ff::{FromUniformBytes, PrimeField};
-use snark_verifier::loader::native::NativeLoader;
-use snark_verifier::system::halo2::transcript::evm::EvmTranscript;
+use halo2curves::{
+    bn256::{Bn256, Fr, G1Affine},
+    ff::{FromUniformBytes, PrimeField},
+};
+use snark_verifier::{loader::native::NativeLoader, system::halo2::transcript::evm::EvmTranscript};
 use std::str::FromStr;
 use wasm_bindgen::prelude::*;
 use wasm_bindgen_console_logger::DEFAULT_LOGGER;
@@ -113,7 +124,7 @@ pub fn feltToInt(
    let felt: Fr = serde_json::from_slice(&array[..])
        .map_err(|e| JsError::new(&format!("Failed to deserialize field element: {}", e)))?;
    Ok(wasm_bindgen::Clamped(
-        serde_json::to_vec(&felt_to_i64(felt))
+        serde_json::to_vec(&felt_to_integer_rep(felt))
            .map_err(|e| JsError::new(&format!("Failed to serialize integer: {}", e)))?,
    ))
 }
@@ -127,7 +138,7 @@ pub fn feltToFloat(
 ) -> Result<f64, JsError> {
    let felt: Fr = serde_json::from_slice(&array[..])
        .map_err(|e| JsError::new(&format!("Failed to deserialize field element: {}", e)))?;
-    let int_rep = felt_to_i64(felt);
+    let int_rep = felt_to_integer_rep(felt);
    let multiplier = scale_to_multiplier(scale);
    Ok(int_rep as f64 / multiplier)
 }
@@ -141,7 +152,7 @@ pub fn floatToFelt(
 ) -> Result<wasm_bindgen::Clamped<Vec<u8>>, JsError> {
    let int_rep =
        quantize_float(&input, 0.0, scale).map_err(|e| JsError::new(&format!("{}", e)))?;
-    let felt = i64_to_felt(int_rep);
+    let felt = integer_rep_to_felt(int_rep);
    let vec = crate::pfsys::field_to_string::<halo2curves::bn256::Fr>(&felt);
    Ok(wasm_bindgen::Clamped(serde_json::to_vec(&vec).map_err(
        |e| JsError::new(&format!("Failed to serialize a float to felt{}", e)),
@@ -275,7 +286,7 @@ pub fn genWitness(
        .map_err(|e| JsError::new(&format!("{}", e)))?;

    let witness = circuit
-        .forward::<KZGCommitmentScheme<Bn256>>(&mut input, None, None, false, false)
+        .forward::<KZGCommitmentScheme<Bn256>>(&mut input, None, None, RegionSettings::all_false())
        .map_err(|e| JsError::new(&format!("{}", e)))?;

    serde_json::to_vec(&witness)
--- a/tests/integration_tests.rs
+++ b/tests/integration_tests.rs
@@ -3,7 +3,7 @@
 mod native_tests {

    use ezkl::circuit::Tolerance;
-    use ezkl::fieldutils::{felt_to_i64, i64_to_felt};
+    use ezkl::fieldutils::{felt_to_integer_rep, integer_rep_to_felt, IntegerRep};
    // use ezkl::circuit::table::RESERVED_BLINDING_ROWS_PAD;
    use ezkl::graph::input::{FileSource, FileSourceInner, GraphData};
    use ezkl::graph::{DataSource, GraphSettings, GraphWitness};
@@ -646,6 +646,15 @@ mod native_tests {
                test_dir.close().unwrap();
            }

+            #(#[test_case(TESTS[N])])*
+            fn mock_hashed_params_public_inputs_(test: &str) {
+                crate::native_tests::init_binary();
+                let test_dir = TempDir::new(test).unwrap();
+                let path = test_dir.path().to_str().unwrap(); crate::native_tests::mv_test_(path, test);
+                mock(path, test.to_string(), "public", "hashed", "private", 1, "resources", None, 0.0);
+                test_dir.close().unwrap();
+            }
+
            #(#[test_case(TESTS[N])])*
            fn mock_fixed_inputs_(test: &str) {
                crate::native_tests::init_binary();
@@ -1413,10 +1422,10 @@ mod native_tests {
                            let perturbation = if v == &halo2curves::bn256::Fr::zero() {
                                halo2curves::bn256::Fr::zero()
                            } else {
-                                i64_to_felt(
-                                    (felt_to_i64(*v) as f32
+                                integer_rep_to_felt(
+                                    (felt_to_integer_rep(*v) as f32
                                        * (rand::thread_rng().gen_range(-0.01..0.01) * tolerance))
-                                        as i64,
+                                        as IntegerRep,
                                )
                            };

@@ -1436,10 +1445,10 @@ mod native_tests {
                            let perturbation = if v == &halo2curves::bn256::Fr::zero() {
                                halo2curves::bn256::Fr::from(2)
                            } else {
-                                i64_to_felt(
-                                    (felt_to_i64(*v) as f32
+                                integer_rep_to_felt(
+                                    (felt_to_integer_rep(*v) as f32
                                        * (rand::thread_rng().gen_range(0.02..0.1) * tolerance))
-                                        as i64,
+                                        as IntegerRep,
                                )
                            };
                            *v + perturbation
--- a/tests/wasm/model.compiled
+++ b/tests/wasm/model.compiled
--- a/tests/wasm/pk.key
+++ b/tests/wasm/pk.key
--- a/tests/wasm/vk.key
+++ b/tests/wasm/vk.key
Author	SHA1	Message	Date
github-actions[bot]	7786528522	ci: update version string in docs	2024-09-05 13:52:21 +00:00
dante	c9f9d17f16	chore: optimized release builds by default (#844 )	2024-09-05 15:52:03 +02:00
Ethan Cemer	b49b0487c4	fix: remove console import from index.ts in in-browser-evm-verifier package (#841 )	2024-08-30 18:47:59 +01:00
dante	61b7a8e9b5	chore: perf updates (#838 )	2024-08-27 09:45:40 -04:00
dante	5dbc7d5176	chore: cache lookup tables (#835 )	2024-08-19 00:24:53 -04:00
dante	ada45a3197	chore: swap h2 collections hash for rustc hasher (#832 )	2024-08-04 17:28:36 -04:00
dante	616b421967	fix: bump compiler to latest to accomodate latest serde `diagnostic` (#830 )	2024-07-25 07:56:21 -04:00
dante	f64f0ecd23	fix: instance order when using processed params (#829 )	2024-07-24 07:58:46 -04:00
dante	5be12b7a54	fix: num groups for conv operations should be specified at load time (#828 )	2024-07-18 09:58:41 -04:00