diff --git a/.github/NIGHTLY_CANARY_DIED.md b/.github/NIGHTLY_CANARY_DIED.md
new file mode 100644
index 0000000..f72f3e1
--- /dev/null
+++ b/.github/NIGHTLY_CANARY_DIED.md
@@ -0,0 +1,8 @@
+---
+title: "Tests fail on latest Nargo nightly release"
+assignees: TomAFrench
+---
+
+The tests on this Noir project have started failing when using the latest nightly release of the Noir compiler. This likely means that there have been breaking changes for which this project needs to be updated to take into account.
+
+Check the [{{env.WORKFLOW_NAME}}]({{env.WORKFLOW_URL}}) workflow for details.
\ No newline at end of file
diff --git a/.github/workflows/nightly-canary.yml b/.github/workflows/nightly-canary.yml
new file mode 100644
index 0000000..03742d0
--- /dev/null
+++ b/.github/workflows/nightly-canary.yml
@@ -0,0 +1,43 @@
+name: Noir Nightly Canary
+
+on:
+  schedule:
+    # Run a check at 9 AM UTC
+    - cron: "0 9 * * *"
+
+env:
+  CARGO_TERM_COLOR: always
+
+permissions:
+  issues: write
+
+jobs:
+  test:
+    name: Test on Nargo ${{matrix.toolchain}}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v4
+
+      - name: Install Nargo
+        uses: noir-lang/noirup@v0.1.3
+        with:
+          toolchain: nightly
+
+      - name: Run Noir tests
+        run: nargo test
+
+      - name: Run formatter
+        run: nargo fmt --check
+
+      - name: Alert on dead canary
+        uses: JasonEtco/create-an-issue@v2
+        if: ${{ failure() }}
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          WORKFLOW_NAME: ${{ github.workflow }}
+          WORKFLOW_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
+        with:
+          update_existing: true
+          filename: .github/NIGHTLY_CANARY_DIED.md
+      
\ No newline at end of file
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
new file mode 100644
index 0000000..d8ab990
--- /dev/null
+++ b/.github/workflows/test.yml
@@ -0,0 +1,44 @@
+name: Noir tests
+
+on:
+  push:
+   branches:
+    - main
+  pull_request:
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  test:
+    name: Test on Nargo ${{matrix.toolchain}}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        toolchain: [nightly, 0.34.0]
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v4
+
+      - name: Install Nargo
+        uses: noir-lang/noirup@v0.1.3
+        with:
+          toolchain: ${{ matrix.toolchain }}
+
+      - name: Run Noir tests
+        run: nargo test
+
+  format:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v4
+
+      - name: Install Nargo
+        uses: noir-lang/noirup@v0.1.3
+        with:
+          toolchain: 0.34.0
+
+      - name: Run formatter
+        run: nargo fmt --check
diff --git a/.gitignore b/.gitignore
index c41cc9e..eb5a316 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1 +1 @@
-/target
\ No newline at end of file
+target
diff --git a/Nargo.toml b/Nargo.toml
index d2e0bb0..93897a3 100644
--- a/Nargo.toml
+++ b/Nargo.toml
@@ -2,6 +2,6 @@
 name = "noir_string_search"
 type = "lib"
 authors = [""]
-compiler_version = ">=0.32.0"
+compiler_version = ">=0.34.0"
 
-[dependencies]
\ No newline at end of file
+[dependencies]
diff --git a/info.sh b/info.sh
deleted file mode 100755
index e08ae09..0000000
--- a/info.sh
+++ /dev/null
@@ -1 +0,0 @@
-nargo compile --force && bb gates -b ./target/noir_string_search.json > target/noir_string_search.txt && grep -i -r 'circuit_size' ./target/noir_string_search.txt
\ No newline at end of file
diff --git a/src/lib.nr b/src/lib.nr
index ac0264f..48d6c3c 100644
--- a/src/lib.nr
+++ b/src/lib.nr
@@ -1,6 +1,6 @@
 mod utils;
 
-use utils::{conditional_select, lt_f, DebugRandomEngine};
+pub use utils::{conditional_select, lt_f, DebugRandomEngine};
 
 /**
  * @brief represents a byte-array of up to MaxBytes, that is used as a "haystack" array,
@@ -149,9 +149,16 @@ impl<let MaxPaddedBytes: u32, let PaddedChunksMinusOne: u32, let MaxBytes: u32>
 
 impl<let MaxPaddedBytes: u32, let PaddedChunksMinusOne: u32, let MaxBytes: u32> SubStringTrait for SubString<MaxPaddedBytes, PaddedChunksMinusOne, MaxBytes> {
 
-    fn len(self) -> u32 { self.byte_length }
-    fn get(self, idx: Field) -> u8 { self.body[idx] }
-    fn get_body(self) -> [u8] { let x = self.body.as_slice(); x }
+    fn len(self) -> u32 {
+        self.byte_length
+    }
+    fn get(self, idx: Field) -> u8 {
+        self.body[idx]
+    }
+    fn get_body(self) -> [u8] {
+        let x = self.body.as_slice();
+        x
+    }
 
     /**
      * @brief given some `haystack` 31-byte chunks, validate that there exist `num_full_chunks`
@@ -187,7 +194,7 @@ impl<let MaxPaddedBytes: u32, let PaddedChunksMinusOne: u32, let MaxBytes: u32>
             let rhs = haystack[predicate as Field * (i as Field + starting_haystack_chunk)];
             assert(predicate * (lhs - rhs) == 0);
         }
-    }   
+    }
 }
 
 // ######################################################
@@ -206,25 +213,7 @@ impl<let MaxPaddedBytes: u32, let PaddedChunks: u32, let MaxBytes: u32> StringBo
         for i in 0..InputBytes {
             body[i] = data[i];
         }
-        StringBody { body, chunks: StringBody::compute_chunks(body), byte_length: length }
-    }
-
-    /**
-     * @brief given an input byte array, convert into 31-byte chunks
-     *        cost is ~0.5 gates per byte
-     **/
-    fn compute_chunks(body: [u8; MaxPaddedBytes]) -> [Field; PaddedChunks] {
-        let mut chunks: [Field; PaddedChunks] = [0; PaddedChunks];
-        for i in 0..PaddedChunks {
-            let mut limb: Field = 0;
-            for j in 0..31 {
-                limb *= 256;
-                limb += body[i * 31 + j] as Field;
-            }
-            chunks[i] = limb;
-            std::as_witness(chunks[i]);
-        }
-        chunks
+        StringBody { body, chunks: compute_chunks(body), byte_length: length }
     }
 
     /**
@@ -237,12 +226,15 @@ impl<let MaxPaddedBytes: u32, let PaddedChunks: u32, let MaxBytes: u32> StringBo
         // use unconstrained function to determine:
         // a: is the substring present in the body text
         // b: the position of the first match in the body text 
-        let position: u32 = utils::search(
-            self.body,
-            substring.get_body(),
-            self.byte_length,
-            substring.len()
-        );
+        let position: u32 = unsafe {
+            // Safety: The rest of this function checks this.
+            utils::search(
+                self.body,
+                substring.get_body(),
+                self.byte_length,
+                substring.len()
+            )
+        };
 
         assert(
             position + substring.len() <= self.byte_length, "substring not present in main text (match found if a padding text included. is main text correctly formatted?)"
@@ -311,8 +303,8 @@ impl<let MaxPaddedBytes: u32, let PaddedChunks: u32, let MaxBytes: u32> StringBo
         let initial_haystack_chunk = self.chunks[chunk_index];
         let final_haystack_chunk = self.chunks[chunk_index_of_final_haystack_chunk_with_matching_needle_bytes];
 
-        let initial_body_bytes: [u8; 31] = initial_haystack_chunk.to_be_bytes(31).as_array();
-        let final_body_bytes: [u8; 31] = final_haystack_chunk.to_be_bytes(31).as_array();
+        let initial_body_bytes: [u8; 31] = initial_haystack_chunk.to_be_bytes();
+        let final_body_bytes: [u8; 31] = final_haystack_chunk.to_be_bytes();
 
         // When defining the initial chunk bytes, we can represent as Field elements as we are deriving values from known bytes.
         // This saves us a few gates
@@ -409,6 +401,23 @@ impl<let MaxPaddedBytes: u32, let PaddedChunks: u32, let MaxBytes: u32> StringBo
     }
 }
 
+/// Given an input byte array, convert into 31-byte chunks
+/// 
+/// Cost: ~0.5 gates per byte
+fn compute_chunks<let MaxPaddedBytes: u32, let PaddedChunks: u32>(body: [u8; MaxPaddedBytes]) -> [Field; PaddedChunks] {
+    let mut chunks: [Field; PaddedChunks] = [0; PaddedChunks];
+    for i in 0..PaddedChunks {
+        let mut limb: Field = 0;
+        for j in 0..31 {
+            limb *= 256;
+            limb += body[i * 31 + j] as Field;
+        }
+        chunks[i] = limb;
+        std::as_witness(chunks[i]);
+    }
+    chunks
+}
+
 #[test]
 fn test() {
     let haystack_text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.".as_bytes();
diff --git a/src/utils.nr b/src/utils.nr
index ad3b317..2071f2e 100644
--- a/src/utils.nr
+++ b/src/utils.nr
@@ -28,64 +28,43 @@ unconstrained pub fn search<let N: u32>(
     found_index
 }
 
-/**
- * @brief validate the body text contains zero-values for all indices >= byte_length
- * @note NOT NEEDED. Consider removing. Values beyond byte_length are not used in matching algorithm so no need to constrain them
- **/
-fn validate_body<let BODYBYTES: u32, let BODYCHUNKS: u32>(data: [u8; BODYBYTES], length: u32, _: [Field; BODYCHUNKS]) {
-    // we want a conditional assert for cases where i >= length
-    // if i >= length we want to assert that data = 0
-    let mut delta: Field = length as Field;
-    for i in 0..BODYBYTES {
-        let predicate = lt_f(i as Field, length as Field);
-        let predicate = get_lt_predicate_f(i as Field, length as Field);
-
-        let lt_parameter = 2 * (predicate as Field) * delta - predicate as Field - delta;
-        lt_parameter.assert_max_bit_size(32);
-        delta = delta - 1;
-        std::as_witness(delta);
-
-        // assert that if predicate = 0 then byte = 0
-        assert(data[i] as Field * predicate as Field == data[i] as Field);
-    }
-}
-
 unconstrained fn __conditional_select(lhs: u8, rhs: u8, predicate: bool) -> u8 {
-    let mut result: u8 = 0;
-    if (predicate) {
-        result = lhs;
-    } else {
-        result = rhs;
-    }
-    result
+    if (predicate) { lhs } else { rhs }
 }
 
 pub fn conditional_select<T>(lhs: u8, rhs: u8, predicate: bool) -> u8 {
-    let result = __conditional_select(lhs, rhs, predicate);
-    let result_f = result as Field;
-    let lhs_f = lhs as Field;
-    let rhs_f = rhs as Field;
+    // Safety: This is all just a very verbose `if (predicate) { lhs } else { rhs }`
+    // formulated as `rhs + (lhs - rhs) * predicate`
+    unsafe {
+        let result = __conditional_select(lhs, rhs, predicate);
+        let result_f = result as Field;
+        let lhs_f = lhs as Field;
+        let rhs_f = rhs as Field;
 
-    let diff = lhs_f - rhs_f;
-    std::as_witness(diff);
-    assert((predicate as Field) * (diff) + rhs_f == result_f);
-    result
+        let diff = lhs_f - rhs_f;
+        std::as_witness(diff);
+        assert_eq((predicate as Field) * diff + rhs_f, result_f);
+        result
+    }
 }
 
 unconstrained pub fn get_lt_predicate_f(x: Field, y: Field) -> bool {
     let a = x as u32;
     let b = y as u32;
-    let r = a < b;
-    r
+    a < b
 }
 
 pub fn lt_f(x: Field, y: Field) -> bool {
-    let predicate = get_lt_predicate_f(x, y);
-    let delta = y as Field - x as Field;
-    let lt_parameter = 2 * (predicate as Field) * delta - predicate as Field - delta;
-    lt_parameter.assert_max_bit_size(32);
+    // Safety: As `x` and `y` are known to be valid `u32`s, this function reimplements the
+    // compiler's internal implementation of `lt` 
+    unsafe {
+        let predicate = get_lt_predicate_f(x, y);
+        let delta = y as Field - x as Field;
+        let lt_parameter = 2 * (predicate as Field) * delta - predicate as Field - delta;
+        lt_parameter.assert_max_bit_size(32);
 
-    predicate
+        predicate
+    }
 }
 
 struct DebugRandomEngine {
@@ -95,7 +74,7 @@ struct DebugRandomEngine {
 impl DebugRandomEngine {
     unconstrained fn get_random_32_bytes(&mut self) -> [u8; 32] {
         self.seed += 1;
-        let input: [u8; 32] = self.seed.to_be_bytes(32).as_array();
+        let input: [u8; 32] = self.seed.to_be_bytes();
         let hash: [u8; 32] = dep::std::hash::sha256(input);
         hash
     }
diff --git a/target/noir_string_search.json b/target/noir_string_search.json
deleted file mode 100644
index cce8c1b..0000000
--- a/target/noir_string_search.json
+++ /dev/null
@@ -1 +0,0 @@
-{"noir_version":"0.32.0+c679f01a19b02ad2ac2287c8e699b46887f7872c","hash":78584144448352783,"abi":{"parameters":[{"name":"body_text","type":{"kind":"array","length":2048,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"},{"name":"substring_text","type":{"kind":"array","length":128,"type":{"kind":"integer","sign":"unsigned","width":8}},"visibility":"private"},{"name":"body_length","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"},{"name":"substring_length","type":{"kind":"integer","sign":"unsigned","width":32},"visibility":"private"}],"return_type":null,"error_types":{}},"bytecode":"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","debug_symbols":"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","file_map":{"23":{"source":"mod bn254;\nuse bn254::lt as bn254_lt;\n\nimpl Field {\n    pub fn to_le_bits(self: Self, bit_size: u32) -> [u1] {\n        crate::assert_constant(bit_size);\n        self.__to_le_bits(bit_size)\n    }\n\n    pub fn to_be_bits(self: Self, bit_size: u32) -> [u1] {\n        crate::assert_constant(bit_size);\n        self.__to_be_bits(bit_size)\n    }\n\n    #[builtin(to_le_bits)]\n    fn __to_le_bits(self, _bit_size: u32) -> [u1] {}\n\n    #[builtin(to_be_bits)]\n    fn __to_be_bits(self, bit_size: u32) -> [u1] {}\n\n    #[builtin(apply_range_constraint)]\n    fn __assert_max_bit_size(self, bit_size: u32) {}\n\n    pub fn assert_max_bit_size(self: Self, bit_size: u32) {\n        crate::assert_constant(bit_size);\n        assert(bit_size < modulus_num_bits() as u32);\n        self.__assert_max_bit_size(bit_size);\n    }\n\n    pub fn to_le_bytes(self: Self, byte_size: u32) -> [u8] {\n        self.to_le_radix(256, byte_size)\n    }\n\n    pub fn to_be_bytes(self: Self, byte_size: u32) -> [u8] {\n        self.to_be_radix(256, byte_size)\n    }\n\n    pub fn to_le_radix(self: Self, radix: u32, result_len: u32) -> [u8] {\n        crate::assert_constant(radix);\n        crate::assert_constant(result_len);\n        self.__to_le_radix(radix, result_len)\n    }\n\n    pub fn to_be_radix(self: Self, radix: u32, result_len: u32) -> [u8] {\n        crate::assert_constant(radix);\n        crate::assert_constant(result_len);\n        self.__to_be_radix(radix, result_len)\n    }\n\n    // decompose `_self` into a `_result_len` vector over the `_radix` basis\n    // `_radix` must be less than 256\n    #[builtin(to_le_radix)]\n    fn __to_le_radix(self, radix: u32, result_len: u32) -> [u8] {}\n\n    #[builtin(to_be_radix)]\n    fn __to_be_radix(self, radix: u32, result_len: u32) -> [u8] {}\n\n    // Returns self to the power of the given exponent value.\n    // Caution: we assume the exponent fits into 32 bits\n    // using a bigger bit size impacts negatively the performance and should be done only if the exponent does not fit in 32 bits\n    pub fn pow_32(self, exponent: Field) -> Field {\n        let mut r: Field = 1;\n        let b = exponent.to_le_bits(32);\n\n        for i in 1..33 {\n            r *= r;\n            r = (b[32-i] as Field) * (r * self) + (1 - b[32-i] as Field) * r;\n        }\n        r\n    }\n\n    // Parity of (prime) Field element, i.e. sgn0(x mod p) = 0 if x ∈ {0, ..., p-1} is even, otherwise sgn0(x mod p) = 1.\n    pub fn sgn0(self) -> u1 {\n        self as u1\n    }\n\n    pub fn lt(self, another: Field) -> bool {\n        if crate::compat::is_bn254() {\n            bn254_lt(self, another)\n        } else {\n            lt_fallback(self, another)\n        }\n    }\n}\n\n#[builtin(modulus_num_bits)]\npub comptime fn modulus_num_bits() -> u64 {}\n\n#[builtin(modulus_be_bits)]\npub comptime fn modulus_be_bits() -> [u1] {}\n\n#[builtin(modulus_le_bits)]\npub comptime fn modulus_le_bits() -> [u1] {}\n\n#[builtin(modulus_be_bytes)]\npub comptime fn modulus_be_bytes() -> [u8] {}\n\n#[builtin(modulus_le_bytes)]\npub comptime fn modulus_le_bytes() -> [u8] {}\n\n// Convert a 32 byte array to a field element by modding\npub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {\n    // Convert it to a field element\n    let mut v = 1;\n    let mut high = 0 as Field;\n    let mut low = 0 as Field;\n\n    for i in 0..16 {\n        high = high + (bytes32[15 - i] as Field) * v;\n        low = low + (bytes32[16 + 15 - i] as Field) * v;\n        v = v * 256;\n    }\n    // Abuse that a % p + b % p = (a + b) % p and that low < p\n    low + high * v\n}\n\nfn lt_fallback(x: Field, y: Field) -> bool {\n    let num_bytes = (modulus_num_bits() as u32 + 7) / 8;\n    let x_bytes = x.to_le_bytes(num_bytes);\n    let y_bytes = y.to_le_bytes(num_bytes);\n    let mut x_is_lt = false;\n    let mut done = false;\n    for i in 0..num_bytes {\n        if (!done) {\n            let x_byte = x_bytes[num_bytes - 1 - i] as u8;\n            let y_byte = y_bytes[num_bytes - 1 - i] as u8;\n            let bytes_match = x_byte == y_byte;\n            if !bytes_match {\n                x_is_lt = x_byte < y_byte;\n                done = true;\n            }\n        }\n    }\n    x_is_lt\n}\n\n","path":"std/field/mod.nr"},"32":{"source":"mod hash;\nmod aes128;\nmod array;\nmod slice;\nmod merkle;\nmod schnorr;\nmod ecdsa_secp256k1;\nmod ecdsa_secp256r1;\nmod eddsa;\nmod embedded_curve_ops;\nmod sha256;\nmod sha512;\nmod field;\nmod ec;\nmod unsafe;\nmod collections;\nmod compat;\nmod convert;\nmod option;\nmod string;\nmod test;\nmod cmp;\nmod ops;\nmod default;\nmod prelude;\nmod uint128;\nmod bigint;\nmod runtime;\nmod meta;\nmod append;\n\n// Oracle calls are required to be wrapped in an unconstrained function\n// Thus, the only argument to the `println` oracle is expected to always be an ident\n#[oracle(print)]\nunconstrained fn print_oracle<T>(with_newline: bool, input: T) {}\n\nunconstrained pub fn print<T>(input: T) {\n    print_oracle(false, input);\n}\n\nunconstrained pub fn println<T>(input: T) {\n    print_oracle(true, input);\n}\n\n#[foreign(recursive_aggregation)]\npub fn verify_proof<N>(verification_key: [Field], proof: [Field], public_inputs: [Field], key_hash: Field) {}\n\n// Asserts that the given value is known at compile-time.\n// Useful for debugging for-loop bounds.\n#[builtin(assert_constant)]\npub fn assert_constant<T>(x: T) {}\n\n// Asserts that the given value is both true and known at compile-time\n#[builtin(static_assert)]\npub fn static_assert<let N: u32>(predicate: bool, message: str<N>) {}\n\n// from_field and as_field are private since they are not valid for every type.\n// `as` should be the default for users to cast between primitive types, and in the future\n// traits can be used to work with generic types.\n#[builtin(from_field)]\nfn from_field<T>(x: Field) -> T {}\n\n#[builtin(as_field)]\nfn as_field<T>(x: T) -> Field {}\n\npub fn wrapping_add<T>(x: T, y: T) -> T {\n    crate::from_field(crate::as_field(x) + crate::as_field(y))\n}\n\npub fn wrapping_sub<T>(x: T, y: T) -> T {\n    //340282366920938463463374607431768211456 is 2^128, it is used to avoid underflow\n    crate::from_field(crate::as_field(x) + 340282366920938463463374607431768211456 - crate::as_field(y))\n}\n\npub fn wrapping_mul<T>(x: T, y: T) -> T {\n    crate::from_field(crate::as_field(x) * crate::as_field(y))\n}\n\n#[builtin(as_witness)]\npub fn as_witness(x: Field) {}\n\n","path":"std/lib.nr"},"53":{"source":"unconstrained pub fn search<let N: u32>(\n    haystack: [u8; N],\n    needle: [u8],\n    haystack_length: u32,\n    needle_length: u32\n) -> u32 {\n    assert(needle_length > 0, \"needle length of size 0 not supported\");\n    assert(haystack_length > 0, \"haystack length of size 0 not supported\");\n    let mut found = false;\n    let mut found_index: u32 = 0;\n    for i in 0..haystack_length - needle_length + 1 {\n        if (found == true) {\n            break;\n        }\n        for j in 0..needle_length {\n            if haystack[i + j] != needle[j] {\n                break;\n            } else if (j == needle_length - 1) {\n                found = true;\n            }\n            if (found == true) {\n                found_index = i;\n                break;\n            }\n        }\n    }\n    assert(found == true, \"utils::search could not find needle in haystack\");\n    found_index\n}\n\n/**\n * @brief validate the body text contains zero-values for all indices >= byte_length\n * @note NOT NEEDED. Consider removing. Values beyond byte_length are not used in matching algorithm so no need to constrain them\n **/\nfn validate_body<let BODYBYTES: u32, let BODYCHUNKS: u32>(data: [u8; BODYBYTES], length: u32, _: [Field; BODYCHUNKS]) {\n    // we want a conditional assert for cases where i >= length\n    // if i >= length we want to assert that data = 0\n    let mut delta: Field = length as Field;\n    for i in 0..BODYBYTES {\n        let predicate = lt_f(i as Field, length as Field);\n        let predicate = get_lt_predicate_f(i as Field, length as Field);\n\n        let lt_parameter = 2 * (predicate as Field) * delta - predicate as Field - delta;\n        lt_parameter.assert_max_bit_size(32);\n        delta = delta - 1;\n        std::as_witness(delta);\n\n        // assert that if predicate = 0 then byte = 0\n        assert(data[i] as Field * predicate as Field == data[i] as Field);\n    }\n}\n\nunconstrained fn __conditional_select(lhs: u8, rhs: u8, predicate: bool) -> u8 {\n    let mut result: u8 = 0;\n    if (predicate) {\n        result = lhs;\n    } else {\n        result = rhs;\n    }\n    result\n}\n\npub fn conditional_select<T>(lhs: u8, rhs: u8, predicate: bool) -> u8 {\n    let result = __conditional_select(lhs, rhs, predicate);\n    let result_f = result as Field;\n    let lhs_f = lhs as Field;\n    let rhs_f = rhs as Field;\n\n    let diff = lhs_f - rhs_f;\n    std::as_witness(diff);\n    assert((predicate as Field) * (diff) + rhs_f == result_f);\n    result\n}\n\nunconstrained pub fn get_lt_predicate_f(x: Field, y: Field) -> bool {\n    let a = x as u32;\n    let b = y as u32;\n    let r = a < b;\n    r\n}\n\npub fn lt_f(x: Field, y: Field) -> bool {\n    let predicate = get_lt_predicate_f(x, y);\n    let delta = y as Field - x as Field;\n    let lt_parameter = 2 * (predicate as Field) * delta - predicate as Field - delta;\n    lt_parameter.assert_max_bit_size(32);\n\n    predicate\n}\n\nstruct DebugRandomEngine {\n    seed: Field,\n}\n\nimpl DebugRandomEngine {\n    unconstrained fn get_random_32_bytes(&mut self) -> [u8; 32] {\n        self.seed += 1;\n        let input: [u8; 32] = self.seed.to_be_bytes(32).as_array();\n        let hash: [u8; 32] = dep::std::hash::sha256(input);\n        hash\n    }\n    unconstrained fn get_random_field(&mut self) -> Field {\n        let hash = self.get_random_32_bytes();\n        let mut result: Field = 0;\n        for i in 0..32 {\n            result *= 256;\n            result += hash[i] as Field;\n        }\n        result\n    }\n\n    unconstrained fn get_random_bytes<let NBytes: u32>(&mut self) -> [u8; NBytes] {\n        let num_chunks = (NBytes / 32) + ((NBytes % 32) != 0) as u32;\n\n        let mut result: [u8; NBytes] = [0; NBytes];\n        for i in 0..num_chunks - 1 {\n            let bytes = self.get_random_32_bytes();\n            for j in 0..32 {\n                result[i * 32 + j] = bytes[j];\n            }\n        }\n\n        let bytes = self.get_random_32_bytes();\n        for j in 0..(NBytes - (num_chunks - 1) * 32) {\n            result[(num_chunks - 1) * 32 + j] = bytes[j];\n        }\n        result\n    }\n}\n\n","path":"/Users/zac/noir_string_search/src/utils.nr"},"54":{"source":"mod utils;\n\nuse utils::{conditional_select, lt_f, DebugRandomEngine};\n\n/**\n * @brief represents a byte-array of up to MaxBytes, that is used as a \"haystack\" array,\n *        where we want to validate a substring \"needle\" is present in the \"haystack\" \n * @details the \"body\" parameter contains some input bytes, zero-padded to the nearest multiple of 31\n *          We pack \"bytes\" into 31-byte \"chunks\", as this is the maximum number of bytes we can fit\n *          into a field element without overflowing.\n *          TODO: once we can derive generics via arithmetic on other generics, we want this \"31\" parameter\n *          to be defined by the backend being used instead of being hardcoded to 31\n *\n * @note We perform this 31-byte packing because it dramatically reduces the number of constraints required for substring matching. See (chicken)\n *\n * @tparam MaxBytes: the maximum number of bytes that StringBody can contain\n * @tparam MaxPaddedBytes: the maximum number of bytes after zero-padding to the nearest multiple of 31\n * @tparam PaddedChunks: the number of 31-byte chunks needed to represent MaxPaddedBytes\n **/\nstruct StringBody<let MaxPaddedBytes: u32, let PaddedChunks: u32, let MaxBytes: u32> {\n    body: [u8; MaxPaddedBytes],\n    chunks: [Field; PaddedChunks],\n    byte_length: u32\n}\n\n/**\n * @brief represents a byte-array of up to MaxBytes, that is used as a \"needle\" array,\n *        where we want to validate a substring \"needle\" is present in the \"haystack\" \n * @tparam MaxBytes: the maximum number of bytes that StringBody can contain\n * @tparam MaxPaddedBytes: the maximum number of bytes after zero-padding to the nearest multiple of 31\n * @tparam PaddedChunksMinusOne: the number of 31-byte chunks needed to represent MaxPaddedBytes minus one!\n *\n * @note PaddedChunksMinusOne is because we are going to do the following:\n *                            1. align the SubString bytes according to the StringBody bytes being matched against\n *                            2. split the aligned bytes into 31-byte chunks. The 1st and last chunks might contain\n *                               fewer than 31 bytes due to the above alignment\n *                            3. validate the aligned-byte-chunks match the StringBody byte chunks\n *       To account for the fact that the 1st and last chunks might have fewer bytes we treat those separately\n *       The param PaddedChunksMinusOne is the number of 31-byte chunks required to represent SubString *EXCLUDING* the initial and final chunks\n */\nstruct SubString<let MaxPaddedBytes: u32, let PaddedChunksMinusOne: u32, let MaxBytes: u32> {\n    body: [u8; MaxPaddedBytes],\n    byte_length: u32\n}\n\ntype StringBody32 = StringBody<62, 2, 32>;\ntype StringBody64 = StringBody<93, 3, 64>;\ntype StringBody128 = StringBody<155, 5, 128>;\ntype StringBody256 = StringBody<279, 9, 256>;\ntype StringBody512 = StringBody<527, 17, 512>;\ntype StringBody1024 = StringBody<1054, 34, 1024>;\ntype StringBody2048 = StringBody<2077, 67, 2048>;\ntype StringBody4096 = StringBody<4123, 133, 4096>;\ntype StringBody8192 = StringBody<8215, 265, 8192>;\ntype StringBody16384 = StringBody<16399, 529, 16384>;\n\ntype SubString32 = SubString<62, 1, 32>;\ntype SubString64 = SubString<93, 2, 64>;\ntype SubString128 = SubString<155, 4, 128>;\ntype SubString256 = SubString<279, 8, 256>;\ntype SubString512 = SubString<527, 16, 512>;\ntype SubString1024 = SubString<1054, 33, 1024>;\n\ntrait SubStringTrait {\n    fn match_chunks<let HaystackChunks: u32>(\n        self,\n        haystack: [Field; HaystackChunks],\n        num_bytes_in_first_chunk: Field,\n        body_chunk_offset: Field,\n        num_full_chunks: Field\n    );\n\n    fn len(self) -> u32;\n    fn get(self, idx: Field) -> u8;\n    fn get_body(self) -> [u8];\n}\n\n// ######################################################\n// S U B S T R I N G\n// ######################################################\nimpl<let MaxPaddedBytes: u32, let PaddedChunksMinusOne: u32, let MaxBytes: u32> SubString<MaxPaddedBytes, PaddedChunksMinusOne, MaxBytes> {\n\n    /**\n     * @brief construct a SubString object from an input byte array\n     * @details the input byte array must have a number of bytes less than or equal to MaxBytes\n     **/\n    fn new<let InputBytes: u32>(input: [u8; InputBytes], input_length: u32) -> Self {\n        assert(MaxBytes <= MaxPaddedBytes);\n        assert(input_length <= MaxBytes);\n        assert(InputBytes <= MaxBytes);\n        let mut body: [u8; MaxPaddedBytes] = [0; MaxPaddedBytes];\n        for i in 0..InputBytes {\n            body[i] = input[i];\n        }\n        SubString { body, byte_length: input_length }\n    }\n\n    /**\n     * @brief concatenate two SubString objects together\n     * @details each SubString can have different MaxBytes sizes, however we need OtherBytes <= MaxBytes\n     *          (use concat_into for cases where this is not the case)\n     **/\n    fn concat<let OtherPaddedBytes: u32, let OtherPaddedChunks: u32, let OtherMaxBytes: u32>(self, other: SubString<OtherPaddedBytes, OtherPaddedChunks, OtherMaxBytes>) -> Self {\n        assert(\n            OtherPaddedBytes <= MaxPaddedBytes, \"SubString::concat. SubString being concatted has larger max length. Try calling concat_into\"\n        );\n        assert(\n            self.byte_length + other.byte_length <= MaxPaddedBytes, \"SubString::concat, concatenated string exceeds MaxPaddedBytes\"\n        );\n        let mut body = self.body;\n        let offset: u32 = self.byte_length;\n        for i in 0..MaxPaddedBytes {\n            if (i + offset < MaxPaddedBytes) {\n                body[i + offset] = other.body[i];\n            }\n        }\n        SubString { body, byte_length: self.byte_length + other.byte_length }\n    }\n\n    /**\n     * @brief concatenate two SubString objects together. Return type has OtherPaddedBytes max bytes\n     * @details each SubString can have different MaxBytes sizes, however we need MaxBytes <= OtherBytes\n     *          (use concat for cases where this is not the case)\n     **/\n    fn concat_into<let OtherPaddedBytes: u32, let OtherPaddedChunks: u32, let OtherMaxBytes: u32>(\n        self,\n        other: SubString<OtherPaddedBytes, OtherPaddedChunks, OtherMaxBytes>\n    ) -> SubString<OtherPaddedBytes, OtherPaddedChunks, OtherMaxBytes> {\n        assert(\n            MaxPaddedBytes <= OtherPaddedBytes, \"SubString::concat_into. SubString being concat has larger max length. Try calling concat\"\n        );\n        assert(\n            self.byte_length + other.byte_length <= OtherPaddedBytes, \"SubString::concat_into, concatenated string exceeds MaxPaddedBytes\"\n        );\n        let mut body: [u8; OtherPaddedBytes] = [0; OtherPaddedBytes];\n        for i in 0..MaxBytes {\n            body[i] = self.body[i];\n        }\n\n        let offset: u32 = self.byte_length;\n        for i in 0..OtherPaddedBytes {\n            if (i + offset < OtherPaddedBytes) {\n                body[i + offset] = other.body[i];\n            }\n        }\n        SubString { body, byte_length: self.byte_length + other.byte_length }\n    }\n}\n\nimpl<let MaxPaddedBytes: u32, let PaddedChunksMinusOne: u32, let MaxBytes: u32> SubStringTrait for SubString<MaxPaddedBytes, PaddedChunksMinusOne, MaxBytes> {\n\n    fn len(self) -> u32 { self.byte_length }\n    fn get(self, idx: Field) -> u8 { self.body[idx] }\n    fn get_body(self) -> [u8] { let x = self.body.as_slice(); println(f\"X = {x}\"); x }\n\n    /**\n     * @brief given some `haystack` 31-byte chunks, validate that there exist `num_full_chunks`\n     *        in the SubString, starting at byte position `starting_needle_byte`.\n     *        The selected chunks must be equal to the haystack chunks starting at `starting_haystack_chunk`\n     **/\n    fn match_chunks<let HaystackChunks: u32>(\n        self,\n        haystack: [Field; HaystackChunks],\n        starting_needle_byte: Field,\n        starting_haystack_chunk: Field,\n        num_full_chunks: Field\n    ) {\n        let mut substring_chunks: [Field; PaddedChunksMinusOne] = [0; PaddedChunksMinusOne];\n        // pack the substring into 31 byte chunks.\n        // This is fairly expensive as we need a ROM table to access the SubString.body\n        // which is 2 gates per byte\n        for i in 0..PaddedChunksMinusOne {\n            let mut slice: Field = 0;\n            for j in 0..31 {\n                slice *= 256;\n                let substring_idx = starting_needle_byte as Field + (i as Field * 31) + j as Field;\n                let mut byte = self.body[substring_idx];\n                slice += byte as Field;\n            }\n            std::as_witness(slice);\n            substring_chunks[i] = slice;\n        }\n        // iterate over the needle chunks and validate they match the haystack chunks\n        for i in 0..PaddedChunksMinusOne {\n            let predicate: Field = lt_f(i as Field, num_full_chunks) as Field;\n            let lhs = substring_chunks[i];\n            let rhs = haystack[predicate as Field * (i as Field + starting_haystack_chunk)];\n            assert(predicate * (lhs - rhs) == 0);\n        }\n    }   \n}\n\n// ######################################################\n// S T R I N G   B O D Y\n// ######################################################\nimpl<let MaxPaddedBytes: u32, let PaddedChunks: u32, let MaxBytes: u32> StringBody<MaxPaddedBytes, PaddedChunks, MaxBytes> {\n\n    /**\n     * @brief construct a StringBody object from an input byte array\n     * @details the input byte array must have a number of bytes less than or equal to MaxBytes\n     **/\n    fn new<let InputBytes: u32>(data: [u8; InputBytes], length: u32) -> Self {\n        assert(length <= MaxBytes);\n        assert(length <= InputBytes);\n        let mut body: [u8; MaxPaddedBytes] = [0; MaxPaddedBytes];\n        for i in 0..InputBytes {\n            body[i] = data[i];\n        }\n        StringBody { body, chunks: StringBody::compute_chunks(body), byte_length: length }\n    }\n\n    /**\n     * @brief given an input byte array, convert into 31-byte chunks\n     *        cost is ~0.5 gates per byte\n     **/\n    fn compute_chunks(body: [u8; MaxPaddedBytes]) -> [Field; PaddedChunks] {\n        let mut chunks: [Field; PaddedChunks] = [0; PaddedChunks];\n        for i in 0..PaddedChunks {\n            let mut limb: Field = 0;\n            for j in 0..31 {\n                limb *= 256;\n                limb += body[i * 31 + j] as Field;\n            }\n            chunks[i] = limb;\n            std::as_witness(chunks[i]);\n        }\n        chunks\n    }\n\n    /**\n     * @brief Validate a substring exists in the StringBody. Returns a success flag and the position within the StringBody that the match was found\n     **/\n    fn substring_match<NeedleSubString>(\n        self,\n        substring: NeedleSubString\n    ) -> (bool, u32) where NeedleSubString : SubStringTrait {\n        // use unconstrained function to determine:\n        // a: is the substring present in the body text\n        // b: the position of the first match in the body text \n        let position: u32 = utils::search(\n            self.body,\n            substring.get_body(),\n            self.byte_length,\n            substring.len()\n        );\n\n        assert(\n            position + substring.len() <= self.byte_length, \"substring not present in main text (match found if a padding text included. is main text correctly formatted?)\"\n        );\n        let substring_length = substring.len();\n\n        // chunk_index = which 31-byte haystack chunk does the needle begin in?\n        let chunk_index: u32 = position / 31;\n        // chunk_offset = how many haystack bytes are present in the 1st haystack chunk?\n        let chunk_offset: u32 = position % 31;\n        // how many needle bytes are in 1st haystack chunk?\n        let num_bytes_in_first_chunk: u32 = 31 - chunk_offset;\n        let mut starting_needle_byte_index_of_final_chunk: Field = 0;\n        let mut chunk_index_of_final_haystack_chunk_with_matching_needle_bytes: Field = 0;\n        let mut num_full_chunks = 0;\n        println(\"A\");\n        // is there only one haystack chunk that contains needle bytes?\n        let merge_initial_final_needle_chunks = lt_f(substring_length as Field, num_bytes_in_first_chunk as Field);\n\n        // if the above is false...\n        if (!merge_initial_final_needle_chunks) {\n            // compute how many full 31-byte haystack chunks contain 31 needle bytes\n            num_full_chunks = (substring_length - num_bytes_in_first_chunk) / 31;\n            // for the final haystack chunk that contains needle bytes, where in the needle does this chunk begin?\n            starting_needle_byte_index_of_final_chunk = num_full_chunks as Field * 31 + num_bytes_in_first_chunk as Field;\n            // what is the index of the final haystack chunk that contains needle bytes?\n            chunk_index_of_final_haystack_chunk_with_matching_needle_bytes = num_full_chunks as Field + chunk_index as Field + 1;\n        } else {\n            starting_needle_byte_index_of_final_chunk = 0;\n            // if the needle bytes does NOT span more than 1 haystack chunk,\n            // the final haystack index will be the same as the initial haystack index\n            chunk_index_of_final_haystack_chunk_with_matching_needle_bytes = chunk_index as Field;\n        }\n\n        // To minimize the number of comparisons between the haystack bytes and the needle bytes,\n        // we pack both the haystack bytes and needle bytes into 31-byte Field \"chunks\" and compare chunks.\n        // To do this correctly, we need to align the needle chunks with the haystack chunks\n        /*\n            e.g. consider a toy example where we pack 3 bytes into a chunk\n            haystack: [VWXZYABCDEQRSTU]\n            needle: [ABCDE]\n\n            when constructing needle chunks, we need to align according to where the needle is located in the haystack\n            haystack chunks:   [VWX] [ZYA] [BCD] [EQR] [STU]\n                                      _..   ...   .__\n            processed needle chunks: [ZYA] [BCD] [EQR]\n\n            a \"_\" symbole means that a chunk byte has been sourced from the haystack bytes,\n            a \".\" symbol means a byte is sourced from the needle bytes\n\n            Both the initial and final chunks of the processed needle are \"composite\" constructions.\n            If chunk byte index < `position` or is > `position + needle length\", byte is sourced from haystack, otherwise byte is sourced from needle\n\n            The way we execute this in code is to define an \"initial\" needle chunk and a \"final\" needle chunk.\n            Num needle bytes in initial chunk = position % 31\n            Num needle bytes in final chunk = (needle_length - (position % 31)) % 31\n\n            If needle_length < 31 then the \"initial\" and \"final\" chunks\n            are actually the *same* chunk and we must perform a merge operation\n            (see later in algo for comments)\n        */\n\n        // instead of directly reading haystack bytes, we derive the bytes from the haystack chunks.\n        // This way we don't have to instantiate the haystack bytes as a ROM table, which would cost 2 * haystack.length gates\n        let offset_to_first_needle_byte_in_chunk: Field = chunk_offset as Field;\n        let initial_haystack_chunk = self.chunks[chunk_index];\n        let final_haystack_chunk = self.chunks[chunk_index_of_final_haystack_chunk_with_matching_needle_bytes];\n\n        let initial_body_bytes: [u8; 31] = initial_haystack_chunk.to_be_bytes(31).as_array();\n        let final_body_bytes: [u8; 31] = final_haystack_chunk.to_be_bytes(31).as_array();\n\n        // When defining the initial chunk bytes, we can represent as Field elements as we are deriving values from known bytes.\n        // This saves us a few gates\n        let mut initial_chunk: [Field; 31] = [0; 31];\n        let mut final_chunk: [Field; 31] = [0; 31];\n        for i in 0..31 {\n            // if i < offset_to_first_needle_byte_in_chunk, we read from the haystack\n            // otherwise we read from the needle\n            // n.b. this can be done with an if statement, but the following code produces fewer constraints\n            let idx: Field = i as Field;\n            let predicate: Field = lt_f(i as Field, offset_to_first_needle_byte_in_chunk) as Field;\n            let lhs: Field = initial_body_bytes[i] as Field;\n            // if i < offset_to_first_needle_byte_in_chunk then `idx - offset_to_first_needle_byte_in_chunk` is negative\n            // to ensure we access array correctly we need to set the lookup index to 0 if predicate = 0\n            let substring_idx = (1 - predicate) * (idx - offset_to_first_needle_byte_in_chunk);\n            let rhs: Field = substring.get(substring_idx) as Field;\n            let byte: Field = predicate * (lhs - rhs) + rhs;\n            initial_chunk[i] = byte;\n        }\n        println(\"C\");\n\n        // If `merge_initial_final_needle_chunks = true`, `final_chunk` will contain the full needle data,\n        // this requires some complex logic to determine where we are sourcing the needle bytes from.\n        // Either they come from the `initial_chunk`, the haystack bytes or the substring bytes.\n        for i in 0..31 {\n            let mut lhs_index: Field = starting_needle_byte_index_of_final_chunk as Field + i as Field;\n            let predicate = lt_f(lhs_index, substring_length as Field);\n\n            /*\n                | merge_initial_final_needle_chunks | predicate | byte_source              |\n                | false                             | false     | body_bytes[i]            |\n                | false                             | true      | substring[lhs_idx]       |\n                | true                              | false     | body_bytes[i]            |\n                | true                              | true      | initial_chunk[lhs_index] |\n\n                NOTE: if `merge = true` and `predicate = true`, we read from `initial_chunk` to short-circuit some extra logic.\n                      if `initial_chunk` did not exist, then we would need to validate whether `i < offset_to_first_needle_byte_in_chunk`.\n                      if true, the byte source would be body_bytes, otherwise the source would be substring bytes\n            */\n            let byte_from_substring = substring.get(lhs_index) as Field;\n            let byte_from_initial_chunk = initial_chunk[i] as Field;\n            let byte_from_haystack = final_body_bytes[i] as Field;\n\n            // TODO: find out why this cuts 1 gate per iteration\n            std::as_witness(byte_from_initial_chunk);\n\n            let p = predicate as Field;\n            let m = merge_initial_final_needle_chunks as Field;\n            // p * (m * (a - b) + (b - c)) + c\n            let ab = byte_from_initial_chunk - byte_from_substring;\n            std::as_witness(ab);\n            let bc = byte_from_substring - byte_from_haystack;\n            let t0 = m * ab + bc;\n            let destination_byte = p * t0 + byte_from_haystack;\n\n            final_chunk[i] = destination_byte;\n        }\n        println(\"D\");\n\n        // TODO: moving this above the previous code block adds 31 gates. find out why? :/ \n        let mut initial_needle_chunk: Field = 0;\n        let mut final_needle_chunk: Field = 0;\n\n        // Construct the initial and final needle chunks from the byte arrays we previously built.\n        // Validate they match the initial and final haystack chunks\n        for i in 0..31 {\n            initial_needle_chunk *= 256;\n            initial_needle_chunk += initial_chunk[i];\n            final_needle_chunk *= 256;\n            final_needle_chunk += final_chunk[i];\n        }\n\n        std::as_witness(initial_needle_chunk);\n        std::as_witness(final_needle_chunk);\n\n        initial_needle_chunk = merge_initial_final_needle_chunks as Field * (final_needle_chunk - initial_needle_chunk) + initial_needle_chunk;\n        assert(initial_needle_chunk == initial_haystack_chunk);\n        assert(final_needle_chunk == final_haystack_chunk);\n\n        // Step 3: Construct needle chunks (for all but the 1st and last chunks) and validate they match the haystack chunks.\n        //         This part is much simpler as we know that all bytes in the chunk are sourced from the needle chunk.\n        // NOTE:   If we chose to not pack bytes into 31-byte chunks, the string matching algorithm would be simpler but more expensive.\n        //         Instead of matching chunks with each other, we would match individual byte values.\n        //         i.e. the number of iterations in this loop would be 31x greater\n        //         each loop iteration would also require a predicate, to check whether the byte index was within the needle range or not\n        //         Combined these two operations would add about 10 gates per loop iteration,\n        //         combined with a 31x iteration length would make this algorithm much more costly than the chunked variant\n        let body_chunk_offset: Field = chunk_index as Field + 1;\n        substring.match_chunks(\n            self.chunks,\n            num_bytes_in_first_chunk as Field,\n            body_chunk_offset,\n            num_full_chunks as Field\n        );\n        (true, position)\n    }\n}\n\n#[test]\nfn test() {\n    let haystack_text = \"Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.\".as_bytes();\n    let needle_text = \" dolor in reprehenderit in voluptate velit esse\".as_bytes();\n\n    let mut haystack: StringBody512 = StringBody::new(haystack_text, haystack_text.len());\n    let mut needle: SubString64 = SubString::new(needle_text, needle_text.len());\n\n    let result = haystack.substring_match(needle);\n    assert(result.0 == true);\n}\n\n#[test]\nfn test_small_needle() {\n    let haystack_text = \"Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.\".as_bytes();\n    let needle_text = \"olor\".as_bytes();\n    let mut haystack: StringBody512 = StringBody::new(haystack_text, haystack_text.len());\n    let mut needle: SubString32 = SubString::new(needle_text, needle_text.len());\n\n    let result = haystack.substring_match(needle);\n    assert(result.0 == true);\n}\n\n#[test]\nfn test_needle_aligned_on_byte_boundary() {\n    let haystack_text = \"the quick brown fox jumped over the lazy dog\".as_bytes();\n    let needle_text = \" the lazy dog\".as_bytes();\n\n    let mut haystack: StringBody256 = StringBody::new(haystack_text, haystack_text.len());\n    let mut needle: SubString256 = SubString::new(needle_text, needle_text.len());\n\n    let result = haystack.substring_match(needle);\n    assert(result.0 == true);\n}\n\n#[test]\nfn test_needle_haystack_equal_size() {\n    let haystack_text = \"the quick brown fox jumped over the lazy dog lorem ipsum blahhhh\".as_bytes();\n    let needle_text = \"the quick brown fox jumped over the lazy dog lorem ipsum blahhhh\".as_bytes();\n\n    let mut haystack: StringBody64 = StringBody::new(haystack_text, haystack_text.len());\n    let mut needle: SubString64 = SubString::new(needle_text, needle_text.len());\n\n    let result = haystack.substring_match(needle);\n    assert(result.0 == true);\n}\n\n#[test]\nfn test_concat() {\n    let email_text = \"account recovery for Bartholomew Fibblesworth\".as_bytes();\n    let username = \"Bartholomew Fibblesworth\".as_bytes();\n    let mut padded_email_text: [u8; 256] = [0; 256];\n    let mut padded_username: [u8; 100] = [0; 100];\n    for i in 0..username.len() {\n        padded_username[i] = username[i];\n    }\n    for i in 0..email_text.len() {\n        padded_email_text[i] = email_text[i];\n    }\n    let needle_text_init = \"account recovery for \".as_bytes();\n\n    let needle_start: SubString128 = SubString::new(needle_text_init, needle_text_init.len());\n    let needle_end: SubString128 = SubString::new(padded_username, username.len());\n    let needle = needle_start.concat(needle_end);\n\n    for i in 0..45 {\n        assert(needle.body[i] == email_text[i]);\n    }\n\n    let haystack: StringBody256 = StringBody::new(padded_email_text, 200);\n    let (result, _): (bool, u32) = haystack.substring_match(needle);\n    assert(result == true);\n}\n\n#[test]\nfn test_concat_into() {\n    let email_text = \"account recovery for Bartholomew Fibblesworth\".as_bytes();\n    let username = \"Bartholomew Fibblesworth\".as_bytes();\n    let mut padded_email_text: [u8; 256] = [0; 256];\n    let mut padded_username: [u8; 100] = [0; 100];\n    for i in 0..username.len() {\n        padded_username[i] = username[i];\n    }\n    for i in 0..email_text.len() {\n        padded_email_text[i] = email_text[i];\n    }\n    let needle_text_init = \"account recovery for \".as_bytes();\n\n    let needle_start: SubString32 = SubString::new(needle_text_init, needle_text_init.len());\n    let needle_end: SubString128 = SubString::new(padded_username, username.len());\n    let needle = needle_start.concat_into(needle_end);\n\n    for i in 0..45 {\n        assert(needle.body[i] == email_text[i]);\n    }\n\n    let haystack: StringBody256 = StringBody::new(padded_email_text, 200);\n    let (result, _): (bool, u32) = haystack.substring_match(needle);\n    assert(result == true);\n}\n\nfn main(body_text: [u8; 2048], substring_text: [u8; 128], body_length: u32, substring_length: u32) {\n    let Body: StringBody2048 = StringBody::new(body_text, body_length);\n    let SubString: SubString128 = SubString::new(substring_text, substring_length);\n\n    let r = Body.substring_match(SubString);\n    assert(r.1 > 0);\n    assert(r.0 == true);\n}\n// 3887 without range check\n// 2735 without byte array initial gates\n// 2447 without byte array range checks\n\n#[test]\nunconstrained fn test_partial_match() {\n    let mut Engine = DebugRandomEngine { seed: 0 };\n    let mut foo: [u8; 1024] = Engine.get_random_bytes();\n    let mut bar: [u8; 128] = [0; 128];\n    for i in 0..128 {\n        bar[i] = foo[i + 123];\n    }\n    let position = utils::search(foo, bar.as_slice(), 1024, 128);\n\n    assert(position == 123);\n}\n","path":"/Users/zac/noir_string_search/src/main.nr"}},"names":["main"]}
\ No newline at end of file
diff --git a/target/noir_string_search.txt b/target/noir_string_search.txt
deleted file mode 100644
index fd40d44..0000000
--- a/target/noir_string_search.txt
+++ /dev/null
@@ -1,7 +0,0 @@
-{"functions": [
-  {
-        "acir_opcodes": 4344,
-        "circuit_size": 8471,
-        "gates_per_opcode": [46,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,2740,2,0,2,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,0,0,2,1,2,0,2,1,1,0,1,9,1,1,1,0,2,1,1,1,1,1,1,0,0,1,1,1,2,1,1,1,1,2,0,2,2,1,1,1,1,1,1,1,1,1,0,24,1,24,0,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,2,1,0,1,4,0,1,1,1,1,4,0,1,1,3,1,4,0,1,1,1,1,4,0,1,1,2,1,4,0,1,1,1,1,4,0,1,1,3,1,4,0,1,1,1,1,4,0,1,1,2,1,4,0,1,1,1,1,4,0,1,1,3,1,4,0,1,1,1,1,4,0,1,1,2,1,4,0,1,1,1,1,4,0,1,1,3,1,4,0,1,1,1,1,4,0,1,1,2,1,4,0,1,1,1,1,4,0,1,1,3,1,4,0,1,1,1,1,4,0,1,1,2,1,4,0,1,1,1,1,4,0,1,1,3,1,4,0,1,1,1,1,4,0,1,1,2,1,4,0,1,1,1,1,4,0,1,1,3,1,4,0,1,1,1,1,4,0,1,1,2,1,4,0,1,1,1,1,4,0,1,1,3,1,4,0,0,1,1,1,1,1,1,1,4,1,1,1,1,1,1,0,1,1,1,2,1,4,1,1,1,1,1,1,0,1,1,1,1,1,4,1,1,1,1,1,1,0,1,1,1,3,1,4,1,1,1,1,1,1,0,1,1,1,1,1,4,1,1,1,1,1,1,0,1,1,1,2,1,4,1,1,1,1,1,1,0,1,1,1,1,1,4,1,1,1,1,1,1,0,1,1,1,3,1,4,1,1,1,1,1,1,0,1,1,1,1,1,4,1,1,1,1,1,1,0,1,1,1,2,1,4,1,1,1,1,1,1,0,1,1,1,1,1,4,1,1,1,1,1,1,0,1,1,1,3,1,4,1,1,1,1,1,1,0,1,1,1,1,1,4,1,1,1,1,1,1,0,1,1,1,2,1,4,1,1,1,1,1,1,0,1,1,1,1,1,4,1,1,1,1,1,1,0,1,1,1,3,1,4,1,1,1,1,1,1,0,1,1,1,1,1,4,1,1,1,1,1,1,0,1,1,1,2,1,4,1,1,1,1,1,1,0,1,1,1,1,1,4,1,1,1,1,1,1,0,1,1,1,3,1,4,1,1,1,1,1,1,0,1,1,1,1,1,4,1,1,1,1,1,1,0,1,1,1,2,1,4,1,1,1,1,1,1,0,1,1,1,1,1,4,1,1,1,1,1,1,0,1,1,1,3,1,4,1,1,1,1,1,1,0,1,1,1,1,1,4,1,1,1,1,1,1,0,1,1,1,2,1,4,1,1,1,1,1,1,0,1,1,1,1,1,4,1,1,1,1,1,1,0,1,1,1,3,1,4,1,1,1,1,1,1,0,1,1,1,1,1,4,1,1,1,1,1,1,0,1,1,1,2,1,4,1,1,1,1,1,1,0,1,1,1,1,1,4,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,3,1,24,1,1,1,0,1,1,1,1,24,1,1,1,0,1,1,2,1,24,1,1,1,0,1,1,1,1,24,1,1,1,0,3,1,1]
-  }
-]}
\ No newline at end of file